1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
|
#include "leaktrace.h"
#include <Windows.h>
#include <DbgHelp.h>
#include <set>
#include <map>
#include <sstream>
static const int FRAMES_TO_SKIP = 3; // StackData::StackData(), __TraceData::regTrace(), TraceAlloc()
static const int FRAMES_TO_CAPTURE = 10;
void initDbgIfNecessary()
{
HANDLE process = ::GetCurrentProcess();
static std::set<DWORD> initialized;
if (initialized.find(::GetCurrentProcessId()) == initialized.end()) {
static bool firstCall = true;
if (firstCall) {
::SymSetOptions(SYMOPT_UNDNAME | SYMOPT_DEFERRED_LOADS);
firstCall = false;
}
if (!::SymInitialize(process, NULL, TRUE)) {
printf("failed to initialize symbols: %d", ::GetLastError());
}
initialized.insert(::GetCurrentProcessId());
}
}
class StackData {
friend bool operator==(const StackData &LHS, const StackData &RHS);
friend bool operator<(const StackData &LHS, const StackData &RHS);
public:
StackData() {
m_Count = ::CaptureStackBackTrace(FRAMES_TO_SKIP, FRAMES_TO_CAPTURE, m_Stack, &m_Hash);
}
std::string toString() const {
initDbgIfNecessary();
char buffer[sizeof(SYMBOL_INFO) + MAX_SYM_NAME * sizeof(TCHAR)];
PSYMBOL_INFO symbol = (PSYMBOL_INFO)buffer;
symbol->SizeOfStruct = sizeof(SYMBOL_INFO);
symbol->MaxNameLen = MAX_SYM_NAME;
std::ostringstream stackStream;
for(unsigned int i = 0; i < m_Count; ++i) {
DWORD64 displacement = 0;
if (!::SymFromAddr(::GetCurrentProcess(), (DWORD64)m_Stack[i], &displacement, symbol)) {
stackStream << m_Count - i - 1 << ": [" << m_Stack[i] << "]\n";
} else {
stackStream << m_Count - i - 1 << ": " << symbol->Name << "\n";
}
}
return stackStream.str();
}
private:
LPVOID m_Stack[FRAMES_TO_CAPTURE];
USHORT m_Count;
ULONG m_Hash;
};
bool operator==(const StackData &LHS, const StackData &RHS) {
return LHS.m_Hash == RHS.m_Hash;
}
bool operator<(const StackData &LHS, const StackData &RHS) {
return LHS.m_Hash < RHS.m_Hash;
}
static struct __TraceData {
void regTrace(void *pointer) {
m_Traces[reinterpret_cast<unsigned long>(pointer)] = StackData();
}
void deregTrace(void *pointer) {
auto iter = m_Traces.find(reinterpret_cast<unsigned long>(pointer));
if (iter != m_Traces.end()) {
m_Traces.erase(iter);
}
}
~__TraceData() {
std::map<StackData, int> result;
for (auto iter = m_Traces.begin(); iter != m_Traces.end(); ++iter) {
result[iter->second] += 1;
}
for (auto iter = result.begin(); iter != result.end(); ++iter) {
printf("-----------------------------------\n"
"%d objects not freed, allocated at:\n%s",
iter->second, iter->first.toString().c_str());
}
}
std::map<unsigned long, StackData> m_Traces;
} __trace;
void LeakTrace::TraceAlloc(void *ptr)
{
__trace.regTrace(ptr);
}
void LeakTrace::TraceDealloc(void *ptr)
{
__trace.deregTrace(ptr);
}
|
