Debian Codegraph @

xo/dmalloc.cxx

raw
1 /* dmalloc.cxx
2 $Id: dmalloc.cxx,v 1.7 1998/10/15 07:12:41 elf Exp $
3
4 written by Marc Singer
5 27 May 1997
6
7 This file is part of the project XO. See the file README for
8 more information.
9
10 Copyright (C) 1997 Marc Singer
11
12 This program is free software; you can redistribute it and/or
13 modify it under the terms of the GNU General Public License as
14 published by the Free Software Foundation; either version 2 of the
15 License, or (at your option) any later version.
16
17 This program is distributed in the hope that it will be useful, but
18 WITHOUT ANY WARRANTY; without even the implied warranty of
19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20 General Public License for more details.
21
22 You should have received a copy of the GNU General Public License
23 in a file called COPYING along with this program; if not, write to
24 the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA
25 02139, USA.
26
27 -----------
28 DESCRIPTION
29 -----------
30
31 */
32
33
34 #define BY_DMALLOC
35 #include "standard.h"
36 #include "dmalloc.h"
37
38 typedef struct _WRAPPER {
39 unsigned32 marker; // Marker for start of block
40 _WRAPPER* pPrev;
41 _WRAPPER* pNext;
42 unsigned long cb; // User's size of block
43 char szModule[16]; // Word aligned name of allocating source
44 } WRAPPER;
45
46 #define CB_WRAPPER (sizeof (WRAPPER) + sizeof (unsigned32))
47 //#define MARKER_HEAD (unsigned32) 0xefacdaed
48 #define MARKER_HEAD ((unsigned32) 0xfecade2b)
49 #define MARKER_TAIL ((unsigned32) 0xd1cefaef)
50
51 #define B_WRAP '+'
52 #define B_FREE '-'
53
54 WRAPPER* g_pWrapperHead; // Head of list of wrapped blocks
55
56
57 void _tell_ (WRAPPER* pWrapper);
58 bool _validate_one_ (WRAPPER* pWrapper);
59 bool _validate_ (WRAPPER* pWrapper);
60 void* _wrap_ (void* pv, int cb, const char* szModule, int iLine,
61 bool fFill, WRAPPER** ppWrapLink);
62
63
64
65 /* ::operator new & delete
66
67 replace global new and delete operators.
68
69 */
70
71 void* operator new (size_t cb)
72 {
73 return _malloc_ (cb, "unknown", 0);
74 }
75
76 void* operator new (size_t cb, const char* szModule, int iLine)
77 {
78 return _malloc_ (cb, szModule, iLine);
79 }
80
81 void operator delete (void* pv)
82 {
83 _free_ (pv);
84 }
85
86
87 void dmalloc_exit (void)
88 {
89 for (WRAPPER* pWrapper = g_pWrapperHead; pWrapper;
90 pWrapper = pWrapper->pNext)
91 _tell_ (pWrapper);
92 }
93
94
95
96 void dmalloc_validate (void)
97 {
98 if (!_validate_ (g_pWrapperHead))
99 fprintf (stderr, "heap invalid on dmalloc_validate\n");
100 }
101
102
103
104 /* _free_
105
106 */
107
108 void _free_ (void* pv)
109 {
110 if (!pv)
111 return;
112
113 // -- Locate
114 WRAPPER* pWrapper = (WRAPPER*) ((unsigned8*) pv - sizeof (WRAPPER));
115 if (!_validate_one_ (pWrapper)) {
116 _tell_ (pWrapper);
117 fprintf (stderr, "heap invalid on free\n");
118 return;
119 }
120 // -- Unlink
121 if (pWrapper->pPrev)
122 pWrapper->pPrev->pNext = pWrapper->pNext;
123 if (pWrapper->pNext)
124 pWrapper->pNext->pPrev = pWrapper->pPrev;
125 if (g_pWrapperHead == pWrapper)
126 g_pWrapperHead = pWrapper->pNext;
127
128 // -- Release
129 free (pWrapper);
130 }
131
132
133 /* _calloc_
134
135 allocate memory and wrap it with tracing information.
136
137 */
138
139 void* _calloc_ (size_t c, size_t cb, const char* szModule, int iLine)
140 {
141 if (!_validate_ (g_pWrapperHead)) {
142 fprintf (stderr, "heap invalid on malloc\n");
143 return NULL;
144 }
145
146 cb *= c;
147 void* pv = malloc (cb + CB_WRAPPER);
148 if (pv && CB_WRAPPER)
149 pv = _wrap_ (pv, cb, szModule, iLine, false, &g_pWrapperHead);
150
151 // ASSERT_FAIL (pv);
152
153 return pv;
154 }
155
156
157 /* _malloc_
158
159 allocate memory and wrap it with tracing information.
160
161 */
162
163 void* _malloc_ (size_t cb, const char* szModule, int iLine)
164 {
165 if (!_validate_ (g_pWrapperHead)) {
166 fprintf (stderr, "heap invalid on malloc\n");
167 return NULL;
168 }
169
170 void* pv = malloc (cb + CB_WRAPPER);
171 if (pv && CB_WRAPPER)
172 pv = _wrap_ (pv, cb, szModule, iLine, true, &g_pWrapperHead);
173
174 // ASSERT_FAIL (pv);
175
176 return pv;
177 }
178
179
180 /* _realloc_
181
182 re-allocate memory and wrap it with tracing information.
183
184 */
185
186 void* _realloc_ (void* pvOld, size_t cb, const char* szModule, int iLine)
187 {
188 if (!_validate_ (g_pWrapperHead)) {
189 fprintf (stderr, "heap invalid on malloc\n");
190 return NULL;
191 }
192
193 void* pv = _malloc_ (cb + CB_WRAPPER, szModule, iLine);
194 if (pv) {
195 unsigned int cbCopy = ((WRAPPER*) pvOld)->cb;
196 if (cbCopy > cb)
197 cbCopy = cb;
198 memcpy ((unsigned8*) pv + sizeof (WRAPPER),
199 (unsigned8*) pvOld + sizeof (WRAPPER), cbCopy);
200 _free_ (pvOld);
201 }
202 if (pv && CB_WRAPPER)
203 pv = _wrap_ (pv, cb, szModule, iLine, true, &g_pWrapperHead);
204
205 // ASSERT_FAIL (pv);
206
207 return pv;
208 }
209
210
211 void* _wrap_ (void* pv, int cb, const char* szModule, int iLine,
212 bool fFill, WRAPPER** ppWrapLink)
213 {
214 // -- Fill
215 if (fFill)
216 memset ((unsigned8*) pv + sizeof (WRAPPER), B_WRAP, cb);
217 else
218 memset ((unsigned8*) pv + sizeof (WRAPPER), 0, cb); // calloc requires this
219
220 // -- Wrap
221 WRAPPER* pWrapper = (WRAPPER*) pv;
222 pWrapper->marker = MARKER_HEAD;
223 pWrapper->cb = cb; // User's requested size
224 memset (pWrapper->szModule, 0, sizeof (pWrapper->szModule));
225 sprintf (pWrapper->szModule, "%.10s.%.4d", szModule, iLine);
226 *(unsigned32*) ((unsigned char*) pv + sizeof (WRAPPER) + cb) = MARKER_TAIL;
227
228 // -- Link
229 pWrapper->pPrev = NULL;
230 pWrapper->pNext = *ppWrapLink;
231 if (*ppWrapLink)
232 (*ppWrapLink)->pPrev = pWrapper;
233 *ppWrapLink = pWrapper;
234 return (void*)(pWrapper + 1);
235 }
236
237
238 void _tell_ (WRAPPER* pWrapper)
239 {
240 fprintf (stderr, "block 0x%lx %ld (0x%lx) bytes for %.*s",
241 (unsigned long) pWrapper + 1, pWrapper->cb, pWrapper->cb,
242 (int) sizeof (pWrapper->szModule), pWrapper->szModule);
243 if (pWrapper->marker != MARKER_HEAD)
244 fprintf (stderr, " [HEAD]");
245 if (*(unsigned32*)((char*) (pWrapper + 1) + pWrapper->cb) != MARKER_TAIL)
246 fprintf (stderr, " [TAIL]");
247 fprintf (stderr, "\n");
248 }
249
250
251 bool _validate_one_ (WRAPPER* pWrapper)
252 {
253 return (pWrapper->marker == MARKER_HEAD
254 && *(unsigned32*)(((unsigned char*) pWrapper)
255 + sizeof (WRAPPER) + pWrapper->cb) == MARKER_TAIL);
256 }
257
258 bool _validate_ (WRAPPER* pWrapper)
259 {
260 for (; pWrapper; pWrapper = pWrapper->pNext) {
261 if (!_validate_one_ (pWrapper)) {
262 _tell_ (pWrapper);
263 fprintf (stderr, "heap invalid\n");
264 return false;
265 }
266 }
267 return true;
268 }