blob: d7f57d76b07c5e3e32d6a8c5b8e8b2b9308be36a [file] [log] [blame]
sewardjde4a1d02002-03-22 01:27:54 +00001
2/*
njn25e49d8e72002-09-23 09:36:25 +00003 ----------------------------------------------------------------
4
5 Notice that the following BSD-style license applies to this one
6 file (valgrind.h) only. The entire rest of Valgrind is licensed
7 under the terms of the GNU General Public License, version 2. See
8 the COPYING file in the source distribution for details.
9
10 ----------------------------------------------------------------
11
njnc9539842002-10-02 13:26:35 +000012 This file is part of Valgrind, an extensible x86 protected-mode
13 emulator for monitoring program execution on x86-Unixes.
sewardjde4a1d02002-03-22 01:27:54 +000014
nethercotebb1c9912004-01-04 16:43:23 +000015 Copyright (C) 2000-2004 Julian Seward. All rights reserved.
sewardjde4a1d02002-03-22 01:27:54 +000016
njn25e49d8e72002-09-23 09:36:25 +000017 Redistribution and use in source and binary forms, with or without
18 modification, are permitted provided that the following conditions
19 are met:
sewardjde4a1d02002-03-22 01:27:54 +000020
njn25e49d8e72002-09-23 09:36:25 +000021 1. Redistributions of source code must retain the above copyright
22 notice, this list of conditions and the following disclaimer.
sewardjde4a1d02002-03-22 01:27:54 +000023
njn25e49d8e72002-09-23 09:36:25 +000024 2. The origin of this software must not be misrepresented; you must
25 not claim that you wrote the original software. If you use this
26 software in a product, an acknowledgment in the product
27 documentation would be appreciated but is not required.
sewardjde4a1d02002-03-22 01:27:54 +000028
njn25e49d8e72002-09-23 09:36:25 +000029 3. Altered source versions must be plainly marked as such, and must
30 not be misrepresented as being the original software.
31
32 4. The name of the author may not be used to endorse or promote
33 products derived from this software without specific prior written
34 permission.
35
36 THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
37 OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
38 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
39 ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
40 DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
41 DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
42 GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
43 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
44 WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
45 NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
46 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
47
48 ----------------------------------------------------------------
49
50 Notice that the above BSD-style license applies to this one file
51 (valgrind.h) only. The entire rest of Valgrind is licensed under
52 the terms of the GNU General Public License, version 2. See the
53 COPYING file in the source distribution for details.
54
55 ----------------------------------------------------------------
sewardjde4a1d02002-03-22 01:27:54 +000056*/
57
58
59#ifndef __VALGRIND_H
60#define __VALGRIND_H
61
fitzhardinge39de4b42003-10-31 07:12:21 +000062#include <stdarg.h>
63
nethercotee90c6832004-10-18 18:07:49 +000064#define __@VG_ARCH@__ // Architecture we're installed on
sewardjde4a1d02002-03-22 01:27:54 +000065
66/* This file is for inclusion into client (your!) code.
67
njn25e49d8e72002-09-23 09:36:25 +000068 You can use these macros to manipulate and query Valgrind's
69 execution inside your own programs.
sewardjde4a1d02002-03-22 01:27:54 +000070
71 The resulting executables will still run without Valgrind, just a
72 little bit more slowly than they otherwise would, but otherwise
sewardj285f77f2003-03-15 23:39:11 +000073 unchanged. When not running on valgrind, each client request
nethercotee90c6832004-10-18 18:07:49 +000074 consumes very few (eg. < 10) instructions, so the resulting performance
sewardj285f77f2003-03-15 23:39:11 +000075 loss is negligible unless you plan to execute client requests
76 millions of times per second. Nevertheless, if that is still a
77 problem, you can compile with the NVALGRIND symbol defined (gcc
78 -DNVALGRIND) so that client requests are not even compiled in. */
sewardjde4a1d02002-03-22 01:27:54 +000079
sewardj37091fb2002-11-16 11:06:50 +000080#ifndef NVALGRIND
nethercotee90c6832004-10-18 18:07:49 +000081
82/* The following defines the magic code sequence which the JITter spots and
83 handles magically. Don't look too closely at this; it will rot
84 your brain. We must ensure that the default value gets put in the return
85 slot, so that everything works when this is executed not under Valgrind.
86 Args are passed in a memory block, and so there's no intrinsic limit to
87 the number that could be passed, but it's currently four.
88
89 Nb: we put the assembly code sequences for all architectures in this one
90 file. This is because this file must be stand-alone, so we can't rely on
91 eg. x86/ subdirectories like we do within the rest of Valgrind.
92*/
93
94#ifdef __x86__
sewardjde4a1d02002-03-22 01:27:54 +000095/* This defines the magic code sequence which the JITter spots and
96 handles magically. Don't look too closely at this; it will rot
sewardj2e93c502002-04-12 11:12:52 +000097 your brain. Valgrind dumps the result value in %EDX, so we first
98 copy the default value there, so that it is returned when not
99 running on Valgrind. Since %EAX points to a block of mem
100 containing the args, you can pass as many args as you want like
101 this. Currently this is set up to deal with 4 args since that's
102 the max that we appear to need (pthread_create).
sewardjde4a1d02002-03-22 01:27:54 +0000103*/
sewardj2e93c502002-04-12 11:12:52 +0000104#define VALGRIND_MAGIC_SEQUENCE( \
105 _zzq_rlval, /* result lvalue */ \
106 _zzq_default, /* result returned when running on real CPU */ \
107 _zzq_request, /* request code */ \
108 _zzq_arg1, /* request first param */ \
109 _zzq_arg2, /* request second param */ \
110 _zzq_arg3, /* request third param */ \
111 _zzq_arg4 /* request fourth param */ ) \
112 \
113 { volatile unsigned int _zzq_args[5]; \
sewardj18d75132002-05-16 11:06:21 +0000114 _zzq_args[0] = (volatile unsigned int)(_zzq_request); \
115 _zzq_args[1] = (volatile unsigned int)(_zzq_arg1); \
116 _zzq_args[2] = (volatile unsigned int)(_zzq_arg2); \
117 _zzq_args[3] = (volatile unsigned int)(_zzq_arg3); \
118 _zzq_args[4] = (volatile unsigned int)(_zzq_arg4); \
sewardj2e93c502002-04-12 11:12:52 +0000119 asm volatile("movl %1, %%eax\n\t" \
120 "movl %2, %%edx\n\t" \
121 "roll $29, %%eax ; roll $3, %%eax\n\t" \
122 "rorl $27, %%eax ; rorl $5, %%eax\n\t" \
123 "roll $13, %%eax ; roll $19, %%eax\n\t" \
124 "movl %%edx, %0\t" \
125 : "=r" (_zzq_rlval) \
126 : "r" (&_zzq_args[0]), "r" (_zzq_default) \
127 : "eax", "edx", "cc", "memory" \
128 ); \
129 }
nethercotee90c6832004-10-18 18:07:49 +0000130#endif // __x86__
131
132// Insert assembly code for other architectures here...
133
sewardj37091fb2002-11-16 11:06:50 +0000134#else /* NVALGRIND */
135/* Define NVALGRIND to completely remove the Valgrind magic sequence
136 from the compiled code (analogous to NDEBUG's effects on
137 assert()) */
138#define VALGRIND_MAGIC_SEQUENCE( \
139 _zzq_rlval, /* result lvalue */ \
140 _zzq_default, /* result returned when running on real CPU */ \
141 _zzq_request, /* request code */ \
142 _zzq_arg1, /* request first param */ \
143 _zzq_arg2, /* request second param */ \
144 _zzq_arg3, /* request third param */ \
145 _zzq_arg4 /* request fourth param */ ) \
146 { \
147 (_zzq_rlval) = (_zzq_default); \
148 }
149#endif /* NVALGRIND */
sewardj2e93c502002-04-12 11:12:52 +0000150
151/* Some request codes. There are many more of these, but most are not
152 exposed to end-user view. These are the public ones, all of the
njn25e49d8e72002-09-23 09:36:25 +0000153 form 0x1000 + small_number.
njnd7994182003-10-02 13:44:04 +0000154
155 Core ones are in the range 0x00000000--0x0000ffff. The non-public ones
156 start at 0x2000.
sewardj2e93c502002-04-12 11:12:52 +0000157*/
158
njn4c791212003-05-02 17:53:54 +0000159#define VG_USERREQ_SKIN_BASE(a,b) \
160 ((unsigned int)(((a)&0xff) << 24 | ((b)&0xff) << 16))
161#define VG_IS_SKIN_USERREQ(a, b, v) \
162 (VG_USERREQ_SKIN_BASE(a,b) == ((v) & 0xffff0000))
sewardj34042512002-10-22 04:14:35 +0000163
njn25e49d8e72002-09-23 09:36:25 +0000164typedef
njn4c791212003-05-02 17:53:54 +0000165 enum { VG_USERREQ__RUNNING_ON_VALGRIND = 0x1001,
166 VG_USERREQ__DISCARD_TRANSLATIONS = 0x1002,
njn3e884182003-04-15 13:03:23 +0000167
168 /* These allow any function of 0--3 args to be called from the
169 simulated CPU but run on the real CPU */
njn4c791212003-05-02 17:53:54 +0000170 VG_USERREQ__CLIENT_CALL0 = 0x1101,
171 VG_USERREQ__CLIENT_CALL1 = 0x1102,
172 VG_USERREQ__CLIENT_CALL2 = 0x1103,
173 VG_USERREQ__CLIENT_CALL3 = 0x1104,
njn3e884182003-04-15 13:03:23 +0000174
njn47363ab2003-04-21 13:24:40 +0000175 /* Can be useful in regression testing suites -- eg. can send
176 Valgrind's output to /dev/null and still count errors. */
njn4c791212003-05-02 17:53:54 +0000177 VG_USERREQ__COUNT_ERRORS = 0x1201,
njn47363ab2003-04-21 13:24:40 +0000178
nethercote7cc9c232004-01-21 15:08:04 +0000179 /* These are useful and can be interpreted by any tool that tracks
njnd7994182003-10-02 13:44:04 +0000180 malloc() et al, by using vg_replace_malloc.c. */
181 VG_USERREQ__MALLOCLIKE_BLOCK = 0x1301,
182 VG_USERREQ__FREELIKE_BLOCK = 0x1302,
rjwalshbc0bb832004-06-19 18:12:36 +0000183 /* Memory pool support. */
184 VG_USERREQ__CREATE_MEMPOOL = 0x1303,
185 VG_USERREQ__DESTROY_MEMPOOL = 0x1304,
186 VG_USERREQ__MEMPOOL_ALLOC = 0x1305,
187 VG_USERREQ__MEMPOOL_FREE = 0x1306,
njnd7994182003-10-02 13:44:04 +0000188
fitzhardinge39de4b42003-10-31 07:12:21 +0000189 /* Allow printfs to valgrind log. */
190 VG_USERREQ__PRINTF = 0x1401,
thughes85c8a502004-08-25 13:25:30 +0000191 VG_USERREQ__PRINTF_BACKTRACE = 0x1402
njn25e49d8e72002-09-23 09:36:25 +0000192 } Vg_ClientRequest;
sewardj2e93c502002-04-12 11:12:52 +0000193
muellerc9b36552003-12-31 14:32:23 +0000194#ifndef __GNUC__
195#define __extension__
196#endif
sewardj2e93c502002-04-12 11:12:52 +0000197
198/* Returns 1 if running on Valgrind, 0 if running on the real CPU.
199 Currently implemented but untested. */
muellerc9b36552003-12-31 14:32:23 +0000200#define RUNNING_ON_VALGRIND __extension__ \
sewardj2e93c502002-04-12 11:12:52 +0000201 ({unsigned int _qzz_res; \
202 VALGRIND_MAGIC_SEQUENCE(_qzz_res, 0 /* returned if not */, \
203 VG_USERREQ__RUNNING_ON_VALGRIND, \
204 0, 0, 0, 0); \
205 _qzz_res; \
sewardjde4a1d02002-03-22 01:27:54 +0000206 })
207
208
sewardj18d75132002-05-16 11:06:21 +0000209/* Discard translation of code in the range [_qzz_addr .. _qzz_addr +
210 _qzz_len - 1]. Useful if you are debugging a JITter or some such,
211 since it provides a way to make sure valgrind will retranslate the
212 invalidated area. Returns no value. */
213#define VALGRIND_DISCARD_TRANSLATIONS(_qzz_addr,_qzz_len) \
214 {unsigned int _qzz_res; \
215 VALGRIND_MAGIC_SEQUENCE(_qzz_res, 0, \
216 VG_USERREQ__DISCARD_TRANSLATIONS, \
217 _qzz_addr, _qzz_len, 0, 0); \
218 }
219
fitzhardinge39de4b42003-10-31 07:12:21 +0000220#ifndef NVALGRIND
221
fitzhardingea09a1b52003-11-07 23:09:48 +0000222int VALGRIND_PRINTF(const char *format, ...)
223 __attribute__((format(__printf__, 1, 2)));
fitzhardinge39de4b42003-10-31 07:12:21 +0000224__attribute__((weak))
225int
fitzhardingea09a1b52003-11-07 23:09:48 +0000226VALGRIND_PRINTF(const char *format, ...)
fitzhardinge39de4b42003-10-31 07:12:21 +0000227{
228 unsigned int _qzz_res;
229 va_list vargs;
230 va_start(vargs, format);
231 VALGRIND_MAGIC_SEQUENCE(_qzz_res, 0, VG_USERREQ__PRINTF,
232 (unsigned int)format, (unsigned int)vargs, 0, 0);
233 va_end(vargs);
234 return _qzz_res;
235}
236
fitzhardingea09a1b52003-11-07 23:09:48 +0000237int VALGRIND_PRINTF_BACKTRACE(const char *format, ...)
238 __attribute__((format(__printf__, 1, 2)));
fitzhardinge39de4b42003-10-31 07:12:21 +0000239__attribute__((weak))
240int
fitzhardingea09a1b52003-11-07 23:09:48 +0000241VALGRIND_PRINTF_BACKTRACE(const char *format, ...)
fitzhardinge39de4b42003-10-31 07:12:21 +0000242{
243 unsigned int _qzz_res;
244 va_list vargs;
245 va_start(vargs, format);
246 VALGRIND_MAGIC_SEQUENCE(_qzz_res, 0, VG_USERREQ__PRINTF_BACKTRACE,
247 (unsigned int)format, (unsigned int)vargs, 0, 0);
248 va_end(vargs);
249 return _qzz_res;
250}
251
252#else /* NVALGRIND */
253
254#define VALGRIND_PRINTF(...)
255#define VALGRIND_PRINTF_BACKTRACE(...)
256
257#endif /* NVALGRIND */
sewardj18d75132002-05-16 11:06:21 +0000258
njn3e884182003-04-15 13:03:23 +0000259/* These requests allow control to move from the simulated CPU to the
260 real CPU, calling an arbitary function */
njn057c65f2003-04-21 13:30:55 +0000261#define VALGRIND_NON_SIMD_CALL0(_qyy_fn) \
njn3e884182003-04-15 13:03:23 +0000262 ({unsigned int _qyy_res; \
263 VALGRIND_MAGIC_SEQUENCE(_qyy_res, 0 /* default return */, \
264 VG_USERREQ__CLIENT_CALL0, \
265 _qyy_fn, \
266 0, 0, 0); \
267 _qyy_res; \
268 })
269
njn057c65f2003-04-21 13:30:55 +0000270#define VALGRIND_NON_SIMD_CALL1(_qyy_fn, _qyy_arg1) \
njn3e884182003-04-15 13:03:23 +0000271 ({unsigned int _qyy_res; \
272 VALGRIND_MAGIC_SEQUENCE(_qyy_res, 0 /* default return */, \
273 VG_USERREQ__CLIENT_CALL1, \
274 _qyy_fn, \
275 _qyy_arg1, 0, 0); \
276 _qyy_res; \
277 })
278
njn057c65f2003-04-21 13:30:55 +0000279#define VALGRIND_NON_SIMD_CALL2(_qyy_fn, _qyy_arg1, _qyy_arg2) \
njn3e884182003-04-15 13:03:23 +0000280 ({unsigned int _qyy_res; \
281 VALGRIND_MAGIC_SEQUENCE(_qyy_res, 0 /* default return */, \
282 VG_USERREQ__CLIENT_CALL2, \
283 _qyy_fn, \
284 _qyy_arg1, _qyy_arg2, 0); \
285 _qyy_res; \
286 })
287
njn057c65f2003-04-21 13:30:55 +0000288#define VALGRIND_NON_SIMD_CALL3(_qyy_fn, _qyy_arg1, _qyy_arg2, _qyy_arg3) \
njn3e884182003-04-15 13:03:23 +0000289 ({unsigned int _qyy_res; \
290 VALGRIND_MAGIC_SEQUENCE(_qyy_res, 0 /* default return */, \
291 VG_USERREQ__CLIENT_CALL3, \
292 _qyy_fn, \
293 _qyy_arg1, _qyy_arg2, _qyy_arg3); \
294 _qyy_res; \
295 })
296
297
nethercote7cc9c232004-01-21 15:08:04 +0000298/* Counts the number of errors that have been recorded by a tool. Nb:
299 the tool must record the errors with VG_(maybe_record_error)() or
njn47363ab2003-04-21 13:24:40 +0000300 VG_(unique_error)() for them to be counted. */
301#define VALGRIND_COUNT_ERRORS \
302 ({unsigned int _qyy_res; \
303 VALGRIND_MAGIC_SEQUENCE(_qyy_res, 0 /* default return */, \
304 VG_USERREQ__COUNT_ERRORS, \
305 0, 0, 0, 0); \
306 _qyy_res; \
307 })
308
njnd7994182003-10-02 13:44:04 +0000309/* Mark a block of memory as having been allocated by a malloc()-like
310 function. `addr' is the start of the usable block (ie. after any
311 redzone) `rzB' is redzone size if the allocator can apply redzones;
312 use '0' if not. Adding redzones makes it more likely Valgrind will spot
313 block overruns. `is_zeroed' indicates if the memory is zeroed, as it is
314 for calloc(). Put it immediately after the point where a block is
315 allocated.
316
317 If you're allocating memory via superblocks, and then handing out small
318 chunks of each superblock, if you don't have redzones on your small
319 blocks, it's worth marking the superblock with VALGRIND_MAKE_NOACCESS
320 when it's created, so that block overruns are detected. But if you can
321 put redzones on, it's probably better to not do this, so that messages
322 for small overruns are described in terms of the small block rather than
323 the superblock (but if you have a big overrun that skips over a redzone,
324 you could miss an error this way). See memcheck/tests/custom_alloc.c
325 for an example.
326
327 Nb: block must be freed via a free()-like function specified
328 with VALGRIND_FREELIKE_BLOCK or mismatch errors will occur. */
329#define VALGRIND_MALLOCLIKE_BLOCK(addr, sizeB, rzB, is_zeroed) \
330 {unsigned int _qzz_res; \
331 VALGRIND_MAGIC_SEQUENCE(_qzz_res, 0, \
332 VG_USERREQ__MALLOCLIKE_BLOCK, \
333 addr, sizeB, rzB, is_zeroed); \
334 }
335
336/* Mark a block of memory as having been freed by a free()-like function.
337 `rzB' is redzone size; it must match that given to
338 VALGRIND_MALLOCLIKE_BLOCK. Memory not freed will be detected by the leak
339 checker. Put it immediately after the point where the block is freed. */
340#define VALGRIND_FREELIKE_BLOCK(addr, rzB) \
341 {unsigned int _qzz_res; \
342 VALGRIND_MAGIC_SEQUENCE(_qzz_res, 0, \
343 VG_USERREQ__FREELIKE_BLOCK, \
344 addr, rzB, 0, 0); \
345 }
346
rjwalshbc0bb832004-06-19 18:12:36 +0000347/* Create a memory pool. */
348#define VALGRIND_CREATE_MEMPOOL(pool, rzB, is_zeroed) \
349 {unsigned int _qzz_res; \
350 VALGRIND_MAGIC_SEQUENCE(_qzz_res, 0, \
351 VG_USERREQ__CREATE_MEMPOOL, \
352 pool, rzB, is_zeroed, 0); \
353 }
354
355/* Destroy a memory pool. */
356#define VALGRIND_DESTROY_MEMPOOL(pool) \
357 {unsigned int _qzz_res; \
358 VALGRIND_MAGIC_SEQUENCE(_qzz_res, 0, \
359 VG_USERREQ__DESTROY_MEMPOOL, \
360 pool, 0, 0, 0); \
361 }
362
363/* Associate a piece of memory with a memory pool. */
364#define VALGRIND_MEMPOOL_ALLOC(pool, addr, size) \
365 {unsigned int _qzz_res; \
366 VALGRIND_MAGIC_SEQUENCE(_qzz_res, 0, \
367 VG_USERREQ__MEMPOOL_ALLOC, \
368 pool, addr, size, 0); \
369 }
370
371/* Disassociate a piece of memory from a memory pool. */
372#define VALGRIND_MEMPOOL_FREE(pool, addr) \
373 {unsigned int _qzz_res; \
374 VALGRIND_MAGIC_SEQUENCE(_qzz_res, 0, \
375 VG_USERREQ__MEMPOOL_FREE, \
376 pool, addr, 0, 0); \
377 }
378
njn3e884182003-04-15 13:03:23 +0000379#endif /* __VALGRIND_H */