blob: 15399df3d1e482f83cf8f287b89f98faaf17e42f [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
njn0e1b5142003-04-15 14:58:06 +000015 Copyright (C) 2000-2003 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
sewardjde4a1d02002-03-22 01:27:54 +000064
65/* This file is for inclusion into client (your!) code.
66
njn25e49d8e72002-09-23 09:36:25 +000067 You can use these macros to manipulate and query Valgrind's
68 execution inside your own programs.
sewardjde4a1d02002-03-22 01:27:54 +000069
70 The resulting executables will still run without Valgrind, just a
71 little bit more slowly than they otherwise would, but otherwise
sewardj285f77f2003-03-15 23:39:11 +000072 unchanged. When not running on valgrind, each client request
73 consumes about 9 x86 instructions, so the resulting performance
74 loss is negligible unless you plan to execute client requests
75 millions of times per second. Nevertheless, if that is still a
76 problem, you can compile with the NVALGRIND symbol defined (gcc
77 -DNVALGRIND) so that client requests are not even compiled in. */
sewardjde4a1d02002-03-22 01:27:54 +000078
79
80
sewardj37091fb2002-11-16 11:06:50 +000081#ifndef NVALGRIND
sewardjde4a1d02002-03-22 01:27:54 +000082/* This defines the magic code sequence which the JITter spots and
83 handles magically. Don't look too closely at this; it will rot
sewardj2e93c502002-04-12 11:12:52 +000084 your brain. Valgrind dumps the result value in %EDX, so we first
85 copy the default value there, so that it is returned when not
86 running on Valgrind. Since %EAX points to a block of mem
87 containing the args, you can pass as many args as you want like
88 this. Currently this is set up to deal with 4 args since that's
89 the max that we appear to need (pthread_create).
sewardjde4a1d02002-03-22 01:27:54 +000090*/
sewardj2e93c502002-04-12 11:12:52 +000091#define VALGRIND_MAGIC_SEQUENCE( \
92 _zzq_rlval, /* result lvalue */ \
93 _zzq_default, /* result returned when running on real CPU */ \
94 _zzq_request, /* request code */ \
95 _zzq_arg1, /* request first param */ \
96 _zzq_arg2, /* request second param */ \
97 _zzq_arg3, /* request third param */ \
98 _zzq_arg4 /* request fourth param */ ) \
99 \
100 { volatile unsigned int _zzq_args[5]; \
sewardj18d75132002-05-16 11:06:21 +0000101 _zzq_args[0] = (volatile unsigned int)(_zzq_request); \
102 _zzq_args[1] = (volatile unsigned int)(_zzq_arg1); \
103 _zzq_args[2] = (volatile unsigned int)(_zzq_arg2); \
104 _zzq_args[3] = (volatile unsigned int)(_zzq_arg3); \
105 _zzq_args[4] = (volatile unsigned int)(_zzq_arg4); \
sewardj2e93c502002-04-12 11:12:52 +0000106 asm volatile("movl %1, %%eax\n\t" \
107 "movl %2, %%edx\n\t" \
108 "roll $29, %%eax ; roll $3, %%eax\n\t" \
109 "rorl $27, %%eax ; rorl $5, %%eax\n\t" \
110 "roll $13, %%eax ; roll $19, %%eax\n\t" \
111 "movl %%edx, %0\t" \
112 : "=r" (_zzq_rlval) \
113 : "r" (&_zzq_args[0]), "r" (_zzq_default) \
114 : "eax", "edx", "cc", "memory" \
115 ); \
116 }
sewardj37091fb2002-11-16 11:06:50 +0000117#else /* NVALGRIND */
118/* Define NVALGRIND to completely remove the Valgrind magic sequence
119 from the compiled code (analogous to NDEBUG's effects on
120 assert()) */
121#define VALGRIND_MAGIC_SEQUENCE( \
122 _zzq_rlval, /* result lvalue */ \
123 _zzq_default, /* result returned when running on real CPU */ \
124 _zzq_request, /* request code */ \
125 _zzq_arg1, /* request first param */ \
126 _zzq_arg2, /* request second param */ \
127 _zzq_arg3, /* request third param */ \
128 _zzq_arg4 /* request fourth param */ ) \
129 { \
130 (_zzq_rlval) = (_zzq_default); \
131 }
132#endif /* NVALGRIND */
sewardj2e93c502002-04-12 11:12:52 +0000133
134/* Some request codes. There are many more of these, but most are not
135 exposed to end-user view. These are the public ones, all of the
njn25e49d8e72002-09-23 09:36:25 +0000136 form 0x1000 + small_number.
njnd7994182003-10-02 13:44:04 +0000137
138 Core ones are in the range 0x00000000--0x0000ffff. The non-public ones
139 start at 0x2000.
sewardj2e93c502002-04-12 11:12:52 +0000140*/
141
njn4c791212003-05-02 17:53:54 +0000142#define VG_USERREQ_SKIN_BASE(a,b) \
143 ((unsigned int)(((a)&0xff) << 24 | ((b)&0xff) << 16))
144#define VG_IS_SKIN_USERREQ(a, b, v) \
145 (VG_USERREQ_SKIN_BASE(a,b) == ((v) & 0xffff0000))
sewardj34042512002-10-22 04:14:35 +0000146
njn25e49d8e72002-09-23 09:36:25 +0000147typedef
njn4c791212003-05-02 17:53:54 +0000148 enum { VG_USERREQ__RUNNING_ON_VALGRIND = 0x1001,
149 VG_USERREQ__DISCARD_TRANSLATIONS = 0x1002,
njn3e884182003-04-15 13:03:23 +0000150
151 /* These allow any function of 0--3 args to be called from the
152 simulated CPU but run on the real CPU */
njn4c791212003-05-02 17:53:54 +0000153 VG_USERREQ__CLIENT_CALL0 = 0x1101,
154 VG_USERREQ__CLIENT_CALL1 = 0x1102,
155 VG_USERREQ__CLIENT_CALL2 = 0x1103,
156 VG_USERREQ__CLIENT_CALL3 = 0x1104,
njn3e884182003-04-15 13:03:23 +0000157
njn47363ab2003-04-21 13:24:40 +0000158 /* Can be useful in regression testing suites -- eg. can send
159 Valgrind's output to /dev/null and still count errors. */
njn4c791212003-05-02 17:53:54 +0000160 VG_USERREQ__COUNT_ERRORS = 0x1201,
njn47363ab2003-04-21 13:24:40 +0000161
njnd7994182003-10-02 13:44:04 +0000162 /* These are useful and can be interpreted by any skin that tracks
163 malloc() et al, by using vg_replace_malloc.c. */
164 VG_USERREQ__MALLOCLIKE_BLOCK = 0x1301,
165 VG_USERREQ__FREELIKE_BLOCK = 0x1302,
166
fitzhardinge39de4b42003-10-31 07:12:21 +0000167 /* Allow printfs to valgrind log. */
168 VG_USERREQ__PRINTF = 0x1401,
169 VG_USERREQ__PRINTF_BACKTRACE = 0x1402,
njn25e49d8e72002-09-23 09:36:25 +0000170 } Vg_ClientRequest;
sewardj2e93c502002-04-12 11:12:52 +0000171
172
173/* Returns 1 if running on Valgrind, 0 if running on the real CPU.
174 Currently implemented but untested. */
175#define RUNNING_ON_VALGRIND \
176 ({unsigned int _qzz_res; \
177 VALGRIND_MAGIC_SEQUENCE(_qzz_res, 0 /* returned if not */, \
178 VG_USERREQ__RUNNING_ON_VALGRIND, \
179 0, 0, 0, 0); \
180 _qzz_res; \
sewardjde4a1d02002-03-22 01:27:54 +0000181 })
182
183
sewardj18d75132002-05-16 11:06:21 +0000184/* Discard translation of code in the range [_qzz_addr .. _qzz_addr +
185 _qzz_len - 1]. Useful if you are debugging a JITter or some such,
186 since it provides a way to make sure valgrind will retranslate the
187 invalidated area. Returns no value. */
188#define VALGRIND_DISCARD_TRANSLATIONS(_qzz_addr,_qzz_len) \
189 {unsigned int _qzz_res; \
190 VALGRIND_MAGIC_SEQUENCE(_qzz_res, 0, \
191 VG_USERREQ__DISCARD_TRANSLATIONS, \
192 _qzz_addr, _qzz_len, 0, 0); \
193 }
194
fitzhardinge39de4b42003-10-31 07:12:21 +0000195#ifndef NVALGRIND
196
fitzhardingea09a1b52003-11-07 23:09:48 +0000197int VALGRIND_PRINTF(const char *format, ...)
198 __attribute__((format(__printf__, 1, 2)));
fitzhardinge39de4b42003-10-31 07:12:21 +0000199__attribute__((weak))
200int
fitzhardingea09a1b52003-11-07 23:09:48 +0000201VALGRIND_PRINTF(const char *format, ...)
fitzhardinge39de4b42003-10-31 07:12:21 +0000202{
203 unsigned int _qzz_res;
204 va_list vargs;
205 va_start(vargs, format);
206 VALGRIND_MAGIC_SEQUENCE(_qzz_res, 0, VG_USERREQ__PRINTF,
207 (unsigned int)format, (unsigned int)vargs, 0, 0);
208 va_end(vargs);
209 return _qzz_res;
210}
211
fitzhardingea09a1b52003-11-07 23:09:48 +0000212int VALGRIND_PRINTF_BACKTRACE(const char *format, ...)
213 __attribute__((format(__printf__, 1, 2)));
fitzhardinge39de4b42003-10-31 07:12:21 +0000214__attribute__((weak))
215int
fitzhardingea09a1b52003-11-07 23:09:48 +0000216VALGRIND_PRINTF_BACKTRACE(const char *format, ...)
fitzhardinge39de4b42003-10-31 07:12:21 +0000217{
218 unsigned int _qzz_res;
219 va_list vargs;
220 va_start(vargs, format);
221 VALGRIND_MAGIC_SEQUENCE(_qzz_res, 0, VG_USERREQ__PRINTF_BACKTRACE,
222 (unsigned int)format, (unsigned int)vargs, 0, 0);
223 va_end(vargs);
224 return _qzz_res;
225}
226
227#else /* NVALGRIND */
228
229#define VALGRIND_PRINTF(...)
230#define VALGRIND_PRINTF_BACKTRACE(...)
231
232#endif /* NVALGRIND */
sewardj18d75132002-05-16 11:06:21 +0000233
njn3e884182003-04-15 13:03:23 +0000234/* These requests allow control to move from the simulated CPU to the
235 real CPU, calling an arbitary function */
njn057c65f2003-04-21 13:30:55 +0000236#define VALGRIND_NON_SIMD_CALL0(_qyy_fn) \
njn3e884182003-04-15 13:03:23 +0000237 ({unsigned int _qyy_res; \
238 VALGRIND_MAGIC_SEQUENCE(_qyy_res, 0 /* default return */, \
239 VG_USERREQ__CLIENT_CALL0, \
240 _qyy_fn, \
241 0, 0, 0); \
242 _qyy_res; \
243 })
244
njn057c65f2003-04-21 13:30:55 +0000245#define VALGRIND_NON_SIMD_CALL1(_qyy_fn, _qyy_arg1) \
njn3e884182003-04-15 13:03:23 +0000246 ({unsigned int _qyy_res; \
247 VALGRIND_MAGIC_SEQUENCE(_qyy_res, 0 /* default return */, \
248 VG_USERREQ__CLIENT_CALL1, \
249 _qyy_fn, \
250 _qyy_arg1, 0, 0); \
251 _qyy_res; \
252 })
253
njn057c65f2003-04-21 13:30:55 +0000254#define VALGRIND_NON_SIMD_CALL2(_qyy_fn, _qyy_arg1, _qyy_arg2) \
njn3e884182003-04-15 13:03:23 +0000255 ({unsigned int _qyy_res; \
256 VALGRIND_MAGIC_SEQUENCE(_qyy_res, 0 /* default return */, \
257 VG_USERREQ__CLIENT_CALL2, \
258 _qyy_fn, \
259 _qyy_arg1, _qyy_arg2, 0); \
260 _qyy_res; \
261 })
262
njn057c65f2003-04-21 13:30:55 +0000263#define VALGRIND_NON_SIMD_CALL3(_qyy_fn, _qyy_arg1, _qyy_arg2, _qyy_arg3) \
njn3e884182003-04-15 13:03:23 +0000264 ({unsigned int _qyy_res; \
265 VALGRIND_MAGIC_SEQUENCE(_qyy_res, 0 /* default return */, \
266 VG_USERREQ__CLIENT_CALL3, \
267 _qyy_fn, \
268 _qyy_arg1, _qyy_arg2, _qyy_arg3); \
269 _qyy_res; \
270 })
271
272
njn47363ab2003-04-21 13:24:40 +0000273/* Counts the number of errors that have been recorded by a skin. Nb:
274 the skin must record the errors with VG_(maybe_record_error)() or
275 VG_(unique_error)() for them to be counted. */
276#define VALGRIND_COUNT_ERRORS \
277 ({unsigned int _qyy_res; \
278 VALGRIND_MAGIC_SEQUENCE(_qyy_res, 0 /* default return */, \
279 VG_USERREQ__COUNT_ERRORS, \
280 0, 0, 0, 0); \
281 _qyy_res; \
282 })
283
njnd7994182003-10-02 13:44:04 +0000284/* Mark a block of memory as having been allocated by a malloc()-like
285 function. `addr' is the start of the usable block (ie. after any
286 redzone) `rzB' is redzone size if the allocator can apply redzones;
287 use '0' if not. Adding redzones makes it more likely Valgrind will spot
288 block overruns. `is_zeroed' indicates if the memory is zeroed, as it is
289 for calloc(). Put it immediately after the point where a block is
290 allocated.
291
292 If you're allocating memory via superblocks, and then handing out small
293 chunks of each superblock, if you don't have redzones on your small
294 blocks, it's worth marking the superblock with VALGRIND_MAKE_NOACCESS
295 when it's created, so that block overruns are detected. But if you can
296 put redzones on, it's probably better to not do this, so that messages
297 for small overruns are described in terms of the small block rather than
298 the superblock (but if you have a big overrun that skips over a redzone,
299 you could miss an error this way). See memcheck/tests/custom_alloc.c
300 for an example.
301
302 Nb: block must be freed via a free()-like function specified
303 with VALGRIND_FREELIKE_BLOCK or mismatch errors will occur. */
304#define VALGRIND_MALLOCLIKE_BLOCK(addr, sizeB, rzB, is_zeroed) \
305 {unsigned int _qzz_res; \
306 VALGRIND_MAGIC_SEQUENCE(_qzz_res, 0, \
307 VG_USERREQ__MALLOCLIKE_BLOCK, \
308 addr, sizeB, rzB, is_zeroed); \
309 }
310
311/* Mark a block of memory as having been freed by a free()-like function.
312 `rzB' is redzone size; it must match that given to
313 VALGRIND_MALLOCLIKE_BLOCK. Memory not freed will be detected by the leak
314 checker. Put it immediately after the point where the block is freed. */
315#define VALGRIND_FREELIKE_BLOCK(addr, rzB) \
316 {unsigned int _qzz_res; \
317 VALGRIND_MAGIC_SEQUENCE(_qzz_res, 0, \
318 VG_USERREQ__FREELIKE_BLOCK, \
319 addr, rzB, 0, 0); \
320 }
321
njn3e884182003-04-15 13:03:23 +0000322#endif /* __VALGRIND_H */