//===== Copyright © 1996-2005, Valve Corporation, All rights reserved. ======//
//
// 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

#if defined( LINUX )
#include <execinfo.h>
#endif

#include "tier0/valve_on.h"

#include "tier0/memdbgon.h"


#if !defined( ENABLE_RUNTIME_STACK_TRANSLATION ) //disable the whole toolset

#if defined( LINUX )

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;	
}