486 lines
14 KiB
C++
486 lines
14 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose: Memory allocation!
|
|
//
|
|
// $NoKeywords: $
|
|
//=============================================================================//
|
|
|
|
#include "pch_tier0.h"
|
|
|
|
#ifndef STEAM
|
|
|
|
#ifdef TIER0_VALIDATE_HEAP
|
|
|
|
#include <malloc.h>
|
|
#include "tier0/dbg.h"
|
|
#include "tier0/memalloc.h"
|
|
#include "mem_helpers.h"
|
|
|
|
extern IMemAlloc *g_pActualAlloc;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// NOTE! This should never be called directly from leaf code
|
|
// Just use new,delete,malloc,free etc. They will call into this eventually
|
|
//-----------------------------------------------------------------------------
|
|
class CValidateAlloc : public IMemAlloc
|
|
{
|
|
public:
|
|
enum
|
|
{
|
|
HEAP_PREFIX_BUFFER_SIZE = 12,
|
|
HEAP_SUFFIX_BUFFER_SIZE = 8,
|
|
};
|
|
|
|
CValidateAlloc();
|
|
|
|
// Release versions
|
|
virtual void *Alloc( size_t nSize );
|
|
virtual void *Realloc( void *pMem, size_t nSize );
|
|
virtual void Free( void *pMem );
|
|
virtual void *Expand_NoLongerSupported( void *pMem, size_t nSize );
|
|
|
|
// Debug versions
|
|
virtual void *Alloc( size_t nSize, const char *pFileName, int nLine );
|
|
virtual void *Realloc( void *pMem, size_t nSize, const char *pFileName, int nLine );
|
|
virtual void Free( void *pMem, const char *pFileName, int nLine );
|
|
virtual void *Expand_NoLongerSupported( void *pMem, size_t nSize, const char *pFileName, int nLine );
|
|
|
|
// Returns size of a particular allocation
|
|
virtual size_t GetSize( void *pMem );
|
|
|
|
// Force file + line information for an allocation
|
|
virtual void PushAllocDbgInfo( const char *pFileName, int nLine );
|
|
virtual void PopAllocDbgInfo();
|
|
|
|
virtual long CrtSetBreakAlloc( long lNewBreakAlloc );
|
|
virtual int CrtSetReportMode( int nReportType, int nReportMode );
|
|
virtual int CrtIsValidHeapPointer( const void *pMem );
|
|
virtual int CrtIsValidPointer( const void *pMem, unsigned int size, int access );
|
|
virtual int CrtCheckMemory( void );
|
|
virtual int CrtSetDbgFlag( int nNewFlag );
|
|
virtual void CrtMemCheckpoint( _CrtMemState *pState );
|
|
void* CrtSetReportFile( int nRptType, void* hFile );
|
|
void* CrtSetReportHook( void* pfnNewHook );
|
|
int CrtDbgReport( int nRptType, const char * szFile,
|
|
int nLine, const char * szModule, const char * pMsg );
|
|
virtual int heapchk();
|
|
|
|
virtual void DumpStats() {}
|
|
virtual void DumpStatsFileBase( char const *pchFileBase ) {}
|
|
|
|
virtual bool IsDebugHeap()
|
|
{
|
|
return true;
|
|
}
|
|
|
|
virtual int GetVersion() { return MEMALLOC_VERSION; }
|
|
|
|
virtual void CompactHeap();
|
|
virtual MemAllocFailHandler_t SetAllocFailHandler( MemAllocFailHandler_t pfnMemAllocFailHandler );
|
|
|
|
virtual uint32 GetDebugInfoSize() { return 0; }
|
|
virtual void SaveDebugInfo( void *pvDebugInfo ) { }
|
|
virtual void RestoreDebugInfo( const void *pvDebugInfo ) {}
|
|
virtual void InitDebugInfo( void *pvDebugInfo, const char *pchRootFileName, int nLine ) {}
|
|
|
|
private:
|
|
struct HeapPrefix_t
|
|
{
|
|
HeapPrefix_t *m_pPrev;
|
|
HeapPrefix_t *m_pNext;
|
|
int m_nSize;
|
|
unsigned char m_Prefix[HEAP_PREFIX_BUFFER_SIZE];
|
|
};
|
|
|
|
struct HeapSuffix_t
|
|
{
|
|
unsigned char m_Suffix[HEAP_SUFFIX_BUFFER_SIZE];
|
|
};
|
|
|
|
private:
|
|
// Returns the actual debug info
|
|
void GetActualDbgInfo( const char *&pFileName, int &nLine );
|
|
|
|
// Updates stats
|
|
void RegisterAllocation( const char *pFileName, int nLine, int nLogicalSize, int nActualSize, unsigned nTime );
|
|
void RegisterDeallocation( const char *pFileName, int nLine, int nLogicalSize, int nActualSize, unsigned nTime );
|
|
|
|
HeapSuffix_t *Suffix( HeapPrefix_t *pPrefix );
|
|
void *AllocationStart( HeapPrefix_t *pBase );
|
|
HeapPrefix_t *PrefixFromAllocation( void *pAlloc );
|
|
const HeapPrefix_t *PrefixFromAllocation( const void *pAlloc );
|
|
|
|
// Add to the list!
|
|
void AddToList( HeapPrefix_t *pHeap, int nSize );
|
|
|
|
// Remove from the list!
|
|
void RemoveFromList( HeapPrefix_t *pHeap );
|
|
|
|
// Validate the allocation
|
|
bool ValidateAllocation( HeapPrefix_t *pHeap );
|
|
|
|
private:
|
|
HeapPrefix_t *m_pFirstAllocation;
|
|
char m_pPrefixImage[HEAP_PREFIX_BUFFER_SIZE];
|
|
char m_pSuffixImage[HEAP_SUFFIX_BUFFER_SIZE];
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Singleton...
|
|
//-----------------------------------------------------------------------------
|
|
static CValidateAlloc s_ValidateAlloc;
|
|
IMemAlloc *g_pMemAlloc = &s_ValidateAlloc;
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Constructor.
|
|
//-----------------------------------------------------------------------------
|
|
CValidateAlloc::CValidateAlloc()
|
|
{
|
|
m_pFirstAllocation = 0;
|
|
memset( m_pPrefixImage, 0xBE, HEAP_PREFIX_BUFFER_SIZE );
|
|
memset( m_pSuffixImage, 0xAF, HEAP_SUFFIX_BUFFER_SIZE );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Accessors...
|
|
//-----------------------------------------------------------------------------
|
|
inline CValidateAlloc::HeapSuffix_t *CValidateAlloc::Suffix( HeapPrefix_t *pPrefix )
|
|
{
|
|
return reinterpret_cast<HeapSuffix_t *>( (unsigned char*)( pPrefix + 1 ) + pPrefix->m_nSize );
|
|
}
|
|
|
|
inline void *CValidateAlloc::AllocationStart( HeapPrefix_t *pBase )
|
|
{
|
|
return static_cast<void *>( pBase + 1 );
|
|
}
|
|
|
|
inline CValidateAlloc::HeapPrefix_t *CValidateAlloc::PrefixFromAllocation( void *pAlloc )
|
|
{
|
|
if ( !pAlloc )
|
|
return NULL;
|
|
|
|
return ((HeapPrefix_t*)pAlloc) - 1;
|
|
}
|
|
|
|
inline const CValidateAlloc::HeapPrefix_t *CValidateAlloc::PrefixFromAllocation( const void *pAlloc )
|
|
{
|
|
return ((const HeapPrefix_t*)pAlloc) - 1;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Add to the list!
|
|
//-----------------------------------------------------------------------------
|
|
void CValidateAlloc::AddToList( HeapPrefix_t *pHeap, int nSize )
|
|
{
|
|
pHeap->m_pPrev = NULL;
|
|
pHeap->m_pNext = m_pFirstAllocation;
|
|
if ( m_pFirstAllocation )
|
|
{
|
|
m_pFirstAllocation->m_pPrev = pHeap;
|
|
}
|
|
pHeap->m_nSize = nSize;
|
|
|
|
m_pFirstAllocation = pHeap;
|
|
|
|
HeapSuffix_t *pSuffix = Suffix( pHeap );
|
|
memcpy( pHeap->m_Prefix, m_pPrefixImage, HEAP_PREFIX_BUFFER_SIZE );
|
|
memcpy( pSuffix->m_Suffix, m_pSuffixImage, HEAP_SUFFIX_BUFFER_SIZE );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Remove from the list!
|
|
//-----------------------------------------------------------------------------
|
|
void CValidateAlloc::RemoveFromList( HeapPrefix_t *pHeap )
|
|
{
|
|
if ( !pHeap )
|
|
return;
|
|
|
|
ValidateAllocation( pHeap );
|
|
if ( pHeap->m_pPrev )
|
|
{
|
|
pHeap->m_pPrev->m_pNext = pHeap->m_pNext;
|
|
}
|
|
else
|
|
{
|
|
m_pFirstAllocation = pHeap->m_pNext;
|
|
}
|
|
|
|
if ( pHeap->m_pNext )
|
|
{
|
|
pHeap->m_pNext->m_pPrev = pHeap->m_pPrev;
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Validate the allocation
|
|
//-----------------------------------------------------------------------------
|
|
bool CValidateAlloc::ValidateAllocation( HeapPrefix_t *pHeap )
|
|
{
|
|
HeapSuffix_t *pSuffix = Suffix( pHeap );
|
|
|
|
bool bOk = true;
|
|
if ( memcmp( pHeap->m_Prefix, m_pPrefixImage, HEAP_PREFIX_BUFFER_SIZE ) )
|
|
{
|
|
bOk = false;
|
|
}
|
|
|
|
if ( memcmp( pSuffix->m_Suffix, m_pSuffixImage, HEAP_SUFFIX_BUFFER_SIZE ) )
|
|
{
|
|
bOk = false;
|
|
}
|
|
|
|
if ( !bOk )
|
|
{
|
|
Warning("Memory trash detected in allocation %X!\n", (void*)(pHeap+1) );
|
|
Assert( 0 );
|
|
}
|
|
|
|
return bOk;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Release versions
|
|
//-----------------------------------------------------------------------------
|
|
void *CValidateAlloc::Alloc( size_t nSize )
|
|
{
|
|
Assert( heapchk() == _HEAPOK );
|
|
Assert( CrtCheckMemory() );
|
|
int nActualSize = nSize + sizeof(HeapPrefix_t) + sizeof(HeapSuffix_t);
|
|
HeapPrefix_t *pHeap = (HeapPrefix_t*)g_pActualAlloc->Alloc( nActualSize );
|
|
AddToList( pHeap, nSize );
|
|
return AllocationStart( pHeap );
|
|
}
|
|
|
|
void *CValidateAlloc::Realloc( void *pMem, size_t nSize )
|
|
{
|
|
Assert( heapchk() == _HEAPOK );
|
|
Assert( CrtCheckMemory() );
|
|
HeapPrefix_t *pHeap = PrefixFromAllocation( pMem );
|
|
RemoveFromList( pHeap );
|
|
|
|
int nActualSize = nSize + sizeof(HeapPrefix_t) + sizeof(HeapSuffix_t);
|
|
pHeap = (HeapPrefix_t*)g_pActualAlloc->Realloc( pHeap, nActualSize );
|
|
AddToList( pHeap, nSize );
|
|
|
|
return AllocationStart( pHeap );
|
|
}
|
|
|
|
void CValidateAlloc::Free( void *pMem )
|
|
{
|
|
Assert( heapchk() == _HEAPOK );
|
|
Assert( CrtCheckMemory() );
|
|
HeapPrefix_t *pHeap = PrefixFromAllocation( pMem );
|
|
RemoveFromList( pHeap );
|
|
|
|
g_pActualAlloc->Free( pHeap );
|
|
}
|
|
|
|
void *CValidateAlloc::Expand_NoLongerSupported( void *pMem, size_t nSize )
|
|
{
|
|
Assert( heapchk() == _HEAPOK );
|
|
Assert( CrtCheckMemory() );
|
|
HeapPrefix_t *pHeap = PrefixFromAllocation( pMem );
|
|
RemoveFromList( pHeap );
|
|
|
|
int nActualSize = nSize + sizeof(HeapPrefix_t) + sizeof(HeapSuffix_t);
|
|
pHeap = (HeapPrefix_t*)g_pActualAlloc->Expand_NoLongerSupported( pHeap, nActualSize );
|
|
AddToList( pHeap, nSize );
|
|
|
|
return AllocationStart( pHeap );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Debug versions
|
|
//-----------------------------------------------------------------------------
|
|
void *CValidateAlloc::Alloc( size_t nSize, const char *pFileName, int nLine )
|
|
{
|
|
Assert( heapchk() == _HEAPOK );
|
|
Assert( CrtCheckMemory() );
|
|
int nActualSize = nSize + sizeof(HeapPrefix_t) + sizeof(HeapSuffix_t);
|
|
HeapPrefix_t *pHeap = (HeapPrefix_t*)g_pActualAlloc->Alloc( nActualSize, pFileName, nLine );
|
|
AddToList( pHeap, nSize );
|
|
return AllocationStart( pHeap );
|
|
}
|
|
|
|
void *CValidateAlloc::Realloc( void *pMem, size_t nSize, const char *pFileName, int nLine )
|
|
{
|
|
Assert( heapchk() == _HEAPOK );
|
|
Assert( CrtCheckMemory() );
|
|
HeapPrefix_t *pHeap = PrefixFromAllocation( pMem );
|
|
RemoveFromList( pHeap );
|
|
|
|
int nActualSize = nSize + sizeof(HeapPrefix_t) + sizeof(HeapSuffix_t);
|
|
pHeap = (HeapPrefix_t*)g_pActualAlloc->Realloc( pHeap, nActualSize, pFileName, nLine );
|
|
AddToList( pHeap, nSize );
|
|
|
|
return AllocationStart( pHeap );
|
|
}
|
|
|
|
void CValidateAlloc::Free( void *pMem, const char *pFileName, int nLine )
|
|
{
|
|
Assert( heapchk() == _HEAPOK );
|
|
Assert( CrtCheckMemory() );
|
|
HeapPrefix_t *pHeap = PrefixFromAllocation( pMem );
|
|
RemoveFromList( pHeap );
|
|
|
|
g_pActualAlloc->Free( pHeap, pFileName, nLine );
|
|
}
|
|
|
|
void *CValidateAlloc::Expand_NoLongerSupported( void *pMem, size_t nSize, const char *pFileName, int nLine )
|
|
{
|
|
Assert( heapchk() == _HEAPOK );
|
|
Assert( CrtCheckMemory() );
|
|
HeapPrefix_t *pHeap = PrefixFromAllocation( pMem );
|
|
RemoveFromList( pHeap );
|
|
|
|
int nActualSize = nSize + sizeof(HeapPrefix_t) + sizeof(HeapSuffix_t);
|
|
pHeap = (HeapPrefix_t*)g_pActualAlloc->Expand_NoLongerSupported( pHeap, nActualSize, pFileName, nLine );
|
|
AddToList( pHeap, nSize );
|
|
|
|
return AllocationStart( pHeap );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Returns size of a particular allocation
|
|
//-----------------------------------------------------------------------------
|
|
size_t CValidateAlloc::GetSize( void *pMem )
|
|
{
|
|
if ( !pMem )
|
|
return CalcHeapUsed();
|
|
|
|
HeapPrefix_t *pHeap = PrefixFromAllocation( pMem );
|
|
return pHeap->m_nSize;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Force file + line information for an allocation
|
|
//-----------------------------------------------------------------------------
|
|
void CValidateAlloc::PushAllocDbgInfo( const char *pFileName, int nLine )
|
|
{
|
|
g_pActualAlloc->PushAllocDbgInfo( pFileName, nLine );
|
|
}
|
|
|
|
void CValidateAlloc::PopAllocDbgInfo()
|
|
{
|
|
g_pActualAlloc->PopAllocDbgInfo( );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// FIXME: Remove when we make our own heap! Crt stuff we're currently using
|
|
//-----------------------------------------------------------------------------
|
|
long CValidateAlloc::CrtSetBreakAlloc( long lNewBreakAlloc )
|
|
{
|
|
return g_pActualAlloc->CrtSetBreakAlloc( lNewBreakAlloc );
|
|
}
|
|
|
|
int CValidateAlloc::CrtSetReportMode( int nReportType, int nReportMode )
|
|
{
|
|
return g_pActualAlloc->CrtSetReportMode( nReportType, nReportMode );
|
|
}
|
|
|
|
int CValidateAlloc::CrtIsValidHeapPointer( const void *pMem )
|
|
{
|
|
const HeapPrefix_t *pHeap = PrefixFromAllocation( pMem );
|
|
return g_pActualAlloc->CrtIsValidHeapPointer( pHeap );
|
|
}
|
|
|
|
int CValidateAlloc::CrtIsValidPointer( const void *pMem, unsigned int size, int access )
|
|
{
|
|
const HeapPrefix_t *pHeap = PrefixFromAllocation( pMem );
|
|
return g_pActualAlloc->CrtIsValidPointer( pHeap, size, access );
|
|
}
|
|
|
|
int CValidateAlloc::CrtCheckMemory( void )
|
|
{
|
|
return g_pActualAlloc->CrtCheckMemory( );
|
|
}
|
|
|
|
int CValidateAlloc::CrtSetDbgFlag( int nNewFlag )
|
|
{
|
|
return g_pActualAlloc->CrtSetDbgFlag( nNewFlag );
|
|
}
|
|
|
|
void CValidateAlloc::CrtMemCheckpoint( _CrtMemState *pState )
|
|
{
|
|
g_pActualAlloc->CrtMemCheckpoint( pState );
|
|
}
|
|
|
|
void* CValidateAlloc::CrtSetReportFile( int nRptType, void* hFile )
|
|
{
|
|
return g_pActualAlloc->CrtSetReportFile( nRptType, hFile );
|
|
}
|
|
|
|
void* CValidateAlloc::CrtSetReportHook( void* pfnNewHook )
|
|
{
|
|
return g_pActualAlloc->CrtSetReportHook( pfnNewHook );
|
|
}
|
|
|
|
int CValidateAlloc::CrtDbgReport( int nRptType, const char * szFile,
|
|
int nLine, const char * szModule, const char * pMsg )
|
|
{
|
|
return g_pActualAlloc->CrtDbgReport( nRptType, szFile, nLine, szModule, pMsg );
|
|
}
|
|
|
|
int CValidateAlloc::heapchk()
|
|
{
|
|
bool bOk = true;
|
|
|
|
// Validate the heap
|
|
HeapPrefix_t *pHeap = m_pFirstAllocation;
|
|
for( pHeap = m_pFirstAllocation; pHeap; pHeap = pHeap->m_pNext )
|
|
{
|
|
if ( !ValidateAllocation( pHeap ) )
|
|
{
|
|
bOk = false;
|
|
}
|
|
}
|
|
|
|
#ifdef _WIN32
|
|
return bOk ? _HEAPOK : 0;
|
|
#elif POSIX
|
|
return bOk;
|
|
#else
|
|
#error
|
|
#endif
|
|
}
|
|
|
|
// Returns the actual debug info
|
|
void CValidateAlloc::GetActualDbgInfo( const char *&pFileName, int &nLine )
|
|
{
|
|
g_pActualAlloc->GetActualDbgInfo( pFileName, nLine );
|
|
}
|
|
|
|
// Updates stats
|
|
void CValidateAlloc::RegisterAllocation( const char *pFileName, int nLine, int nLogicalSize, int nActualSize, unsigned nTime )
|
|
{
|
|
g_pActualAlloc->RegisterAllocation( pFileName, nLine, nLogicalSize, nActualSize, nTime );
|
|
}
|
|
|
|
void CValidateAlloc::RegisterDeallocation( const char *pFileName, int nLine, int nLogicalSize, int nActualSize, unsigned nTime )
|
|
{
|
|
g_pActualAlloc->RegisterDeallocation( pFileName, nLine, nLogicalSize, nActualSize, nTime );
|
|
}
|
|
|
|
void CValidateAlloc::CompactHeap()
|
|
{
|
|
g_pActualAlloc->CompactHeap();
|
|
}
|
|
|
|
MemAllocFailHandler_t CValidateAlloc::SetAllocFailHandler( MemAllocFailHandler_t pfnMemAllocFailHandler )
|
|
{
|
|
return g_pActualAlloc->SetAllocFailHandler( pfnMemAllocFailHandler );
|
|
}
|
|
|
|
#endif // TIER0_VALIDATE_HEAP
|
|
|
|
#endif // STEAM
|