void allocStrdup(bool bFree)
{
int* leaked_memory = (int*)_strdup("_strdup() leaks!");
int* leaked_memory_dbg = (int*)_strdup_dbg("_strdup_dbg() leaks!", _NORMAL_BLOCK, __FILE__, __LINE__);
void* leaked_wmemory = (int*)_wcsdup(L"_wcsdup() leaks!");
void* leaked_wmemory_dbg = (int*)_wcsdup_dbg(L"_wcsdup_dbg() leaks!", _NORMAL_BLOCK, __FILE__, __LINE__);
if (bFree)
{
free(leaked_memory);
_free_dbg(leaked_memory_dbg, _NORMAL_BLOCK);
free(leaked_wmemory);
_free_dbg(leaked_wmemory_dbg, _NORMAL_BLOCK);
}
}
void operator delete(
void *pUserData
)
{
_CrtMemBlockHeader * pHead;
RTCCALLBACK(_RTC_Free_hook, (pUserData, 0));
if (pUserData == NULL)
return;
_mlock(_HEAP_LOCK); /* block other threads */
__TRY
/* get a pointer to memory block header */
pHead = pHdr(pUserData);
/* verify block type */
_ASSERTE(_BLOCK_TYPE_IS_VALID(pHead->nBlockUse));
_free_dbg( pUserData, pHead->nBlockUse );
__FINALLY
_munlock(_HEAP_LOCK); /* release other threads */
__END_TRY_FINALLY
return;
}
//=============================================================================
void MemFree (void * ptr) {
#ifdef USE_MALLOC
_free_dbg(ptr, _NORMAL_BLOCK);
#else
HeapFree(s_heap, 0, ptr);
#endif
}
void MemFreeReal( PTR ptr, const STR8 pcFile, INT32 iLine )
{
UINT32 uiSize;
if ( !fMemManagerInit )
DbgMessage( TOPIC_MEMORY_MANAGER, DBG_LEVEL_0, String("MemFree: Warning -- Memory manager not initialized -- Line %d in %s", iLine, pcFile) );
if (ptr != NULL)
{
uiSize = _msize(ptr);
guiMemTotal -= uiSize;
guiMemFreed += uiSize;
_free_dbg( ptr, _NORMAL_BLOCK );
#ifdef DEBUG_MEM_LEAKS
DbgMessage( TOPIC_MEMORY_MANAGER, DBG_LEVEL_1, String("MemFree %p: %d bytes (line %d file %s)", ptr, uiSize, iLine, pcFile) );
#endif
}
else
{
DbgMessage( TOPIC_MEMORY_MANAGER, DBG_LEVEL_0, String("MemFree ERROR: NULL ptr received (line %d file %s)", iLine, pcFile) );
}
// count even a NULL ptr as a MemFree, not because it's really a memory leak, but because it is still an error of some
// sort (nobody should ever be freeing NULL pointers), and this will help in tracking it down if the above DbgMessage
// is not noticed.
MemDebugCounter--;
}
void _vm_free( void *ptr )
#endif
{
if (!ptr)
{
#ifndef NDEBUG
mprintf(("Why are you trying to free a NULL pointer? [%s(%d)]\n", clean_filename(filename), line));
#else
mprintf(("Why are you trying to free a NULL pointer?\n"));
#endif
return;
}
#ifndef NDEBUG
_CrtMemBlockHeader* phd = pHdr(ptr);
int nSize = phd->nDataSize;
TotalRam -= nSize;
if (Cmdline_show_mem_usage)
unregister_malloc(filename, nSize, ptr);
#endif
_free_dbg(ptr, _NORMAL_BLOCK);
}
void ZFree(void* pv)
{
if (pv != NULL) {
_CrtMemBlockHeader* pHead = (((_CrtMemBlockHeader *)pv)-1);
_free_dbg(pv, pHead->nBlockUse);
}
}
void __cdecl operator delete(void* p, int nType, LPCSTR /* lpszFileName */, int /* nLine */)
{
#if !defined(_AFX_NO_DEBUG_CRT) && defined(_DEBUG)
_free_dbg(p, nType);
#else
free(p);
#endif
}
void operator delete(void *p)
{
if(p)
{
MemoryUsedCount-=_msize(p);
_free_dbg(p,_NORMAL_BLOCK);
}
}
void __cdecl operator delete(void* p)
{
#if !defined(_AFX_NO_DEBUG_CRT) && defined(_DEBUG)
_free_dbg(p, _NORMAL_BLOCK);
#else
free(p);
#endif
}
void PASCAL CObject::operator delete(void* p, void*)
{
#ifdef _AFX_NO_DEBUG_CRT
free(p);
#else
_free_dbg(p, _CLIENT_BLOCK);
#endif
}
void CMemLeakDetector::ClearAllocInfo()
{
m_AllocInfoMap.clear();
#if defined(PLATFORM_WINDOWS)
for(std::size_t i = 0; i < m_ModuleInfoVector.size(); ++i)
_free_dbg(m_ModuleInfoVector[i].m_ModuleName, _CRT_BLOCK);
m_ModuleInfoVector.clear();
#endif
}
void allocNew(bool bFree)
{
int* leaked_memory = (int*)malloc(78);
int* leaked_memory_dbg = (int*)_malloc_dbg(80, _NORMAL_BLOCK, __FILE__, __LINE__);
if (bFree)
{
free(leaked_memory);
_free_dbg(leaked_memory_dbg, _NORMAL_BLOCK);
}
}
void allocCalloc(bool bFree)
{
int* leaked_memory = (int*)calloc(47, sizeof(int));
int* leaked_memory_dbg = (int*)_calloc_dbg(39, sizeof(int), _NORMAL_BLOCK, __FILE__, __LINE__);
if (bFree)
{
free(leaked_memory);
_free_dbg(leaked_memory_dbg, _NORMAL_BLOCK);
}
}
void FreeMemory(void* memory) {
if (memory == NULL) {
return;
}
#if defined(_WIN32) && !defined(NDEBUG)
_free_dbg(memory, _NORMAL_BLOCK);
#else
free(memory);
#endif
}
void VMemoryManager_CRT::Free(void* ptr)
{
#if defined(VBASE_USE_CRT_DEBUG)
_free_dbg(ptr, _NORMAL_BLOCK);
#elif defined(_VISION_WIIU)
return MEMFreeToDefaultHeap(ptr);
#else
free(ptr);
#endif
}
void PASCAL
CObject::operator delete(void *pObject, LPCSTR /* lpszFileName */,
int /* nLine */)
{
#ifdef _AFX_NO_DEBUG_CRT
free(pObject);
#else
_free_dbg(pObject, _CLIENT_BLOCK);
#endif
}
void BioAPI _BioAPI_free(void* ptr, void* ref,
const char * szFilename, uint32 u32LineNumber )
{
if (ptr)
{
#ifdef _DEBUG
_free_dbg( ptr, _NORMAL_BLOCK );
#else
free( ptr );
#endif
}
}
void allocRealloc(bool bFree)
{
int* temp = (int*)malloc(17);
int* old_leaked_memory = (int*)realloc(temp, 23);
int* leaked_memory = (int*)_recalloc(old_leaked_memory, 1, 31);
int* old_leaked_memory_dbg = (int*)malloc(9);
int* leaked_memory_dbg = (int*)_realloc_dbg(old_leaked_memory_dbg, 21, _NORMAL_BLOCK, __FILE__, __LINE__);
if (bFree)
{
free(leaked_memory);
_free_dbg(leaked_memory_dbg, _NORMAL_BLOCK);
}
}
CMemLeakDetector::~CMemLeakDetector()
{
#if defined(AUTO_ENABLE_MEMLEAKDETECTOR)
// report leaks
Disable();
ReportLeaks();
#endif
#if defined(PLATFORM_WINDOWS)
for(std::size_t i = 0; i < m_ModuleInfoVector.size(); ++i)
_free_dbg(m_ModuleInfoVector[i].m_ModuleName, _CRT_BLOCK);
#endif
delete m_Reporter;
}
void utFree(void* ptr, const char* file, int line)
{
my_freeCount++;
if (my_freeHandler)
{
my_freeHandler(ptr, file, line);
return;
}
#if defined(CRTDBG_MAP_ALLOC)
_free_dbg(ptr, _NORMAL_BLOCK);
#else
free(ptr);
#endif
}
void CDbgMemAlloc::Free( void *pMem, const char *pFileName, int nLine )
{
if (!pMem)
return;
/*
int nOldSize = GetSize( pMem );
const char *pOldFileName = GetAllocatonFileName( pMem );
int oldLine = GetAllocatonLineNumber( pMem );
*/
// m_Timer.Start();
_free_dbg( pMem, _NORMAL_BLOCK );
// m_Timer.End();
// unsigned long nTime = m_Timer.GetDuration().GetMicroseconds();
// RegisterDeallocation( m_GlobalInfo, nOldSize, nTime );
// RegisterDeallocation( FindOrCreateEntry( pOldFileName, oldLine ), nOldSize, nTime );
}
void _vm_free( void *ptr )
#endif
{
if ( !ptr ) {
return;
}
#ifndef NDEBUG
_CrtMemBlockHeader *phd = pHdr(ptr);
int nSize = phd->nDataSize;
TotalRam -= nSize;
if(Cmdline_show_mem_usage)
unregister_malloc(filename, nSize, ptr);
#endif
_free_dbg(ptr,_NORMAL_BLOCK);
}
/***
*void operator delete() - delete a block in the debug heap
*
*Purpose:
* Deletes any type of block.
*
*Entry:
* void *pUserData - pointer to a (user portion) of memory block in the
* debug heap
*
*Return:
* <void>
*
*******************************************************************************/
void operator delete(
void *pUserData
)
{
_CrtMemBlockHeader * pHead;
if (pUserData == NULL)
return;
_mlock(_HEAP_LOCK); /* block other threads */
/* get a pointer to memory block header */
pHead = pHdr(pUserData);
/* verify block type */
_ASSERTE(_BLOCK_TYPE_IS_VALID(pHead->nBlockUse));
_free_dbg( pUserData, pHead->nBlockUse );
_munlock(_HEAP_LOCK); /* release other threads */
return;
}
void __cdecl _free_dbg_nolock( void * pUserData, int nBlockUse)
{
_free_dbg(pUserData, 0);
}
void __cdecl _free_nolock( void * pUserData)
{
// I don't think the second param is used in memoverride
_free_dbg(pUserData, 0);
}
inline void operator delete(void *pVoid, LPCSTR strFileName, INT iLine)
{_free_dbg(pVoid, _NORMAL_BLOCK);}
void _osip_free(void *ptr)
{
_free_dbg(ptr, _NORMAL_BLOCK);
}
void __cdecl operator delete( void* p, const char* /*lpszFileName*/, int /*nLine*/ )
{
_cs.Enter();
_free_dbg( p, _CLIENT_BLOCK );
_cs.Leave();
}
void operator delete( void *pData, const char *lpszFileName, int nLine )
{
// Free the data.
_free_dbg( pData, _CLIENT_BLOCK );
}
void operator delete(void * _P, const char *filename, int linenumber)
{ _free_dbg(_P, _NORMAL_BLOCK); return; }
