blob: 750a9d94571931ea149f5beeeb686fd8285addf9 [file] [log] [blame]
sewardjb5f6f512005-03-10 23:59:00 +00001/* -*- c -*-
njn25e49d8e72002-09-23 09:36:25 +00002 ----------------------------------------------------------------
3
4 Notice that the following BSD-style license applies to this one
5 file (valgrind.h) only. The entire rest of Valgrind is licensed
6 under the terms of the GNU General Public License, version 2. See
7 the COPYING file in the source distribution for details.
8
9 ----------------------------------------------------------------
10
njnb9c427c2004-12-01 14:14:42 +000011 This file is part of Valgrind, a dynamic binary instrumentation
12 framework.
sewardjde4a1d02002-03-22 01:27:54 +000013
njn53612422005-03-12 16:22:54 +000014 Copyright (C) 2000-2005 Julian Seward. All rights reserved.
sewardjde4a1d02002-03-22 01:27:54 +000015
njn25e49d8e72002-09-23 09:36:25 +000016 Redistribution and use in source and binary forms, with or without
17 modification, are permitted provided that the following conditions
18 are met:
sewardjde4a1d02002-03-22 01:27:54 +000019
njn25e49d8e72002-09-23 09:36:25 +000020 1. Redistributions of source code must retain the above copyright
21 notice, this list of conditions and the following disclaimer.
sewardjde4a1d02002-03-22 01:27:54 +000022
njn25e49d8e72002-09-23 09:36:25 +000023 2. The origin of this software must not be misrepresented; you must
24 not claim that you wrote the original software. If you use this
25 software in a product, an acknowledgment in the product
26 documentation would be appreciated but is not required.
sewardjde4a1d02002-03-22 01:27:54 +000027
njn25e49d8e72002-09-23 09:36:25 +000028 3. Altered source versions must be plainly marked as such, and must
29 not be misrepresented as being the original software.
30
31 4. The name of the author may not be used to endorse or promote
32 products derived from this software without specific prior written
33 permission.
34
35 THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
36 OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
37 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
38 ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
39 DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
40 DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
41 GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
42 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
43 WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
44 NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
45 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
46
47 ----------------------------------------------------------------
48
49 Notice that the above BSD-style license applies to this one file
50 (valgrind.h) only. The entire rest of Valgrind is licensed under
51 the terms of the GNU General Public License, version 2. See the
52 COPYING file in the source distribution for details.
53
54 ----------------------------------------------------------------
sewardjde4a1d02002-03-22 01:27:54 +000055*/
56
57
58#ifndef __VALGRIND_H
59#define __VALGRIND_H
60
fitzhardinge39de4b42003-10-31 07:12:21 +000061#include <stdarg.h>
62
sewardjb5f6f512005-03-10 23:59:00 +000063/* If we're not compiling for our target architecture, don't generate
njn26aba4d2005-05-16 13:31:23 +000064 any inline asms. Note that in this file we're using the compiler's
65 CPP symbols for identifying architectures, which are different to
66 the ones we use within the rest of Valgrind. */
67#if !defined(__i386__) && !defined(__x86_64__)
sewardjb5f6f512005-03-10 23:59:00 +000068# ifndef NVALGRIND
69# define NVALGRIND 1
70# endif /* NVALGRIND */
71#endif
72
73
sewardjde4a1d02002-03-22 01:27:54 +000074/* This file is for inclusion into client (your!) code.
75
njn25e49d8e72002-09-23 09:36:25 +000076 You can use these macros to manipulate and query Valgrind's
77 execution inside your own programs.
sewardjde4a1d02002-03-22 01:27:54 +000078
79 The resulting executables will still run without Valgrind, just a
80 little bit more slowly than they otherwise would, but otherwise
sewardj285f77f2003-03-15 23:39:11 +000081 unchanged. When not running on valgrind, each client request
nethercotee90c6832004-10-18 18:07:49 +000082 consumes very few (eg. < 10) instructions, so the resulting performance
sewardj285f77f2003-03-15 23:39:11 +000083 loss is negligible unless you plan to execute client requests
84 millions of times per second. Nevertheless, if that is still a
85 problem, you can compile with the NVALGRIND symbol defined (gcc
86 -DNVALGRIND) so that client requests are not even compiled in. */
sewardjde4a1d02002-03-22 01:27:54 +000087
njn26aba4d2005-05-16 13:31:23 +000088#ifdef NVALGRIND
89
90/* Define NVALGRIND to completely remove the Valgrind magic sequence
91 from the compiled code (analogous to NDEBUG's effects on assert()) */
92#define VALGRIND_MAGIC_SEQUENCE( \
93 _zzq_rlval, _zzq_default, _zzq_request, \
94 _zzq_arg1, _zzq_arg2, _zzq_arg3, _zzq_arg4) \
95 { \
96 (_zzq_rlval) = (_zzq_default); \
97 }
98
99#else /* NVALGRIND */
nethercotee90c6832004-10-18 18:07:49 +0000100
nethercote54265442004-10-26 12:56:58 +0000101/* The following defines the magic code sequences which the JITter spots and
102 handles magically. Don't look too closely at them; they will rot
nethercotee90c6832004-10-18 18:07:49 +0000103 your brain. We must ensure that the default value gets put in the return
104 slot, so that everything works when this is executed not under Valgrind.
105 Args are passed in a memory block, and so there's no intrinsic limit to
106 the number that could be passed, but it's currently four.
107
nethercote54265442004-10-26 12:56:58 +0000108 The macro args are:
109 _zzq_rlval result lvalue
110 _zzq_default default value (result returned when running on real CPU)
111 _zzq_request request code
112 _zzq_arg1..4 request params
113
nethercotee90c6832004-10-18 18:07:49 +0000114 Nb: we put the assembly code sequences for all architectures in this one
njn26aba4d2005-05-16 13:31:23 +0000115 file. This is because this file must be stand-alone, and we don't want
116 to have multiple files.
nethercotee90c6832004-10-18 18:07:49 +0000117*/
118
njn26aba4d2005-05-16 13:31:23 +0000119#ifdef __x86_64__
sewardjde4a4ab2005-03-23 13:10:32 +0000120extern int printf (__const char *__restrict __format, ...);
121extern void exit (int __status);
122#define VALGRIND_MAGIC_SEQUENCE( \
123 _zzq_rlval, _zzq_default, _zzq_request, \
124 _zzq_arg1, _zzq_arg2, _zzq_arg3, _zzq_arg4) \
125 \
126 { volatile unsigned long long _zzq_args[5]; \
127 _zzq_args[0] = (volatile unsigned long long)(_zzq_request); \
128 _zzq_args[1] = (volatile unsigned long long)(_zzq_arg1); \
129 _zzq_args[2] = (volatile unsigned long long)(_zzq_arg2); \
130 _zzq_args[3] = (volatile unsigned long long)(_zzq_arg3); \
131 _zzq_args[4] = (volatile unsigned long long)(_zzq_arg4); \
132 asm volatile("roll $29, %%eax ; roll $3, %%eax\n\t" \
133 "rorl $27, %%eax ; rorl $5, %%eax\n\t" \
134 "roll $13, %%eax ; roll $19, %%eax" \
135 : "=d" (_zzq_rlval) \
136 : "a" (&_zzq_args[0]), "0" (_zzq_default) \
137 : "cc", "memory" \
138 ); \
139 }
njn26aba4d2005-05-16 13:31:23 +0000140#endif // __x86_64__
sewardjde4a4ab2005-03-23 13:10:32 +0000141
142#ifdef __i386__
143#define VALGRIND_MAGIC_SEQUENCE( \
144 _zzq_rlval, _zzq_default, _zzq_request, \
145 _zzq_arg1, _zzq_arg2, _zzq_arg3, _zzq_arg4) \
146 \
147 { unsigned int _zzq_args[5]; \
148 _zzq_args[0] = (unsigned int)(_zzq_request); \
149 _zzq_args[1] = (unsigned int)(_zzq_arg1); \
150 _zzq_args[2] = (unsigned int)(_zzq_arg2); \
151 _zzq_args[3] = (unsigned int)(_zzq_arg3); \
152 _zzq_args[4] = (unsigned int)(_zzq_arg4); \
153 asm volatile("roll $29, %%eax ; roll $3, %%eax\n\t" \
154 "rorl $27, %%eax ; rorl $5, %%eax\n\t" \
155 "roll $13, %%eax ; roll $19, %%eax" \
156 : "=d" (_zzq_rlval) \
157 : "a" (&_zzq_args[0]), "0" (_zzq_default) \
158 : "cc", "memory" \
159 ); \
160 }
161#endif // __i386__
sewardjde4a4ab2005-03-23 13:10:32 +0000162
njnc6168192004-11-29 13:54:10 +0000163#ifdef __arm__
njn26aba4d2005-05-16 13:31:23 +0000164// XXX: temporary, until MAGIC_SEQUENCE is written properly
njnc6168192004-11-29 13:54:10 +0000165extern int printf (__const char *__restrict __format, ...);
166extern void exit (int __status);
167#define VALGRIND_MAGIC_SEQUENCE( \
168 _zzq_rlval, _zzq_default, _zzq_request, \
169 _zzq_arg1, _zzq_arg2, _zzq_arg3, _zzq_arg4) \
170 \
171 { volatile unsigned int _zzq_args[5]; \
172 _zzq_args[0] = (volatile unsigned int)(_zzq_request); \
173 _zzq_args[1] = (volatile unsigned int)(_zzq_arg1); \
174 _zzq_args[2] = (volatile unsigned int)(_zzq_arg2); \
175 _zzq_args[3] = (volatile unsigned int)(_zzq_arg3); \
176 _zzq_args[4] = (volatile unsigned int)(_zzq_arg4); \
177 (_zzq_rlval) = (_zzq_default);/* temporary only */ \
178 printf("argh: MAGIC_SEQUENCE"); exit(1); \
179 asm volatile(""); \
180 }
181// XXX: make sure that the register holding the args and the register taking
njn26aba4d2005-05-16 13:31:23 +0000182// the return value match what the scheduler is expecting.
njnc6168192004-11-29 13:54:10 +0000183#endif // __arm__
nethercotee90c6832004-10-18 18:07:49 +0000184
njn26aba4d2005-05-16 13:31:23 +0000185// Insert assembly code for other architectures here...
186
sewardj37091fb2002-11-16 11:06:50 +0000187#endif /* NVALGRIND */
sewardj2e93c502002-04-12 11:12:52 +0000188
nethercote69d9c462004-10-26 13:00:12 +0000189
sewardj2e93c502002-04-12 11:12:52 +0000190/* Some request codes. There are many more of these, but most are not
191 exposed to end-user view. These are the public ones, all of the
njn25e49d8e72002-09-23 09:36:25 +0000192 form 0x1000 + small_number.
njnd7994182003-10-02 13:44:04 +0000193
194 Core ones are in the range 0x00000000--0x0000ffff. The non-public ones
195 start at 0x2000.
sewardj2e93c502002-04-12 11:12:52 +0000196*/
197
njnfc26ff92004-11-22 19:12:49 +0000198// These macros are used by tools -- they must be public, but don't embed them
199// into other programs.
200#define VG_USERREQ_TOOL_BASE(a,b) \
njn4c791212003-05-02 17:53:54 +0000201 ((unsigned int)(((a)&0xff) << 24 | ((b)&0xff) << 16))
njnfc26ff92004-11-22 19:12:49 +0000202#define VG_IS_TOOL_USERREQ(a, b, v) \
203 (VG_USERREQ_TOOL_BASE(a,b) == ((v) & 0xffff0000))
sewardj34042512002-10-22 04:14:35 +0000204
njn25e49d8e72002-09-23 09:36:25 +0000205typedef
njn4c791212003-05-02 17:53:54 +0000206 enum { VG_USERREQ__RUNNING_ON_VALGRIND = 0x1001,
207 VG_USERREQ__DISCARD_TRANSLATIONS = 0x1002,
njn3e884182003-04-15 13:03:23 +0000208
njnd4795be2004-11-24 11:57:51 +0000209 /* These allow any function to be called from the
210 simulated CPU but run on the real CPU.
211 Nb: the first arg passed to the function is always the ThreadId of
212 the running thread! So CLIENT_CALL0 actually requires a 1 arg
213 function, etc. */
njn4c791212003-05-02 17:53:54 +0000214 VG_USERREQ__CLIENT_CALL0 = 0x1101,
215 VG_USERREQ__CLIENT_CALL1 = 0x1102,
216 VG_USERREQ__CLIENT_CALL2 = 0x1103,
217 VG_USERREQ__CLIENT_CALL3 = 0x1104,
njn3e884182003-04-15 13:03:23 +0000218
njn47363ab2003-04-21 13:24:40 +0000219 /* Can be useful in regression testing suites -- eg. can send
220 Valgrind's output to /dev/null and still count errors. */
njn4c791212003-05-02 17:53:54 +0000221 VG_USERREQ__COUNT_ERRORS = 0x1201,
njn47363ab2003-04-21 13:24:40 +0000222
nethercote7cc9c232004-01-21 15:08:04 +0000223 /* These are useful and can be interpreted by any tool that tracks
njnd7994182003-10-02 13:44:04 +0000224 malloc() et al, by using vg_replace_malloc.c. */
225 VG_USERREQ__MALLOCLIKE_BLOCK = 0x1301,
226 VG_USERREQ__FREELIKE_BLOCK = 0x1302,
rjwalshbc0bb832004-06-19 18:12:36 +0000227 /* Memory pool support. */
228 VG_USERREQ__CREATE_MEMPOOL = 0x1303,
229 VG_USERREQ__DESTROY_MEMPOOL = 0x1304,
230 VG_USERREQ__MEMPOOL_ALLOC = 0x1305,
231 VG_USERREQ__MEMPOOL_FREE = 0x1306,
njnd7994182003-10-02 13:44:04 +0000232
fitzhardinge39de4b42003-10-31 07:12:21 +0000233 /* Allow printfs to valgrind log. */
234 VG_USERREQ__PRINTF = 0x1401,
thughes85c8a502004-08-25 13:25:30 +0000235 VG_USERREQ__PRINTF_BACKTRACE = 0x1402
njn25e49d8e72002-09-23 09:36:25 +0000236 } Vg_ClientRequest;
sewardj2e93c502002-04-12 11:12:52 +0000237
muellerc9b36552003-12-31 14:32:23 +0000238#ifndef __GNUC__
239#define __extension__
240#endif
sewardj2e93c502002-04-12 11:12:52 +0000241
njnf09745a2005-05-10 03:01:23 +0000242/* Returns the number of Valgrinds this code is running under. That is,
243 0 if running natively, 1 if running under Valgrind, 2 if running under
244 Valgrind which is running under another Valgrind, etc. */
muellerc9b36552003-12-31 14:32:23 +0000245#define RUNNING_ON_VALGRIND __extension__ \
sewardj2e93c502002-04-12 11:12:52 +0000246 ({unsigned int _qzz_res; \
247 VALGRIND_MAGIC_SEQUENCE(_qzz_res, 0 /* returned if not */, \
248 VG_USERREQ__RUNNING_ON_VALGRIND, \
249 0, 0, 0, 0); \
250 _qzz_res; \
sewardjde4a1d02002-03-22 01:27:54 +0000251 })
252
253
sewardj18d75132002-05-16 11:06:21 +0000254/* Discard translation of code in the range [_qzz_addr .. _qzz_addr +
255 _qzz_len - 1]. Useful if you are debugging a JITter or some such,
256 since it provides a way to make sure valgrind will retranslate the
257 invalidated area. Returns no value. */
258#define VALGRIND_DISCARD_TRANSLATIONS(_qzz_addr,_qzz_len) \
259 {unsigned int _qzz_res; \
260 VALGRIND_MAGIC_SEQUENCE(_qzz_res, 0, \
261 VG_USERREQ__DISCARD_TRANSLATIONS, \
262 _qzz_addr, _qzz_len, 0, 0); \
263 }
264
njn26aba4d2005-05-16 13:31:23 +0000265#ifdef NVALGRIND
266
267#define VALGRIND_PRINTF(...)
268#define VALGRIND_PRINTF_BACKTRACE(...)
269
270#else /* NVALGRIND */
fitzhardinge39de4b42003-10-31 07:12:21 +0000271
fitzhardingea09a1b52003-11-07 23:09:48 +0000272int VALGRIND_PRINTF(const char *format, ...)
273 __attribute__((format(__printf__, 1, 2)));
fitzhardinge39de4b42003-10-31 07:12:21 +0000274__attribute__((weak))
275int
fitzhardingea09a1b52003-11-07 23:09:48 +0000276VALGRIND_PRINTF(const char *format, ...)
fitzhardinge39de4b42003-10-31 07:12:21 +0000277{
njnc6168192004-11-29 13:54:10 +0000278 unsigned long _qzz_res;
fitzhardinge39de4b42003-10-31 07:12:21 +0000279 va_list vargs;
280 va_start(vargs, format);
281 VALGRIND_MAGIC_SEQUENCE(_qzz_res, 0, VG_USERREQ__PRINTF,
njnc6168192004-11-29 13:54:10 +0000282 (unsigned long)format, (unsigned long)vargs, 0, 0);
fitzhardinge39de4b42003-10-31 07:12:21 +0000283 va_end(vargs);
njnc6168192004-11-29 13:54:10 +0000284 return (int)_qzz_res;
fitzhardinge39de4b42003-10-31 07:12:21 +0000285}
286
fitzhardingea09a1b52003-11-07 23:09:48 +0000287int VALGRIND_PRINTF_BACKTRACE(const char *format, ...)
288 __attribute__((format(__printf__, 1, 2)));
fitzhardinge39de4b42003-10-31 07:12:21 +0000289__attribute__((weak))
290int
fitzhardingea09a1b52003-11-07 23:09:48 +0000291VALGRIND_PRINTF_BACKTRACE(const char *format, ...)
fitzhardinge39de4b42003-10-31 07:12:21 +0000292{
njnc6168192004-11-29 13:54:10 +0000293 unsigned long _qzz_res;
fitzhardinge39de4b42003-10-31 07:12:21 +0000294 va_list vargs;
295 va_start(vargs, format);
296 VALGRIND_MAGIC_SEQUENCE(_qzz_res, 0, VG_USERREQ__PRINTF_BACKTRACE,
njnc6168192004-11-29 13:54:10 +0000297 (unsigned long)format, (unsigned long)vargs, 0, 0);
fitzhardinge39de4b42003-10-31 07:12:21 +0000298 va_end(vargs);
njnc6168192004-11-29 13:54:10 +0000299 return (int)_qzz_res;
fitzhardinge39de4b42003-10-31 07:12:21 +0000300}
301
fitzhardinge39de4b42003-10-31 07:12:21 +0000302#endif /* NVALGRIND */
sewardj18d75132002-05-16 11:06:21 +0000303
njn3e884182003-04-15 13:03:23 +0000304/* These requests allow control to move from the simulated CPU to the
305 real CPU, calling an arbitary function */
njn057c65f2003-04-21 13:30:55 +0000306#define VALGRIND_NON_SIMD_CALL0(_qyy_fn) \
njnc6168192004-11-29 13:54:10 +0000307 ({unsigned long _qyy_res; \
njn3e884182003-04-15 13:03:23 +0000308 VALGRIND_MAGIC_SEQUENCE(_qyy_res, 0 /* default return */, \
309 VG_USERREQ__CLIENT_CALL0, \
310 _qyy_fn, \
311 0, 0, 0); \
312 _qyy_res; \
313 })
314
njn057c65f2003-04-21 13:30:55 +0000315#define VALGRIND_NON_SIMD_CALL1(_qyy_fn, _qyy_arg1) \
njnc6168192004-11-29 13:54:10 +0000316 ({unsigned long _qyy_res; \
njn3e884182003-04-15 13:03:23 +0000317 VALGRIND_MAGIC_SEQUENCE(_qyy_res, 0 /* default return */, \
318 VG_USERREQ__CLIENT_CALL1, \
319 _qyy_fn, \
320 _qyy_arg1, 0, 0); \
321 _qyy_res; \
322 })
323
njn057c65f2003-04-21 13:30:55 +0000324#define VALGRIND_NON_SIMD_CALL2(_qyy_fn, _qyy_arg1, _qyy_arg2) \
njnc6168192004-11-29 13:54:10 +0000325 ({unsigned long _qyy_res; \
njn3e884182003-04-15 13:03:23 +0000326 VALGRIND_MAGIC_SEQUENCE(_qyy_res, 0 /* default return */, \
327 VG_USERREQ__CLIENT_CALL2, \
328 _qyy_fn, \
329 _qyy_arg1, _qyy_arg2, 0); \
330 _qyy_res; \
331 })
332
njn057c65f2003-04-21 13:30:55 +0000333#define VALGRIND_NON_SIMD_CALL3(_qyy_fn, _qyy_arg1, _qyy_arg2, _qyy_arg3) \
njnc6168192004-11-29 13:54:10 +0000334 ({unsigned long _qyy_res; \
njn3e884182003-04-15 13:03:23 +0000335 VALGRIND_MAGIC_SEQUENCE(_qyy_res, 0 /* default return */, \
336 VG_USERREQ__CLIENT_CALL3, \
337 _qyy_fn, \
338 _qyy_arg1, _qyy_arg2, _qyy_arg3); \
339 _qyy_res; \
340 })
341
342
nethercote7cc9c232004-01-21 15:08:04 +0000343/* Counts the number of errors that have been recorded by a tool. Nb:
344 the tool must record the errors with VG_(maybe_record_error)() or
njn47363ab2003-04-21 13:24:40 +0000345 VG_(unique_error)() for them to be counted. */
346#define VALGRIND_COUNT_ERRORS \
347 ({unsigned int _qyy_res; \
348 VALGRIND_MAGIC_SEQUENCE(_qyy_res, 0 /* default return */, \
349 VG_USERREQ__COUNT_ERRORS, \
350 0, 0, 0, 0); \
351 _qyy_res; \
352 })
353
njnd7994182003-10-02 13:44:04 +0000354/* Mark a block of memory as having been allocated by a malloc()-like
355 function. `addr' is the start of the usable block (ie. after any
356 redzone) `rzB' is redzone size if the allocator can apply redzones;
357 use '0' if not. Adding redzones makes it more likely Valgrind will spot
358 block overruns. `is_zeroed' indicates if the memory is zeroed, as it is
359 for calloc(). Put it immediately after the point where a block is
360 allocated.
361
362 If you're allocating memory via superblocks, and then handing out small
363 chunks of each superblock, if you don't have redzones on your small
364 blocks, it's worth marking the superblock with VALGRIND_MAKE_NOACCESS
365 when it's created, so that block overruns are detected. But if you can
366 put redzones on, it's probably better to not do this, so that messages
367 for small overruns are described in terms of the small block rather than
368 the superblock (but if you have a big overrun that skips over a redzone,
369 you could miss an error this way). See memcheck/tests/custom_alloc.c
370 for an example.
371
372 Nb: block must be freed via a free()-like function specified
373 with VALGRIND_FREELIKE_BLOCK or mismatch errors will occur. */
374#define VALGRIND_MALLOCLIKE_BLOCK(addr, sizeB, rzB, is_zeroed) \
375 {unsigned int _qzz_res; \
376 VALGRIND_MAGIC_SEQUENCE(_qzz_res, 0, \
377 VG_USERREQ__MALLOCLIKE_BLOCK, \
378 addr, sizeB, rzB, is_zeroed); \
379 }
380
381/* Mark a block of memory as having been freed by a free()-like function.
382 `rzB' is redzone size; it must match that given to
383 VALGRIND_MALLOCLIKE_BLOCK. Memory not freed will be detected by the leak
384 checker. Put it immediately after the point where the block is freed. */
385#define VALGRIND_FREELIKE_BLOCK(addr, rzB) \
386 {unsigned int _qzz_res; \
387 VALGRIND_MAGIC_SEQUENCE(_qzz_res, 0, \
388 VG_USERREQ__FREELIKE_BLOCK, \
389 addr, rzB, 0, 0); \
390 }
391
rjwalshbc0bb832004-06-19 18:12:36 +0000392/* Create a memory pool. */
393#define VALGRIND_CREATE_MEMPOOL(pool, rzB, is_zeroed) \
394 {unsigned int _qzz_res; \
395 VALGRIND_MAGIC_SEQUENCE(_qzz_res, 0, \
396 VG_USERREQ__CREATE_MEMPOOL, \
397 pool, rzB, is_zeroed, 0); \
398 }
399
400/* Destroy a memory pool. */
401#define VALGRIND_DESTROY_MEMPOOL(pool) \
402 {unsigned int _qzz_res; \
403 VALGRIND_MAGIC_SEQUENCE(_qzz_res, 0, \
404 VG_USERREQ__DESTROY_MEMPOOL, \
405 pool, 0, 0, 0); \
406 }
407
408/* Associate a piece of memory with a memory pool. */
409#define VALGRIND_MEMPOOL_ALLOC(pool, addr, size) \
410 {unsigned int _qzz_res; \
411 VALGRIND_MAGIC_SEQUENCE(_qzz_res, 0, \
412 VG_USERREQ__MEMPOOL_ALLOC, \
413 pool, addr, size, 0); \
414 }
415
416/* Disassociate a piece of memory from a memory pool. */
417#define VALGRIND_MEMPOOL_FREE(pool, addr) \
418 {unsigned int _qzz_res; \
419 VALGRIND_MAGIC_SEQUENCE(_qzz_res, 0, \
420 VG_USERREQ__MEMPOOL_FREE, \
421 pool, addr, 0, 0); \
422 }
423
njn3e884182003-04-15 13:03:23 +0000424#endif /* __VALGRIND_H */