d4708
/
source-engine
mirror of https://github.com/nillerusr/source-engine.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
528 Commits
25 Branches
6 Tags
221 MiB
Tree: 047f8b1185
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '047f8b1185'
${ noResults }
source-engine/tier0/stacktools.cpp

1708 lines
52 KiB
Raw Normal View History Unescape

Fix clang compile
4 years ago
//===== Copyright <EFBFBD> 1996-2005, Valve Corporation, All rights reserved. ======//
1
5 years ago
//
// Purpose:
//
// $Workfile: $
// $NoKeywords: $
//===========================================================================//
#include "pch_tier0.h"
#include "tier0/stacktools.h"
#include "tier0/threadtools.h"
#include "tier0/icommandline.h"
#include "tier0/valve_off.h"
#if defined( PLATFORM_WINDOWS_PC )
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <dbghelp.h>
#endif
#if defined( PLATFORM_X360 )
#include <xbdm.h>
#include "xbox/xbox_console.h"
#include "xbox/xbox_vxconsole.h"
#include <map>
#include <set>
#endif
WIP: musl port
2 years ago
#if defined( LINUX ) && defined( PLATFORM_GLIBC )
1
5 years ago
#include <execinfo.h>
#endif
#include "tier0/valve_on.h"
#include "tier0/memdbgon.h"
#if !defined( ENABLE_RUNTIME_STACK_TRANSLATION ) //disable the whole toolset
WIP: musl port
2 years ago
#if defined( LINUX ) && defined( PLATFORM_GLIBC )
1
5 years ago
int GetCallStack( void **pReturnAddressesOut, int iArrayCount, int iSkipCount )
{
return backtrace( pReturnAddressesOut, iArrayCount );
}
int GetCallStack_Fast( void **pReturnAddressesOut, int iArrayCount, int iSkipCount )
{
return backtrace( pReturnAddressesOut, iArrayCount );
}
#else
int GetCallStack( void **pReturnAddressesOut, int iArrayCount, int iSkipCount )
{
return 0;
}
int GetCallStack_Fast( void **pReturnAddressesOut, int iArrayCount, int iSkipCount )
{
return 0;
}
#endif
//where we'll find our PDB's for win32. Translation will not work until this has been called once (even if with NULL)
void SetStackTranslationSymbolSearchPath( const char *szSemicolonSeparatedList )
{
}
void StackToolsNotify_LoadedLibrary( const char *szLibName )
{
}
int TranslateStackInfo( const void * const *pCallStack, int iCallStackCount, tchar *szOutput, int iOutBufferSize, const tchar *szEntrySeparator, TranslateStackInfo_StyleFlags_t style )
{
if( iOutBufferSize > 0 )
*szOutput = '\0';
return 0;
}
void PreloadStackInformation( const void **pAddresses, int iAddressCount )
{
}
bool GetFileAndLineFromAddress( const void *pAddress, tchar *pFileNameOut, int iMaxFileNameLength, uint32 &iLineNumberOut, uint32 *pDisplacementOut )
{
if( iMaxFileNameLength > 0 )
*pFileNameOut = '\0';
return false;
}
bool GetSymbolNameFromAddress( const void *pAddress, tchar *pSymbolNameOut, int iMaxSymbolNameLength, uint64 *pDisplacementOut )
{
if( iMaxSymbolNameLength > 0 )
*pSymbolNameOut = '\0';
return false;
}
bool GetModuleNameFromAddress( const void *pAddress, tchar *pModuleNameOut, int iMaxModuleNameLength )
{
if( iMaxModuleNameLength > 0 )
*pModuleNameOut = '\0';
return false;
}
#else //#if !defined( ENABLE_RUNTIME_STACK_TRANSLATION )
//===============================================================================================================
// Shared Windows/X360 code
//===============================================================================================================
CTHREADLOCALPTR( CStackTop_Base ) g_StackTop;
class CStackTop_FriendFuncs : public CStackTop_Base
{
public:
friend int AppendParentStackTrace( void **pReturnAddressesOut, int iArrayCount, int iAlreadyFilled );
friend int GetCallStack_Fast( void **pReturnAddressesOut, int iArrayCount, int iSkipCount );
};
inline int AppendParentStackTrace( void **pReturnAddressesOut, int iArrayCount, int iAlreadyFilled )
{
CStackTop_FriendFuncs *pTop = (CStackTop_FriendFuncs *)(CStackTop_Base *)g_StackTop;
if( pTop != NULL )
{
if( pTop->m_pReplaceAddress != NULL )
{
for( int i = iAlreadyFilled; --i >= 0; )
{
if( pReturnAddressesOut[i] == pTop->m_pReplaceAddress )
{
iAlreadyFilled = i;
break;
}
}
}
if( pTop->m_iParentStackTraceLength != 0 )
{
int iCopy = MIN( iArrayCount - iAlreadyFilled, pTop->m_iParentStackTraceLength );
memcpy( pReturnAddressesOut + iAlreadyFilled, pTop->m_pParentStackTrace, iCopy * sizeof( void * ) );
iAlreadyFilled += iCopy;
}
}
return iAlreadyFilled;
}
inline bool ValidStackAddress( void *pAddress, const void *pNoLessThan, const void *pNoGreaterThan )
{
if( (uintp)pAddress & 3 )
return false;
if( pAddress < pNoLessThan ) //frame pointer traversal should always increase the pointer
return false;
if( pAddress > pNoGreaterThan ) //never traverse outside the stack (Oh 0xCCCCCCCC, how I hate you)
return false;
#if defined( WIN32 ) && !defined( _X360 ) && 1
if( IsBadReadPtr( pAddress, (sizeof( void * ) * 2) ) ) //safety net, but also throws an exception (handled internally) to stop bad access
return false;
#endif
return true;
}
#pragma auto_inline( off )
int GetCallStack_Fast( void **pReturnAddressesOut, int iArrayCount, int iSkipCount )
{
//Only tested in windows. This function won't work with frame pointer omission enabled. "vpc /nofpo" all projects
#if (defined( TIER0_FPO_DISABLED ) || defined( _DEBUG )) &&\
(defined( WIN32 ) && !defined( _X360 ) && !defined(_M_X64))
void *pStackCrawlEBP;
__asm
{
mov [pStackCrawlEBP], ebp;
}
/*
With frame pointer omission disabled, this should be the pattern all the way up the stack
[ebp+00] Old ebp value
[ebp+04] Return address
*/
void *pNoLessThan = pStackCrawlEBP; //impossible for a valid stack to traverse before this address
int i;
CStackTop_FriendFuncs *pTop = (CStackTop_FriendFuncs *)(CStackTop_Base *)g_StackTop;
if( pTop != NULL ) //we can do fewer error checks if we have a valid reference point for the top of the stack
{
void *pNoGreaterThan = pTop->m_pStackBase;
//skips
for( i = 0; i != iSkipCount; ++i )
{
if( (pStackCrawlEBP < pNoLessThan) || (pStackCrawlEBP > pNoGreaterThan) )
return AppendParentStackTrace( pReturnAddressesOut, iArrayCount, 0 );
pNoLessThan = pStackCrawlEBP;
pStackCrawlEBP = *(void **)pStackCrawlEBP; //should be pointing at old ebp value
}
//store
for( i = 0; i != iArrayCount; ++i )
{
if( (pStackCrawlEBP < pNoLessThan) || (pStackCrawlEBP > pNoGreaterThan) )
break;
pReturnAddressesOut[i] = *((void **)pStackCrawlEBP + 1);
pNoLessThan = pStackCrawlEBP;
pStackCrawlEBP = *(void **)pStackCrawlEBP; //should be pointing at old ebp value
}
return AppendParentStackTrace( pReturnAddressesOut, iArrayCount, i );
}
else
{
void *pNoGreaterThan = ((unsigned char *)pNoLessThan) + (1024 * 1024); //standard stack is 1MB. TODO: Get actual stack end address if available since this check isn't foolproof
//skips
for( i = 0; i != iSkipCount; ++i )
{
if( !ValidStackAddress( pStackCrawlEBP, pNoLessThan, pNoGreaterThan ) )
return AppendParentStackTrace( pReturnAddressesOut, iArrayCount, 0 );
pNoLessThan = pStackCrawlEBP;
pStackCrawlEBP = *(void **)pStackCrawlEBP; //should be pointing at old ebp value
}
//store
for( i = 0; i != iArrayCount; ++i )
{
if( !ValidStackAddress( pStackCrawlEBP, pNoLessThan, pNoGreaterThan ) )
break;
pReturnAddressesOut[i] = *((void **)pStackCrawlEBP + 1);
pNoLessThan = pStackCrawlEBP;
pStackCrawlEBP = *(void **)pStackCrawlEBP; //should be pointing at old ebp value
}
return AppendParentStackTrace( pReturnAddressesOut, iArrayCount, i );
}
#endif
return 0;
}
#pragma auto_inline( on )
#if defined( WIN32 ) && !defined( _X360 )
//===============================================================================================================
// Windows version of the toolset
//===============================================================================================================
#if defined( TIER0_FPO_DISABLED )
//# define USE_CAPTURESTACKBACKTRACE //faster than StackWalk64, but only works on XP or newer and only with Frame Pointer Omission optimization disabled(/Oy-) for every function it traces through
#endif
#if defined(_M_IX86) || defined(_M_X64)
# define USE_STACKWALK64
# if defined(_M_IX86)
# define STACKWALK64_MACHINETYPE IMAGE_FILE_MACHINE_I386
# else
# define STACKWALK64_MACHINETYPE IMAGE_FILE_MACHINE_AMD64
# endif
#endif
typedef DWORD (WINAPI *PFN_SymGetOptions)( VOID );
typedef DWORD (WINAPI *PFN_SymSetOptions)( IN DWORD SymOptions );
typedef BOOL (WINAPI *PFN_SymSetSearchPath)( IN HANDLE hProcess, IN PSTR SearchPath );
typedef BOOL (WINAPI *PFN_SymInitialize)( IN HANDLE hProcess, IN PSTR UserSearchPath, IN BOOL fInvadeProcess );
typedef BOOL (WINAPI *PFN_SymCleanup)( IN HANDLE hProcess );
typedef BOOL (WINAPI *PFN_SymEnumerateModules64)( IN HANDLE hProcess, IN PSYM_ENUMMODULES_CALLBACK64 EnumModulesCallback, IN PVOID UserContext );
typedef BOOL (WINAPI *PFN_EnumerateLoadedModules64)( IN HANDLE hProcess, IN PENUMLOADED_MODULES_CALLBACK64 EnumLoadedModulesCallback, IN PVOID UserContext );
typedef DWORD64 (WINAPI *PFN_SymLoadModule64)( IN HANDLE hProcess, IN HANDLE hFile, IN PSTR ImageName, IN PSTR ModuleName, IN DWORD64 BaseOfDll, IN DWORD SizeOfDll );
typedef BOOL (WINAPI *PFN_SymUnloadModule64)( IN HANDLE hProcess, IN DWORD64 BaseOfDll );
typedef BOOL (WINAPI *PFN_SymFromAddr)( IN HANDLE hProcess, IN DWORD64 Address, OUT PDWORD64 Displacement, IN OUT PSYMBOL_INFO Symbol );
typedef BOOL (WINAPI *PFN_SymGetLineFromAddr64)( IN HANDLE hProcess, IN DWORD64 qwAddr, OUT PDWORD pdwDisplacement, OUT PIMAGEHLP_LINE64 Line64 );
typedef BOOL (WINAPI *PFN_SymGetModuleInfo64)( IN HANDLE hProcess, IN DWORD64 dwAddr, OUT PIMAGEHLP_MODULE64 ModuleInfo );
typedef BOOL (WINAPI *PFN_StackWalk64)( DWORD MachineType, HANDLE hProcess, HANDLE hThread, LPSTACKFRAME64 StackFrame, PVOID ContextRecord, PREAD_PROCESS_MEMORY_ROUTINE64 ReadMemoryRoutine, PFUNCTION_TABLE_ACCESS_ROUTINE64 FunctionTableAccessRoutine, PGET_MODULE_BASE_ROUTINE64 GetModuleBaseRoutine, PTRANSLATE_ADDRESS_ROUTINE64 TranslateAddress );
typedef USHORT (WINAPI *PFN_CaptureStackBackTrace)( IN ULONG FramesToSkip, IN ULONG FramesToCapture, OUT PVOID *BackTrace, OUT OPTIONAL PULONG BackTraceHash );
DWORD WINAPI SymGetOptions_DummyFn( VOID )
{
return 0;
}
DWORD WINAPI SymSetOptions_DummyFn( IN DWORD SymOptions )
{
return 0;
}
BOOL WINAPI SymSetSearchPath_DummyFn( IN HANDLE hProcess, IN PSTR SearchPath )
{
return FALSE;
}
BOOL WINAPI SymInitialize_DummyFn( IN HANDLE hProcess, IN PSTR UserSearchPath, IN BOOL fInvadeProcess )
{
return FALSE;
}
BOOL WINAPI SymCleanup_DummyFn( IN HANDLE hProcess )
{
return TRUE;
}
BOOL WINAPI SymEnumerateModules64_DummyFn( IN HANDLE hProcess, IN PSYM_ENUMMODULES_CALLBACK64 EnumModulesCallback, IN PVOID UserContext )
{
return FALSE;
}
BOOL WINAPI EnumerateLoadedModules64_DummyFn( IN HANDLE hProcess, IN PENUMLOADED_MODULES_CALLBACK64 EnumLoadedModulesCallback, IN PVOID UserContext )
{
return FALSE;
}
DWORD64 WINAPI SymLoadModule64_DummyFn( IN HANDLE hProcess, IN HANDLE hFile, IN PSTR ImageName, IN PSTR ModuleName, IN DWORD64 BaseOfDll, IN DWORD SizeOfDll )
{
return 0;
}
BOOL WINAPI SymUnloadModule64_DummyFn( IN HANDLE hProcess, IN DWORD64 BaseOfDll )
{
return FALSE;
}
BOOL WINAPI SymFromAddr_DummyFn( IN HANDLE hProcess, IN DWORD64 Address, OUT PDWORD64 Displacement, IN OUT PSYMBOL_INFO Symbol )
{
return FALSE;
}
BOOL WINAPI SymGetLineFromAddr64_DummyFn( IN HANDLE hProcess, IN DWORD64 qwAddr, OUT PDWORD pdwDisplacement, OUT PIMAGEHLP_LINE64 Line64 )
{
return FALSE;
}
BOOL WINAPI SymGetModuleInfo64_DummyFn( IN HANDLE hProcess, IN DWORD64 dwAddr, OUT PIMAGEHLP_MODULE64 ModuleInfo )
{
return FALSE;
}
BOOL WINAPI StackWalk64_DummyFn( DWORD MachineType, HANDLE hProcess, HANDLE hThread, LPSTACKFRAME64 StackFrame, PVOID ContextRecord, PREAD_PROCESS_MEMORY_ROUTINE64 ReadMemoryRoutine, PFUNCTION_TABLE_ACCESS_ROUTINE64 FunctionTableAccessRoutine, PGET_MODULE_BASE_ROUTINE64 GetModuleBaseRoutine, PTRANSLATE_ADDRESS_ROUTINE64 TranslateAddress )
{
return FALSE;
}
USHORT WINAPI CaptureStackBackTrace_DummyFn( IN ULONG FramesToSkip, IN ULONG FramesToCapture, OUT PVOID *BackTrace, OUT OPTIONAL PULONG BackTraceHash )
{
return 0;
}
class CHelperFunctionsLoader
{
public:
CHelperFunctionsLoader( void )
{
m_bIsInitialized = false;
m_bShouldReloadSymbols = false;
m_hDbgHelpDll = NULL;
m_szPDBSearchPath = NULL;
m_pSymInitialize = SymInitialize_DummyFn;
m_pSymCleanup = SymCleanup_DummyFn;
m_pSymSetOptions = SymSetOptions_DummyFn;
m_pSymGetOptions = SymGetOptions_DummyFn;
m_pSymSetSearchPath = SymSetSearchPath_DummyFn;
m_pSymEnumerateModules64 = SymEnumerateModules64_DummyFn;
m_pEnumerateLoadedModules64 = EnumerateLoadedModules64_DummyFn;
m_pSymLoadModule64 = SymLoadModule64_DummyFn;
m_pSymUnloadModule64 = SymUnloadModule64_DummyFn;
m_pSymFromAddr = SymFromAddr_DummyFn;
m_pSymGetLineFromAddr64 = SymGetLineFromAddr64_DummyFn;
m_pSymGetModuleInfo64 = SymGetModuleInfo64_DummyFn;
#if defined( USE_STACKWALK64 )
m_pStackWalk64 = StackWalk64_DummyFn;
#endif
#if defined( USE_CAPTURESTACKBACKTRACE )
m_pCaptureStackBackTrace = CaptureStackBackTrace_DummyFn;
m_hNTDllDll = NULL;
#endif
}
~CHelperFunctionsLoader( void )
{
m_pSymCleanup( m_hProcess );
if( m_hDbgHelpDll != NULL )
::FreeLibrary( m_hDbgHelpDll );
#if defined( USE_CAPTURESTACKBACKTRACE )
if( m_hNTDllDll != NULL )
::FreeLibrary( m_hNTDllDll );
#endif
if( m_szPDBSearchPath != NULL )
delete []m_szPDBSearchPath;
}
static BOOL CALLBACK UnloadSymbolsCallback( PSTR ModuleName, DWORD64 BaseOfDll, PVOID UserContext )
{
const CHelperFunctionsLoader *pThis = ((CHelperFunctionsLoader *)UserContext);
pThis->m_pSymUnloadModule64( pThis->m_hProcess, BaseOfDll );
return TRUE;
}
#if _MSC_VER >= 1600
static BOOL CALLBACK LoadSymbolsCallback( PCSTR ModuleName, DWORD64 ModuleBase, ULONG ModuleSize, PVOID UserContext )
#else
static BOOL CALLBACK LoadSymbolsCallback( PSTR ModuleName, DWORD64 ModuleBase, ULONG ModuleSize, PVOID UserContext )
#endif
{
const CHelperFunctionsLoader *pThis = ((CHelperFunctionsLoader *)UserContext);
//SymLoadModule64( IN HANDLE hProcess, IN HANDLE hFile, IN PSTR ImageName, IN PSTR ModuleName, IN DWORD64 BaseOfDll, IN DWORD SizeOfDll );
pThis->m_pSymLoadModule64( pThis->m_hProcess, NULL, (PSTR)ModuleName, (PSTR)ModuleName, ModuleBase, ModuleSize );
return TRUE;
}
void TryLoadingNewSymbols( void )
{
AUTO_LOCK( m_Mutex );
if( m_bIsInitialized )
{
//m_pSymEnumerateModules64( m_hProcess, UnloadSymbolsCallback, this ); //unloaded modules we've already loaded
m_pEnumerateLoadedModules64( m_hProcess, LoadSymbolsCallback, this ); //load everything
m_bShouldReloadSymbols = false;
}
}
void SetStackTranslationSymbolSearchPath( const char *szSemicolonSeparatedList )
{
AUTO_LOCK( m_Mutex );
if( m_szPDBSearchPath != NULL )
delete []m_szPDBSearchPath;
if( szSemicolonSeparatedList == NULL )
{
m_szPDBSearchPath = NULL;
return;
}
int iLength = (int)strlen( szSemicolonSeparatedList ) + 1;
char *pNewPath = new char [iLength];
memcpy( pNewPath, szSemicolonSeparatedList, iLength );
m_szPDBSearchPath = pNewPath;
//re-init search paths. Or if we haven't yet loaded dbghelp.dll, this will go to the dummy function and do nothing
m_pSymSetSearchPath( m_hProcess, m_szPDBSearchPath );
//TryLoadingNewSymbols();
m_bShouldReloadSymbols = true;
}
bool GetSymbolNameFromAddress( const void *pAddress, tchar *pSymbolNameOut, int iMaxSymbolNameLength, uint64 *pDisplacementOut )
{
if( pAddress == NULL )
return false;
AUTO_LOCK( m_Mutex );
unsigned char genericbuffer[sizeof(SYMBOL_INFO) + MAX_SYM_NAME*sizeof(TCHAR)];
((PSYMBOL_INFO)genericbuffer)->SizeOfStruct = sizeof(SYMBOL_INFO);
((PSYMBOL_INFO)genericbuffer)->MaxNameLen = MAX_SYM_NAME;
DWORD64 dwDisplacement;
if( m_pSymFromAddr( m_hProcess, (DWORD64)pAddress, &dwDisplacement, (PSYMBOL_INFO)genericbuffer) )
{
strncpy( pSymbolNameOut, ((PSYMBOL_INFO)genericbuffer)->Name, iMaxSymbolNameLength );
if( pDisplacementOut != NULL )
*pDisplacementOut = dwDisplacement;
return true;
}
return false;
}
bool GetFileAndLineFromAddress( const void *pAddress, tchar *pFileNameOut, int iMaxFileNameLength, uint32 &iLineNumberOut, uint32 *pDisplacementOut )
{
if( pAddress == NULL )
return false;
AUTO_LOCK( m_Mutex );
tchar szBuffer[1024];
szBuffer[0] = _T('\0');
IMAGEHLP_LINE64 imageHelpLine64;
imageHelpLine64.SizeOfStruct = sizeof(IMAGEHLP_LINE64);
imageHelpLine64.FileName = szBuffer;
DWORD dwDisplacement;
if( m_pSymGetLineFromAddr64( m_hProcess, (DWORD64)pAddress, &dwDisplacement, &imageHelpLine64 ) )
{
strncpy( pFileNameOut, imageHelpLine64.FileName, iMaxFileNameLength );
iLineNumberOut = imageHelpLine64.LineNumber;
if( pDisplacementOut != NULL )
*pDisplacementOut = dwDisplacement;
return true;
}
return false;
}
bool GetModuleNameFromAddress( const void *pAddress, tchar *pModuleNameOut, int iMaxModuleNameLength )
{
AUTO_LOCK( m_Mutex );
IMAGEHLP_MODULE64 moduleInfo;
moduleInfo.SizeOfStruct = sizeof(IMAGEHLP_MODULE64);
if ( m_pSymGetModuleInfo64( m_hProcess, (DWORD64)pAddress, &moduleInfo ) )
{
strncpy( pModuleNameOut, moduleInfo.ModuleName, iMaxModuleNameLength );
return true;
}
return false;
}
//only returns false if we ran out of buffer space.
bool TranslatePointer( const void * const pAddress, tchar *pTranslationOut, int iTranslationBufferLength, TranslateStackInfo_StyleFlags_t style )
{
//AUTO_LOCK( m_Mutex );
if( pTranslationOut == NULL )
return false;
if( iTranslationBufferLength <= 0 )
return false;
//sample desired output
// valid translation - "tier0.dll!CHelperFunctionsLoader::TranslatePointer - u:\Dev\L4D\src\tier0\stacktools.cpp(162) + 4 bytes"
// fallback translation - "tier0.dll!0x01234567"
tchar *pWrite = pTranslationOut;
*pWrite = '\0';
int iLength;
if( style & TSISTYLEFLAG_MODULENAME )
{
if( !this->GetModuleNameFromAddress( pAddress, pWrite, iTranslationBufferLength ) )
strncpy( pWrite, "unknown_module", iTranslationBufferLength );
iLength = (int)strlen( pWrite );
pWrite += iLength;
iTranslationBufferLength -= iLength;
if( iTranslationBufferLength < 2 )
return false; //need more buffer
if( style & TSISTYLEFLAG_SYMBOLNAME )
{
*pWrite = '!';
++pWrite;
--iTranslationBufferLength;
*pWrite = '\0';
}
}
//use symbol name to test if the rest is going to work. So grab it whether they want it or not
if( !this->GetSymbolNameFromAddress( pAddress, pWrite, iTranslationBufferLength, NULL ) )
{
int nBytesWritten = _snprintf( pWrite, iTranslationBufferLength, "0x%p", pAddress );
if ( nBytesWritten < 0 )
{
*pWrite = '\0'; // if we can't write all of the line/lineandoffset, don't write any at all
return false;
}
return true;
}
else if( style & TSISTYLEFLAG_SYMBOLNAME )
{
iLength = (int)strlen( pWrite );
pWrite += iLength;
iTranslationBufferLength -= iLength;
}
else
{
*pWrite = '\0'; //symbol name lookup worked, but unwanted, discard
}
if( style & (TSISTYLEFLAG_FULLPATH | TSISTYLEFLAG_SHORTPATH | TSISTYLEFLAG_LINE | TSISTYLEFLAG_LINEANDOFFSET) )
{
if( pWrite != pTranslationOut ) //if we've written anything yet, separate the printed data from the file name and line
{
if( iTranslationBufferLength < 6 )
return false; //need more buffer
pWrite[0] = ' '; //append " - "
pWrite[1] = '-';
pWrite[2] = ' ';
pWrite[3] = '\0';
pWrite += 3;
iTranslationBufferLength -= 3;
}
uint32 iLine;
uint32 iDisplacement;
char szFileName[MAX_PATH];
if( this->GetFileAndLineFromAddress( pAddress, szFileName, MAX_PATH, iLine, &iDisplacement ) )
{
if( style & TSISTYLEFLAG_FULLPATH )
{
iLength = (int)strlen( szFileName );
if ( iTranslationBufferLength < iLength + 1 )
return false;
memcpy( pWrite, szFileName, iLength + 1 );
pWrite += iLength;
iTranslationBufferLength -= iLength;
}
else if( style & TSISTYLEFLAG_SHORTPATH )
{
//shorten the path and copy
iLength = (int)strlen( szFileName );
char *pShortened = szFileName + iLength;
int iSlashesAllowed = 3;
while( pShortened > szFileName )
{
if( (*pShortened == '\\') || (*pShortened == '/') )
{
--iSlashesAllowed;
if( iSlashesAllowed == 0 )
break;
}
--pShortened;
}
iLength = (int)strlen( pShortened );
if( iTranslationBufferLength < iLength + 1 )
{
//Remove the " - " that we can't append to
pWrite -= 3;
iTranslationBufferLength += 3;
*pWrite = '\0';
return false;
}
memcpy( pWrite, szFileName, iLength + 1 );
pWrite += iLength;
iTranslationBufferLength -= iLength;
}
if( style & (TSISTYLEFLAG_LINE | TSISTYLEFLAG_LINEANDOFFSET) )
{
int nBytesWritten = _snprintf( pWrite, iTranslationBufferLength, ((style & TSISTYLEFLAG_LINEANDOFFSET) && (iDisplacement != 0)) ? "(%d) + %d bytes" : "(%d)", iLine, iDisplacement );
if ( nBytesWritten < 0 )
{
*pWrite = '\0'; // if we can't write all of the line/lineandoffset, don't write any at all
return false;
}
pWrite += nBytesWritten;
iTranslationBufferLength -= nBytesWritten;
}
}
else
{
//Remove the " - " that we didn't append to
pWrite -= 3;
iTranslationBufferLength += 3;
*pWrite = '\0';
}
}
return true;
}
//about to actually use the functions, load if necessary
void EnsureReady( void )
{
if( m_bIsInitialized )
{
if( m_bShouldReloadSymbols )
TryLoadingNewSymbols();
return;
}
AUTO_LOCK( m_Mutex );
//Only enabled for P4 and Steam Beta builds
if( (CommandLine()->FindParm( "-steam" ) != 0) && //is steam
(CommandLine()->FindParm( "-internalbuild" ) == 0) ) //is not steam beta
{
//disable the toolset by falsifying initialized state
m_bIsInitialized = true;
return;
}
m_hProcess = GetCurrentProcess();
if( m_hProcess == NULL )
return;
m_bIsInitialized = true;
// get the function pointer directly so that we don't have to include the .lib, and that
// we can easily change it to using our own dll when this code is used on win98/ME/2K machines
m_hDbgHelpDll = ::LoadLibrary( "DbgHelp.dll" );
if ( !m_hDbgHelpDll )
{
//it's possible it's just way too early to initialize (as shown with attempts at using these tools in the memory allocator)
if( m_szPDBSearchPath == NULL ) //not a rock solid check, but pretty good compromise between endless failing initialization and general failure due to trying too early
m_bIsInitialized = false;
return;
}
m_pSymInitialize = (PFN_SymInitialize) ::GetProcAddress( m_hDbgHelpDll, "SymInitialize" );
if( m_pSymInitialize == NULL )
{
//very bad
::FreeLibrary( m_hDbgHelpDll );
m_hDbgHelpDll = NULL;
m_pSymInitialize = SymInitialize_DummyFn;
return;
}
m_pSymCleanup = (PFN_SymCleanup) ::GetProcAddress( m_hDbgHelpDll, "SymCleanup" );
if( m_pSymCleanup == NULL )
m_pSymCleanup = SymCleanup_DummyFn;
m_pSymGetOptions = (PFN_SymGetOptions) ::GetProcAddress( m_hDbgHelpDll, "SymGetOptions" );
if( m_pSymGetOptions == NULL )
m_pSymGetOptions = SymGetOptions_DummyFn;
m_pSymSetOptions = (PFN_SymSetOptions) ::GetProcAddress( m_hDbgHelpDll, "SymSetOptions" );
if( m_pSymSetOptions == NULL )
m_pSymSetOptions = SymSetOptions_DummyFn;
m_pSymSetSearchPath = (PFN_SymSetSearchPath) ::GetProcAddress( m_hDbgHelpDll, "SymSetSearchPath" );
if( m_pSymSetSearchPath == NULL )
m_pSymSetSearchPath = SymSetSearchPath_DummyFn;
m_pSymEnumerateModules64 = (PFN_SymEnumerateModules64) ::GetProcAddress( m_hDbgHelpDll, "SymEnumerateModules64" );
if( m_pSymEnumerateModules64 == NULL )
m_pSymEnumerateModules64 = SymEnumerateModules64_DummyFn;
m_pEnumerateLoadedModules64 = (PFN_EnumerateLoadedModules64) ::GetProcAddress( m_hDbgHelpDll, "EnumerateLoadedModules64" );
if( m_pEnumerateLoadedModules64 == NULL )
m_pEnumerateLoadedModules64 = EnumerateLoadedModules64_DummyFn;
m_pSymLoadModule64 = (PFN_SymLoadModule64) ::GetProcAddress( m_hDbgHelpDll, "SymLoadModule64" );
if( m_pSymLoadModule64 == NULL )
m_pSymLoadModule64 = SymLoadModule64_DummyFn;
m_pSymUnloadModule64 = (PFN_SymUnloadModule64) ::GetProcAddress( m_hDbgHelpDll, "SymUnloadModule64" );
if( m_pSymUnloadModule64 == NULL )
m_pSymUnloadModule64 = SymUnloadModule64_DummyFn;
m_pSymFromAddr = (PFN_SymFromAddr) ::GetProcAddress( m_hDbgHelpDll, "SymFromAddr" );
if( m_pSymFromAddr == NULL )
m_pSymFromAddr = SymFromAddr_DummyFn;
m_pSymGetLineFromAddr64 = (PFN_SymGetLineFromAddr64) ::GetProcAddress( m_hDbgHelpDll, "SymGetLineFromAddr64" );
if( m_pSymGetLineFromAddr64 == NULL )
m_pSymGetLineFromAddr64 = SymGetLineFromAddr64_DummyFn;
m_pSymGetModuleInfo64 = (PFN_SymGetModuleInfo64) ::GetProcAddress( m_hDbgHelpDll, "SymGetModuleInfo64" );
if( m_pSymGetModuleInfo64 == NULL )
m_pSymGetModuleInfo64 = SymGetModuleInfo64_DummyFn;
#if defined( USE_STACKWALK64 )
m_pStackWalk64 = (PFN_StackWalk64) ::GetProcAddress( m_hDbgHelpDll, "StackWalk64" );
if( m_pStackWalk64 == NULL )
m_pStackWalk64 = StackWalk64_DummyFn;
#endif
#if defined( USE_CAPTURESTACKBACKTRACE )
m_hNTDllDll = ::LoadLibrary( "ntdll.dll" );
m_pCaptureStackBackTrace = (PFN_CaptureStackBackTrace) ::GetProcAddress( m_hNTDllDll, "RtlCaptureStackBackTrace" );
if( m_pCaptureStackBackTrace == NULL )
m_pCaptureStackBackTrace = CaptureStackBackTrace_DummyFn;
#endif
m_pSymSetOptions( m_pSymGetOptions() |
SYMOPT_DEFERRED_LOADS | //load on demand
SYMOPT_EXACT_SYMBOLS | //don't load the wrong file
SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS | //don't prompt ever
SYMOPT_LOAD_LINES ); //load line info
m_pSymInitialize( m_hProcess, m_szPDBSearchPath, FALSE );
TryLoadingNewSymbols();
}
bool m_bIsInitialized;
bool m_bShouldReloadSymbols;
HANDLE m_hProcess;
HMODULE m_hDbgHelpDll;
char *m_szPDBSearchPath;
CThreadFastMutex m_Mutex; //DbgHelp functions are all single threaded.
PFN_SymInitialize m_pSymInitialize;
PFN_SymCleanup m_pSymCleanup;
PFN_SymGetOptions m_pSymGetOptions;
PFN_SymSetOptions m_pSymSetOptions;
PFN_SymSetSearchPath m_pSymSetSearchPath;
PFN_SymEnumerateModules64 m_pSymEnumerateModules64;
PFN_EnumerateLoadedModules64 m_pEnumerateLoadedModules64;
PFN_SymLoadModule64 m_pSymLoadModule64;
PFN_SymUnloadModule64 m_pSymUnloadModule64;
PFN_SymFromAddr m_pSymFromAddr;
PFN_SymGetLineFromAddr64 m_pSymGetLineFromAddr64;
PFN_SymGetModuleInfo64 m_pSymGetModuleInfo64;
#if defined( USE_STACKWALK64 )
PFN_StackWalk64 m_pStackWalk64;
#endif
#if defined( USE_CAPTURESTACKBACKTRACE )
HMODULE m_hNTDllDll;
PFN_CaptureStackBackTrace m_pCaptureStackBackTrace;
#endif
};
static CHelperFunctionsLoader s_HelperFunctions;
#if defined( USE_STACKWALK64 ) //most reliable method thanks to boatloads of windows helper functions. Also the slowest.
int CrawlStack_StackWalk64( CONTEXT *pExceptionContext, void **pReturnAddressesOut, int iArrayCount, int iSkipCount )
{
s_HelperFunctions.EnsureReady();
AUTO_LOCK( s_HelperFunctions.m_Mutex );
CONTEXT currentContext;
memcpy( &currentContext, pExceptionContext, sizeof( CONTEXT ) );
STACKFRAME64 sfFrame = { 0 }; //memset(&sfFrame, 0x0, sizeof(sfFrame));
sfFrame.AddrPC.Mode = sfFrame.AddrFrame.Mode = AddrModeFlat;
#ifdef _M_X64
sfFrame.AddrPC.Offset = currentContext.Rip;
sfFrame.AddrFrame.Offset = currentContext.Rbp; // ????
#else
sfFrame.AddrPC.Offset = currentContext.Eip;
sfFrame.AddrFrame.Offset = currentContext.Ebp;
#endif
HANDLE hThread = GetCurrentThread();
int i;
for( i = 0; i != iSkipCount; ++i ) //skip entries that the requesting function thinks are uninformative
{
if(!s_HelperFunctions.m_pStackWalk64( STACKWALK64_MACHINETYPE, s_HelperFunctions.m_hProcess, hThread, &sfFrame, &currentContext, NULL, NULL, NULL, NULL ) ||
(sfFrame.AddrFrame.Offset == 0) )
{
return 0;
}
}
for( i = 0; i != iArrayCount; ++i )
{
if(!s_HelperFunctions.m_pStackWalk64( STACKWALK64_MACHINETYPE, s_HelperFunctions.m_hProcess, hThread, &sfFrame, &currentContext, NULL, NULL, NULL, NULL ) ||
(sfFrame.AddrFrame.Offset == 0) )
{
break;
}
pReturnAddressesOut[i] = (void *)sfFrame.AddrPC.Offset;
}
return i;
}
void GetCallStackReturnAddresses_Exception( void **CallStackReturnAddresses, int *pRetCount, int iSkipCount, _EXCEPTION_POINTERS * pExceptionInfo )
{
int iCount = CrawlStack_StackWalk64( pExceptionInfo->ContextRecord, CallStackReturnAddresses, *pRetCount, iSkipCount + 1 ); //skipping RaiseException()
*pRetCount = iCount;
}
#endif //#if defined( USE_STACKWALK64 )
int GetCallStack( void **pReturnAddressesOut, int iArrayCount, int iSkipCount )
{
s_HelperFunctions.EnsureReady();
++iSkipCount; //skip this function
#if defined( USE_CAPTURESTACKBACKTRACE )
if( s_HelperFunctions.m_pCaptureStackBackTrace != CaptureStackBackTrace_DummyFn )
{
//docs state a total limit of 63 back traces between skipped and stored
int iRetVal = s_HelperFunctions.m_pCaptureStackBackTrace( iSkipCount, MIN( iArrayCount, 63 - iSkipCount ), pReturnAddressesOut, NULL );
return AppendParentStackTrace( pReturnAddressesOut, iArrayCount, iRetVal );
}
#endif
#if defined( USE_STACKWALK64 )
if( s_HelperFunctions.m_pStackWalk64 != StackWalk64_DummyFn )
{
int iInOutArrayCount = iArrayCount; //array count becomes both input and output with exception handler version
__try
{
::RaiseException( 0, EXCEPTION_NONCONTINUABLE, 0, NULL );
}
__except ( GetCallStackReturnAddresses_Exception( pReturnAddressesOut, &iInOutArrayCount, iSkipCount, GetExceptionInformation() ), EXCEPTION_EXECUTE_HANDLER )
{
return AppendParentStackTrace( pReturnAddressesOut, iArrayCount, iInOutArrayCount );
}
}
#endif
return GetCallStack_Fast( pReturnAddressesOut, iArrayCount, iSkipCount );
}
void SetStackTranslationSymbolSearchPath( const char *szSemicolonSeparatedList )
{
s_HelperFunctions.SetStackTranslationSymbolSearchPath( szSemicolonSeparatedList );
}
void StackToolsNotify_LoadedLibrary( const char *szLibName )
{
s_HelperFunctions.m_bShouldReloadSymbols = true;
}
int TranslateStackInfo( const void * const *pCallStack, int iCallStackCount, tchar *szOutput, int iOutBufferSize, const tchar *szEntrySeparator, TranslateStackInfo_StyleFlags_t style )
{
s_HelperFunctions.EnsureReady();
tchar *szStartOutput = szOutput;
if( szEntrySeparator == NULL )
szEntrySeparator = _T("");
int iSeparatorSize = (int)strlen( szEntrySeparator );
for( int i = 0; i < iCallStackCount; ++i )
{
if( !s_HelperFunctions.TranslatePointer( pCallStack[i], szOutput, iOutBufferSize, style ) )
{
return i;
}
int iLength = (int)strlen( szOutput );
szOutput += iLength;
iOutBufferSize -= iLength;
if( iOutBufferSize > iSeparatorSize )
{
memcpy( szOutput, szEntrySeparator, iSeparatorSize * sizeof( tchar ) );
szOutput += iSeparatorSize;
iOutBufferSize -= iSeparatorSize;
}
*szOutput = '\0';
}
szOutput -= iSeparatorSize;
if( szOutput >= szStartOutput )
*szOutput = '\0';
return iCallStackCount;
}
void PreloadStackInformation( void * const *pAddresses, int iAddressCount )
{
//nop on anything but 360
}
bool GetFileAndLineFromAddress( const void *pAddress, tchar *pFileNameOut, int iMaxFileNameLength, uint32 &iLineNumberOut, uint32 *pDisplacementOut )
{
s_HelperFunctions.EnsureReady();
return s_HelperFunctions.GetFileAndLineFromAddress( pAddress, pFileNameOut, iMaxFileNameLength, iLineNumberOut, pDisplacementOut );
}
bool GetSymbolNameFromAddress( const void *pAddress, tchar *pSymbolNameOut, int iMaxSymbolNameLength, uint64 *pDisplacementOut )
{
s_HelperFunctions.EnsureReady();
return s_HelperFunctions.GetSymbolNameFromAddress( pAddress, pSymbolNameOut, iMaxSymbolNameLength, pDisplacementOut );
}
bool GetModuleNameFromAddress( const void *pAddress, tchar *pModuleNameOut, int iMaxModuleNameLength )
{
s_HelperFunctions.EnsureReady();
return s_HelperFunctions.GetModuleNameFromAddress( pAddress, pModuleNameOut, iMaxModuleNameLength );
}
#else //#if defined( WIN32 ) && !defined( _X360 )
//===============================================================================================================
// X360 version of the toolset
//===============================================================================================================
class C360StackTranslationHelper
{
public:
C360StackTranslationHelper( void )
{
m_bInitialized = true;
}
~C360StackTranslationHelper( void )
{
StringSet_t::const_iterator iter;
//module names
{
iter = m_ModuleNameSet.begin();
while(iter != m_ModuleNameSet.end())
{
char *pModuleName = (char*)(*iter);
delete []pModuleName;
iter++;
}
m_ModuleNameSet.clear();
}
//file names
{
iter = m_FileNameSet.begin();
while(iter != m_FileNameSet.end())
{
char *pFileName = (char*)(*iter);
delete []pFileName;
iter++;
}
m_FileNameSet.clear();
}
//symbol names
{
iter = m_SymbolNameSet.begin();
while(iter != m_SymbolNameSet.end())
{
char *pSymbolName = (char*)(*iter);
delete []pSymbolName;
iter++;
}
m_SymbolNameSet.clear();
}
m_bInitialized = false;
}
private:
struct StackAddressInfo_t;
public:
inline StackAddressInfo_t *CreateEntry( const FullStackInfo_t &info )
{
std::pair<AddressInfoMapIter_t, bool> retval = m_AddressInfoMap.insert( AddressInfoMapEntry_t( info.pAddress, StackAddressInfo_t() ) );
if( retval.first->second.szModule != NULL )
return &retval.first->second; //already initialized
retval.first->second.iLine = info.iLine;
//share strings
//module
{
const char *pModuleName;
StringSet_t::const_iterator iter = m_ModuleNameSet.find( info.szModuleName );
if ( iter == m_ModuleNameSet.end() )
{
int nLen = strlen(info.szModuleName) + 1;
pModuleName = new char [nLen];
memcpy( (char *)pModuleName, info.szModuleName, nLen );
m_ModuleNameSet.insert( pModuleName );
}
else
{
pModuleName = (char *)(*iter);
}
retval.first->second.szModule = pModuleName;
}
//file
{
const char *pFileName;
StringSet_t::const_iterator iter = m_FileNameSet.find( info.szFileName );
if ( iter == m_FileNameSet.end() )
{
int nLen = strlen(info.szFileName) + 1;
pFileName = new char [nLen];
memcpy( (char *)pFileName, info.szFileName, nLen );
m_FileNameSet.insert( pFileName );
}
else
{
pFileName = (char *)(*iter);
}
retval.first->second.szFileName = pFileName;
}
//symbol
{
const char *pSymbolName;
StringSet_t::const_iterator iter = m_SymbolNameSet.find( info.szSymbol );
if ( iter == m_SymbolNameSet.end() )
{
int nLen = strlen(info.szSymbol) + 1;
pSymbolName = new char [nLen];
memcpy( (char *)pSymbolName, info.szSymbol, nLen );
m_SymbolNameSet.insert( pSymbolName );
}
else
{
pSymbolName = (char *)(*iter);
}
retval.first->second.szSymbol = pSymbolName;
}
return &retval.first->second;
}
inline StackAddressInfo_t *FindInfoEntry( const void *pAddress )
{
AddressInfoMapIter_t Iter = m_AddressInfoMap.find( pAddress );
if( Iter != m_AddressInfoMap.end() )
return &Iter->second;
return NULL;
}
inline int RetrieveStackInfo( const void * const *pAddresses, FullStackInfo_t *pReturnedStructs, int iAddressCount )
{
int ReturnedTranslatedCount = -1;
//construct the message
// Header Finished Count(out) Input Count Input Array Returned data write address
int iMessageSize = 2 + sizeof( int * ) + sizeof( uint32 ) + (sizeof( void * ) * iAddressCount) + sizeof( FullStackInfo_t * );
uint8 *pMessage = (uint8 *)stackalloc( iMessageSize );
uint8 *pMessageWrite = pMessage;
pMessageWrite[0] = XBX_DBG_BNH_STACKTRANSLATOR; //have this message handled by stack translator handler
pMessageWrite[1] = ST_BHC_GETTRANSLATIONINFO;
pMessageWrite += 2;
*(int **)pMessageWrite = (int *)BigDWord( (DWORD)&ReturnedTranslatedCount );
pMessageWrite += sizeof( int * );
*(uint32 *)pMessageWrite = (uint32)BigDWord( (DWORD)iAddressCount );
pMessageWrite += sizeof( uint32 );
memcpy( pMessageWrite, pAddresses, iAddressCount * sizeof( void * ) );
pMessageWrite += iAddressCount * sizeof( void * );
*(FullStackInfo_t **)pMessageWrite = (FullStackInfo_t *)BigDWord( (DWORD)pReturnedStructs );
bool bSuccess = XBX_SendBinaryData( pMessage, iMessageSize, false, 30000 );
ReturnedTranslatedCount = BigDWord( ReturnedTranslatedCount );
if( bSuccess && (ReturnedTranslatedCount > 0) )
{
return ReturnedTranslatedCount;
}
return 0;
}
inline StackAddressInfo_t *CreateEntry( const void *pAddress )
{
//ask VXConsole for information about the addresses we're clueless about
FullStackInfo_t ReturnedData;
ReturnedData.pAddress = pAddress;
ReturnedData.szFileName[0] = '\0'; //strncpy( ReturnedData.szFileName, "FileUninitialized", sizeof( ReturnedData.szFileName ) );
ReturnedData.szModuleName[0] = '\0'; //strncpy( ReturnedData.szModuleName, "ModuleUninitialized", sizeof( ReturnedData.szModuleName ) );
ReturnedData.szSymbol[0] = '\0'; //strncpy( ReturnedData.szSymbol, "SymbolUninitialized", sizeof( ReturnedData.szSymbol ) );
ReturnedData.iLine = 0;
ReturnedData.iSymbolOffset = 0;
int iTranslated = RetrieveStackInfo( &pAddress, &ReturnedData, 1 );
if( iTranslated == 1 )
{
//store
return CreateEntry( ReturnedData );
}
return FindInfoEntry( pAddress ); //probably won't work, but last ditch.
}
inline StackAddressInfo_t *FindOrCreateEntry( const void *pAddress )
{
StackAddressInfo_t *pReturn = FindInfoEntry( pAddress );
if( pReturn == NULL )
{
pReturn = CreateEntry( pAddress );
}
return pReturn;
}
inline void LoadStackInformation( void * const *pAddresses, int iAddressCount )
{
Assert( (iAddressCount > 0) && (pAddresses != NULL) );
int iNeedLoading = 0;
void **pNeedLoading = (void **)stackalloc( sizeof( const void * ) * iAddressCount ); //addresses we need to ask VXConsole about
for( int i = 0; i != iAddressCount; ++i )
{
if( FindInfoEntry( pAddresses[i] ) == NULL )
{
//need to load this address
pNeedLoading[iNeedLoading] = pAddresses[i];
++iNeedLoading;
}
}
if( iNeedLoading != 0 )
{
//ask VXConsole for information about the addresses we're clueless about
FullStackInfo_t *pReturnedStructs = (FullStackInfo_t *)stackalloc( sizeof( FullStackInfo_t ) * iNeedLoading );
for( int i = 0; i < iNeedLoading; ++i )
{
pReturnedStructs[i].pAddress = 0;
pReturnedStructs[i].szFileName[0] = '\0'; //strncpy( pReturnedStructs[i].szFileName, "FileUninitialized", sizeof( pReturnedStructs[i].szFileName ) );
pReturnedStructs[i].szModuleName[0] = '\0'; //strncpy( pReturnedStructs[i].szModuleName, "ModuleUninitialized", sizeof( pReturnedStructs[i].szModuleName ) );
pReturnedStructs[i].szSymbol[0] = '\0'; //strncpy( pReturnedStructs[i].szSymbol, "SymbolUninitialized", sizeof( pReturnedStructs[i].szSymbol ) );
pReturnedStructs[i].iLine = 0;
pReturnedStructs[i].iSymbolOffset = 0;
}
int iTranslated = RetrieveStackInfo( pNeedLoading, pReturnedStructs, iNeedLoading );
if( iTranslated == iNeedLoading )
{
//store
for( int i = 0; i < iTranslated; ++i )
{
CreateEntry( pReturnedStructs[i] );
}
}
}
}
inline bool GetFileAndLineFromAddress( const void *pAddress, tchar *pFileNameOut, int iMaxFileNameLength, uint32 &iLineNumberOut, uint32 *pDisplacementOut )
{
StackAddressInfo_t *pInfo = FindOrCreateEntry( pAddress );
if( pInfo && (pInfo->szFileName[0] != '\0') )
{
strncpy( pFileNameOut, pInfo->szFileName, iMaxFileNameLength );
iLineNumberOut = pInfo->iLine;
if( pDisplacementOut )
*pDisplacementOut = 0; //can't get line displacement on 360
return true;
}
return false;
}
inline bool GetSymbolNameFromAddress( const void *pAddress, tchar *pSymbolNameOut, int iMaxSymbolNameLength, uint64 *pDisplacementOut )
{
StackAddressInfo_t *pInfo = FindOrCreateEntry( pAddress );
if( pInfo && (pInfo->szSymbol[0] != '\0') )
{
strncpy( pSymbolNameOut, pInfo->szSymbol, iMaxSymbolNameLength );
if( pDisplacementOut )
*pDisplacementOut = pInfo->iSymbolOffset;
return true;
}
return false;
}
inline bool GetModuleNameFromAddress( const void *pAddress, tchar *pModuleNameOut, int iMaxModuleNameLength )
{
StackAddressInfo_t *pInfo = FindOrCreateEntry( pAddress );
if( pInfo && (pInfo->szModule[0] != '\0') )
{
strncpy( pModuleNameOut, pInfo->szModule, iMaxModuleNameLength );
return true;
}
return false;
}
CThreadFastMutex m_hMutex;
private:
#pragma pack(push)
#pragma pack(1)
struct StackAddressInfo_t
{
StackAddressInfo_t( void ) : szModule(NULL), szFileName(NULL), szSymbol(NULL), iLine(0), iSymbolOffset(0) {}
const char *szModule;
const char *szFileName;
const char *szSymbol;
uint32 iLine;
uint32 iSymbolOffset;
};
#pragma pack(pop)
typedef std::map< const void *, StackAddressInfo_t, std::less<const void *>> AddressInfoMap_t;
typedef AddressInfoMap_t::iterator AddressInfoMapIter_t;
typedef AddressInfoMap_t::value_type AddressInfoMapEntry_t;
class CStringLess
{
public:
bool operator()(const char *pszLeft, const char *pszRight ) const
{
return ( V_tier0_stricmp( pszLeft, pszRight ) < 0 );
}
};
typedef std::set<const char *, CStringLess> StringSet_t;
AddressInfoMap_t m_AddressInfoMap; //TODO: retire old entries?
StringSet_t m_ModuleNameSet;
StringSet_t m_FileNameSet;
StringSet_t m_SymbolNameSet;
bool m_bInitialized;
};
static C360StackTranslationHelper s_360StackTranslator;
int GetCallStack( void **pReturnAddressesOut, int iArrayCount, int iSkipCount )
{
++iSkipCount; //skip this function
//DmCaptureStackBackTrace() has no skip functionality, so we need to grab everything and skip within that list
void **pAllResults = (void **)stackalloc( sizeof( void * ) * (iArrayCount + iSkipCount) );
if( DmCaptureStackBackTrace( iArrayCount + iSkipCount, pAllResults ) == XBDM_NOERR )
{
for( int i = 0; i != iSkipCount; ++i )
{
if( *pAllResults == NULL ) //DmCaptureStackBackTrace() NULL terminates the list instead of telling us how many were returned
return AppendParentStackTrace( pReturnAddressesOut, iArrayCount, 0 );
++pAllResults; //move the pointer forward so the second loop indices match up
}
for( int i = 0; i != iArrayCount; ++i )
{
if( pAllResults[i] == NULL ) //DmCaptureStackBackTrace() NULL terminates the list instead of telling us how many were returned
return AppendParentStackTrace( pReturnAddressesOut, iArrayCount, i );
pReturnAddressesOut[i] = pAllResults[i];
}
return iArrayCount; //no room to append parent
}
return GetCallStack_Fast( pReturnAddressesOut, iArrayCount, iSkipCount );
}
void SetStackTranslationSymbolSearchPath( const char *szSemicolonSeparatedList )
{
//nop on 360
}
void StackToolsNotify_LoadedLibrary( const char *szLibName )
{
//send off the notice to VXConsole
uint8 message[2];
message[0] = XBX_DBG_BNH_STACKTRANSLATOR; //have this message handled by stack translator handler
message[1] = ST_BHC_LOADEDLIBARY; //loaded a library notification
XBX_SendBinaryData( message, 2 );
}
int TranslateStackInfo( const void * const *pCallStack, int iCallStackCount, tchar *szOutput, int iOutBufferSize, const tchar *szEntrySeparator, TranslateStackInfo_StyleFlags_t style )
{
if( iCallStackCount == 0 )
{
if( iOutBufferSize > 1 )
*szOutput = '\0';
return 0;
}
if( szEntrySeparator == NULL )
szEntrySeparator = "";
int iSeparatorLength = strlen( szEntrySeparator ) + 1;
int iDataSize = (sizeof( void * ) * iCallStackCount) + (iSeparatorLength * sizeof( tchar )) + 1; //1 for style flags
//360 is incapable of translation on it's own. Encode the stack for translation in VXConsole
//Encoded section is as such ":CSDECODE[encoded binary]"
int iEncodedSize = -EncodeBinaryToString( NULL, iDataSize, NULL, 0 ); //get needed buffer size
static const tchar cControlPrefix[] = XBX_CALLSTACKDECODEPREFIX;
const size_t cControlLength = (sizeof( cControlPrefix )/sizeof(tchar)) - 1; //-1 to remove null terminator
if( iOutBufferSize > (iEncodedSize + (int)cControlLength + 2) ) //+2 for ']' and null term
{
COMPILE_TIME_ASSERT( TSISTYLEFLAG_LAST < (1<<8) ); //need to update the encoder/decoder to use more than a byte for style flags
uint8 *pData = (uint8 *)stackalloc( iDataSize );
pData[0] = (uint8)style;
memcpy( pData + 1, szEntrySeparator, iSeparatorLength * sizeof( tchar ) );
memcpy( pData + 1 + (iSeparatorLength * sizeof( tchar )), pCallStack, iCallStackCount * sizeof( void * ) );
memcpy( szOutput, XBX_CALLSTACKDECODEPREFIX, cControlLength * sizeof( tchar ) );
int iLength = cControlLength + EncodeBinaryToString( pData, iDataSize, &szOutput[cControlLength], (iOutBufferSize - cControlLength) );
szOutput[iLength] = ']';
szOutput[iLength + 1] = '\0';
}
return iCallStackCount;
}
void PreloadStackInformation( void * const *pAddresses, int iAddressCount )
{
AUTO_LOCK( s_360StackTranslator.m_hMutex );
s_360StackTranslator.LoadStackInformation( pAddresses, iAddressCount );
}
bool GetFileAndLineFromAddress( const void *pAddress, tchar *pFileNameOut, int iMaxFileNameLength, uint32 &iLineNumberOut, uint32 *pDisplacementOut )
{
AUTO_LOCK( s_360StackTranslator.m_hMutex );
return s_360StackTranslator.GetFileAndLineFromAddress( pAddress, pFileNameOut, iMaxFileNameLength, iLineNumberOut, pDisplacementOut );
}
bool GetSymbolNameFromAddress( const void *pAddress, tchar *pSymbolNameOut, int iMaxSymbolNameLength, uint64 *pDisplacementOut )
{
AUTO_LOCK( s_360StackTranslator.m_hMutex );
return s_360StackTranslator.GetSymbolNameFromAddress( pAddress, pSymbolNameOut, iMaxSymbolNameLength, pDisplacementOut );
}
bool GetModuleNameFromAddress( const void *pAddress, tchar *pModuleNameOut, int iMaxModuleNameLength )
{
AUTO_LOCK( s_360StackTranslator.m_hMutex );
return s_360StackTranslator.GetModuleNameFromAddress( pAddress, pModuleNameOut, iMaxModuleNameLength );
}
#endif //#else //#if defined( WIN32 ) && !defined( _X360 )
#endif //#if !defined( ENABLE_RUNTIME_STACK_TRANSLATION )
CCallStackStorage::CCallStackStorage( FN_GetCallStack GetStackFunction, uint32 iSkipCalls )
{
iValidEntries = GetStackFunction( pStack, ARRAYSIZE( pStack ), iSkipCalls + 1 );
}
CStackTop_CopyParentStack::CStackTop_CopyParentStack( void * const *pParentStackTrace, int iParentStackTraceLength )
{
#if defined( ENABLE_RUNTIME_STACK_TRANSLATION )
//miniature version of GetCallStack_Fast()
#if (defined( TIER0_FPO_DISABLED ) || defined( _DEBUG )) &&\
(defined( WIN32 ) && !defined( _X360 ) && !defined(_M_X64))
void *pStackCrawlEBP;
__asm
{
mov [pStackCrawlEBP], ebp;
}
pStackCrawlEBP = *(void **)pStackCrawlEBP;
m_pReplaceAddress = *((void **)pStackCrawlEBP + 1);
m_pStackBase = (void *)((void **)pStackCrawlEBP + 1);
#else
m_pReplaceAddress = NULL;
m_pStackBase = this;
#endif
m_pParentStackTrace = NULL;
if( (pParentStackTrace != NULL) && (iParentStackTraceLength > 0) )
{
while( (iParentStackTraceLength > 0) && (pParentStackTrace[iParentStackTraceLength - 1] == NULL) )
{
--iParentStackTraceLength;
}
if( iParentStackTraceLength > 0 )
{
m_pParentStackTrace = new void * [iParentStackTraceLength];
memcpy( (void **)m_pParentStackTrace, pParentStackTrace, sizeof( void * ) * iParentStackTraceLength );
}
}
m_iParentStackTraceLength = iParentStackTraceLength;
m_pPrevTop = g_StackTop;
g_StackTop = this;
Assert( (CStackTop_Base *)g_StackTop == this );
#endif //#if defined( ENABLE_RUNTIME_STACK_TRANSLATION )
}
CStackTop_CopyParentStack::~CStackTop_CopyParentStack( void )
{
#if defined( ENABLE_RUNTIME_STACK_TRANSLATION )
Assert( (CStackTop_Base *)g_StackTop == this );
g_StackTop = m_pPrevTop;
if( m_pParentStackTrace != NULL )
{
delete []m_pParentStackTrace;
}
#endif
}
CStackTop_ReferenceParentStack::CStackTop_ReferenceParentStack( void * const *pParentStackTrace, int iParentStackTraceLength )
{
#if defined( ENABLE_RUNTIME_STACK_TRANSLATION )
//miniature version of GetCallStack_Fast()
#if (defined( TIER0_FPO_DISABLED ) || defined( _DEBUG )) &&\
(defined( WIN32 ) && !defined( _X360 ) && !defined(_M_X64))
void *pStackCrawlEBP;
__asm
{
mov [pStackCrawlEBP], ebp;
}
pStackCrawlEBP = *(void **)pStackCrawlEBP;
m_pReplaceAddress = *((void **)pStackCrawlEBP + 1);
m_pStackBase = (void *)((void **)pStackCrawlEBP + 1);
#else
m_pReplaceAddress = NULL;
m_pStackBase = this;
#endif
m_pParentStackTrace = pParentStackTrace;
if( (pParentStackTrace != NULL) && (iParentStackTraceLength > 0) )
{
while( (iParentStackTraceLength > 0) && (pParentStackTrace[iParentStackTraceLength - 1] == NULL) )
{
--iParentStackTraceLength;
}
}
m_iParentStackTraceLength = iParentStackTraceLength;
m_pPrevTop = g_StackTop;
g_StackTop = this;
Assert( (CStackTop_Base *)g_StackTop == this );
#endif //#if defined( ENABLE_RUNTIME_STACK_TRANSLATION )
}
CStackTop_ReferenceParentStack::~CStackTop_ReferenceParentStack( void )
{
#if defined( ENABLE_RUNTIME_STACK_TRANSLATION )
Assert( (CStackTop_Base *)g_StackTop == this );
g_StackTop = m_pPrevTop;
ReleaseParentStackReferences();
#endif
}
void CStackTop_ReferenceParentStack::ReleaseParentStackReferences( void )
{
#if defined( ENABLE_RUNTIME_STACK_TRANSLATION )
m_pParentStackTrace = NULL;
m_iParentStackTraceLength = 0;
#endif
}
//Encodes data so that every byte's most significant bit is a 1. Ensuring no null terminators.
//This puts the encoded data in the 128-255 value range. Leaving all standard ascii characters for control.
//Returns string length (not including the written null terminator as is standard).
//Or if the buffer is too small. Returns negative of necessary buffer size (including room needed for null terminator)
int EncodeBinaryToString( const void *pToEncode, int iDataLength, char *pEncodeOut, int iEncodeBufferSize )
{
int iEncodedSize = iDataLength;
iEncodedSize += (iEncodedSize + 6) / 7; //Have 1 control byte for every 7 actual bytes
iEncodedSize += sizeof( uint32 ) + 1; //data size at the beginning of the blob and null terminator at the end
if( (iEncodedSize > iEncodeBufferSize) || (pEncodeOut == NULL) || (pToEncode == NULL) )
return -iEncodedSize; //not enough room
uint8 *pEncodeWrite = (uint8 *)pEncodeOut;
//first encode the data size. Encodes lowest 28 bits and discards the high 4
pEncodeWrite[0] = ((iDataLength >> 21) & 0xFF) | 0x80;
pEncodeWrite[1] = ((iDataLength >> 14) & 0xFF) | 0x80;
pEncodeWrite[2] = ((iDataLength >> 7) & 0xFF) | 0x80;
pEncodeWrite[3] = ((iDataLength >> 0) & 0xFF) | 0x80;
pEncodeWrite += 4;
const uint8 *pEncodeRead = (const uint8 *)pToEncode;
const uint8 *pEncodeStop = pEncodeRead + iDataLength;
uint8 *pEncodeWriteLastControlByte = pEncodeWrite;
int iControl = 0;
//Encode the data
while( pEncodeRead < pEncodeStop )
{
if( iControl == 0 )
{
pEncodeWriteLastControlByte = pEncodeWrite;
*pEncodeWriteLastControlByte = 0x80;
}
else
{
*pEncodeWrite = *pEncodeRead | 0x80; //encoded data always has the MSB bit set (cheap avoidance of null terminators)
*pEncodeWriteLastControlByte |= (((*pEncodeRead) & 0x80) ^ 0x80) >> iControl; //We use the control byte to XOR the MSB back to original values on decode
++pEncodeRead;
}
++pEncodeWrite;
++iControl;
iControl &= 7; //8->0
}
*pEncodeWrite = '\0';
return iEncodedSize - 1;
}
//Decodes a string produced by EncodeBinaryToString(). Safe to decode in place if you don't mind trashing your string, binary byte count always less than string byte count.
//Returns:
// >= 0 is the decoded data size
// INT_MIN (most negative value possible) indicates an improperly formatted string (not our data)
// all other negative values are the negative of how much dest buffer size is necessary.
int DecodeBinaryFromString( const char *pString, void *pDestBuffer, int iDestBufferSize, char **ppParseFinishOut )
{
const uint8 *pDecodeRead = (const uint8 *)pString;
if( (pDecodeRead[0] < 0x80) || (pDecodeRead[1] < 0x80) || (pDecodeRead[2] < 0x80) || (pDecodeRead[3] < 0x80) )
{
if( ppParseFinishOut != NULL )
*ppParseFinishOut = (char *)pString;
return INT_MIN; //Don't know what the string is, but it's not our format
}
int iDecodedSize = 0;
iDecodedSize |= (pDecodeRead[0] & 0x7F) << 21;
iDecodedSize |= (pDecodeRead[1] & 0x7F) << 14;
iDecodedSize |= (pDecodeRead[2] & 0x7F) << 7;
iDecodedSize |= (pDecodeRead[3] & 0x7F) << 0;
pDecodeRead += 4;
int iTextLength = iDecodedSize;
iTextLength += (iTextLength + 6) / 7; //Have 1 control byte for every 7 actual bytes
//make sure it's formatted properly
for( int i = 0; i != iTextLength; ++i )
{
if( pDecodeRead[i] < 0x80 ) //encoded data always has MSB set
{
if( ppParseFinishOut != NULL )
*ppParseFinishOut = (char *)pString;
return INT_MIN; //either not our data, or part of the string is missing
}
}
if( iDestBufferSize < iDecodedSize )
{
if( ppParseFinishOut != NULL )
*ppParseFinishOut = (char *)pDecodeRead;
return -iDecodedSize; //dest buffer not big enough to hold the data
}
const uint8 *pStopDecoding = pDecodeRead + iTextLength;
uint8 *pDecodeWrite = (uint8 *)pDestBuffer;
int iControl = 0;
int iLSBXOR = 0;
while( pDecodeRead < pStopDecoding )
{
if( iControl == 0 )
{
iLSBXOR = *pDecodeRead;
}
else
{
*pDecodeWrite = *pDecodeRead ^ ((iLSBXOR << iControl) & 0x80);
++pDecodeWrite;
}
++pDecodeRead;
++iControl;
iControl &= 7; //8->0
}
if( ppParseFinishOut != NULL )
*ppParseFinishOut = (char *)pDecodeRead;
return iDecodedSize;
}