1
2 /*--------------------------------------------------------------------*/
3 /*--- Replacements for malloc() et al, which run on the simulated ---*/
4 /*--- CPU. vg_replace_malloc.c ---*/
5 /*--------------------------------------------------------------------*/
6
7 /*
8 This file is part of Valgrind, a dynamic binary instrumentation
9 framework.
10
11 Copyright (C) 2000-2012 Julian Seward
12 jseward@acm.org
13
14 This program is free software; you can redistribute it and/or
15 modify it under the terms of the GNU General Public License as
16 published by the Free Software Foundation; either version 2 of the
17 License, or (at your option) any later version.
18
19 This program is distributed in the hope that it will be useful, but
20 WITHOUT ANY WARRANTY; without even the implied warranty of
21 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
22 General Public License for more details.
23
24 You should have received a copy of the GNU General Public License
25 along with this program; if not, write to the Free Software
26 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
27 02111-1307, USA.
28
29 The GNU General Public License is contained in the file COPYING.
30 */
31
32 /* ---------------------------------------------------------------------
33 ALL THE CODE IN THIS FILE RUNS ON THE SIMULATED CPU.
34
35 These functions are drop-in replacements for malloc() and friends.
36 They have global scope, but are not intended to be called directly.
37 See pub_core_redir.h for the gory details.
38
39 This file can be linked into the vg_preload_<tool>.so file for any tool
40 that wishes to know about calls to malloc(). The tool must define all
41 the functions that will be called via 'info'.
42
43 It is called vg_replace_malloc.c because this filename appears in stack
44 traces, so we want the name to be (hopefully!) meaningful to users.
45
46 IMPORTANT: this file must not contain any floating point code, nor
47 any integer division. This is because on ARM these can cause calls
48 to helper functions, which will be unresolved within this .so.
49 Although it is usually the case that the client's ld.so instance
50 can bind them at runtime to the relevant functions in the client
51 executable, there is no guarantee of this; and so the client may
52 die via a runtime link failure. Hence the only safe approach is to
53 avoid such function calls in the first place. See "#define CALLOC"
54 below for a specific example.
55
56 A useful command is
57 for f in `find . -name "*preload*.so*"` ; \
58 do nm -A $f | grep " U " ; \
59 done
60
61 to see all the undefined symbols in all the preload shared objects.
62 ------------------------------------------------------------------ */
63
64 #include "pub_core_basics.h"
65 #include "pub_core_vki.h" // VKI_EINVAL, VKI_ENOMEM
66 #include "pub_core_clreq.h" // for VALGRIND_INTERNAL_PRINTF,
67 // VALGRIND_NON_SIMD_CALL[12]
68 #include "pub_core_debuginfo.h" // needed for pub_core_redir.h :(
69 #include "pub_core_mallocfree.h" // for VG_MIN_MALLOC_SZB, VG_AR_CLIENT
70 #include "pub_core_redir.h" // for VG_REPLACE_FUNCTION_*
71 #include "pub_core_replacemalloc.h"
72
73 /* Assignment of behavioural equivalence class tags: 1NNNP is intended
74 to be reserved for the Valgrind core. Current usage:
75
76 10010 ALLOC_or_NULL
77 10020 ZONEALLOC_or_NULL
78 10030 ALLOC_or_BOMB
79 10040 ZONEFREE
80 10050 FREE
81 10060 ZONECALLOC
82 10070 CALLOC
83 10080 ZONEREALLOC
84 10090 REALLOC
85 10100 ZONEMEMALIGN
86 10110 MEMALIGN
87 10120 VALLOC
88 10130 ZONEVALLOC
89 10140 MALLOPT
90 10150 MALLOC_TRIM
91 10160 POSIX_MEMALIGN
92 10170 MALLOC_USABLE_SIZE
93 10180 PANIC
94 10190 MALLOC_STATS
95 10200 MALLINFO
96 10210 DEFAULT_ZONE
97 10220 ZONE_CHECK
98 */
99
100 /* 2 Apr 05: the Portland Group compiler, which uses cfront/ARM style
101 mangling, could be supported properly by the redirects in this
102 module. Except we can't because it doesn't put its allocation
103 functions in libpgc.so but instead hardwires them into the
104 compilation unit holding main(), which makes them impossible to
105 intercept directly. Fortunately those fns seem to route everything
106 through to malloc/free.
107
108 mid-06: could be improved, since we can now intercept in the main
109 executable too.
110 */
111
112
113
114 /* Call here to exit if we can't continue. On Android we can't call
115 _exit for some reason, so we have to blunt-instrument it. */
116 __attribute__ ((__noreturn__))
my_exit(int x)117 static inline void my_exit ( int x )
118 {
119 # if defined(VGPV_arm_linux_android)
120 __asm__ __volatile__(".word 0xFFFFFFFF");
121 while (1) {}
122 # elif defined(VGPV_x86_linux_android)
123 __asm__ __volatile__("ud2");
124 while (1) {}
125 # else
126 extern __attribute__ ((__noreturn__)) void _exit(int status);
127 _exit(x);
128 # endif
129 }
130
131 /* Same problem with getpagesize. */
my_getpagesize(void)132 static inline int my_getpagesize ( void )
133 {
134 # if defined(VGPV_arm_linux_android) || defined(VGPV_x86_linux_android)
135 return 4096; /* kludge - link failure on Android, for some reason */
136 # else
137 extern int getpagesize (void);
138 return getpagesize();
139 # endif
140 }
141
142
143 /* Compute the high word of the double-length unsigned product of U
144 and V. This is for calloc argument overflow checking; see comments
145 below. Algorithm as described in Hacker's Delight, chapter 8. */
umulHW(UWord u,UWord v)146 static UWord umulHW ( UWord u, UWord v )
147 {
148 UWord u0, v0, w0, rHi;
149 UWord u1, v1, w1,w2,t;
150 UWord halfMask = sizeof(UWord)==4 ? (UWord)0xFFFF
151 : (UWord)0xFFFFFFFFULL;
152 UWord halfShift = sizeof(UWord)==4 ? 16 : 32;
153 u0 = u & halfMask;
154 u1 = u >> halfShift;
155 v0 = v & halfMask;
156 v1 = v >> halfShift;
157 w0 = u0 * v0;
158 t = u1 * v0 + (w0 >> halfShift);
159 w1 = t & halfMask;
160 w2 = t >> halfShift;
161 w1 = u0 * v1 + w1;
162 rHi = u1 * v1 + w2 + (w1 >> halfShift);
163 return rHi;
164 }
165
166
167 /*------------------------------------------------------------*/
168 /*--- Replacing malloc() et al ---*/
169 /*------------------------------------------------------------*/
170
171 /* This struct is initially empty. Before the first use of any of
172 these functions, we make a client request which fills in the
173 fields.
174 */
175 static struct vg_mallocfunc_info info;
176 static int init_done;
177
178 /* Startup hook - called as init section */
179 __attribute__((constructor))
180 static void init(void);
181
182 #define MALLOC_TRACE(format, args...) \
183 if (info.clo_trace_malloc) { \
184 VALGRIND_INTERNAL_PRINTF(format, ## args ); }
185
186 /* Below are new versions of malloc, __builtin_new, free,
187 __builtin_delete, calloc, realloc, memalign, and friends.
188
189 None of these functions are called directly - they are not meant to
190 be found by the dynamic linker. But ALL client calls to malloc()
191 and friends wind up here eventually. They get called because
192 vg_replace_malloc installs a bunch of code redirects which causes
193 Valgrind to use these functions rather than the ones they're
194 replacing.
195 */
196
197
198 /*---------------------- malloc ----------------------*/
199
200 /* Generate a replacement for 'fnname' in object 'soname', which calls
201 'vg_replacement' to allocate memory. If that fails, return NULL.
202 */
203 #define ALLOC_or_NULL(soname, fnname, vg_replacement) \
204 \
205 void* VG_REPLACE_FUNCTION_EZU(10010,soname,fnname) (SizeT n); \
206 void* VG_REPLACE_FUNCTION_EZU(10010,soname,fnname) (SizeT n) \
207 { \
208 void* v; \
209 \
210 if (!init_done) init(); \
211 MALLOC_TRACE(#fnname "(%llu)", (ULong)n ); \
212 \
213 v = (void*)VALGRIND_NON_SIMD_CALL1( info.tl_##vg_replacement, n ); \
214 MALLOC_TRACE(" = %p\n", v ); \
215 return v; \
216 }
217
218 #define ZONEALLOC_or_NULL(soname, fnname, vg_replacement) \
219 \
220 void* VG_REPLACE_FUNCTION_EZU(10020,soname,fnname) (void *zone, SizeT n); \
221 void* VG_REPLACE_FUNCTION_EZU(10020,soname,fnname) (void *zone, SizeT n) \
222 { \
223 void* v; \
224 \
225 if (!init_done) init(); \
226 MALLOC_TRACE(#fnname "(%p, %llu)", zone, (ULong)n ); \
227 \
228 v = (void*)VALGRIND_NON_SIMD_CALL1( info.tl_##vg_replacement, n ); \
229 MALLOC_TRACE(" = %p\n", v ); \
230 return v; \
231 }
232
233
234 /* Generate a replacement for 'fnname' in object 'soname', which calls
235 'vg_replacement' to allocate memory. If that fails, it bombs the
236 system.
237 */
238 #define ALLOC_or_BOMB(soname, fnname, vg_replacement) \
239 \
240 void* VG_REPLACE_FUNCTION_EZU(10030,soname,fnname) (SizeT n); \
241 void* VG_REPLACE_FUNCTION_EZU(10030,soname,fnname) (SizeT n) \
242 { \
243 void* v; \
244 \
245 if (!init_done) init(); \
246 MALLOC_TRACE(#fnname "(%llu)", (ULong)n ); \
247 \
248 v = (void*)VALGRIND_NON_SIMD_CALL1( info.tl_##vg_replacement, n ); \
249 MALLOC_TRACE(" = %p\n", v ); \
250 if (NULL == v) { \
251 VALGRIND_PRINTF( \
252 "new/new[] failed and should throw an exception, but Valgrind\n"); \
253 VALGRIND_PRINTF_BACKTRACE( \
254 " cannot throw exceptions and so is aborting instead. Sorry.\n"); \
255 my_exit(1); \
256 } \
257 return v; \
258 }
259
260 // Each of these lines generates a replacement function:
261 // (from_so, from_fn, v's replacement)
262 // For some lines, we will also define a replacement function
263 // whose only purpose is to be a soname synonym place holder
264 // that can be replaced using --soname-synonyms.
265 #define SO_SYN_MALLOC VG_SO_SYN(somalloc)
266
267 // malloc
268 #if defined(VGO_linux)
269 ALLOC_or_NULL(VG_Z_LIBSTDCXX_SONAME, malloc, malloc);
270 ALLOC_or_NULL(VG_Z_LIBC_SONAME, malloc, malloc);
271 ALLOC_or_NULL(SO_SYN_MALLOC, malloc, malloc);
272
273 #elif defined(VGO_darwin)
274 ALLOC_or_NULL(VG_Z_LIBC_SONAME, malloc, malloc);
275 ALLOC_or_NULL(SO_SYN_MALLOC, malloc, malloc);
276 ZONEALLOC_or_NULL(VG_Z_LIBC_SONAME, malloc_zone_malloc, malloc);
277 ZONEALLOC_or_NULL(SO_SYN_MALLOC, malloc_zone_malloc, malloc);
278
279 #endif
280
281
282 /*---------------------- new ----------------------*/
283
284 #if defined(VGO_linux)
285 // operator new(unsigned int), not mangled (for gcc 2.96)
286 ALLOC_or_BOMB(VG_Z_LIBSTDCXX_SONAME, builtin_new, __builtin_new);
287 ALLOC_or_BOMB(VG_Z_LIBC_SONAME, builtin_new, __builtin_new);
288 ALLOC_or_BOMB(VG_Z_LIBSTDCXX_SONAME, __builtin_new, __builtin_new);
289 ALLOC_or_BOMB(VG_Z_LIBC_SONAME, __builtin_new, __builtin_new);
290 // operator new(unsigned int), GNU mangling
291 #if VG_WORDSIZE == 4
292 ALLOC_or_BOMB(VG_Z_LIBSTDCXX_SONAME, _Znwj, __builtin_new);
293 ALLOC_or_BOMB(VG_Z_LIBC_SONAME, _Znwj, __builtin_new);
294 ALLOC_or_BOMB(SO_SYN_MALLOC, _Znwj, __builtin_new);
295 #endif
296 // operator new(unsigned long), GNU mangling
297 #if VG_WORDSIZE == 8
298 ALLOC_or_BOMB(VG_Z_LIBSTDCXX_SONAME, _Znwm, __builtin_new);
299 ALLOC_or_BOMB(VG_Z_LIBC_SONAME, _Znwm, __builtin_new);
300 ALLOC_or_BOMB(SO_SYN_MALLOC, _Znwm, __builtin_new);
301 #endif
302
303 #elif defined(VGO_darwin)
304 // operator new(unsigned int), GNU mangling
305 #if VG_WORDSIZE == 4
306 //ALLOC_or_BOMB(VG_Z_LIBSTDCXX_SONAME, _Znwj, __builtin_new);
307 //ALLOC_or_BOMB(VG_Z_LIBC_SONAME, _Znwj, __builtin_new);
308 #endif
309 // operator new(unsigned long), GNU mangling
310 #if 1 // FIXME: is this right?
311 //ALLOC_or_BOMB(VG_Z_LIBSTDCXX_SONAME, _Znwm, __builtin_new);
312 //ALLOC_or_BOMB(VG_Z_LIBC_SONAME, _Znwm, __builtin_new);
313 #endif
314
315 #endif
316
317
318 /*---------------------- new nothrow ----------------------*/
319
320 #if defined(VGO_linux)
321 // operator new(unsigned, std::nothrow_t const&), GNU mangling
322 #if VG_WORDSIZE == 4
323 ALLOC_or_NULL(VG_Z_LIBSTDCXX_SONAME, _ZnwjRKSt9nothrow_t, __builtin_new);
324 ALLOC_or_NULL(VG_Z_LIBC_SONAME, _ZnwjRKSt9nothrow_t, __builtin_new);
325 ALLOC_or_NULL(SO_SYN_MALLOC, _ZnwjRKSt9nothrow_t, __builtin_new);
326 #endif
327 // operator new(unsigned long, std::nothrow_t const&), GNU mangling
328 #if VG_WORDSIZE == 8
329 ALLOC_or_NULL(VG_Z_LIBSTDCXX_SONAME, _ZnwmRKSt9nothrow_t, __builtin_new);
330 ALLOC_or_NULL(VG_Z_LIBC_SONAME, _ZnwmRKSt9nothrow_t, __builtin_new);
331 ALLOC_or_NULL(SO_SYN_MALLOC, _ZnwmRKSt9nothrow_t, __builtin_new);
332 #endif
333
334 #elif defined(VGO_darwin)
335 // operator new(unsigned, std::nothrow_t const&), GNU mangling
336 #if VG_WORDSIZE == 4
337 //ALLOC_or_NULL(VG_Z_LIBSTDCXX_SONAME, _ZnwjRKSt9nothrow_t, __builtin_new);
338 //ALLOC_or_NULL(VG_Z_LIBC_SONAME, _ZnwjRKSt9nothrow_t, __builtin_new);
339 #endif
340 // operator new(unsigned long, std::nothrow_t const&), GNU mangling
341 #if 1 // FIXME: is this right?
342 //ALLOC_or_NULL(VG_Z_LIBSTDCXX_SONAME, _ZnwmRKSt9nothrow_t, __builtin_new);
343 //ALLOC_or_NULL(VG_Z_LIBC_SONAME, _ZnwmRKSt9nothrow_t, __builtin_new);
344 #endif
345
346 #endif
347
348
349 /*---------------------- new [] ----------------------*/
350
351 #if defined(VGO_linux)
352 // operator new[](unsigned int), not mangled (for gcc 2.96)
353 ALLOC_or_BOMB(VG_Z_LIBSTDCXX_SONAME, __builtin_vec_new, __builtin_vec_new );
354 ALLOC_or_BOMB(VG_Z_LIBC_SONAME, __builtin_vec_new, __builtin_vec_new );
355 // operator new[](unsigned int), GNU mangling
356 #if VG_WORDSIZE == 4
357 ALLOC_or_BOMB(VG_Z_LIBSTDCXX_SONAME, _Znaj, __builtin_vec_new );
358 ALLOC_or_BOMB(VG_Z_LIBC_SONAME, _Znaj, __builtin_vec_new );
359 ALLOC_or_BOMB(SO_SYN_MALLOC, _Znaj, __builtin_vec_new );
360 #endif
361 // operator new[](unsigned long), GNU mangling
362 #if VG_WORDSIZE == 8
363 ALLOC_or_BOMB(VG_Z_LIBSTDCXX_SONAME, _Znam, __builtin_vec_new );
364 ALLOC_or_BOMB(VG_Z_LIBC_SONAME, _Znam, __builtin_vec_new );
365 ALLOC_or_BOMB(SO_SYN_MALLOC, _Znam, __builtin_vec_new );
366 #endif
367
368 #elif defined(VGO_darwin)
369 // operator new[](unsigned int), GNU mangling
370 #if VG_WORDSIZE == 4
371 //ALLOC_or_BOMB(VG_Z_LIBSTDCXX_SONAME, _Znaj, __builtin_vec_new );
372 //ALLOC_or_BOMB(VG_Z_LIBC_SONAME, _Znaj, __builtin_vec_new );
373 #endif
374 // operator new[](unsigned long), GNU mangling
375 #if 1 // FIXME: is this right?
376 //ALLOC_or_BOMB(VG_Z_LIBSTDCXX_SONAME, _Znam, __builtin_vec_new );
377 //ALLOC_or_BOMB(VG_Z_LIBC_SONAME, _Znam, __builtin_vec_new );
378 #endif
379
380 #endif
381
382
383 /*---------------------- new [] nothrow ----------------------*/
384
385 #if defined(VGO_linux)
386 // operator new[](unsigned, std::nothrow_t const&), GNU mangling
387 #if VG_WORDSIZE == 4
388 ALLOC_or_NULL(VG_Z_LIBSTDCXX_SONAME, _ZnajRKSt9nothrow_t, __builtin_vec_new );
389 ALLOC_or_NULL(VG_Z_LIBC_SONAME, _ZnajRKSt9nothrow_t, __builtin_vec_new );
390 ALLOC_or_NULL(SO_SYN_MALLOC, _ZnajRKSt9nothrow_t, __builtin_vec_new );
391 #endif
392 // operator new[](unsigned long, std::nothrow_t const&), GNU mangling
393 #if VG_WORDSIZE == 8
394 ALLOC_or_NULL(VG_Z_LIBSTDCXX_SONAME, _ZnamRKSt9nothrow_t, __builtin_vec_new );
395 ALLOC_or_NULL(VG_Z_LIBC_SONAME, _ZnamRKSt9nothrow_t, __builtin_vec_new );
396 ALLOC_or_NULL(SO_SYN_MALLOC, _ZnamRKSt9nothrow_t, __builtin_vec_new );
397 #endif
398
399 #elif defined(VGO_darwin)
400 // operator new[](unsigned, std::nothrow_t const&), GNU mangling
401 #if VG_WORDSIZE == 4
402 //ALLOC_or_NULL(VG_Z_LIBSTDCXX_SONAME, _ZnajRKSt9nothrow_t, __builtin_vec_new );
403 //ALLOC_or_NULL(VG_Z_LIBC_SONAME, _ZnajRKSt9nothrow_t, __builtin_vec_new );
404 #endif
405 // operator new[](unsigned long, std::nothrow_t const&), GNU mangling
406 #if 1 // FIXME: is this right?
407 //ALLOC_or_NULL(VG_Z_LIBSTDCXX_SONAME, _ZnamRKSt9nothrow_t, __builtin_vec_new );
408 //ALLOC_or_NULL(VG_Z_LIBC_SONAME, _ZnamRKSt9nothrow_t, __builtin_vec_new );
409 #endif
410
411 #endif
412
413
414 /*---------------------- free ----------------------*/
415
416 /* Generate a replacement for 'fnname' in object 'soname', which calls
417 'vg_replacement' to free previously allocated memory.
418 */
419 #define ZONEFREE(soname, fnname, vg_replacement) \
420 \
421 void VG_REPLACE_FUNCTION_EZU(10040,soname,fnname) (void *zone, void *p); \
422 void VG_REPLACE_FUNCTION_EZU(10040,soname,fnname) (void *zone, void *p) \
423 { \
424 if (!init_done) init(); \
425 MALLOC_TRACE(#fnname "(%p, %p)\n", zone, p ); \
426 if (p == NULL) \
427 return; \
428 (void)VALGRIND_NON_SIMD_CALL1( info.tl_##vg_replacement, p ); \
429 }
430
431 #define FREE(soname, fnname, vg_replacement) \
432 \
433 void VG_REPLACE_FUNCTION_EZU(10050,soname,fnname) (void *p); \
434 void VG_REPLACE_FUNCTION_EZU(10050,soname,fnname) (void *p) \
435 { \
436 if (!init_done) init(); \
437 MALLOC_TRACE(#fnname "(%p)\n", p ); \
438 if (p == NULL) \
439 return; \
440 (void)VALGRIND_NON_SIMD_CALL1( info.tl_##vg_replacement, p ); \
441 }
442
443
444 #if defined(VGO_linux)
445 FREE(VG_Z_LIBSTDCXX_SONAME, free, free );
446 FREE(VG_Z_LIBC_SONAME, free, free );
447 FREE(SO_SYN_MALLOC, free, free );
448
449 #elif defined(VGO_darwin)
450 FREE(VG_Z_LIBC_SONAME, free, free );
451 FREE(SO_SYN_MALLOC, free, free );
452 ZONEFREE(VG_Z_LIBC_SONAME, malloc_zone_free, free );
453 ZONEFREE(SO_SYN_MALLOC, malloc_zone_free, free );
454
455 #endif
456
457
458 /*---------------------- cfree ----------------------*/
459
460 // cfree
461 #if defined(VGO_linux)
462 FREE(VG_Z_LIBSTDCXX_SONAME, cfree, free );
463 FREE(VG_Z_LIBC_SONAME, cfree, free );
464 FREE(SO_SYN_MALLOC, cfree, free );
465
466 #elif defined(VGO_darwin)
467 //FREE(VG_Z_LIBSTDCXX_SONAME, cfree, free );
468 //FREE(VG_Z_LIBC_SONAME, cfree, free );
469
470 #endif
471
472
473 /*---------------------- delete ----------------------*/
474
475 #if defined(VGO_linux)
476 // operator delete(void*), not mangled (for gcc 2.96)
477 FREE(VG_Z_LIBSTDCXX_SONAME, __builtin_delete, __builtin_delete );
478 FREE(VG_Z_LIBC_SONAME, __builtin_delete, __builtin_delete );
479 // operator delete(void*), GNU mangling
480 FREE(VG_Z_LIBSTDCXX_SONAME, _ZdlPv, __builtin_delete );
481 FREE(VG_Z_LIBC_SONAME, _ZdlPv, __builtin_delete );
482 FREE(SO_SYN_MALLOC, _ZdlPv, __builtin_delete );
483
484 #elif defined(VGO_darwin)
485 // operator delete(void*), GNU mangling
486 //FREE(VG_Z_LIBSTDCXX_SONAME, _ZdlPv, __builtin_delete );
487 //FREE(VG_Z_LIBC_SONAME, _ZdlPv, __builtin_delete );
488
489 #endif
490
491
492 /*---------------------- delete nothrow ----------------------*/
493
494 #if defined(VGO_linux)
495 // operator delete(void*, std::nothrow_t const&), GNU mangling
496 FREE(VG_Z_LIBSTDCXX_SONAME, _ZdlPvRKSt9nothrow_t, __builtin_delete );
497 FREE(VG_Z_LIBC_SONAME, _ZdlPvRKSt9nothrow_t, __builtin_delete );
498 FREE(SO_SYN_MALLOC, _ZdlPvRKSt9nothrow_t, __builtin_delete );
499
500 #elif defined(VGO_darwin)
501 // operator delete(void*, std::nothrow_t const&), GNU mangling
502 //FREE(VG_Z_LIBSTDCXX_SONAME, _ZdlPvRKSt9nothrow_t, __builtin_delete );
503 //FREE(VG_Z_LIBC_SONAME, _ZdlPvRKSt9nothrow_t, __builtin_delete );
504
505 #endif
506
507
508 /*---------------------- delete [] ----------------------*/
509
510 #if defined(VGO_linux)
511 // operator delete[](void*), not mangled (for gcc 2.96)
512 FREE(VG_Z_LIBSTDCXX_SONAME, __builtin_vec_delete, __builtin_vec_delete );
513 FREE(VG_Z_LIBC_SONAME, __builtin_vec_delete, __builtin_vec_delete );
514 // operator delete[](void*), GNU mangling
515 FREE(VG_Z_LIBSTDCXX_SONAME, _ZdaPv, __builtin_vec_delete );
516 FREE(VG_Z_LIBC_SONAME, _ZdaPv, __builtin_vec_delete );
517 FREE(SO_SYN_MALLOC, _ZdaPv, __builtin_vec_delete );
518
519 #elif defined(VGO_darwin)
520 // operator delete[](void*), not mangled (for gcc 2.96)
521 //FREE(VG_Z_LIBSTDCXX_SONAME, __builtin_vec_delete, __builtin_vec_delete );
522 //FREE(VG_Z_LIBC_SONAME, __builtin_vec_delete, __builtin_vec_delete );
523 // operator delete[](void*), GNU mangling
524 //FREE(VG_Z_LIBSTDCXX_SONAME, _ZdaPv, __builtin_vec_delete );
525 //FREE(VG_Z_LIBC_SONAME, _ZdaPv, __builtin_vec_delete );
526
527 #endif
528
529
530 /*---------------------- delete [] nothrow ----------------------*/
531
532 #if defined(VGO_linux)
533 // operator delete[](void*, std::nothrow_t const&), GNU mangling
534 FREE(VG_Z_LIBSTDCXX_SONAME, _ZdaPvRKSt9nothrow_t, __builtin_vec_delete );
535 FREE(VG_Z_LIBC_SONAME, _ZdaPvRKSt9nothrow_t, __builtin_vec_delete );
536 FREE(SO_SYN_MALLOC, _ZdaPvRKSt9nothrow_t, __builtin_vec_delete );
537
538 #elif defined(VGO_darwin)
539 // operator delete[](void*, std::nothrow_t const&), GNU mangling
540 //FREE(VG_Z_LIBSTDCXX_SONAME, _ZdaPvRKSt9nothrow_t, __builtin_vec_delete );
541 //FREE(VG_Z_LIBC_SONAME, _ZdaPvRKSt9nothrow_t, __builtin_vec_delete );
542
543 #endif
544
545
546 /*---------------------- calloc ----------------------*/
547
548 #define ZONECALLOC(soname, fnname) \
549 \
550 void* VG_REPLACE_FUNCTION_EZU(10060,soname,fnname) \
551 ( void *zone, SizeT nmemb, SizeT size ); \
552 void* VG_REPLACE_FUNCTION_EZU(10060,soname,fnname) \
553 ( void *zone, SizeT nmemb, SizeT size ) \
554 { \
555 void* v; \
556 \
557 if (!init_done) init(); \
558 MALLOC_TRACE("zone_calloc(%p, %llu,%llu)", zone, (ULong)nmemb, (ULong)size ); \
559 \
560 v = (void*)VALGRIND_NON_SIMD_CALL2( info.tl_calloc, nmemb, size ); \
561 MALLOC_TRACE(" = %p\n", v ); \
562 return v; \
563 }
564
565 #define CALLOC(soname, fnname) \
566 \
567 void* VG_REPLACE_FUNCTION_EZU(10070,soname,fnname) \
568 ( SizeT nmemb, SizeT size ); \
569 void* VG_REPLACE_FUNCTION_EZU(10070,soname,fnname) \
570 ( SizeT nmemb, SizeT size ) \
571 { \
572 void* v; \
573 \
574 if (!init_done) init(); \
575 MALLOC_TRACE("calloc(%llu,%llu)", (ULong)nmemb, (ULong)size ); \
576 \
577 /* Protect against overflow. See bug 24078. (that bug number is
578 invalid. Which one really?) */ \
579 /* But don't use division, since that produces an external symbol
580 reference on ARM, in the form of a call to __aeabi_uidiv. It's
581 normally OK, because ld.so manages to resolve it to something in the
582 executable, or one of its shared objects. But that isn't guaranteed
583 to be the case, and it has been observed to fail in rare cases, eg:
584 echo x | valgrind /bin/sed -n "s/.*-\>\ //p"
585 So instead compute the high word of the product and check it is zero. */ \
586 if (umulHW(size, nmemb) != 0) return NULL; \
587 v = (void*)VALGRIND_NON_SIMD_CALL2( info.tl_calloc, nmemb, size ); \
588 MALLOC_TRACE(" = %p\n", v ); \
589 return v; \
590 }
591
592 #if defined(VGO_linux)
593 CALLOC(VG_Z_LIBC_SONAME, calloc);
594 CALLOC(SO_SYN_MALLOC, calloc);
595
596 #elif defined(VGO_darwin)
597 CALLOC(VG_Z_LIBC_SONAME, calloc);
598 CALLOC(SO_SYN_MALLOC, calloc);
599 ZONECALLOC(VG_Z_LIBC_SONAME, malloc_zone_calloc);
600 ZONECALLOC(SO_SYN_MALLOC, malloc_zone_calloc);
601
602 #endif
603
604
605 /*---------------------- realloc ----------------------*/
606
607 #define ZONEREALLOC(soname, fnname) \
608 \
609 void* VG_REPLACE_FUNCTION_EZU(10080,soname,fnname) \
610 ( void *zone, void* ptrV, SizeT new_size ); \
611 void* VG_REPLACE_FUNCTION_EZU(10080,soname,fnname) \
612 ( void *zone, void* ptrV, SizeT new_size ) \
613 { \
614 void* v; \
615 \
616 if (!init_done) init(); \
617 MALLOC_TRACE("zone_realloc(%p,%p,%llu)", zone, ptrV, (ULong)new_size ); \
618 \
619 if (ptrV == NULL) \
620 /* We need to call a malloc-like function; so let's use \
621 one which we know exists. GrP fixme use zonemalloc instead? */ \
622 return VG_REPLACE_FUNCTION_EZU(10010,VG_Z_LIBC_SONAME,malloc) \
623 (new_size); \
624 if (new_size <= 0) { \
625 VG_REPLACE_FUNCTION_EZU(10050,VG_Z_LIBC_SONAME,free)(ptrV); \
626 MALLOC_TRACE(" = 0\n"); \
627 return NULL; \
628 } \
629 v = (void*)VALGRIND_NON_SIMD_CALL2( info.tl_realloc, ptrV, new_size ); \
630 MALLOC_TRACE(" = %p\n", v ); \
631 return v; \
632 }
633
634 #define REALLOC(soname, fnname) \
635 \
636 void* VG_REPLACE_FUNCTION_EZU(10090,soname,fnname) \
637 ( void* ptrV, SizeT new_size );\
638 void* VG_REPLACE_FUNCTION_EZU(10090,soname,fnname) \
639 ( void* ptrV, SizeT new_size ) \
640 { \
641 void* v; \
642 \
643 if (!init_done) init(); \
644 MALLOC_TRACE("realloc(%p,%llu)", ptrV, (ULong)new_size ); \
645 \
646 if (ptrV == NULL) \
647 /* We need to call a malloc-like function; so let's use \
648 one which we know exists. */ \
649 return VG_REPLACE_FUNCTION_EZU(10010,VG_Z_LIBC_SONAME,malloc) \
650 (new_size); \
651 if (new_size <= 0) { \
652 VG_REPLACE_FUNCTION_EZU(10050,VG_Z_LIBC_SONAME,free)(ptrV); \
653 MALLOC_TRACE(" = 0\n"); \
654 return NULL; \
655 } \
656 v = (void*)VALGRIND_NON_SIMD_CALL2( info.tl_realloc, ptrV, new_size ); \
657 MALLOC_TRACE(" = %p\n", v ); \
658 return v; \
659 }
660
661 #if defined(VGO_linux)
662 REALLOC(VG_Z_LIBC_SONAME, realloc);
663 REALLOC(SO_SYN_MALLOC, realloc);
664
665 #elif defined(VGO_darwin)
666 REALLOC(VG_Z_LIBC_SONAME, realloc);
667 REALLOC(SO_SYN_MALLOC, realloc);
668 ZONEREALLOC(VG_Z_LIBC_SONAME, malloc_zone_realloc);
669 ZONEREALLOC(SO_SYN_MALLOC, malloc_zone_realloc);
670
671 #endif
672
673
674 /*---------------------- memalign ----------------------*/
675
676 #define ZONEMEMALIGN(soname, fnname) \
677 \
678 void* VG_REPLACE_FUNCTION_EZU(10100,soname,fnname) \
679 ( void *zone, SizeT alignment, SizeT n ); \
680 void* VG_REPLACE_FUNCTION_EZU(10100,soname,fnname) \
681 ( void *zone, SizeT alignment, SizeT n ) \
682 { \
683 void* v; \
684 \
685 if (!init_done) init(); \
686 MALLOC_TRACE("zone_memalign(%p, al %llu, size %llu)", \
687 zone, (ULong)alignment, (ULong)n ); \
688 \
689 /* Round up to minimum alignment if necessary. */ \
690 if (alignment < VG_MIN_MALLOC_SZB) \
691 alignment = VG_MIN_MALLOC_SZB; \
692 \
693 /* Round up to nearest power-of-two if necessary (like glibc). */ \
694 while (0 != (alignment & (alignment - 1))) alignment++; \
695 \
696 v = (void*)VALGRIND_NON_SIMD_CALL2( info.tl_memalign, alignment, n ); \
697 MALLOC_TRACE(" = %p\n", v ); \
698 return v; \
699 }
700
701 #define MEMALIGN(soname, fnname) \
702 \
703 void* VG_REPLACE_FUNCTION_EZU(10110,soname,fnname) \
704 ( SizeT alignment, SizeT n ); \
705 void* VG_REPLACE_FUNCTION_EZU(10110,soname,fnname) \
706 ( SizeT alignment, SizeT n ) \
707 { \
708 void* v; \
709 \
710 if (!init_done) init(); \
711 MALLOC_TRACE("memalign(al %llu, size %llu)", \
712 (ULong)alignment, (ULong)n ); \
713 \
714 /* Round up to minimum alignment if necessary. */ \
715 if (alignment < VG_MIN_MALLOC_SZB) \
716 alignment = VG_MIN_MALLOC_SZB; \
717 \
718 /* Round up to nearest power-of-two if necessary (like glibc). */ \
719 while (0 != (alignment & (alignment - 1))) alignment++; \
720 \
721 v = (void*)VALGRIND_NON_SIMD_CALL2( info.tl_memalign, alignment, n ); \
722 MALLOC_TRACE(" = %p\n", v ); \
723 return v; \
724 }
725
726 #if defined(VGO_linux)
727 MEMALIGN(VG_Z_LIBC_SONAME, memalign);
728 MEMALIGN(SO_SYN_MALLOC, memalign);
729
730 #elif defined(VGO_darwin)
731 MEMALIGN(VG_Z_LIBC_SONAME, memalign);
732 MEMALIGN(SO_SYN_MALLOC, memalign);
733 ZONEMEMALIGN(VG_Z_LIBC_SONAME, malloc_zone_memalign);
734 ZONEMEMALIGN(SO_SYN_MALLOC, malloc_zone_memalign);
735
736 #endif
737
738
739 /*---------------------- valloc ----------------------*/
740
741 #define VALLOC(soname, fnname) \
742 \
743 void* VG_REPLACE_FUNCTION_EZU(10120,soname,fnname) ( SizeT size ); \
744 void* VG_REPLACE_FUNCTION_EZU(10120,soname,fnname) ( SizeT size ) \
745 { \
746 static int pszB = 0; \
747 if (pszB == 0) \
748 pszB = my_getpagesize(); \
749 return VG_REPLACE_FUNCTION_EZU(10110,VG_Z_LIBC_SONAME,memalign) \
750 ((SizeT)pszB, size); \
751 }
752
753 #define ZONEVALLOC(soname, fnname) \
754 \
755 void* VG_REPLACE_FUNCTION_EZU(10130,soname,fnname) \
756 ( void *zone, SizeT size ); \
757 void* VG_REPLACE_FUNCTION_EZU(10130,soname,fnname) \
758 ( void *zone, SizeT size ) \
759 { \
760 static int pszB = 0; \
761 if (pszB == 0) \
762 pszB = my_getpagesize(); \
763 return VG_REPLACE_FUNCTION_EZU(10110,VG_Z_LIBC_SONAME,memalign) \
764 ((SizeT)pszB, size); \
765 }
766
767 #if defined(VGO_linux)
768 VALLOC(VG_Z_LIBC_SONAME, valloc);
769 VALLOC(SO_SYN_MALLOC, valloc);
770
771 #elif defined(VGO_darwin)
772 VALLOC(VG_Z_LIBC_SONAME, valloc);
773 VALLOC(SO_SYN_MALLOC, valloc);
774 ZONEVALLOC(VG_Z_LIBC_SONAME, malloc_zone_valloc);
775 ZONEVALLOC(SO_SYN_MALLOC, malloc_zone_valloc);
776
777 #endif
778
779
780 /*---------------------- mallopt ----------------------*/
781
782 /* Various compatibility wrapper functions, for glibc and libstdc++. */
783
784 #define MALLOPT(soname, fnname) \
785 \
786 int VG_REPLACE_FUNCTION_EZU(10140,soname,fnname) ( int cmd, int value ); \
787 int VG_REPLACE_FUNCTION_EZU(10140,soname,fnname) ( int cmd, int value ) \
788 { \
789 /* In glibc-2.2.4, 1 denotes a successful return value for \
790 mallopt */ \
791 return 1; \
792 }
793
794 #if defined(VGO_linux)
795 MALLOPT(VG_Z_LIBC_SONAME, mallopt);
796 MALLOPT(SO_SYN_MALLOC, mallopt);
797
798 #elif defined(VGO_darwin)
799 //MALLOPT(VG_Z_LIBC_SONAME, mallopt);
800
801 #endif
802
803
804 /*---------------------- malloc_trim ----------------------*/
805 // Documentation says:
806 // malloc_trim(size_t pad);
807 //
808 // If possible, gives memory back to the system (via negative arguments to
809 // sbrk) if there is unused memory at the `high' end of the malloc pool.
810 // You can call this after freeing large blocks of memory to potentially
811 // reduce the system-level memory requirements of a program. However, it
812 // cannot guarantee to reduce memory. Under some allocation patterns,
813 // some large free blocks of memory will be locked between two used
814 // chunks, so they cannot be given back to the system.
815 //
816 // The `pad' argument to malloc_trim represents the amount of free
817 // trailing space to leave untrimmed. If this argument is zero, only the
818 // minimum amount of memory to maintain internal data structures will be
819 // left (one page or less). Non-zero arguments can be supplied to maintain
820 // enough trailing space to service future expected allocations without
821 // having to re-obtain memory from the system.
822 //
823 // Malloc_trim returns 1 if it actually released any memory, else 0. On
824 // systems that do not support "negative sbrks", it will always return 0.
825 //
826 // For simplicity, we always return 0.
827 #define MALLOC_TRIM(soname, fnname) \
828 \
829 int VG_REPLACE_FUNCTION_EZU(10150,soname,fnname) ( SizeT pad ); \
830 int VG_REPLACE_FUNCTION_EZU(10150,soname,fnname) ( SizeT pad ) \
831 { \
832 /* 0 denotes that malloc_trim() either wasn't able \
833 to do anything, or was not implemented */ \
834 return 0; \
835 }
836
837 #if defined(VGO_linux)
838 MALLOC_TRIM(VG_Z_LIBC_SONAME, malloc_trim);
839 MALLOC_TRIM(SO_SYN_MALLOC, malloc_trim);
840
841 #elif defined(VGO_darwin)
842 //MALLOC_TRIM(VG_Z_LIBC_SONAME, malloc_trim);
843
844 #endif
845
846
847 /*---------------------- posix_memalign ----------------------*/
848
849 #define POSIX_MEMALIGN(soname, fnname) \
850 \
851 int VG_REPLACE_FUNCTION_EZU(10160,soname,fnname) \
852 ( void **memptr, SizeT alignment, SizeT size ); \
853 int VG_REPLACE_FUNCTION_EZU(10160,soname,fnname) \
854 ( void **memptr, SizeT alignment, SizeT size ) \
855 { \
856 void *mem; \
857 \
858 /* Test whether the alignment argument is valid. It must be \
859 a power of two multiple of sizeof (void *). */ \
860 if (alignment % sizeof (void *) != 0 \
861 || (alignment & (alignment - 1)) != 0) \
862 return VKI_EINVAL; \
863 \
864 mem = VG_REPLACE_FUNCTION_EZU(10110,VG_Z_LIBC_SONAME,memalign) \
865 (alignment, size); \
866 \
867 if (mem != NULL) { \
868 *memptr = mem; \
869 return 0; \
870 } \
871 \
872 return VKI_ENOMEM; \
873 }
874
875 #if defined(VGO_linux)
876 POSIX_MEMALIGN(VG_Z_LIBC_SONAME, posix_memalign);
877 POSIX_MEMALIGN(SO_SYN_MALLOC, posix_memalign);
878
879 #elif defined(VGO_darwin)
880 //POSIX_MEMALIGN(VG_Z_LIBC_SONAME, posix_memalign);
881
882 #endif
883
884
885 /*---------------------- malloc_usable_size ----------------------*/
886
887 #define MALLOC_USABLE_SIZE(soname, fnname) \
888 \
889 SizeT VG_REPLACE_FUNCTION_EZU(10170,soname,fnname) ( void* p ); \
890 SizeT VG_REPLACE_FUNCTION_EZU(10170,soname,fnname) ( void* p ) \
891 { \
892 SizeT pszB; \
893 \
894 if (!init_done) init(); \
895 MALLOC_TRACE("malloc_usable_size(%p)", p ); \
896 if (NULL == p) \
897 return 0; \
898 \
899 pszB = (SizeT)VALGRIND_NON_SIMD_CALL1( info.tl_malloc_usable_size, p ); \
900 MALLOC_TRACE(" = %llu\n", (ULong)pszB ); \
901 \
902 return pszB; \
903 }
904
905 #if defined(VGO_linux)
906 MALLOC_USABLE_SIZE(VG_Z_LIBC_SONAME, malloc_usable_size);
907 MALLOC_USABLE_SIZE(SO_SYN_MALLOC, malloc_usable_size);
908 MALLOC_USABLE_SIZE(VG_Z_LIBC_SONAME, malloc_size);
909 MALLOC_USABLE_SIZE(SO_SYN_MALLOC, malloc_size);
910 # if defined(VGPV_arm_linux_android) || defined(VGPV_x86_linux_android)
911 MALLOC_USABLE_SIZE(VG_Z_LIBC_SONAME, dlmalloc_usable_size);
912 MALLOC_USABLE_SIZE(SO_SYN_MALLOC, dlmalloc_usable_size);
913 # endif
914
915 #elif defined(VGO_darwin)
916 //MALLOC_USABLE_SIZE(VG_Z_LIBC_SONAME, malloc_usable_size);
917 MALLOC_USABLE_SIZE(VG_Z_LIBC_SONAME, malloc_size);
918 MALLOC_USABLE_SIZE(SO_SYN_MALLOC, malloc_size);
919
920 #endif
921
922
923 /*---------------------- (unimplemented) ----------------------*/
924
925 /* Bomb out if we get any of these. */
926
panic(const char * str)927 static void panic(const char *str)
928 {
929 VALGRIND_PRINTF_BACKTRACE("Program aborting because of call to %s\n", str);
930 my_exit(99);
931 *(volatile int *)0 = 'x';
932 }
933
934 #define PANIC(soname, fnname) \
935 \
936 void VG_REPLACE_FUNCTION_EZU(10180,soname,fnname) ( void ); \
937 void VG_REPLACE_FUNCTION_EZU(10180,soname,fnname) ( void ) \
938 { \
939 panic(#fnname); \
940 }
941
942 #if defined(VGO_linux)
943 PANIC(VG_Z_LIBC_SONAME, pvalloc);
944 PANIC(VG_Z_LIBC_SONAME, malloc_get_state);
945 PANIC(VG_Z_LIBC_SONAME, malloc_set_state);
946
947 #elif defined(VGO_darwin)
948 PANIC(VG_Z_LIBC_SONAME, pvalloc);
949 PANIC(VG_Z_LIBC_SONAME, malloc_get_state);
950 PANIC(VG_Z_LIBC_SONAME, malloc_set_state);
951
952 #endif
953
954
955 #define MALLOC_STATS(soname, fnname) \
956 \
957 void VG_REPLACE_FUNCTION_EZU(10190,soname,fnname) ( void ); \
958 void VG_REPLACE_FUNCTION_EZU(10190,soname,fnname) ( void ) \
959 { \
960 /* Valgrind's malloc_stats implementation does nothing. */ \
961 }
962
963 #if defined(VGO_linux)
964 MALLOC_STATS(VG_Z_LIBC_SONAME, malloc_stats);
965 MALLOC_STATS(SO_SYN_MALLOC, malloc_stats);
966
967 #elif defined(VGO_darwin)
968 //MALLOC_STATS(VG_Z_LIBC_SONAME, malloc_stats);
969
970 #endif
971
972
973 /*---------------------- mallinfo ----------------------*/
974
975 // mi must be static; if it is auto then Memcheck thinks it is
976 // uninitialised when used by the caller of this function, because Memcheck
977 // doesn't know that the call to mallinfo fills in mi.
978 #define MALLINFO(soname, fnname) \
979 \
980 struct vg_mallinfo VG_REPLACE_FUNCTION_EZU(10200,soname,fnname) ( void ); \
981 struct vg_mallinfo VG_REPLACE_FUNCTION_EZU(10200,soname,fnname) ( void ) \
982 { \
983 static struct vg_mallinfo mi; \
984 if (!init_done) init(); \
985 MALLOC_TRACE("mallinfo()\n"); \
986 (void)VALGRIND_NON_SIMD_CALL1( info.mallinfo, &mi ); \
987 return mi; \
988 }
989
990 #if defined(VGO_linux)
991 MALLINFO(VG_Z_LIBC_SONAME, mallinfo);
992 MALLINFO(SO_SYN_MALLOC, mallinfo);
993
994 #elif defined(VGO_darwin)
995 //MALLINFO(VG_Z_LIBC_SONAME, mallinfo);
996
997 #endif
998
999
1000 /*------------------ Darwin zone stuff ------------------*/
1001
1002 #if defined(VGO_darwin)
1003
my_malloc_size(void * zone,void * ptr)1004 static size_t my_malloc_size ( void* zone, void* ptr )
1005 {
1006 /* Implement "malloc_size" by handing the request through to the
1007 tool's .tl_usable_size method. */
1008 if (!init_done) init();
1009 size_t res = (size_t)VALGRIND_NON_SIMD_CALL1(
1010 info.tl_malloc_usable_size, ptr);
1011 return res;
1012 }
1013
1014 /* Note that the (void*) casts below are a kludge which stops
1015 compilers complaining about the fact that the the replacement
1016 functions aren't really of the right type. */
1017 static vki_malloc_zone_t vg_default_zone = {
1018 NULL, // reserved1
1019 NULL, // reserved2
1020 (void*)my_malloc_size, // JRS fixme: is this right?
1021 (void*)VG_REPLACE_FUNCTION_EZU(10020,VG_Z_LIBC_SONAME,malloc_zone_malloc),
1022 (void*)VG_REPLACE_FUNCTION_EZU(10060,VG_Z_LIBC_SONAME,malloc_zone_calloc),
1023 (void*)VG_REPLACE_FUNCTION_EZU(10130,VG_Z_LIBC_SONAME,malloc_zone_valloc),
1024 (void*)VG_REPLACE_FUNCTION_EZU(10040,VG_Z_LIBC_SONAME,malloc_zone_free),
1025 (void*)VG_REPLACE_FUNCTION_EZU(10080,VG_Z_LIBC_SONAME,malloc_zone_realloc),
1026 NULL, // GrP fixme: destroy
1027 "ValgrindMallocZone",
1028 NULL, // batch_malloc
1029 NULL, // batch_free
1030 NULL, // GrP fixme: introspect
1031 2, // version (GrP fixme 3?)
1032 NULL, /* memalign */ // DDD: this field exists in Mac OS 10.6, but not 10.5.
1033 NULL, /* free_definite_size */
1034 NULL, /* pressure_relief */
1035 };
1036
1037
1038 #define DEFAULT_ZONE(soname, fnname) \
1039 \
1040 void *VG_REPLACE_FUNCTION_EZU(10210,soname,fnname) ( void ); \
1041 void *VG_REPLACE_FUNCTION_EZU(10210,soname,fnname) ( void ) \
1042 { \
1043 return &vg_default_zone; \
1044 }
1045
1046 DEFAULT_ZONE(VG_Z_LIBC_SONAME, malloc_default_zone);
1047 DEFAULT_ZONE(SO_SYN_MALLOC, malloc_default_zone);
1048
1049
1050 #define ZONE_FROM_PTR(soname, fnname) \
1051 \
1052 void *VG_REPLACE_FUNCTION_EZU(10220,soname,fnname) ( void* ptr ); \
1053 void *VG_REPLACE_FUNCTION_EZU(10220,soname,fnname) ( void* ptr ) \
1054 { \
1055 return &vg_default_zone; \
1056 }
1057
1058 ZONE_FROM_PTR(VG_Z_LIBC_SONAME, malloc_zone_from_ptr);
1059 ZONE_FROM_PTR(SO_SYN_MALLOC, malloc_zone_from_ptr);
1060
1061
1062 // GrP fixme bypass libc's use of zone->introspect->check
1063 #define ZONE_CHECK(soname, fnname) \
1064 \
1065 int VG_REPLACE_FUNCTION_EZU(10230,soname,fnname)(void* zone); \
1066 int VG_REPLACE_FUNCTION_EZU(10230,soname,fnname)(void* zone) \
1067 { \
1068 return 1; \
1069 }
1070
1071 //ZONE_CHECK(VG_Z_LIBC_SONAME, malloc_zone_check);
1072
1073 #endif /* defined(VGO_darwin) */
1074
1075
1076 /*------------------ (startup related) ------------------*/
1077
1078 /* All the code in here is unused until this function is called */
1079
1080 __attribute__((constructor))
init(void)1081 static void init(void)
1082 {
1083 // This doesn't look thread-safe, but it should be ok... Bart says:
1084 //
1085 // Every program I know of calls malloc() at least once before calling
1086 // pthread_create(). So init_done gets initialized before any thread is
1087 // created, and is only read when multiple threads are active
1088 // simultaneously. Such an access pattern is safe.
1089 //
1090 // If the assignment to the variable init_done would be triggering a race
1091 // condition, both DRD and Helgrind would report this race.
1092 //
1093 // By the way, although the init() function in
1094 // coregrind/m_replacemalloc/vg_replace_malloc.c has been declared
1095 // __attribute__((constructor)), it is not safe to remove the variable
1096 // init_done. This is because it is possible that malloc() and hence
1097 // init() gets called before shared library initialization finished.
1098 //
1099 if (init_done)
1100 return;
1101
1102 init_done = 1;
1103
1104 VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__GET_MALLOCFUNCS, &info,
1105 0, 0, 0, 0);
1106 }
1107
1108 /*--------------------------------------------------------------------*/
1109 /*--- end ---*/
1110 /*--------------------------------------------------------------------*/
1111