summaryrefslogtreecommitdiffstats
path: root/source/LeakFinder.cpp
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--source/LeakFinder.cpp2080
1 files changed, 1040 insertions, 1040 deletions
diff --git a/source/LeakFinder.cpp b/source/LeakFinder.cpp
index 1490025f8..769b52222 100644
--- a/source/LeakFinder.cpp
+++ b/source/LeakFinder.cpp
@@ -1,1040 +1,1040 @@
-
-// LeakFinder.cpp
-
-// Finds memory leaks rather effectively
-
-// _X: downloaded from http://www.codeproject.com/Articles/3134/Memory-Leak-and-Exception-Trace-CRT-and-COM-Leaks - the real link is in the comments, RC11 version
-
-
-
-
-
-/**********************************************************************
- *
- * LEAKFINDER.CPP
- *
- *
- *
- * History:
- * 2010-04-15 RC10 - Updated to VC10 RTM
- * Fixed Bug: Application Verifier, thanks to handsinmypocket!
- * http://www.codeproject.com/KB/applications/leakfinder.aspx?msg=3439751#xx3439751xx
- * 2008-08-04 RC6 - Updated to VC9 RTM
- * Fixed Bug: Missing "ole32.lib" LIB
- * http://www.codeproject.com/KB/applications/leakfinder.aspx?msg=2253980#xx2253980xx
- * Fixed Bug: Compiled with "WIN32_LEAN_AND_MEAN"
- * http://www.codeproject.com/KB/applications/leakfinder.aspx?msg=1824718#xx1824718xx
- * Fixed Bug: Compiling with "/Wall"
- * http://www.codeproject.com/KB/threads/StackWalker.aspx?msg=2638243#xx2638243xx
- * Removed "#pragma init_seg (compiler)" from h-file
- *
- * 2005-12-30 RC5 - Now again VC8 RTM compatible
- * - Added Xml-Output (like in the old Leakfinder)
- * YOu need to define XML_LEAK_FINDER to activate it
- * So you can use the LeakAnalyseTool from
- * http://www.codeproject.com/tools/leakfinder.asp
- *
- * 2005-12-13 RC4 - Merged with the new "StackWalker"-project on
- * http://www.codeproject.com/threads/StackWalker.asp
- *
- * 2005-08-01 RC3 - Merged with the new "StackWalker"-project on
- * http://www.codeproject.com/threads/StackWalker.asp
- *
- * 2005-07-05 RC2 - First version with x86, IA64 and x64 support
- *
- * 2005-07-04 RC1 - Added "OutputOptions"
- * - New define "INIT_LEAK_FINDER_VERBOSE" to
- * display more info (for error reporting)
- *
- * 2005-07-01 Beta3 - Workaround for a bug in the new dbghelp.dll
- * (version 6.5.3.7 from 2005-05-30; StakWalk64 no
- * refused to produce an callstack on x86 systems
- * if the context is NULL or has some registers set
- * to 0 (for example Esp). This is against the
- * documented behaviour of StackWalk64...)
- * - First version with x64-support
- *
- * 2005-06-16 Beta1 First public release with the following features:
- * - Completely rewritten in C++ (object oriented)
- * - CRT-Leak-Report
- * - COM-Leak-Report
- * - Report is done via "OutputDebugString" so
- * the line can directly selected in the debugger
- * and is opening the corresponding file/line of
- * the allocation
- * - Tried to support x64 systems, bud had some
- * trouble wih StackWalk64
- * See: http://blog.kalmbachnet.de/?postid=43
- *
- * LICENSE (http://www.opensource.org/licenses/bsd-license.php)
- *
- * Copyright (c) 2005-2010, Jochen Kalmbach
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without modification,
- * are permitted provided that the following conditions are met:
- *
- * Redistributions of source code must retain the above copyright notice,
- * this list of conditions and the following disclaimer.
- * Redistributions in binary form must reproduce the above copyright notice,
- * this list of conditions and the following disclaimer in the documentation
- * and/or other materials provided with the distribution.
- * Neither the name of Jochen Kalmbach nor the names of its contributors may be
- * used to endorse or promote products derived from this software without
- * specific prior written permission.
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
- * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- **********************************************************************/
-
-#include <windows.h>
-#include <objidl.h> // Needed if compiled with "WIN32_LEAN_AND_MEAN"
-#include <tchar.h>
-#include <crtdbg.h>
-#include <stdio.h>
-
-#include <string>
-#include <vector>
-
-
-#include "LeakFinder.h"
-
-// Currently only tested with MS VC++ 5 to 10
-#if (_MSC_VER < 1100) || (_MSC_VER > 1600)
-#error Only MS VC++ 5/6/7/7.1/8/9 supported. Check if the '_CrtMemBlockHeader' has not changed with this compiler!
-#endif
-
-
-// Controlling the callstack depth
-#define MAX_CALLSTACK_LEN_BUF 0x2000
-
-#define IGNORE_CRT_ALLOC
-
-// disable 64-bit compatibility-checks (because we explicite have here either x86 or x64!)
-#pragma warning(disable:4312) // warning C4312: 'type cast' : conversion from 'DWORD' to 'LPCVOID' of greater size
-#pragma warning(disable:4826)
-
-
-// secure-CRT_functions are only available starting with VC8
-#if _MSC_VER < 1400
-#define _snprintf_s _snprintf
-#define _tcscat_s _tcscat
-#endif
-
-static std::string SimpleXMLEncode(LPCSTR szText)
-{
- std::string szRet;
- for (size_t i=0; i<strlen(szText); i++)
- {
- switch(szText[i])
- {
- case '&':
- szRet.append("&amp;");
- break;
- case '<':
- szRet.append("&lt;");
- break;
- case '>':
- szRet.append("&gt;");
- break;
- case '"':
- szRet.append("&quot;");
- break;
- case '\'':
- szRet.append("&apos;");
- break;
- default:
- szRet += szText[i];
- }
- }
- return szRet;
-}
-
-
-LeakFinderOutput::LeakFinderOutput(int options, LPCSTR szSymPath)
- : StackWalker(options, szSymPath)
-{
-}
-void LeakFinderOutput::OnLeakSearchStart(LPCSTR szLeakFinderName)
-{
- CHAR buffer[1024];
- _snprintf_s(buffer, 1024, "######## %s ########\n", szLeakFinderName);
- this->OnOutput(buffer);
-}
-void LeakFinderOutput::OnLeakStartEntry(LPCSTR szKeyName, SIZE_T nDataSize)
-{
- CHAR buffer[1024];
- _snprintf_s(buffer, 1024, "--------------- Key: %s, %d bytes ---------\n", szKeyName, nDataSize);
- this->OnOutput(buffer);
-}
-void LeakFinderOutput::OnCallstackEntry(CallstackEntryType eType, CallstackEntry &entry)
-{
- if ( (eType != lastEntry) && (entry.offset != 0) )
- {
- if ( ((this->m_options & LeakFinderShowCompleteCallstack) == 0) && (
- (strstr(entry.lineFileName, "afxmem.cpp") != NULL) ||
- (strstr(entry.lineFileName, "dbgheap.c") != NULL) ||
- (strstr(entry.lineFileName, "new.cpp") != NULL) ||
- (strstr(entry.lineFileName, "newop.cpp") != NULL) ||
- (strstr(entry.lineFileName, "leakfinder.cpp") != NULL) ||
- (strstr(entry.lineFileName, "stackwalker.cpp") != NULL)
- ) )
- {
- return;
- }
- }
- StackWalker::OnCallstackEntry(eType, entry);
-}
-
-
-// ####################################################################
-// XML-Output
-LeakFinderXmlOutput::LeakFinderXmlOutput()
-{
- TCHAR szXMLFileName[1024];
-
- GetModuleFileName(NULL, szXMLFileName, sizeof(szXMLFileName) / sizeof(TCHAR));
- _tcscat_s(szXMLFileName, _T(".mem.xml-leaks"));
-#if _MSC_VER < 1400
- m_fXmlFile = _tfopen(szXMLFileName, _T("w"));
-#else
- m_fXmlFile = NULL;
- _tfopen_s(&m_fXmlFile, szXMLFileName, _T("w"));
-#endif
- if (m_fXmlFile != NULL)
- {
- SYSTEMTIME st;
- GetLocalTime(&st);
- fprintf(m_fXmlFile, "<MEMREPORT date=\"%.2d/%.2d/%.4d\" time=\"%.2d:%.2d:%.2d\">\n",
- st.wMonth, st.wDay, st.wYear,
- st.wHour, st.wMinute, st.wSecond);
- }
- else
- {
- MessageBox(NULL, _T("Could not open xml-logfile for leakfinder!"), _T("Warning"), MB_ICONHAND);
- }
-}
-LeakFinderXmlOutput::LeakFinderXmlOutput(LPCTSTR szFileName)
-{
-#if _MSC_VER < 1400
- m_fXmlFile = _tfopen(szFileName, _T("w"));
-#else
- m_fXmlFile = NULL;
- _tfopen_s(&m_fXmlFile, szFileName, _T("w"));
-#endif
- if (m_fXmlFile == NULL)
- {
- MessageBox(NULL, _T("Could not open xml-logfile for leakfinder!"), _T("Warning"), MB_ICONHAND);
- }
-}
-LeakFinderXmlOutput::~LeakFinderXmlOutput()
-{
- if (m_fXmlFile != NULL)
- {
- // Write the ending-tags and close the file
- fprintf(m_fXmlFile, "</MEMREPORT>\n");
- fclose(m_fXmlFile);
- }
- m_fXmlFile = NULL;
-}
-void LeakFinderXmlOutput::OnLeakSearchStart(LPCSTR sszLeakFinderName)
-{
-}
-void LeakFinderXmlOutput::OnLeakStartEntry(LPCSTR szKeyName, SIZE_T nDataSize)
-{
- if (m_fXmlFile != NULL)
- {
- fprintf(m_fXmlFile, " <LEAK requestID=\"%s\" size=\"%d\">\n", SimpleXMLEncode(szKeyName).c_str(), nDataSize);
- }
-}
-void LeakFinderXmlOutput::OnCallstackEntry(CallstackEntryType eType, CallstackEntry &entry)
-{
- if (m_fXmlFile != NULL)
- {
- if (eType != lastEntry)
- {
- fprintf(m_fXmlFile, " <STACKENTRY decl=\"%s\" decl_offset=\"%+ld\" ", SimpleXMLEncode(entry.undName).c_str(), entry.offsetFromSmybol);
- fprintf(m_fXmlFile, "srcfile=\"%s\" line=\"%d\" line_offset=\"%+ld\" ", SimpleXMLEncode(entry.lineFileName).c_str(), entry.lineNumber, entry.offsetFromLine);
- fprintf(m_fXmlFile, "module=\"%s\" base=\"%08lx\" ", SimpleXMLEncode(entry.moduleName).c_str(), entry.baseOfImage);
- fprintf(m_fXmlFile, "/>\n");
- }
- else
- {
- fprintf(m_fXmlFile, " </LEAK>\n");
- }
- }
-}
-
-// ##########################################################################
-// ##########################################################################
-// ##########################################################################
-// Base class for storing contexts in a hashtable
-template <typename HASHTABLE_KEY> class ContextHashtableBase
-{
-public:
- ContextHashtableBase(SIZE_T sizeOfHastable, LPCSTR finderName)
- {
- SIZE_T s = sizeOfHastable*sizeof(AllocHashEntryType);
- m_hHeap = HeapCreate(0, 10*1024 + s, 0);
- if (m_hHeap == NULL)
- throw;
- pAllocHashTable = (AllocHashEntryType*) own_malloc(s);
- sAllocEntries = sizeOfHastable;
- m_finderName = own_strdup(finderName);
- }
-
-protected:
- virtual ~ContextHashtableBase()
- {
- if (pAllocHashTable != NULL)
- own_free(pAllocHashTable);
- pAllocHashTable = NULL;
-
- own_free(m_finderName);
- m_finderName = NULL;
-
- if (m_hHeap != NULL)
- HeapDestroy(m_hHeap);
- }
-
- __inline LPVOID own_malloc(SIZE_T size)
- {
- return HeapAlloc(m_hHeap, HEAP_ZERO_MEMORY, size);
- }
- __inline VOID own_free(LPVOID memblock)
- {
- HeapFree(m_hHeap, 0, memblock);
- }
- __inline CHAR *own_strdup(const char *str)
- {
- size_t len = strlen(str)+1;
- CHAR *c = (CHAR*)own_malloc(len);
-#if _MSC_VER >= 1400
- strcpy_s(c, len, str);
-#else
- strcpy(c, str);
-#endif
- return c;
- }
-
- // Disables this leak-finder
- virtual LONG Disable() = 0;
- // enables the leak-finder again...
- virtual LONG Enable() = 0;
-
-private:
- // Entry for each allocation
- typedef struct AllocHashEntryType {
- HASHTABLE_KEY key;
- SIZE_T nDataSize; // Size of the allocated memory
- struct AllocHashEntryType *Next;
- CONTEXT c;
- PVOID pStackBaseAddr;
- SIZE_T nMaxStackSize;
-
- PVOID pCallstackOffset;
- SIZE_T nCallstackLen;
- char pcCallstackAddr[MAX_CALLSTACK_LEN_BUF]; // min of both values...
- } AllocHashEntryType;
-
-protected:
- virtual SIZE_T HashFunction(HASHTABLE_KEY &key) = 0;
- virtual BOOL IsKeyEmpty(HASHTABLE_KEY &key) = 0;
- virtual VOID SetEmptyKey(HASHTABLE_KEY &key) = 0;
- virtual VOID GetKeyAsString(HASHTABLE_KEY &key, CHAR *szName, SIZE_T nBufferLen) = 0;
- //virtual SIZE_T GetNativeBytes(HASHTABLE_KEY &key, CHAR *szName, SIZE_T nBufferLen) { return 0; }
-
-public:
- VOID Insert(HASHTABLE_KEY &key, CONTEXT &context, SIZE_T nDataSize)
- {
- SIZE_T HashIdx;
- AllocHashEntryType *pHashEntry;
-
- // generate hash-value
- HashIdx = HashFunction(key);
-
- pHashEntry = &pAllocHashTable[HashIdx];
- if (IsKeyEmpty(pHashEntry->key) != FALSE) {
- // Entry is empty...
- }
- else {
- // Entry is not empy! make a list of entries for this hash value...
- while(pHashEntry->Next != NULL) {
- pHashEntry = pHashEntry->Next;
- }
-
- pHashEntry->Next = (AllocHashEntryType*) own_malloc(sizeof(AllocHashEntryType));
- pHashEntry = pHashEntry->Next;
- }
- pHashEntry->key = key;
- pHashEntry->nDataSize = nDataSize;
- pHashEntry->Next = NULL;
-#ifdef _M_IX86
- pHashEntry->pCallstackOffset = (LPVOID) min(context.Ebp, context.Esp);
-#elif _M_X64
- pHashEntry->pCallstackOffset = (LPVOID) min(context.Rdi, context.Rsp);
-#elif _M_IA64
- pHashEntry->pCallstackOffset = (LPVOID) min(context.IntSp, context.RsBSP);
-#else
-#error "Platform not supported!"
-#endif
- pHashEntry->c = context;
-
- // Query the max. stack-area:
- MEMORY_BASIC_INFORMATION MemBuffer;
- if(VirtualQuery((LPCVOID) pHashEntry->pCallstackOffset, &MemBuffer, sizeof(MemBuffer)) > 0)
- {
- pHashEntry->pStackBaseAddr = MemBuffer.BaseAddress;
- pHashEntry->nMaxStackSize = MemBuffer.RegionSize;
- }
- else
- {
- pHashEntry->pStackBaseAddr = 0;
- pHashEntry->nMaxStackSize = 0;
- }
-
- SIZE_T bytesToRead = MAX_CALLSTACK_LEN_BUF;
- if (pHashEntry->nMaxStackSize > 0)
- {
- SIZE_T len = ((SIZE_T) pHashEntry->pStackBaseAddr + pHashEntry->nMaxStackSize) - (SIZE_T)pHashEntry->pCallstackOffset;
- bytesToRead = min(len, MAX_CALLSTACK_LEN_BUF);
- }
- // Now read the callstack:
- if (ReadProcessMemory(GetCurrentProcess(), (LPCVOID) pHashEntry->pCallstackOffset, &(pHashEntry->pcCallstackAddr), bytesToRead, &(pHashEntry->nCallstackLen)) == 0)
- {
- // Could not read memory...
- pHashEntry->nCallstackLen = 0;
- pHashEntry->pCallstackOffset = 0;
- } // read callstack
- } // Insert
-
- BOOL Remove(HASHTABLE_KEY &key)
- {
- SIZE_T HashIdx;
- AllocHashEntryType *pHashEntry, *pHashEntryLast;
-
- // get the Hash-Value
- HashIdx = HashFunction(key);
-
- pHashEntryLast = NULL;
- pHashEntry = &pAllocHashTable[HashIdx];
- while(pHashEntry != NULL) {
- if (pHashEntry->key == key) {
- // release my memory
- if (pHashEntryLast == NULL) {
- // It is an entry in the table, so do not release this memory
- if (pHashEntry->Next == NULL) {
- // It was the last entry, so empty the table entry
- SetEmptyKey(pAllocHashTable[HashIdx].key);
- //memset(&pAllocHashTable[HashIdx], 0, sizeof(pAllocHashTable[HashIdx]));
- }
- else {
- // There are some more entries, so shorten the list
- AllocHashEntryType *pTmp = pHashEntry->Next;
- *pHashEntry = *(pHashEntry->Next);
- own_free(pTmp);
- }
- return TRUE;
- }
- else {
- // now, I am in an dynamic allocated entry (it was a collision)
- pHashEntryLast->Next = pHashEntry->Next;
- own_free(pHashEntry);
- return TRUE;
- }
- }
- pHashEntryLast = pHashEntry;
- pHashEntry = pHashEntry->Next;
- }
-
- // if we are here, we could not find the RequestID
- return FALSE;
- }
-
- AllocHashEntryType *Find(HASHTABLE_KEY &key)
- {
- SIZE_T HashIdx;
- AllocHashEntryType *pHashEntry;
-
- // get the Hash-Value
- HashIdx = HashFunction(key);
-
- pHashEntry = &pAllocHashTable[HashIdx];
- while(pHashEntry != NULL) {
- if (pHashEntry->key == key) {
- return pHashEntry;
- }
- pHashEntry = pHashEntry->Next;
- }
-
- // entry was not found!
- return NULL;
- }
-
- // For the followong static-var See comment in "ShowCallstack"...
- static BOOL CALLBACK ReadProcessMemoryFromHashEntry64(
- HANDLE hProcess, // hProcess must be a pointer to an hash-entry!
- DWORD64 lpBaseAddress,
- PVOID lpBuffer,
- DWORD nSize,
- LPDWORD lpNumberOfBytesRead,
- LPVOID pUserData // optional data, which was passed in "ShowCallstack"
- )
- {
- *lpNumberOfBytesRead = 0;
- AllocHashEntryType *pHashEntry = (AllocHashEntryType*) pUserData;
- if (pHashEntry == NULL)
- {
- return FALSE;
- }
-
- if ( ( (DWORD64)lpBaseAddress >= (DWORD64)pHashEntry->pCallstackOffset) && ((DWORD64)lpBaseAddress <= ((DWORD64)pHashEntry->pCallstackOffset+pHashEntry->nCallstackLen)) ) {
- // Memory is located in saved Callstack:
- // Calculate the offset
- DWORD dwOffset = (DWORD) ((DWORD64)lpBaseAddress - (DWORD64)pHashEntry->pCallstackOffset);
- DWORD dwSize = __min(nSize, MAX_CALLSTACK_LEN_BUF-dwOffset);
- memcpy(lpBuffer, &(pHashEntry->pcCallstackAddr[dwOffset]), dwSize);
- *lpNumberOfBytesRead = dwSize;
- if (dwSize != nSize)
- {
- return FALSE;
- }
- *lpNumberOfBytesRead = nSize;
- return TRUE;
- }
-
- if (*lpNumberOfBytesRead == 0) // Memory could not be found
- {
- if ( ( (DWORD64)lpBaseAddress < (DWORD64)pHashEntry->pStackBaseAddr) || ((DWORD64)lpBaseAddress > ((DWORD64)pHashEntry->pStackBaseAddr+pHashEntry->nMaxStackSize)) )
- {
- // Stackwalking is done by reading the "real memory" (normally this happens when the StackWalk64 tries to read some code)
- SIZE_T st = 0;
- BOOL bRet = ReadProcessMemory(hProcess, (LPCVOID) lpBaseAddress, lpBuffer, nSize, &st);
- *lpNumberOfBytesRead = (DWORD) st;
- return bRet;
- }
- }
-
- return TRUE;
- }
-
- VOID ShowLeaks(LeakFinderOutput &leakFinderOutput)
- {
- SIZE_T ulTemp;
- AllocHashEntryType *pHashEntry;
- ULONG ulCount = 0;
- SIZE_T ulLeaksByte = 0;
-
- leakFinderOutput.OnLeakSearchStart(this->m_finderName);
-
- // Move throu every entry
- CHAR keyName[1024];
- for(ulTemp = 0; ulTemp < this->sAllocEntries; ulTemp++) {
- pHashEntry = &pAllocHashTable[ulTemp];
- if (IsKeyEmpty(pHashEntry->key) == FALSE) {
- while(pHashEntry != NULL) {
- ulCount++;
- CONTEXT c;
- memcpy(&c, &(pHashEntry->c), sizeof(CONTEXT));
-
- this->GetKeyAsString(pHashEntry->key, keyName, 1024);
-
- leakFinderOutput.OnLeakStartEntry(keyName, pHashEntry->nDataSize);
- leakFinderOutput.ShowCallstack(GetCurrentThread(), &c, ReadProcessMemoryFromHashEntry64, pHashEntry);
-
- // Count the number of leaky bytes
- ulLeaksByte += pHashEntry->nDataSize;
-
- pHashEntry = pHashEntry->Next;
- } // while
- }
- }
- }
-
- AllocHashEntryType *pAllocHashTable;
- SIZE_T sAllocEntries;
- HANDLE m_hHeap;
- LPSTR m_finderName;
- bool m_bSupressUselessLines;
-}; // template <typename HASHTABLE_KEY> class ContextHashtableBase
-
-
-// ##########################################################################
-// ##########################################################################
-// ##########################################################################
-// Specialization for CRT-Leaks:
-// VC5 has excluded all types in release-builds
-#ifdef _DEBUG
-
-// The follwoing is copied from dbgint.h:
-// <CRT_INTERNALS>
-/*
-* For diagnostic purpose, blocks are allocated with extra information and
-* stored in a doubly-linked list. This makes all blocks registered with
-* how big they are, when they were allocated, and what they are used for.
-*/
-
-// forward declaration:
-#ifndef _M_CEE_PURE
-#define MyAllocHookCallingConvention __cdecl
-#endif
-#if _MSC_VER >= 1400
-#ifdef _M_CEE
-#define MyAllocHookCallingConvention __clrcall
-#endif
-#endif
-
-static int MyAllocHookCallingConvention MyAllocHook(int nAllocType, void *pvData,
- size_t nSize, int nBlockUse, long lRequest,
-#if _MSC_VER <= 1100 // Special case for VC 5 and before
- const char * szFileName,
-#else
- const unsigned char * szFileName,
-#endif
- int nLine);
-
-static _CRT_ALLOC_HOOK s_pfnOldCrtAllocHook = NULL;
-static LONG s_CrtDisableCount = 0;
-static LONG s_lMallocCalled = 0;
-
-
-class CRTTable : public ContextHashtableBase<LONG>
-{
-public:
- CRTTable() : ContextHashtableBase<LONG>(1021, "CRT-Leaks")
- {
- // save the previous alloc hook
- s_pfnOldCrtAllocHook = _CrtSetAllocHook(MyAllocHook);
- }
-
- virtual ~CRTTable()
- {
- _CrtSetAllocHook(s_pfnOldCrtAllocHook);
- }
-
- virtual LONG Disable()
- {
- return InterlockedIncrement(&s_CrtDisableCount);
- }
- virtual LONG Enable()
- {
- return InterlockedDecrement(&s_CrtDisableCount);
- }
-
- virtual SIZE_T HashFunction(LONG &key)
- {
- // I couldn´t find any better and faster
- return key % sAllocEntries;
- }
- virtual BOOL IsKeyEmpty(LONG &key)
- {
- if (key == 0)
- return TRUE;
- return FALSE;
- }
- virtual VOID SetEmptyKey(LONG &key)
- {
- key = 0;
- }
- virtual VOID GetKeyAsString(LONG &key, CHAR *szName, SIZE_T nBufferLen)
- {
-#if _MSC_VER < 1400
- _snprintf_s(szName, nBufferLen, "%d", key);
-#else
- _snprintf_s(szName, nBufferLen, nBufferLen, "%d", key);
-#endif
- }
-
-protected:
- CHAR *m_pBuffer;
- SIZE_T m_maxBufferLen;
- SIZE_T m_bufferLen;
-}; // class CRTTable
-
-
-#define nNoMansLandSize 4
-
-typedef struct _CrtMemBlockHeader
-{
- struct _CrtMemBlockHeader * pBlockHeaderNext;
- struct _CrtMemBlockHeader * pBlockHeaderPrev;
- char * szFileName;
- int nLine;
-#ifdef _WIN64
- /* These items are reversed on Win64 to eliminate gaps in the struct
- * and ensure that sizeof(struct)%16 == 0, so 16-byte alignment is
- * maintained in the debug heap.
- */
- int nBlockUse;
- size_t nDataSize;
-#else /* _WIN64 */
- size_t nDataSize;
- int nBlockUse;
-#endif /* _WIN64 */
- long lRequest;
- unsigned char gap[nNoMansLandSize];
- /* followed by:
- * unsigned char data[nDataSize];
- * unsigned char anotherGap[nNoMansLandSize];
- */
-} _CrtMemBlockHeader;
-#define pbData(pblock) ((unsigned char *)((_CrtMemBlockHeader *)pblock + 1))
-#define pHdr(pbData) (((_CrtMemBlockHeader *)pbData)-1)
-// </CRT_INTERNALS>
-
-static CRTTable *g_pCRTTable = NULL;
-
-
-// MyAllocHook is Single-Threaded, that means the the calls are serialized in the calling function!
-static int MyAllocHook(int nAllocType, void *pvData,
- size_t nSize, int nBlockUse, long lRequest,
-#if _MSC_VER <= 1100 // Special case for VC 5
- const char * szFileName,
-#else
- const unsigned char * szFileName,
-#endif
- int nLine)
-{
- //static TCHAR *operation[] = { _T(""), _T("ALLOCATIONG"), _T("RE-ALLOCATING"), _T("FREEING") };
- //static TCHAR *blockType[] = { _T("Free"), _T("Normal"), _T("CRT"), _T("Ignore"), _T("Client") };
-
-#ifdef IGNORE_CRT_ALLOC
- if (_BLOCK_TYPE(nBlockUse) == _CRT_BLOCK) // Ignore internal C runtime library allocations
- return TRUE;
-#endif
- extern int _crtDbgFlag;
- if ( ((_CRTDBG_ALLOC_MEM_DF & _crtDbgFlag) == 0) && ( (nAllocType == _HOOK_ALLOC) || (nAllocType == _HOOK_REALLOC) ) )
- {
- // Someone has disabled that the runtime should log this allocation
- // so we do not log this allocation
- if (s_pfnOldCrtAllocHook != NULL)
- s_pfnOldCrtAllocHook(nAllocType, pvData, nSize, nBlockUse, lRequest, szFileName, nLine);
- return TRUE;
- }
-
- // Handle the Disable/Enable setting
- if (InterlockedExchangeAdd(&s_CrtDisableCount, 0) != 0)
- return TRUE;
-
- // Prevent from reentrat calls
- if (InterlockedIncrement(&s_lMallocCalled) > 1) { // I was already called
- InterlockedDecrement(&s_lMallocCalled);
- // call the previous alloc hook
- if (s_pfnOldCrtAllocHook != NULL)
- s_pfnOldCrtAllocHook(nAllocType, pvData, nSize, nBlockUse, lRequest, szFileName, nLine);
- return TRUE;
- }
-
- _ASSERT( (nAllocType == _HOOK_ALLOC) || (nAllocType == _HOOK_REALLOC) || (nAllocType == _HOOK_FREE) );
- _ASSERT( ( _BLOCK_TYPE(nBlockUse) >= 0 ) && ( _BLOCK_TYPE(nBlockUse) < 5 ) );
-
- if (nAllocType == _HOOK_FREE) { // freeing
- // Try to get the header information
- if (_CrtIsValidHeapPointer(pvData)) { // it is a valid Heap-Pointer
- // get the ID
- _CrtMemBlockHeader *pHead;
- // get a pointer to memory block header
- pHead = pHdr(pvData);
- nSize = pHead->nDataSize;
- lRequest = pHead->lRequest; // This is the ID!
-
- if (pHead->nBlockUse == _IGNORE_BLOCK)
- {
- InterlockedDecrement(&s_lMallocCalled);
- if (s_pfnOldCrtAllocHook != NULL)
- s_pfnOldCrtAllocHook(nAllocType, pvData, nSize, nBlockUse, lRequest, szFileName, nLine);
- return TRUE;
- }
- }
- if (lRequest != 0) { // RequestID was found
- g_pCRTTable->Remove(lRequest);
- }
- } // freeing
-
- if (nAllocType == _HOOK_REALLOC) { // re-allocating
- // Try to get the header information
- if (_CrtIsValidHeapPointer(pvData)) { // it is a valid Heap-Pointer
- BOOL bRet;
- LONG lReallocRequest;
- // get the ID
- _CrtMemBlockHeader *pHead;
- // get a pointer to memory block header
- pHead = pHdr(pvData);
- // Try to find the RequestID in the Hash-Table, mark it that it was freed
- lReallocRequest = pHead->lRequest;
- bRet = g_pCRTTable->Remove(lReallocRequest);
- } // ValidHeapPointer
- } // re-allocating
-
- //if ( (g_ulShowStackAtAlloc < 3) && (nAllocType == _HOOK_FREE) ) {
- if (nAllocType == _HOOK_FREE) {
- InterlockedDecrement(&s_lMallocCalled);
- // call the previous alloc hook
- if (s_pfnOldCrtAllocHook != NULL)
- s_pfnOldCrtAllocHook(nAllocType, pvData, nSize, nBlockUse, lRequest, szFileName, nLine);
- return TRUE;
- }
-
- CONTEXT c;
- GET_CURRENT_CONTEXT(c, CONTEXT_FULL);
-
- // Only insert in the Hash-Table if it is not a "freeing"
- if (nAllocType != _HOOK_FREE) {
- if(lRequest != 0) // Always a valid RequestID should be provided (see comments in the header)
- g_pCRTTable->Insert(lRequest, c, nSize);
- }
-
- InterlockedDecrement(&s_lMallocCalled);
- // call the previous alloc hook
- if (s_pfnOldCrtAllocHook != NULL)
- s_pfnOldCrtAllocHook(nAllocType, pvData, nSize, nBlockUse, lRequest, szFileName, nLine);
- return TRUE; // allow the memory operation to proceed
-} // MyAllocHook
-
-#endif // _DEBUG
-
-
-// ##########################################################################
-// ##########################################################################
-// ##########################################################################
-// Specialization for COM-Leaks:
-
-// forwards:
-class COMTable;
-class CMallocSpy : public IMallocSpy
-{
-public:
- CMallocSpy() { m_cbRequest = 0; m_cRef = 0; m_disableCount = 0; }
- virtual ~CMallocSpy() {}
- // IUnknown methods
- STDMETHOD(QueryInterface) (REFIID riid, LPVOID *ppUnk);
- STDMETHOD_(ULONG, AddRef) ();
- STDMETHOD_(ULONG, Release) ();
- // IMallocSpy methods
- STDMETHOD_(SIZE_T, PreAlloc) (SIZE_T cbRequest);
- STDMETHOD_(void *, PostAlloc) (void *pActual);
- STDMETHOD_(void *, PreFree) (void *pRequest, BOOL fSpyed);
- STDMETHOD_(void, PostFree) (BOOL fSpyed) { return; };
- STDMETHOD_(SIZE_T, PreRealloc) (void *pRequest, SIZE_T cbRequest, void **ppNewRequest, BOOL fSpyed);
- STDMETHOD_(void *, PostRealloc) (void *pActual, BOOL fSpyed);
- STDMETHOD_(void *, PreGetSize) (void *pRequest, BOOL fSpyed) { return pRequest; }
- STDMETHOD_(SIZE_T, PostGetSize) (SIZE_T cbActual, BOOL fSpyed) { return cbActual; }
- STDMETHOD_(void *, PreDidAlloc) (void *pRequest, BOOL fSpyed) { return pRequest; }
- STDMETHOD_(BOOL, PostDidAlloc) (void *pRequest, BOOL fSpyed, BOOL fActual) { return fActual; }
- STDMETHOD_(void, PreHeapMinimize) (void) { return; }
- STDMETHOD_(void, PostHeapMinimize) (void) { return; }
-private:
- LONG m_cRef;
- SIZE_T m_cbRequest;
-protected:
- COMTable *m_pComTable;
- LONG m_disableCount;
- friend COMTable;
-};
-
-class COMTable : public ContextHashtableBase<LPVOID>
-{
-public:
- COMTable() : ContextHashtableBase<LPVOID>(1021, "COM-Leaks")
- {
- m_pMallocSpy = new CMallocSpy(); // wird später durch Release freigegeben
- if (m_pMallocSpy != NULL)
- {
- m_pMallocSpy->m_pComTable = this;
- // CoInitilize(); // ??? Is this necessary ?
- HRESULT hr = CoRegisterMallocSpy(m_pMallocSpy);
- if FAILED(hr)
- {
- _tprintf(_T("\nCoRegisterMallocSpay failed with %.8x"), hr);
- }
- }
- }
-
- virtual ~COMTable()
- {
- if (m_pMallocSpy != NULL)
- m_pMallocSpy->m_pComTable = NULL;
- CoRevokeMallocSpy();
- }
-
- virtual LONG Disable()
- {
- return InterlockedIncrement(&(m_pMallocSpy->m_disableCount));
- }
- virtual LONG Enable()
- {
- return InterlockedDecrement(&(m_pMallocSpy->m_disableCount));
- }
-
- virtual SIZE_T HashFunction(LPVOID &key)
- {
- // I couldn´t find any better and faster
-#ifdef _M_IX86
-#if _MSC_VER > 1100
-#pragma warning (push)
-#endif
-#pragma warning (disable: 4311)
- DWORD llP = (DWORD) key;
-#if _MSC_VER > 1100
-#pragma warning (pop)
-#endif
-#else
- ULONGLONG llP = (ULONGLONG) key;
-#endif
- return (SIZE_T) llP % sAllocEntries;
- }
- virtual BOOL IsKeyEmpty(LPVOID &key)
- {
- if (key == 0)
- return TRUE;
- return FALSE;
- }
- virtual VOID SetEmptyKey(LPVOID &key)
- {
- key = 0;
- }
- virtual VOID GetKeyAsString(LPVOID &key, CHAR *szName, SIZE_T nBufferLen)
- {
-#if _MSC_VER < 1400
- _snprintf_s(szName, nBufferLen, "%p", key);
-#else
- _snprintf_s(szName, nBufferLen, nBufferLen, "%p", key);
-#endif
- }
-
- CMallocSpy *m_pMallocSpy;
- friend CMallocSpy;
-}; // class COMTable
-
-
-STDMETHODIMP CMallocSpy::QueryInterface(REFIID riid, LPVOID *ppUnk) {
- HRESULT hr = S_OK;
- if (IsEqualIID(riid, IID_IUnknown)) {
- *ppUnk = (IUnknown *) this;
- }
- else if (IsEqualIID(riid, IID_IMallocSpy)) {
- *ppUnk = (IMalloc *) this;
- }
- else {
- *ppUnk = NULL;
- hr = E_NOINTERFACE;
- }
- AddRef();
- return hr;
-}
-STDMETHODIMP_(ULONG) CMallocSpy::AddRef(void) {
- return (ULONG) InterlockedIncrement(&m_cRef);
-}
-STDMETHODIMP_(ULONG) CMallocSpy::Release(void) {
- LONG cRef;
- cRef = InterlockedDecrement(&m_cRef);
- if (cRef == 0)
- {
- delete this;
- }
- return (ULONG) cRef;
-}
-// IMallocSpy methods
-STDMETHODIMP_(SIZE_T) CMallocSpy::PreAlloc(SIZE_T cbRequest) {
- m_cbRequest = cbRequest;
- return cbRequest;
-}
-STDMETHODIMP_(void *) CMallocSpy::PostAlloc(void *pActual) {
- if (m_pComTable != NULL)
- {
- CONTEXT c;
- GET_CURRENT_CONTEXT(c, CONTEXT_FULL);
- m_pComTable->Insert(pActual, c, m_cbRequest);
- }
- return pActual;
-}
-STDMETHODIMP_(void *) CMallocSpy::PreFree(void *pRequest, BOOL fSpyed) {
- if (m_pComTable != NULL)
- {
- m_pComTable->Remove(pRequest);
- }
- return pRequest;
-}
-STDMETHODIMP_(SIZE_T) CMallocSpy::PreRealloc(void *pRequest, SIZE_T cbRequest,
- void **ppNewRequest, BOOL fSpyed) {
- if (m_pComTable != NULL)
- {
- m_pComTable->Remove(pRequest);
- }
- *ppNewRequest = pRequest; // Bug fixed. Thanx to Christoph Weber
- return cbRequest;
-}
-STDMETHODIMP_(void *) CMallocSpy::PostRealloc(void *pActual, BOOL fSpyed) {
- if (m_pComTable != NULL)
- {
- CONTEXT c;
- GET_CURRENT_CONTEXT(c, CONTEXT_FULL);
- m_pComTable->Insert(pActual, c, m_cbRequest);
- }
- return pActual;
-}
-
-
-
-
-// ##########################################################################
-// ##########################################################################
-// ##########################################################################
-// Init/Deinit functions
-
-
-static COMTable *g_pCOMTable;
-HRESULT InitLeakFinder()
-{
- // _X: Disabled COM monitoring: g_pCOMTable = new COMTable();
-#ifdef _DEBUG
- g_pCRTTable = new CRTTable();
-#endif
- return S_OK;
-}
-
-void DeinitLeakFinder(LeakFinderOutput *output)
-{
- LeakFinderOutput *pLeakFinderOutput = output;
-
-#ifdef _DEBUG
- g_pCRTTable->Disable();
-#endif
- // _X: Disabled COM monitoring: g_pCOMTable->Disable();
-
- if (pLeakFinderOutput == NULL)
- pLeakFinderOutput = new LeakFinderOutput();
-
- // explicite load the modules:
- pLeakFinderOutput->LoadModules();
-
-#ifdef _DEBUG
- g_pCRTTable->ShowLeaks(*pLeakFinderOutput);
- if (g_pCRTTable != NULL)
- delete g_pCRTTable;
- g_pCRTTable = NULL;
-#endif
-
- /*
- // _X: Disabled COM monitoring:
- g_pCOMTable->ShowLeaks(*pLeakFinderOutput);
- if (g_pCOMTable != NULL)
- delete g_pCOMTable;
- g_pCOMTable = NULL;
- */
-
- if (output == NULL)
- delete pLeakFinderOutput;
-}
-void DeinitLeakFinder()
-{
- DeinitLeakFinder(NULL);
-}
+
+// LeakFinder.cpp
+
+// Finds memory leaks rather effectively
+
+// _X: downloaded from http://www.codeproject.com/Articles/3134/Memory-Leak-and-Exception-Trace-CRT-and-COM-Leaks - the real link is in the comments, RC11 version
+
+
+
+
+
+/**********************************************************************
+ *
+ * LEAKFINDER.CPP
+ *
+ *
+ *
+ * History:
+ * 2010-04-15 RC10 - Updated to VC10 RTM
+ * Fixed Bug: Application Verifier, thanks to handsinmypocket!
+ * http://www.codeproject.com/KB/applications/leakfinder.aspx?msg=3439751#xx3439751xx
+ * 2008-08-04 RC6 - Updated to VC9 RTM
+ * Fixed Bug: Missing "ole32.lib" LIB
+ * http://www.codeproject.com/KB/applications/leakfinder.aspx?msg=2253980#xx2253980xx
+ * Fixed Bug: Compiled with "WIN32_LEAN_AND_MEAN"
+ * http://www.codeproject.com/KB/applications/leakfinder.aspx?msg=1824718#xx1824718xx
+ * Fixed Bug: Compiling with "/Wall"
+ * http://www.codeproject.com/KB/threads/StackWalker.aspx?msg=2638243#xx2638243xx
+ * Removed "#pragma init_seg (compiler)" from h-file
+ *
+ * 2005-12-30 RC5 - Now again VC8 RTM compatible
+ * - Added Xml-Output (like in the old Leakfinder)
+ * YOu need to define XML_LEAK_FINDER to activate it
+ * So you can use the LeakAnalyseTool from
+ * http://www.codeproject.com/tools/leakfinder.asp
+ *
+ * 2005-12-13 RC4 - Merged with the new "StackWalker"-project on
+ * http://www.codeproject.com/threads/StackWalker.asp
+ *
+ * 2005-08-01 RC3 - Merged with the new "StackWalker"-project on
+ * http://www.codeproject.com/threads/StackWalker.asp
+ *
+ * 2005-07-05 RC2 - First version with x86, IA64 and x64 support
+ *
+ * 2005-07-04 RC1 - Added "OutputOptions"
+ * - New define "INIT_LEAK_FINDER_VERBOSE" to
+ * display more info (for error reporting)
+ *
+ * 2005-07-01 Beta3 - Workaround for a bug in the new dbghelp.dll
+ * (version 6.5.3.7 from 2005-05-30; StakWalk64 no
+ * refused to produce an callstack on x86 systems
+ * if the context is NULL or has some registers set
+ * to 0 (for example Esp). This is against the
+ * documented behaviour of StackWalk64...)
+ * - First version with x64-support
+ *
+ * 2005-06-16 Beta1 First public release with the following features:
+ * - Completely rewritten in C++ (object oriented)
+ * - CRT-Leak-Report
+ * - COM-Leak-Report
+ * - Report is done via "OutputDebugString" so
+ * the line can directly selected in the debugger
+ * and is opening the corresponding file/line of
+ * the allocation
+ * - Tried to support x64 systems, bud had some
+ * trouble wih StackWalk64
+ * See: http://blog.kalmbachnet.de/?postid=43
+ *
+ * LICENSE (http://www.opensource.org/licenses/bsd-license.php)
+ *
+ * Copyright (c) 2005-2010, Jochen Kalmbach
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ * Neither the name of Jochen Kalmbach nor the names of its contributors may be
+ * used to endorse or promote products derived from this software without
+ * specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ **********************************************************************/
+
+#include <windows.h>
+#include <objidl.h> // Needed if compiled with "WIN32_LEAN_AND_MEAN"
+#include <tchar.h>
+#include <crtdbg.h>
+#include <stdio.h>
+
+#include <string>
+#include <vector>
+
+
+#include "LeakFinder.h"
+
+// Currently only tested with MS VC++ 5 to 10
+#if (_MSC_VER < 1100) || (_MSC_VER > 1600)
+#error Only MS VC++ 5/6/7/7.1/8/9 supported. Check if the '_CrtMemBlockHeader' has not changed with this compiler!
+#endif
+
+
+// Controlling the callstack depth
+#define MAX_CALLSTACK_LEN_BUF 0x2000
+
+#define IGNORE_CRT_ALLOC
+
+// disable 64-bit compatibility-checks (because we explicite have here either x86 or x64!)
+#pragma warning(disable:4312) // warning C4312: 'type cast' : conversion from 'DWORD' to 'LPCVOID' of greater size
+#pragma warning(disable:4826)
+
+
+// secure-CRT_functions are only available starting with VC8
+#if _MSC_VER < 1400
+#define _snprintf_s _snprintf
+#define _tcscat_s _tcscat
+#endif
+
+static std::string SimpleXMLEncode(LPCSTR szText)
+{
+ std::string szRet;
+ for (size_t i=0; i<strlen(szText); i++)
+ {
+ switch(szText[i])
+ {
+ case '&':
+ szRet.append("&amp;");
+ break;
+ case '<':
+ szRet.append("&lt;");
+ break;
+ case '>':
+ szRet.append("&gt;");
+ break;
+ case '"':
+ szRet.append("&quot;");
+ break;
+ case '\'':
+ szRet.append("&apos;");
+ break;
+ default:
+ szRet += szText[i];
+ }
+ }
+ return szRet;
+}
+
+
+LeakFinderOutput::LeakFinderOutput(int options, LPCSTR szSymPath)
+ : StackWalker(options, szSymPath)
+{
+}
+void LeakFinderOutput::OnLeakSearchStart(LPCSTR szLeakFinderName)
+{
+ CHAR buffer[1024];
+ _snprintf_s(buffer, 1024, "######## %s ########\n", szLeakFinderName);
+ this->OnOutput(buffer);
+}
+void LeakFinderOutput::OnLeakStartEntry(LPCSTR szKeyName, SIZE_T nDataSize)
+{
+ CHAR buffer[1024];
+ _snprintf_s(buffer, 1024, "--------------- Key: %s, %d bytes ---------\n", szKeyName, nDataSize);
+ this->OnOutput(buffer);
+}
+void LeakFinderOutput::OnCallstackEntry(CallstackEntryType eType, CallstackEntry &entry)
+{
+ if ( (eType != lastEntry) && (entry.offset != 0) )
+ {
+ if ( ((this->m_options & LeakFinderShowCompleteCallstack) == 0) && (
+ (strstr(entry.lineFileName, "afxmem.cpp") != NULL) ||
+ (strstr(entry.lineFileName, "dbgheap.c") != NULL) ||
+ (strstr(entry.lineFileName, "new.cpp") != NULL) ||
+ (strstr(entry.lineFileName, "newop.cpp") != NULL) ||
+ (strstr(entry.lineFileName, "leakfinder.cpp") != NULL) ||
+ (strstr(entry.lineFileName, "stackwalker.cpp") != NULL)
+ ) )
+ {
+ return;
+ }
+ }
+ StackWalker::OnCallstackEntry(eType, entry);
+}
+
+
+// ####################################################################
+// XML-Output
+LeakFinderXmlOutput::LeakFinderXmlOutput()
+{
+ TCHAR szXMLFileName[1024];
+
+ GetModuleFileName(NULL, szXMLFileName, sizeof(szXMLFileName) / sizeof(TCHAR));
+ _tcscat_s(szXMLFileName, _T(".mem.xml-leaks"));
+#if _MSC_VER < 1400
+ m_fXmlFile = _tfopen(szXMLFileName, _T("w"));
+#else
+ m_fXmlFile = NULL;
+ _tfopen_s(&m_fXmlFile, szXMLFileName, _T("w"));
+#endif
+ if (m_fXmlFile != NULL)
+ {
+ SYSTEMTIME st;
+ GetLocalTime(&st);
+ fprintf(m_fXmlFile, "<MEMREPORT date=\"%.2d/%.2d/%.4d\" time=\"%.2d:%.2d:%.2d\">\n",
+ st.wMonth, st.wDay, st.wYear,
+ st.wHour, st.wMinute, st.wSecond);
+ }
+ else
+ {
+ MessageBox(NULL, _T("Could not open xml-logfile for leakfinder!"), _T("Warning"), MB_ICONHAND);
+ }
+}
+LeakFinderXmlOutput::LeakFinderXmlOutput(LPCTSTR szFileName)
+{
+#if _MSC_VER < 1400
+ m_fXmlFile = _tfopen(szFileName, _T("w"));
+#else
+ m_fXmlFile = NULL;
+ _tfopen_s(&m_fXmlFile, szFileName, _T("w"));
+#endif
+ if (m_fXmlFile == NULL)
+ {
+ MessageBox(NULL, _T("Could not open xml-logfile for leakfinder!"), _T("Warning"), MB_ICONHAND);
+ }
+}
+LeakFinderXmlOutput::~LeakFinderXmlOutput()
+{
+ if (m_fXmlFile != NULL)
+ {
+ // Write the ending-tags and close the file
+ fprintf(m_fXmlFile, "</MEMREPORT>\n");
+ fclose(m_fXmlFile);
+ }
+ m_fXmlFile = NULL;
+}
+void LeakFinderXmlOutput::OnLeakSearchStart(LPCSTR sszLeakFinderName)
+{
+}
+void LeakFinderXmlOutput::OnLeakStartEntry(LPCSTR szKeyName, SIZE_T nDataSize)
+{
+ if (m_fXmlFile != NULL)
+ {
+ fprintf(m_fXmlFile, " <LEAK requestID=\"%s\" size=\"%d\">\n", SimpleXMLEncode(szKeyName).c_str(), nDataSize);
+ }
+}
+void LeakFinderXmlOutput::OnCallstackEntry(CallstackEntryType eType, CallstackEntry &entry)
+{
+ if (m_fXmlFile != NULL)
+ {
+ if (eType != lastEntry)
+ {
+ fprintf(m_fXmlFile, " <STACKENTRY decl=\"%s\" decl_offset=\"%+ld\" ", SimpleXMLEncode(entry.undName).c_str(), entry.offsetFromSmybol);
+ fprintf(m_fXmlFile, "srcfile=\"%s\" line=\"%d\" line_offset=\"%+ld\" ", SimpleXMLEncode(entry.lineFileName).c_str(), entry.lineNumber, entry.offsetFromLine);
+ fprintf(m_fXmlFile, "module=\"%s\" base=\"%08lx\" ", SimpleXMLEncode(entry.moduleName).c_str(), entry.baseOfImage);
+ fprintf(m_fXmlFile, "/>\n");
+ }
+ else
+ {
+ fprintf(m_fXmlFile, " </LEAK>\n");
+ }
+ }
+}
+
+// ##########################################################################
+// ##########################################################################
+// ##########################################################################
+// Base class for storing contexts in a hashtable
+template <typename HASHTABLE_KEY> class ContextHashtableBase
+{
+public:
+ ContextHashtableBase(SIZE_T sizeOfHastable, LPCSTR finderName)
+ {
+ SIZE_T s = sizeOfHastable*sizeof(AllocHashEntryType);
+ m_hHeap = HeapCreate(0, 10*1024 + s, 0);
+ if (m_hHeap == NULL)
+ throw;
+ pAllocHashTable = (AllocHashEntryType*) own_malloc(s);
+ sAllocEntries = sizeOfHastable;
+ m_finderName = own_strdup(finderName);
+ }
+
+protected:
+ virtual ~ContextHashtableBase()
+ {
+ if (pAllocHashTable != NULL)
+ own_free(pAllocHashTable);
+ pAllocHashTable = NULL;
+
+ own_free(m_finderName);
+ m_finderName = NULL;
+
+ if (m_hHeap != NULL)
+ HeapDestroy(m_hHeap);
+ }
+
+ __inline LPVOID own_malloc(SIZE_T size)
+ {
+ return HeapAlloc(m_hHeap, HEAP_ZERO_MEMORY, size);
+ }
+ __inline VOID own_free(LPVOID memblock)
+ {
+ HeapFree(m_hHeap, 0, memblock);
+ }
+ __inline CHAR *own_strdup(const char *str)
+ {
+ size_t len = strlen(str)+1;
+ CHAR *c = (CHAR*)own_malloc(len);
+#if _MSC_VER >= 1400
+ strcpy_s(c, len, str);
+#else
+ strcpy(c, str);
+#endif
+ return c;
+ }
+
+ // Disables this leak-finder
+ virtual LONG Disable() = 0;
+ // enables the leak-finder again...
+ virtual LONG Enable() = 0;
+
+private:
+ // Entry for each allocation
+ typedef struct AllocHashEntryType {
+ HASHTABLE_KEY key;
+ SIZE_T nDataSize; // Size of the allocated memory
+ struct AllocHashEntryType *Next;
+ CONTEXT c;
+ PVOID pStackBaseAddr;
+ SIZE_T nMaxStackSize;
+
+ PVOID pCallstackOffset;
+ SIZE_T nCallstackLen;
+ char pcCallstackAddr[MAX_CALLSTACK_LEN_BUF]; // min of both values...
+ } AllocHashEntryType;
+
+protected:
+ virtual SIZE_T HashFunction(HASHTABLE_KEY &key) = 0;
+ virtual BOOL IsKeyEmpty(HASHTABLE_KEY &key) = 0;
+ virtual VOID SetEmptyKey(HASHTABLE_KEY &key) = 0;
+ virtual VOID GetKeyAsString(HASHTABLE_KEY &key, CHAR *szName, SIZE_T nBufferLen) = 0;
+ //virtual SIZE_T GetNativeBytes(HASHTABLE_KEY &key, CHAR *szName, SIZE_T nBufferLen) { return 0; }
+
+public:
+ VOID Insert(HASHTABLE_KEY &key, CONTEXT &context, SIZE_T nDataSize)
+ {
+ SIZE_T HashIdx;
+ AllocHashEntryType *pHashEntry;
+
+ // generate hash-value
+ HashIdx = HashFunction(key);
+
+ pHashEntry = &pAllocHashTable[HashIdx];
+ if (IsKeyEmpty(pHashEntry->key) != FALSE) {
+ // Entry is empty...
+ }
+ else {
+ // Entry is not empy! make a list of entries for this hash value...
+ while(pHashEntry->Next != NULL) {
+ pHashEntry = pHashEntry->Next;
+ }
+
+ pHashEntry->Next = (AllocHashEntryType*) own_malloc(sizeof(AllocHashEntryType));
+ pHashEntry = pHashEntry->Next;
+ }
+ pHashEntry->key = key;
+ pHashEntry->nDataSize = nDataSize;
+ pHashEntry->Next = NULL;
+#ifdef _M_IX86
+ pHashEntry->pCallstackOffset = (LPVOID) min(context.Ebp, context.Esp);
+#elif _M_X64
+ pHashEntry->pCallstackOffset = (LPVOID) min(context.Rdi, context.Rsp);
+#elif _M_IA64
+ pHashEntry->pCallstackOffset = (LPVOID) min(context.IntSp, context.RsBSP);
+#else
+#error "Platform not supported!"
+#endif
+ pHashEntry->c = context;
+
+ // Query the max. stack-area:
+ MEMORY_BASIC_INFORMATION MemBuffer;
+ if(VirtualQuery((LPCVOID) pHashEntry->pCallstackOffset, &MemBuffer, sizeof(MemBuffer)) > 0)
+ {
+ pHashEntry->pStackBaseAddr = MemBuffer.BaseAddress;
+ pHashEntry->nMaxStackSize = MemBuffer.RegionSize;
+ }
+ else
+ {
+ pHashEntry->pStackBaseAddr = 0;
+ pHashEntry->nMaxStackSize = 0;
+ }
+
+ SIZE_T bytesToRead = MAX_CALLSTACK_LEN_BUF;
+ if (pHashEntry->nMaxStackSize > 0)
+ {
+ SIZE_T len = ((SIZE_T) pHashEntry->pStackBaseAddr + pHashEntry->nMaxStackSize) - (SIZE_T)pHashEntry->pCallstackOffset;
+ bytesToRead = min(len, MAX_CALLSTACK_LEN_BUF);
+ }
+ // Now read the callstack:
+ if (ReadProcessMemory(GetCurrentProcess(), (LPCVOID) pHashEntry->pCallstackOffset, &(pHashEntry->pcCallstackAddr), bytesToRead, &(pHashEntry->nCallstackLen)) == 0)
+ {
+ // Could not read memory...
+ pHashEntry->nCallstackLen = 0;
+ pHashEntry->pCallstackOffset = 0;
+ } // read callstack
+ } // Insert
+
+ BOOL Remove(HASHTABLE_KEY &key)
+ {
+ SIZE_T HashIdx;
+ AllocHashEntryType *pHashEntry, *pHashEntryLast;
+
+ // get the Hash-Value
+ HashIdx = HashFunction(key);
+
+ pHashEntryLast = NULL;
+ pHashEntry = &pAllocHashTable[HashIdx];
+ while(pHashEntry != NULL) {
+ if (pHashEntry->key == key) {
+ // release my memory
+ if (pHashEntryLast == NULL) {
+ // It is an entry in the table, so do not release this memory
+ if (pHashEntry->Next == NULL) {
+ // It was the last entry, so empty the table entry
+ SetEmptyKey(pAllocHashTable[HashIdx].key);
+ //memset(&pAllocHashTable[HashIdx], 0, sizeof(pAllocHashTable[HashIdx]));
+ }
+ else {
+ // There are some more entries, so shorten the list
+ AllocHashEntryType *pTmp = pHashEntry->Next;
+ *pHashEntry = *(pHashEntry->Next);
+ own_free(pTmp);
+ }
+ return TRUE;
+ }
+ else {
+ // now, I am in an dynamic allocated entry (it was a collision)
+ pHashEntryLast->Next = pHashEntry->Next;
+ own_free(pHashEntry);
+ return TRUE;
+ }
+ }
+ pHashEntryLast = pHashEntry;
+ pHashEntry = pHashEntry->Next;
+ }
+
+ // if we are here, we could not find the RequestID
+ return FALSE;
+ }
+
+ AllocHashEntryType *Find(HASHTABLE_KEY &key)
+ {
+ SIZE_T HashIdx;
+ AllocHashEntryType *pHashEntry;
+
+ // get the Hash-Value
+ HashIdx = HashFunction(key);
+
+ pHashEntry = &pAllocHashTable[HashIdx];
+ while(pHashEntry != NULL) {
+ if (pHashEntry->key == key) {
+ return pHashEntry;
+ }
+ pHashEntry = pHashEntry->Next;
+ }
+
+ // entry was not found!
+ return NULL;
+ }
+
+ // For the followong static-var See comment in "ShowCallstack"...
+ static BOOL CALLBACK ReadProcessMemoryFromHashEntry64(
+ HANDLE hProcess, // hProcess must be a pointer to an hash-entry!
+ DWORD64 lpBaseAddress,
+ PVOID lpBuffer,
+ DWORD nSize,
+ LPDWORD lpNumberOfBytesRead,
+ LPVOID pUserData // optional data, which was passed in "ShowCallstack"
+ )
+ {
+ *lpNumberOfBytesRead = 0;
+ AllocHashEntryType *pHashEntry = (AllocHashEntryType*) pUserData;
+ if (pHashEntry == NULL)
+ {
+ return FALSE;
+ }
+
+ if ( ( (DWORD64)lpBaseAddress >= (DWORD64)pHashEntry->pCallstackOffset) && ((DWORD64)lpBaseAddress <= ((DWORD64)pHashEntry->pCallstackOffset+pHashEntry->nCallstackLen)) ) {
+ // Memory is located in saved Callstack:
+ // Calculate the offset
+ DWORD dwOffset = (DWORD) ((DWORD64)lpBaseAddress - (DWORD64)pHashEntry->pCallstackOffset);
+ DWORD dwSize = __min(nSize, MAX_CALLSTACK_LEN_BUF-dwOffset);
+ memcpy(lpBuffer, &(pHashEntry->pcCallstackAddr[dwOffset]), dwSize);
+ *lpNumberOfBytesRead = dwSize;
+ if (dwSize != nSize)
+ {
+ return FALSE;
+ }
+ *lpNumberOfBytesRead = nSize;
+ return TRUE;
+ }
+
+ if (*lpNumberOfBytesRead == 0) // Memory could not be found
+ {
+ if ( ( (DWORD64)lpBaseAddress < (DWORD64)pHashEntry->pStackBaseAddr) || ((DWORD64)lpBaseAddress > ((DWORD64)pHashEntry->pStackBaseAddr+pHashEntry->nMaxStackSize)) )
+ {
+ // Stackwalking is done by reading the "real memory" (normally this happens when the StackWalk64 tries to read some code)
+ SIZE_T st = 0;
+ BOOL bRet = ReadProcessMemory(hProcess, (LPCVOID) lpBaseAddress, lpBuffer, nSize, &st);
+ *lpNumberOfBytesRead = (DWORD) st;
+ return bRet;
+ }
+ }
+
+ return TRUE;
+ }
+
+ VOID ShowLeaks(LeakFinderOutput &leakFinderOutput)
+ {
+ SIZE_T ulTemp;
+ AllocHashEntryType *pHashEntry;
+ ULONG ulCount = 0;
+ SIZE_T ulLeaksByte = 0;
+
+ leakFinderOutput.OnLeakSearchStart(this->m_finderName);
+
+ // Move throu every entry
+ CHAR keyName[1024];
+ for(ulTemp = 0; ulTemp < this->sAllocEntries; ulTemp++) {
+ pHashEntry = &pAllocHashTable[ulTemp];
+ if (IsKeyEmpty(pHashEntry->key) == FALSE) {
+ while(pHashEntry != NULL) {
+ ulCount++;
+ CONTEXT c;
+ memcpy(&c, &(pHashEntry->c), sizeof(CONTEXT));
+
+ this->GetKeyAsString(pHashEntry->key, keyName, 1024);
+
+ leakFinderOutput.OnLeakStartEntry(keyName, pHashEntry->nDataSize);
+ leakFinderOutput.ShowCallstack(GetCurrentThread(), &c, ReadProcessMemoryFromHashEntry64, pHashEntry);
+
+ // Count the number of leaky bytes
+ ulLeaksByte += pHashEntry->nDataSize;
+
+ pHashEntry = pHashEntry->Next;
+ } // while
+ }
+ }
+ }
+
+ AllocHashEntryType *pAllocHashTable;
+ SIZE_T sAllocEntries;
+ HANDLE m_hHeap;
+ LPSTR m_finderName;
+ bool m_bSupressUselessLines;
+}; // template <typename HASHTABLE_KEY> class ContextHashtableBase
+
+
+// ##########################################################################
+// ##########################################################################
+// ##########################################################################
+// Specialization for CRT-Leaks:
+// VC5 has excluded all types in release-builds
+#ifdef _DEBUG
+
+// The follwoing is copied from dbgint.h:
+// <CRT_INTERNALS>
+/*
+* For diagnostic purpose, blocks are allocated with extra information and
+* stored in a doubly-linked list. This makes all blocks registered with
+* how big they are, when they were allocated, and what they are used for.
+*/
+
+// forward declaration:
+#ifndef _M_CEE_PURE
+#define MyAllocHookCallingConvention __cdecl
+#endif
+#if _MSC_VER >= 1400
+#ifdef _M_CEE
+#define MyAllocHookCallingConvention __clrcall
+#endif
+#endif
+
+static int MyAllocHookCallingConvention MyAllocHook(int nAllocType, void *pvData,
+ size_t nSize, int nBlockUse, long lRequest,
+#if _MSC_VER <= 1100 // Special case for VC 5 and before
+ const char * szFileName,
+#else
+ const unsigned char * szFileName,
+#endif
+ int nLine);
+
+static _CRT_ALLOC_HOOK s_pfnOldCrtAllocHook = NULL;
+static LONG s_CrtDisableCount = 0;
+static LONG s_lMallocCalled = 0;
+
+
+class CRTTable : public ContextHashtableBase<LONG>
+{
+public:
+ CRTTable() : ContextHashtableBase<LONG>(1021, "CRT-Leaks")
+ {
+ // save the previous alloc hook
+ s_pfnOldCrtAllocHook = _CrtSetAllocHook(MyAllocHook);
+ }
+
+ virtual ~CRTTable()
+ {
+ _CrtSetAllocHook(s_pfnOldCrtAllocHook);
+ }
+
+ virtual LONG Disable()
+ {
+ return InterlockedIncrement(&s_CrtDisableCount);
+ }
+ virtual LONG Enable()
+ {
+ return InterlockedDecrement(&s_CrtDisableCount);
+ }
+
+ virtual SIZE_T HashFunction(LONG &key)
+ {
+ // I couldn´t find any better and faster
+ return key % sAllocEntries;
+ }
+ virtual BOOL IsKeyEmpty(LONG &key)
+ {
+ if (key == 0)
+ return TRUE;
+ return FALSE;
+ }
+ virtual VOID SetEmptyKey(LONG &key)
+ {
+ key = 0;
+ }
+ virtual VOID GetKeyAsString(LONG &key, CHAR *szName, SIZE_T nBufferLen)
+ {
+#if _MSC_VER < 1400
+ _snprintf_s(szName, nBufferLen, "%d", key);
+#else
+ _snprintf_s(szName, nBufferLen, nBufferLen, "%d", key);
+#endif
+ }
+
+protected:
+ CHAR *m_pBuffer;
+ SIZE_T m_maxBufferLen;
+ SIZE_T m_bufferLen;
+}; // class CRTTable
+
+
+#define nNoMansLandSize 4
+
+typedef struct _CrtMemBlockHeader
+{
+ struct _CrtMemBlockHeader * pBlockHeaderNext;
+ struct _CrtMemBlockHeader * pBlockHeaderPrev;
+ char * szFileName;
+ int nLine;
+#ifdef _WIN64
+ /* These items are reversed on Win64 to eliminate gaps in the struct
+ * and ensure that sizeof(struct)%16 == 0, so 16-byte alignment is
+ * maintained in the debug heap.
+ */
+ int nBlockUse;
+ size_t nDataSize;
+#else /* _WIN64 */
+ size_t nDataSize;
+ int nBlockUse;
+#endif /* _WIN64 */
+ long lRequest;
+ unsigned char gap[nNoMansLandSize];
+ /* followed by:
+ * unsigned char data[nDataSize];
+ * unsigned char anotherGap[nNoMansLandSize];
+ */
+} _CrtMemBlockHeader;
+#define pbData(pblock) ((unsigned char *)((_CrtMemBlockHeader *)pblock + 1))
+#define pHdr(pbData) (((_CrtMemBlockHeader *)pbData)-1)
+// </CRT_INTERNALS>
+
+static CRTTable *g_pCRTTable = NULL;
+
+
+// MyAllocHook is Single-Threaded, that means the the calls are serialized in the calling function!
+static int MyAllocHook(int nAllocType, void *pvData,
+ size_t nSize, int nBlockUse, long lRequest,
+#if _MSC_VER <= 1100 // Special case for VC 5
+ const char * szFileName,
+#else
+ const unsigned char * szFileName,
+#endif
+ int nLine)
+{
+ //static TCHAR *operation[] = { _T(""), _T("ALLOCATIONG"), _T("RE-ALLOCATING"), _T("FREEING") };
+ //static TCHAR *blockType[] = { _T("Free"), _T("Normal"), _T("CRT"), _T("Ignore"), _T("Client") };
+
+#ifdef IGNORE_CRT_ALLOC
+ if (_BLOCK_TYPE(nBlockUse) == _CRT_BLOCK) // Ignore internal C runtime library allocations
+ return TRUE;
+#endif
+ extern int _crtDbgFlag;
+ if ( ((_CRTDBG_ALLOC_MEM_DF & _crtDbgFlag) == 0) && ( (nAllocType == _HOOK_ALLOC) || (nAllocType == _HOOK_REALLOC) ) )
+ {
+ // Someone has disabled that the runtime should log this allocation
+ // so we do not log this allocation
+ if (s_pfnOldCrtAllocHook != NULL)
+ s_pfnOldCrtAllocHook(nAllocType, pvData, nSize, nBlockUse, lRequest, szFileName, nLine);
+ return TRUE;
+ }
+
+ // Handle the Disable/Enable setting
+ if (InterlockedExchangeAdd(&s_CrtDisableCount, 0) != 0)
+ return TRUE;
+
+ // Prevent from reentrat calls
+ if (InterlockedIncrement(&s_lMallocCalled) > 1) { // I was already called
+ InterlockedDecrement(&s_lMallocCalled);
+ // call the previous alloc hook
+ if (s_pfnOldCrtAllocHook != NULL)
+ s_pfnOldCrtAllocHook(nAllocType, pvData, nSize, nBlockUse, lRequest, szFileName, nLine);
+ return TRUE;
+ }
+
+ _ASSERT( (nAllocType == _HOOK_ALLOC) || (nAllocType == _HOOK_REALLOC) || (nAllocType == _HOOK_FREE) );
+ _ASSERT( ( _BLOCK_TYPE(nBlockUse) >= 0 ) && ( _BLOCK_TYPE(nBlockUse) < 5 ) );
+
+ if (nAllocType == _HOOK_FREE) { // freeing
+ // Try to get the header information
+ if (_CrtIsValidHeapPointer(pvData)) { // it is a valid Heap-Pointer
+ // get the ID
+ _CrtMemBlockHeader *pHead;
+ // get a pointer to memory block header
+ pHead = pHdr(pvData);
+ nSize = pHead->nDataSize;
+ lRequest = pHead->lRequest; // This is the ID!
+
+ if (pHead->nBlockUse == _IGNORE_BLOCK)
+ {
+ InterlockedDecrement(&s_lMallocCalled);
+ if (s_pfnOldCrtAllocHook != NULL)
+ s_pfnOldCrtAllocHook(nAllocType, pvData, nSize, nBlockUse, lRequest, szFileName, nLine);
+ return TRUE;
+ }
+ }
+ if (lRequest != 0) { // RequestID was found
+ g_pCRTTable->Remove(lRequest);
+ }
+ } // freeing
+
+ if (nAllocType == _HOOK_REALLOC) { // re-allocating
+ // Try to get the header information
+ if (_CrtIsValidHeapPointer(pvData)) { // it is a valid Heap-Pointer
+ BOOL bRet;
+ LONG lReallocRequest;
+ // get the ID
+ _CrtMemBlockHeader *pHead;
+ // get a pointer to memory block header
+ pHead = pHdr(pvData);
+ // Try to find the RequestID in the Hash-Table, mark it that it was freed
+ lReallocRequest = pHead->lRequest;
+ bRet = g_pCRTTable->Remove(lReallocRequest);
+ } // ValidHeapPointer
+ } // re-allocating
+
+ //if ( (g_ulShowStackAtAlloc < 3) && (nAllocType == _HOOK_FREE) ) {
+ if (nAllocType == _HOOK_FREE) {
+ InterlockedDecrement(&s_lMallocCalled);
+ // call the previous alloc hook
+ if (s_pfnOldCrtAllocHook != NULL)
+ s_pfnOldCrtAllocHook(nAllocType, pvData, nSize, nBlockUse, lRequest, szFileName, nLine);
+ return TRUE;
+ }
+
+ CONTEXT c;
+ GET_CURRENT_CONTEXT(c, CONTEXT_FULL);
+
+ // Only insert in the Hash-Table if it is not a "freeing"
+ if (nAllocType != _HOOK_FREE) {
+ if(lRequest != 0) // Always a valid RequestID should be provided (see comments in the header)
+ g_pCRTTable->Insert(lRequest, c, nSize);
+ }
+
+ InterlockedDecrement(&s_lMallocCalled);
+ // call the previous alloc hook
+ if (s_pfnOldCrtAllocHook != NULL)
+ s_pfnOldCrtAllocHook(nAllocType, pvData, nSize, nBlockUse, lRequest, szFileName, nLine);
+ return TRUE; // allow the memory operation to proceed
+} // MyAllocHook
+
+#endif // _DEBUG
+
+
+// ##########################################################################
+// ##########################################################################
+// ##########################################################################
+// Specialization for COM-Leaks:
+
+// forwards:
+class COMTable;
+class CMallocSpy : public IMallocSpy
+{
+public:
+ CMallocSpy() { m_cbRequest = 0; m_cRef = 0; m_disableCount = 0; }
+ virtual ~CMallocSpy() {}
+ // IUnknown methods
+ STDMETHOD(QueryInterface) (REFIID riid, LPVOID *ppUnk);
+ STDMETHOD_(ULONG, AddRef) ();
+ STDMETHOD_(ULONG, Release) ();
+ // IMallocSpy methods
+ STDMETHOD_(SIZE_T, PreAlloc) (SIZE_T cbRequest);
+ STDMETHOD_(void *, PostAlloc) (void *pActual);
+ STDMETHOD_(void *, PreFree) (void *pRequest, BOOL fSpyed);
+ STDMETHOD_(void, PostFree) (BOOL fSpyed) { return; };
+ STDMETHOD_(SIZE_T, PreRealloc) (void *pRequest, SIZE_T cbRequest, void **ppNewRequest, BOOL fSpyed);
+ STDMETHOD_(void *, PostRealloc) (void *pActual, BOOL fSpyed);
+ STDMETHOD_(void *, PreGetSize) (void *pRequest, BOOL fSpyed) { return pRequest; }
+ STDMETHOD_(SIZE_T, PostGetSize) (SIZE_T cbActual, BOOL fSpyed) { return cbActual; }
+ STDMETHOD_(void *, PreDidAlloc) (void *pRequest, BOOL fSpyed) { return pRequest; }
+ STDMETHOD_(BOOL, PostDidAlloc) (void *pRequest, BOOL fSpyed, BOOL fActual) { return fActual; }
+ STDMETHOD_(void, PreHeapMinimize) (void) { return; }
+ STDMETHOD_(void, PostHeapMinimize) (void) { return; }
+private:
+ LONG m_cRef;
+ SIZE_T m_cbRequest;
+protected:
+ COMTable *m_pComTable;
+ LONG m_disableCount;
+ friend COMTable;
+};
+
+class COMTable : public ContextHashtableBase<LPVOID>
+{
+public:
+ COMTable() : ContextHashtableBase<LPVOID>(1021, "COM-Leaks")
+ {
+ m_pMallocSpy = new CMallocSpy(); // wird später durch Release freigegeben
+ if (m_pMallocSpy != NULL)
+ {
+ m_pMallocSpy->m_pComTable = this;
+ // CoInitilize(); // ??? Is this necessary ?
+ HRESULT hr = CoRegisterMallocSpy(m_pMallocSpy);
+ if FAILED(hr)
+ {
+ _tprintf(_T("\nCoRegisterMallocSpay failed with %.8x"), hr);
+ }
+ }
+ }
+
+ virtual ~COMTable()
+ {
+ if (m_pMallocSpy != NULL)
+ m_pMallocSpy->m_pComTable = NULL;
+ CoRevokeMallocSpy();
+ }
+
+ virtual LONG Disable()
+ {
+ return InterlockedIncrement(&(m_pMallocSpy->m_disableCount));
+ }
+ virtual LONG Enable()
+ {
+ return InterlockedDecrement(&(m_pMallocSpy->m_disableCount));
+ }
+
+ virtual SIZE_T HashFunction(LPVOID &key)
+ {
+ // I couldn´t find any better and faster
+#ifdef _M_IX86
+#if _MSC_VER > 1100
+#pragma warning (push)
+#endif
+#pragma warning (disable: 4311)
+ DWORD llP = (DWORD) key;
+#if _MSC_VER > 1100
+#pragma warning (pop)
+#endif
+#else
+ ULONGLONG llP = (ULONGLONG) key;
+#endif
+ return (SIZE_T) llP % sAllocEntries;
+ }
+ virtual BOOL IsKeyEmpty(LPVOID &key)
+ {
+ if (key == 0)
+ return TRUE;
+ return FALSE;
+ }
+ virtual VOID SetEmptyKey(LPVOID &key)
+ {
+ key = 0;
+ }
+ virtual VOID GetKeyAsString(LPVOID &key, CHAR *szName, SIZE_T nBufferLen)
+ {
+#if _MSC_VER < 1400
+ _snprintf_s(szName, nBufferLen, "%p", key);
+#else
+ _snprintf_s(szName, nBufferLen, nBufferLen, "%p", key);
+#endif
+ }
+
+ CMallocSpy *m_pMallocSpy;
+ friend CMallocSpy;
+}; // class COMTable
+
+
+STDMETHODIMP CMallocSpy::QueryInterface(REFIID riid, LPVOID *ppUnk) {
+ HRESULT hr = S_OK;
+ if (IsEqualIID(riid, IID_IUnknown)) {
+ *ppUnk = (IUnknown *) this;
+ }
+ else if (IsEqualIID(riid, IID_IMallocSpy)) {
+ *ppUnk = (IMalloc *) this;
+ }
+ else {
+ *ppUnk = NULL;
+ hr = E_NOINTERFACE;
+ }
+ AddRef();
+ return hr;
+}
+STDMETHODIMP_(ULONG) CMallocSpy::AddRef(void) {
+ return (ULONG) InterlockedIncrement(&m_cRef);
+}
+STDMETHODIMP_(ULONG) CMallocSpy::Release(void) {
+ LONG cRef;
+ cRef = InterlockedDecrement(&m_cRef);
+ if (cRef == 0)
+ {
+ delete this;
+ }
+ return (ULONG) cRef;
+}
+// IMallocSpy methods
+STDMETHODIMP_(SIZE_T) CMallocSpy::PreAlloc(SIZE_T cbRequest) {
+ m_cbRequest = cbRequest;
+ return cbRequest;
+}
+STDMETHODIMP_(void *) CMallocSpy::PostAlloc(void *pActual) {
+ if (m_pComTable != NULL)
+ {
+ CONTEXT c;
+ GET_CURRENT_CONTEXT(c, CONTEXT_FULL);
+ m_pComTable->Insert(pActual, c, m_cbRequest);
+ }
+ return pActual;
+}
+STDMETHODIMP_(void *) CMallocSpy::PreFree(void *pRequest, BOOL fSpyed) {
+ if (m_pComTable != NULL)
+ {
+ m_pComTable->Remove(pRequest);
+ }
+ return pRequest;
+}
+STDMETHODIMP_(SIZE_T) CMallocSpy::PreRealloc(void *pRequest, SIZE_T cbRequest,
+ void **ppNewRequest, BOOL fSpyed) {
+ if (m_pComTable != NULL)
+ {
+ m_pComTable->Remove(pRequest);
+ }
+ *ppNewRequest = pRequest; // Bug fixed. Thanx to Christoph Weber
+ return cbRequest;
+}
+STDMETHODIMP_(void *) CMallocSpy::PostRealloc(void *pActual, BOOL fSpyed) {
+ if (m_pComTable != NULL)
+ {
+ CONTEXT c;
+ GET_CURRENT_CONTEXT(c, CONTEXT_FULL);
+ m_pComTable->Insert(pActual, c, m_cbRequest);
+ }
+ return pActual;
+}
+
+
+
+
+// ##########################################################################
+// ##########################################################################
+// ##########################################################################
+// Init/Deinit functions
+
+
+static COMTable *g_pCOMTable;
+HRESULT InitLeakFinder()
+{
+ // _X: Disabled COM monitoring: g_pCOMTable = new COMTable();
+#ifdef _DEBUG
+ g_pCRTTable = new CRTTable();
+#endif
+ return S_OK;
+}
+
+void DeinitLeakFinder(LeakFinderOutput *output)
+{
+ LeakFinderOutput *pLeakFinderOutput = output;
+
+#ifdef _DEBUG
+ g_pCRTTable->Disable();
+#endif
+ // _X: Disabled COM monitoring: g_pCOMTable->Disable();
+
+ if (pLeakFinderOutput == NULL)
+ pLeakFinderOutput = new LeakFinderOutput();
+
+ // explicite load the modules:
+ pLeakFinderOutput->LoadModules();
+
+#ifdef _DEBUG
+ g_pCRTTable->ShowLeaks(*pLeakFinderOutput);
+ if (g_pCRTTable != NULL)
+ delete g_pCRTTable;
+ g_pCRTTable = NULL;
+#endif
+
+ /*
+ // _X: Disabled COM monitoring:
+ g_pCOMTable->ShowLeaks(*pLeakFinderOutput);
+ if (g_pCOMTable != NULL)
+ delete g_pCOMTable;
+ g_pCOMTable = NULL;
+ */
+
+ if (output == NULL)
+ delete pLeakFinderOutput;
+}
+void DeinitLeakFinder()
+{
+ DeinitLeakFinder(NULL);
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-16 19:31:45 +0100