Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / external / valgrind / ead61df62ca9c9194f62d4c4a8ba288782acbb0e / . / include / valgrind.h
blob: 812446c379c118142afec9d4b72de593e323db1a [file] [log] [blame]
sewardjb5f6f512005-03-10 23:59:00 +0000[diff] [blame]1/* -*- c -*-
njn25e49d8e72002-09-23 09:36:25 +0000[diff] [blame]2 ----------------------------------------------------------------
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 +0000[diff] [blame]11 This file is part of Valgrind, a dynamic binary instrumentation
12 framework.
sewardjde4a1d02002-03-22 01:27:54 +0000[diff] [blame]13
njn53612422005-03-12 16:22:54 +0000[diff] [blame]14 Copyright (C) 2000-2005 Julian Seward. All rights reserved.
sewardjde4a1d02002-03-22 01:27:54 +0000[diff] [blame]15
njn25e49d8e72002-09-23 09:36:25 +0000[diff] [blame]16 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 +0000[diff] [blame]19
njn25e49d8e72002-09-23 09:36:25 +0000[diff] [blame]20 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 +0000[diff] [blame]22
njn25e49d8e72002-09-23 09:36:25 +0000[diff] [blame]23 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 +0000[diff] [blame]27
njn25e49d8e72002-09-23 09:36:25 +0000[diff] [blame]28 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 +0000[diff] [blame]55*/
56
57
njn30d76c62005-06-18 15:07:39 +0000[diff] [blame]58/* This file is for inclusion into client (your!) code.
59
60 You can use these macros to manipulate and query Valgrind's
61 execution inside your own programs.
62
63 The resulting executables will still run without Valgrind, just a
64 little bit more slowly than they otherwise would, but otherwise
65 unchanged. When not running on valgrind, each client request
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]66 consumes very few (eg. 7) instructions, so the resulting performance
njn30d76c62005-06-18 15:07:39 +0000[diff] [blame]67 loss is negligible unless you plan to execute client requests
68 millions of times per second. Nevertheless, if that is still a
69 problem, you can compile with the NVALGRIND symbol defined (gcc
70 -DNVALGRIND) so that client requests are not even compiled in. */
71
sewardjde4a1d02002-03-22 01:27:54 +0000[diff] [blame]72#ifndef __VALGRIND_H
73#define __VALGRIND_H
74
fitzhardinge39de4b42003-10-31 07:12:21 +0000[diff] [blame]75#include <stdarg.h>
76
njn3dd0a912005-06-28 19:44:10 +0000[diff] [blame]77/* Nb: this file might be included in a file compiled with -ansi. So
78 we can't use C++ style "//" comments nor the "asm" keyword (instead
79 use "__asm__"). */
80
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]81/* Derive some tags indicating what the target architecture is. Note
82 that in this file we're using the compiler's CPP symbols for
83 identifying architectures, which are different to the ones we use
84 within the rest of Valgrind. Note, __powerpc__ is active for both
85 32 and 64-bit PPC, whereas __powerpc64__ is only active for the
86 latter. */
87#undef ARCH_x86
88#undef ARCH_amd64
89#undef ARCH_ppc32
90#undef ARCH_ppc64
91
92#if defined(__i386__)
93# define ARCH_x86 1
94#elif defined(__x86_64__)
95# define ARCH_amd64 1
96#elif defined(__powerpc__) && !defined(__powerpc64__)
97# define ARCH_ppc32 1
98#elif defined(__powerpc__) && defined(__powerpc64__)
99# define ARCH_ppc64 1
sewardjb5f6f512005-03-10 23:59:00 +0000[diff] [blame]100#endif
101
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]102/* If we're not compiling for our target architecture, don't generate
103 any inline asms. */
104#if !defined(ARCH_x86) && !defined(ARCH_amd64) \
105 && !defined(ARCH_ppc32) && !defined(ARCH_ppc64)
106# if !defined(NVALGRIND)
107# define NVALGRIND 1
108# endif
109#endif
110
111
njn30d76c62005-06-18 15:07:39 +0000[diff] [blame]112/* ------------------------------------------------------------------ */
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]113/* ARCHITECTURE SPECIFICS for SPECIAL INSTRUCTIONS. There is nothing */
114/* in here of use to end-users -- skip to the next section. */
njn30d76c62005-06-18 15:07:39 +0000[diff] [blame]115/* ------------------------------------------------------------------ */
sewardjde4a1d02002-03-22 01:27:54 +0000[diff] [blame]116
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]117#if defined(NVALGRIND)
njn26aba4d2005-05-16 13:31:23 +0000[diff] [blame]118
119/* Define NVALGRIND to completely remove the Valgrind magic sequence
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]120 from the compiled code (analogous to NDEBUG's effects on
121 assert()) */
122#define VALGRIND_DO_CLIENT_REQUEST( \
123 _zzq_rlval, _zzq_default, _zzq_request, \
sewardj9af10a12006-02-01 14:59:42 +0000[diff] [blame]124 _zzq_arg1, _zzq_arg2, _zzq_arg3, _zzq_arg4, _zzq_arg5) \
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]125 { \
126 (_zzq_rlval) = (_zzq_default); \
njn26aba4d2005-05-16 13:31:23 +0000[diff] [blame]127 }
128
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]129#else /* ! NVALGRIND */
nethercotee90c6832004-10-18 18:07:49 +0000[diff] [blame]130
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]131/* The following defines the magic code sequences which the JITter
132 spots and handles magically. Don't look too closely at them as
133 they will rot your brain.
134
135 The assembly code sequences for all architectures is in this one
136 file. This is because this file must be stand-alone, and we don't
137 want to have multiple files.
138
139 For VALGRIND_DO_CLIENT_REQUEST, we must ensure that the default
140 value gets put in the return slot, so that everything works when
141 this is executed not under Valgrind. Args are passed in a memory
142 block, and so there's no intrinsic limit to the number that could
sewardj9af10a12006-02-01 14:59:42 +0000[diff] [blame]143 be passed, but it's currently five.
nethercotee90c6832004-10-18 18:07:49 +0000[diff] [blame]144
nethercote54265442004-10-26 12:56:58 +0000[diff] [blame]145 The macro args are:
146 _zzq_rlval result lvalue
147 _zzq_default default value (result returned when running on real CPU)
148 _zzq_request request code
sewardj9af10a12006-02-01 14:59:42 +0000[diff] [blame]149 _zzq_arg1..5 request params
nethercote54265442004-10-26 12:56:58 +0000[diff] [blame]150
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]151 The other two macros are used to support function wrapping, and are
sewardjd68ac3e2006-01-20 14:31:57 +0000[diff] [blame]152 a lot simpler. VALGRIND_GET_NR_CONTEXT returns the value of the
153 guest's NRADDR pseudo-register and whatever other information is
154 needed to safely run the call original from the wrapper: on
155 ppc64-linux, the R2 value at the divert point is also needed. This
156 information is abstracted into a user-visible type, OrigFn.
157
158 VALGRIND_CALL_NOREDIR_* behaves the same as the following on the
159 guest, but guarantees that the branch instruction will not be
160 redirected: x86: call *%eax, amd64: call *%rax, ppc32/ppc64:
161 branch-and-link-to-r11. VALGRIND_CALL_NOREDIR is just text, not a
162 complete inline asm, since it needs to be combined with more magic
163 inline asm stuff to be useful.
nethercotee90c6832004-10-18 18:07:49 +0000[diff] [blame]164*/
165
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]166/* ---------------------------- x86 ---------------------------- */
sewardjde4a4ab2005-03-23 13:10:32 +0000[diff] [blame]167
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]168#if defined(ARCH_x86)
sewardjc8858442006-01-20 15:17:20 +0000[diff] [blame]169
170typedef
171 struct {
172 unsigned int nraddr; /* where's the code? */
173 }
174 OrigFn;
175
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]176#define __SPECIAL_INSTRUCTION_PREAMBLE \
177 "roll $3, %%edi ; roll $13, %%edi\n\t" \
sewardj1a85f4f2006-01-12 21:15:35 +0000[diff] [blame]178 "roll $29, %%edi ; roll $19, %%edi\n\t"
sewardjde4a4ab2005-03-23 13:10:32 +0000[diff] [blame]179
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]180#define VALGRIND_DO_CLIENT_REQUEST( \
181 _zzq_rlval, _zzq_default, _zzq_request, \
sewardj9af10a12006-02-01 14:59:42 +0000[diff] [blame]182 _zzq_arg1, _zzq_arg2, _zzq_arg3, _zzq_arg4, _zzq_arg5) \
183 { volatile unsigned int _zzq_args[6]; \
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]184 volatile unsigned int _zzq_result; \
185 _zzq_args[0] = (unsigned int)(_zzq_request); \
186 _zzq_args[1] = (unsigned int)(_zzq_arg1); \
187 _zzq_args[2] = (unsigned int)(_zzq_arg2); \
188 _zzq_args[3] = (unsigned int)(_zzq_arg3); \
189 _zzq_args[4] = (unsigned int)(_zzq_arg4); \
sewardj9af10a12006-02-01 14:59:42 +0000[diff] [blame]190 _zzq_args[5] = (unsigned int)(_zzq_arg5); \
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]191 __asm__ volatile(__SPECIAL_INSTRUCTION_PREAMBLE \
192 /* %EDX = client_request ( %EAX ) */ \
193 "xchgl %%ebx,%%ebx" \
194 : "=d" (_zzq_result) \
195 : "a" (&_zzq_args[0]), "0" (_zzq_default) \
196 : "cc", "memory" \
197 ); \
198 _zzq_rlval = _zzq_result; \
cerion85665ca2005-06-20 15:51:07 +0000[diff] [blame]199 }
sewardj2c48c7b2005-11-29 13:05:56 +0000[diff] [blame]200
sewardjc8858442006-01-20 15:17:20 +0000[diff] [blame]201#define VALGRIND_GET_NR_CONTEXT(_zzq_rlval) \
202 { volatile OrigFn* _zzq_orig = &(_zzq_rlval); \
203 volatile unsigned int __addr; \
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]204 __asm__ volatile(__SPECIAL_INSTRUCTION_PREAMBLE \
205 /* %EAX = guest_NRADDR */ \
206 "xchgl %%ecx,%%ecx" \
207 : "=a" (__addr) \
208 : \
209 : "cc", "memory" \
210 ); \
sewardjc8858442006-01-20 15:17:20 +0000[diff] [blame]211 _zzq_orig->nraddr = __addr; \
sewardj2c48c7b2005-11-29 13:05:56 +0000[diff] [blame]212 }
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]213
214#define VALGRIND_CALL_NOREDIR_EAX \
215 __SPECIAL_INSTRUCTION_PREAMBLE \
216 /* call-noredir *%EAX */ \
217 "xchgl %%edx,%%edx\n\t"
218#endif /* ARCH_x86 */
219
220/* --------------------------- amd64 --------------------------- */
221
222#if defined(ARCH_amd64)
sewardjc8858442006-01-20 15:17:20 +0000[diff] [blame]223
224typedef
225 struct {
226 unsigned long long int nraddr; /* where's the code? */
227 }
228 OrigFn;
229
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]230#define __SPECIAL_INSTRUCTION_PREAMBLE \
231 "rolq $3, %%rdi ; rolq $13, %%rdi\n\t" \
sewardj1a85f4f2006-01-12 21:15:35 +0000[diff] [blame]232 "rolq $61, %%rdi ; rolq $51, %%rdi\n\t"
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]233
234#define VALGRIND_DO_CLIENT_REQUEST( \
235 _zzq_rlval, _zzq_default, _zzq_request, \
sewardj9af10a12006-02-01 14:59:42 +0000[diff] [blame]236 _zzq_arg1, _zzq_arg2, _zzq_arg3, _zzq_arg4, _zzq_arg5) \
237 { volatile unsigned long long int _zzq_args[6]; \
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]238 volatile unsigned long long int _zzq_result; \
239 _zzq_args[0] = (unsigned long long int)(_zzq_request); \
240 _zzq_args[1] = (unsigned long long int)(_zzq_arg1); \
241 _zzq_args[2] = (unsigned long long int)(_zzq_arg2); \
242 _zzq_args[3] = (unsigned long long int)(_zzq_arg3); \
243 _zzq_args[4] = (unsigned long long int)(_zzq_arg4); \
sewardj9af10a12006-02-01 14:59:42 +0000[diff] [blame]244 _zzq_args[5] = (unsigned long long int)(_zzq_arg5); \
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]245 __asm__ volatile(__SPECIAL_INSTRUCTION_PREAMBLE \
246 /* %RDX = client_request ( %RAX ) */ \
247 "xchgq %%rbx,%%rbx" \
248 : "=d" (_zzq_result) \
249 : "a" (&_zzq_args[0]), "0" (_zzq_default) \
250 : "cc", "memory" \
251 ); \
252 _zzq_rlval = _zzq_result; \
253 }
254
sewardjc8858442006-01-20 15:17:20 +0000[diff] [blame]255#define VALGRIND_GET_NR_CONTEXT(_zzq_rlval) \
256 { volatile OrigFn* _zzq_orig = &(_zzq_rlval); \
257 volatile unsigned long long int __addr; \
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]258 __asm__ volatile(__SPECIAL_INSTRUCTION_PREAMBLE \
259 /* %RAX = guest_NRADDR */ \
260 "xchgq %%rcx,%%rcx" \
261 : "=a" (__addr) \
262 : \
263 : "cc", "memory" \
264 ); \
sewardjc8858442006-01-20 15:17:20 +0000[diff] [blame]265 _zzq_orig->nraddr = __addr; \
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]266 }
267
268#define VALGRIND_CALL_NOREDIR_RAX \
269 __SPECIAL_INSTRUCTION_PREAMBLE \
270 /* call-noredir *%RAX */ \
271 "xchgq %%rdx,%%rdx\n\t"
272#endif /* ARCH_amd64 */
273
274/* --------------------------- ppc32 --------------------------- */
275
276#if defined(ARCH_ppc32)
sewardjd68ac3e2006-01-20 14:31:57 +0000[diff] [blame]277
278typedef
279 struct {
sewardjc8858442006-01-20 15:17:20 +0000[diff] [blame]280 unsigned int nraddr; /* where's the code? */
sewardjd68ac3e2006-01-20 14:31:57 +0000[diff] [blame]281 }
282 OrigFn;
283
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]284#define __SPECIAL_INSTRUCTION_PREAMBLE \
285 "rlwinm 0,0,3,0,0 ; rlwinm 0,0,13,0,0\n\t" \
sewardj1a85f4f2006-01-12 21:15:35 +0000[diff] [blame]286 "rlwinm 0,0,29,0,0 ; rlwinm 0,0,19,0,0\n\t"
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]287
288#define VALGRIND_DO_CLIENT_REQUEST( \
289 _zzq_rlval, _zzq_default, _zzq_request, \
sewardj9af10a12006-02-01 14:59:42 +0000[diff] [blame]290 _zzq_arg1, _zzq_arg2, _zzq_arg3, _zzq_arg4, _zzq_arg5) \
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]291 \
sewardj9af10a12006-02-01 14:59:42 +0000[diff] [blame]292 { unsigned int _zzq_args[6]; \
sewardj1a85f4f2006-01-12 21:15:35 +0000[diff] [blame]293 register unsigned int _zzq_result __asm__("r3"); \
294 register unsigned int* _zzq_ptr __asm__("r4"); \
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]295 _zzq_args[0] = (unsigned int)(_zzq_request); \
296 _zzq_args[1] = (unsigned int)(_zzq_arg1); \
297 _zzq_args[2] = (unsigned int)(_zzq_arg2); \
298 _zzq_args[3] = (unsigned int)(_zzq_arg3); \
299 _zzq_args[4] = (unsigned int)(_zzq_arg4); \
sewardj9af10a12006-02-01 14:59:42 +0000[diff] [blame]300 _zzq_args[5] = (unsigned int)(_zzq_arg5); \
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]301 _zzq_ptr = _zzq_args; \
302 __asm__ volatile(__SPECIAL_INSTRUCTION_PREAMBLE \
303 /* %R3 = client_request ( %R4 ) */ \
304 "or 1,1,1" \
305 : "=r" (_zzq_result) \
306 : "0" (_zzq_default), "r" (_zzq_ptr) \
307 : "cc", "memory"); \
308 _zzq_rlval = _zzq_result; \
309 }
310
sewardjd68ac3e2006-01-20 14:31:57 +0000[diff] [blame]311#define VALGRIND_GET_NR_CONTEXT(_zzq_rlval) \
312 { volatile OrigFn* _zzq_orig = &(_zzq_rlval); \
313 register unsigned int __addr __asm__("r3"); \
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]314 __asm__ volatile(__SPECIAL_INSTRUCTION_PREAMBLE \
315 /* %R3 = guest_NRADDR */ \
316 "or 2,2,2" \
317 : "=r" (__addr) \
318 : \
319 : "cc", "memory" \
320 ); \
sewardjd68ac3e2006-01-20 14:31:57 +0000[diff] [blame]321 _zzq_orig->nraddr = __addr; \
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]322 }
323
324#define VALGRIND_BRANCH_AND_LINK_TO_NOREDIR_R11 \
325 __SPECIAL_INSTRUCTION_PREAMBLE \
326 /* branch-and-link-to-noredir *%R11 */ \
327 "or 3,3,3\n\t"
328#endif /* ARCH_ppc32 */
329
330/* --------------------------- ppc64 --------------------------- */
331
332#if defined(ARCH_ppc64)
sewardjd68ac3e2006-01-20 14:31:57 +0000[diff] [blame]333
334typedef
335 struct {
336 unsigned long long int nraddr; /* where's the code? */
337 unsigned long long int r2; /* what tocptr do we need? */
338 }
339 OrigFn;
340
sewardj1a85f4f2006-01-12 21:15:35 +0000[diff] [blame]341#define __SPECIAL_INSTRUCTION_PREAMBLE \
342 "rotldi 0,0,3 ; rotldi 0,0,13\n\t" \
343 "rotldi 0,0,61 ; rotldi 0,0,51\n\t"
344
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]345#define VALGRIND_DO_CLIENT_REQUEST( \
346 _zzq_rlval, _zzq_default, _zzq_request, \
sewardj9af10a12006-02-01 14:59:42 +0000[diff] [blame]347 _zzq_arg1, _zzq_arg2, _zzq_arg3, _zzq_arg4, _zzq_arg5) \
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]348 \
sewardj9af10a12006-02-01 14:59:42 +0000[diff] [blame]349 { unsigned long long int _zzq_args[6]; \
sewardj1a85f4f2006-01-12 21:15:35 +0000[diff] [blame]350 register unsigned long long int _zzq_result __asm__("r3"); \
351 register unsigned long long int* _zzq_ptr __asm__("r4"); \
352 _zzq_args[0] = (unsigned long long int)(_zzq_request); \
353 _zzq_args[1] = (unsigned long long int)(_zzq_arg1); \
354 _zzq_args[2] = (unsigned long long int)(_zzq_arg2); \
355 _zzq_args[3] = (unsigned long long int)(_zzq_arg3); \
356 _zzq_args[4] = (unsigned long long int)(_zzq_arg4); \
sewardj9af10a12006-02-01 14:59:42 +0000[diff] [blame]357 _zzq_args[5] = (unsigned long long int)(_zzq_arg5); \
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]358 _zzq_ptr = _zzq_args; \
sewardj1a85f4f2006-01-12 21:15:35 +0000[diff] [blame]359 __asm__ volatile(__SPECIAL_INSTRUCTION_PREAMBLE \
360 /* %R3 = client_request ( %R4 ) */ \
361 "or 1,1,1" \
362 : "=r" (_zzq_result) \
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]363 : "0" (_zzq_default), "r" (_zzq_ptr) \
sewardj1a85f4f2006-01-12 21:15:35 +0000[diff] [blame]364 : "cc", "memory"); \
365 _zzq_rlval = _zzq_result; \
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]366 }
sewardj1a85f4f2006-01-12 21:15:35 +0000[diff] [blame]367
sewardjd68ac3e2006-01-20 14:31:57 +0000[diff] [blame]368#define VALGRIND_GET_NR_CONTEXT(_zzq_rlval) \
369 { volatile OrigFn* _zzq_orig = &(_zzq_rlval); \
370 register unsigned long long int __addr __asm__("r3"); \
sewardj1a85f4f2006-01-12 21:15:35 +0000[diff] [blame]371 __asm__ volatile(__SPECIAL_INSTRUCTION_PREAMBLE \
372 /* %R3 = guest_NRADDR */ \
373 "or 2,2,2" \
374 : "=r" (__addr) \
375 : \
376 : "cc", "memory" \
377 ); \
sewardjd68ac3e2006-01-20 14:31:57 +0000[diff] [blame]378 _zzq_orig->nraddr = __addr; \
379 __asm__ volatile(__SPECIAL_INSTRUCTION_PREAMBLE \
380 /* %R3 = guest_NRADDR_GPR2 */ \
381 "or 4,4,4" \
382 : "=r" (__addr) \
383 : \
384 : "cc", "memory" \
385 ); \
386 _zzq_orig->r2 = __addr; \
sewardj1a85f4f2006-01-12 21:15:35 +0000[diff] [blame]387 }
388
389#define VALGRIND_BRANCH_AND_LINK_TO_NOREDIR_R11 \
390 __SPECIAL_INSTRUCTION_PREAMBLE \
391 /* branch-and-link-to-noredir *%R11 */ \
392 "or 3,3,3\n\t"
393
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]394#endif /* ARCH_ppc64 */
cerion85665ca2005-06-20 15:51:07 +0000[diff] [blame]395
njn3dd0a912005-06-28 19:44:10 +0000[diff] [blame]396/* Insert assembly code for other architectures here... */
njn26aba4d2005-05-16 13:31:23 +0000[diff] [blame]397
sewardj37091fb2002-11-16 11:06:50 +0000[diff] [blame]398#endif /* NVALGRIND */
sewardj2e93c502002-04-12 11:12:52 +0000[diff] [blame]399
nethercote69d9c462004-10-26 13:00:12 +0000[diff] [blame]400
njn30d76c62005-06-18 15:07:39 +0000[diff] [blame]401/* ------------------------------------------------------------------ */
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]402/* ARCHITECTURE SPECIFICS for FUNCTION WRAPPING. This is all very */
403/* ugly. It's the least-worst tradeoff I can think of. */
404/* ------------------------------------------------------------------ */
405
406/* This section defines magic (a.k.a appalling-hack) macros for doing
407 guaranteed-no-redirection macros, so as to get from function
408 wrappers to the functions they are wrapping. The whole point is to
409 construct standard call sequences, but to do the call itself with a
410 special no-redirect call pseudo-instruction that the JIT
411 understands and handles specially. This section is long and
412 repetitious, and I can't see a way to make it shorter.
413
414 The naming scheme is as follows:
415
416 CALL_FN_{W,v}_{v,W,WW,WWW,WWWW,5W,6W,7W,etc}
417
418 'W' stands for "word" and 'v' for "void". Hence there are
419 different macros for calling arity 0, 1, 2, 3, 4, etc, functions,
420 and for each, the possibility of returning a word-typed result, or
421 no result.
422*/
423
424/* Use these to write the name of your wrapper. NOTE: duplicates
425 VG_WRAP_FUNCTION_Z{U,Z} in pub_tool_redir.h. */
426
427#define I_WRAP_SONAME_FNNAME_ZU(soname,fnname) \
428 _vgwZU_##soname##_##fnname
429
430#define I_WRAP_SONAME_FNNAME_ZZ(soname,fnname) \
431 _vgwZZ_##soname##_##fnname
432
sewardjd68ac3e2006-01-20 14:31:57 +0000[diff] [blame]433/* Use this macro from within a wrapper function to collect the
434 context (address and possibly other info) of the original function.
435 Once you have that you can then use it in one of the CALL_FN_
436 macros. The type of the argument _lval is OrigFn. */
437#define VALGRIND_GET_ORIG_FN(_lval) VALGRIND_GET_NR_CONTEXT(_lval)
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]438
439/* Derivatives of the main macros below, for calling functions
440 returning void. */
441
442#define CALL_FN_v_v(fnptr) \
443 do { volatile unsigned long _junk; \
444 CALL_FN_W_v(_junk,fnptr); } while (0)
445
446#define CALL_FN_v_W(fnptr, arg1) \
447 do { volatile unsigned long _junk; \
448 CALL_FN_W_W(_junk,fnptr,arg1); } while (0)
449
450#define CALL_FN_v_WW(fnptr, arg1,arg2) \
451 do { volatile unsigned long _junk; \
452 CALL_FN_W_WW(_junk,fnptr,arg1,arg2); } while (0)
453
sewardj5ce4b152006-03-11 12:57:41 +0000[diff] [blame]454#define CALL_FN_v_WWW(fnptr, arg1,arg2,arg3) \
455 do { volatile unsigned long _junk; \
456 CALL_FN_W_WWW(_junk,fnptr,arg1,arg2,arg3); } while (0)
457
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]458/* ---------------------------- x86 ---------------------------- */
459
460#if defined(ARCH_x86)
461
462/* These regs are trashed by the hidden call. No need to mention eax
463 as gcc can already see that, plus causes gcc to bomb. */
464#define __CALLER_SAVED_REGS /*"eax"*/ "ecx", "edx"
465
466/* These CALL_FN_ macros assume that on x86-linux, sizeof(unsigned
467 long) == 4. */
468
sewardj66226cc2006-01-20 15:46:46 +0000[diff] [blame]469#define CALL_FN_W_v(lval, orig) \
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]470 do { \
sewardj66226cc2006-01-20 15:46:46 +0000[diff] [blame]471 volatile OrigFn _orig = (orig); \
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]472 volatile unsigned long _argvec[1]; \
473 volatile unsigned long _res; \
sewardj66226cc2006-01-20 15:46:46 +0000[diff] [blame]474 _argvec[0] = (unsigned long)_orig.nraddr; \
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]475 __asm__ volatile( \
476 "movl (%%eax), %%eax\n\t" /* target->%eax */ \
477 VALGRIND_CALL_NOREDIR_EAX \
478 : /*out*/ "=a" (_res) \
479 : /*in*/ "a" (&_argvec[0]) \
480 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS \
481 ); \
482 lval = (__typeof__(lval)) _res; \
483 } while (0)
484
sewardj66226cc2006-01-20 15:46:46 +0000[diff] [blame]485#define CALL_FN_W_W(lval, orig, arg1) \
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]486 do { \
sewardj66226cc2006-01-20 15:46:46 +0000[diff] [blame]487 volatile OrigFn _orig = (orig); \
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]488 volatile unsigned long _argvec[2]; \
489 volatile unsigned long _res; \
sewardj66226cc2006-01-20 15:46:46 +0000[diff] [blame]490 _argvec[0] = (unsigned long)_orig.nraddr; \
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]491 _argvec[1] = (unsigned long)(arg1); \
492 __asm__ volatile( \
493 "pushl 4(%%eax)\n\t" \
494 "movl (%%eax), %%eax\n\t" /* target->%eax */ \
495 VALGRIND_CALL_NOREDIR_EAX \
496 "addl $4, %%esp\n" \
497 : /*out*/ "=a" (_res) \
498 : /*in*/ "a" (&_argvec[0]) \
499 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS \
500 ); \
501 lval = (__typeof__(lval)) _res; \
502 } while (0)
503
sewardj66226cc2006-01-20 15:46:46 +0000[diff] [blame]504#define CALL_FN_W_WW(lval, orig, arg1,arg2) \
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]505 do { \
sewardj66226cc2006-01-20 15:46:46 +0000[diff] [blame]506 volatile OrigFn _orig = (orig); \
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]507 volatile unsigned long _argvec[3]; \
508 volatile unsigned long _res; \
sewardj66226cc2006-01-20 15:46:46 +0000[diff] [blame]509 _argvec[0] = (unsigned long)_orig.nraddr; \
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]510 _argvec[1] = (unsigned long)(arg1); \
511 _argvec[2] = (unsigned long)(arg2); \
512 __asm__ volatile( \
513 "pushl 8(%%eax)\n\t" \
514 "pushl 4(%%eax)\n\t" \
515 "movl (%%eax), %%eax\n\t" /* target->%eax */ \
516 VALGRIND_CALL_NOREDIR_EAX \
517 "addl $8, %%esp\n" \
518 : /*out*/ "=a" (_res) \
519 : /*in*/ "a" (&_argvec[0]) \
520 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS \
521 ); \
522 lval = (__typeof__(lval)) _res; \
523 } while (0)
524
sewardj9e8b07a2006-02-18 21:13:29 +0000[diff] [blame]525#define CALL_FN_W_WWW(lval, orig, arg1,arg2,arg3) \
526 do { \
527 volatile OrigFn _orig = (orig); \
528 volatile unsigned long _argvec[4]; \
529 volatile unsigned long _res; \
530 _argvec[0] = (unsigned long)_orig.nraddr; \
531 _argvec[1] = (unsigned long)(arg1); \
532 _argvec[2] = (unsigned long)(arg2); \
533 _argvec[3] = (unsigned long)(arg3); \
534 __asm__ volatile( \
535 "pushl 12(%%eax)\n\t" \
536 "pushl 8(%%eax)\n\t" \
537 "pushl 4(%%eax)\n\t" \
538 "movl (%%eax), %%eax\n\t" /* target->%eax */ \
539 VALGRIND_CALL_NOREDIR_EAX \
540 "addl $12, %%esp\n" \
541 : /*out*/ "=a" (_res) \
542 : /*in*/ "a" (&_argvec[0]) \
543 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS \
544 ); \
545 lval = (__typeof__(lval)) _res; \
546 } while (0)
547
sewardj66226cc2006-01-20 15:46:46 +0000[diff] [blame]548#define CALL_FN_W_WWWW(lval, orig, arg1,arg2,arg3,arg4) \
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]549 do { \
sewardj66226cc2006-01-20 15:46:46 +0000[diff] [blame]550 volatile OrigFn _orig = (orig); \
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]551 volatile unsigned long _argvec[5]; \
552 volatile unsigned long _res; \
sewardj66226cc2006-01-20 15:46:46 +0000[diff] [blame]553 _argvec[0] = (unsigned long)_orig.nraddr; \
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]554 _argvec[1] = (unsigned long)(arg1); \
555 _argvec[2] = (unsigned long)(arg2); \
556 _argvec[3] = (unsigned long)(arg3); \
557 _argvec[4] = (unsigned long)(arg4); \
558 __asm__ volatile( \
559 "pushl 16(%%eax)\n\t" \
560 "pushl 12(%%eax)\n\t" \
561 "pushl 8(%%eax)\n\t" \
562 "pushl 4(%%eax)\n\t" \
563 "movl (%%eax), %%eax\n\t" /* target->%eax */ \
564 VALGRIND_CALL_NOREDIR_EAX \
565 "addl $16, %%esp\n" \
566 : /*out*/ "=a" (_res) \
567 : /*in*/ "a" (&_argvec[0]) \
568 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS \
569 ); \
570 lval = (__typeof__(lval)) _res; \
571 } while (0)
572
sewardj66226cc2006-01-20 15:46:46 +0000[diff] [blame]573#define CALL_FN_W_5W(lval, orig, arg1,arg2,arg3,arg4,arg5) \
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]574 do { \
sewardj66226cc2006-01-20 15:46:46 +0000[diff] [blame]575 volatile OrigFn _orig = (orig); \
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]576 volatile unsigned long _argvec[6]; \
577 volatile unsigned long _res; \
sewardj66226cc2006-01-20 15:46:46 +0000[diff] [blame]578 _argvec[0] = (unsigned long)_orig.nraddr; \
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]579 _argvec[1] = (unsigned long)(arg1); \
580 _argvec[2] = (unsigned long)(arg2); \
581 _argvec[3] = (unsigned long)(arg3); \
582 _argvec[4] = (unsigned long)(arg4); \
583 _argvec[5] = (unsigned long)(arg5); \
584 __asm__ volatile( \
585 "pushl 20(%%eax)\n\t" \
586 "pushl 16(%%eax)\n\t" \
587 "pushl 12(%%eax)\n\t" \
588 "pushl 8(%%eax)\n\t" \
589 "pushl 4(%%eax)\n\t" \
590 "movl (%%eax), %%eax\n\t" /* target->%eax */ \
591 VALGRIND_CALL_NOREDIR_EAX \
592 "addl $20, %%esp\n" \
593 : /*out*/ "=a" (_res) \
594 : /*in*/ "a" (&_argvec[0]) \
595 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS \
596 ); \
597 lval = (__typeof__(lval)) _res; \
598 } while (0)
599
sewardj66226cc2006-01-20 15:46:46 +0000[diff] [blame]600#define CALL_FN_W_6W(lval, orig, arg1,arg2,arg3,arg4,arg5,arg6) \
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]601 do { \
sewardj66226cc2006-01-20 15:46:46 +0000[diff] [blame]602 volatile OrigFn _orig = (orig); \
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]603 volatile unsigned long _argvec[7]; \
604 volatile unsigned long _res; \
sewardj66226cc2006-01-20 15:46:46 +0000[diff] [blame]605 _argvec[0] = (unsigned long)_orig.nraddr; \
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]606 _argvec[1] = (unsigned long)(arg1); \
607 _argvec[2] = (unsigned long)(arg2); \
608 _argvec[3] = (unsigned long)(arg3); \
609 _argvec[4] = (unsigned long)(arg4); \
610 _argvec[5] = (unsigned long)(arg5); \
611 _argvec[6] = (unsigned long)(arg6); \
612 __asm__ volatile( \
613 "pushl 24(%%eax)\n\t" \
614 "pushl 20(%%eax)\n\t" \
615 "pushl 16(%%eax)\n\t" \
616 "pushl 12(%%eax)\n\t" \
617 "pushl 8(%%eax)\n\t" \
618 "pushl 4(%%eax)\n\t" \
619 "movl (%%eax), %%eax\n\t" /* target->%eax */ \
620 VALGRIND_CALL_NOREDIR_EAX \
621 "addl $24, %%esp\n" \
622 : /*out*/ "=a" (_res) \
623 : /*in*/ "a" (&_argvec[0]) \
624 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS \
625 ); \
626 lval = (__typeof__(lval)) _res; \
627 } while (0)
628
sewardj66226cc2006-01-20 15:46:46 +0000[diff] [blame]629#define CALL_FN_W_7W(lval, orig, arg1,arg2,arg3,arg4,arg5,arg6, \
630 arg7) \
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]631 do { \
sewardj66226cc2006-01-20 15:46:46 +0000[diff] [blame]632 volatile OrigFn _orig = (orig); \
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]633 volatile unsigned long _argvec[8]; \
634 volatile unsigned long _res; \
sewardj66226cc2006-01-20 15:46:46 +0000[diff] [blame]635 _argvec[0] = (unsigned long)_orig.nraddr; \
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]636 _argvec[1] = (unsigned long)(arg1); \
637 _argvec[2] = (unsigned long)(arg2); \
638 _argvec[3] = (unsigned long)(arg3); \
639 _argvec[4] = (unsigned long)(arg4); \
640 _argvec[5] = (unsigned long)(arg5); \
641 _argvec[6] = (unsigned long)(arg6); \
642 _argvec[7] = (unsigned long)(arg7); \
643 __asm__ volatile( \
644 "pushl 28(%%eax)\n\t" \
645 "pushl 24(%%eax)\n\t" \
646 "pushl 20(%%eax)\n\t" \
647 "pushl 16(%%eax)\n\t" \
648 "pushl 12(%%eax)\n\t" \
649 "pushl 8(%%eax)\n\t" \
650 "pushl 4(%%eax)\n\t" \
651 "movl (%%eax), %%eax\n\t" /* target->%eax */ \
652 VALGRIND_CALL_NOREDIR_EAX \
653 "addl $28, %%esp\n" \
654 : /*out*/ "=a" (_res) \
655 : /*in*/ "a" (&_argvec[0]) \
656 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS \
657 ); \
658 lval = (__typeof__(lval)) _res; \
659 } while (0)
660
sewardj66226cc2006-01-20 15:46:46 +0000[diff] [blame]661#define CALL_FN_W_8W(lval, orig, arg1,arg2,arg3,arg4,arg5,arg6, \
662 arg7,arg8) \
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]663 do { \
sewardj66226cc2006-01-20 15:46:46 +0000[diff] [blame]664 volatile OrigFn _orig = (orig); \
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]665 volatile unsigned long _argvec[9]; \
666 volatile unsigned long _res; \
sewardj66226cc2006-01-20 15:46:46 +0000[diff] [blame]667 _argvec[0] = (unsigned long)_orig.nraddr; \
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]668 _argvec[1] = (unsigned long)(arg1); \
669 _argvec[2] = (unsigned long)(arg2); \
670 _argvec[3] = (unsigned long)(arg3); \
671 _argvec[4] = (unsigned long)(arg4); \
672 _argvec[5] = (unsigned long)(arg5); \
673 _argvec[6] = (unsigned long)(arg6); \
674 _argvec[7] = (unsigned long)(arg7); \
675 _argvec[8] = (unsigned long)(arg8); \
676 __asm__ volatile( \
677 "pushl 32(%%eax)\n\t" \
678 "pushl 28(%%eax)\n\t" \
679 "pushl 24(%%eax)\n\t" \
680 "pushl 20(%%eax)\n\t" \
681 "pushl 16(%%eax)\n\t" \
682 "pushl 12(%%eax)\n\t" \
683 "pushl 8(%%eax)\n\t" \
684 "pushl 4(%%eax)\n\t" \
685 "movl (%%eax), %%eax\n\t" /* target->%eax */ \
686 VALGRIND_CALL_NOREDIR_EAX \
687 "addl $32, %%esp\n" \
688 : /*out*/ "=a" (_res) \
689 : /*in*/ "a" (&_argvec[0]) \
690 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS \
691 ); \
692 lval = (__typeof__(lval)) _res; \
693 } while (0)
694
sewardj45fa5b02006-03-09 19:06:23 +0000[diff] [blame]695#define CALL_FN_W_9W(lval, orig, arg1,arg2,arg3,arg4,arg5,arg6, \
696 arg7,arg8,arg9) \
697 do { \
698 volatile OrigFn _orig = (orig); \
699 volatile unsigned long _argvec[10]; \
700 volatile unsigned long _res; \
701 _argvec[0] = (unsigned long)_orig.nraddr; \
702 _argvec[1] = (unsigned long)(arg1); \
703 _argvec[2] = (unsigned long)(arg2); \
704 _argvec[3] = (unsigned long)(arg3); \
705 _argvec[4] = (unsigned long)(arg4); \
706 _argvec[5] = (unsigned long)(arg5); \
707 _argvec[6] = (unsigned long)(arg6); \
708 _argvec[7] = (unsigned long)(arg7); \
709 _argvec[8] = (unsigned long)(arg8); \
710 _argvec[9] = (unsigned long)(arg9); \
711 __asm__ volatile( \
712 "pushl 36(%%eax)\n\t" \
713 "pushl 32(%%eax)\n\t" \
714 "pushl 28(%%eax)\n\t" \
715 "pushl 24(%%eax)\n\t" \
716 "pushl 20(%%eax)\n\t" \
717 "pushl 16(%%eax)\n\t" \
718 "pushl 12(%%eax)\n\t" \
719 "pushl 8(%%eax)\n\t" \
720 "pushl 4(%%eax)\n\t" \
721 "movl (%%eax), %%eax\n\t" /* target->%eax */ \
722 VALGRIND_CALL_NOREDIR_EAX \
723 "addl $36, %%esp\n" \
724 : /*out*/ "=a" (_res) \
725 : /*in*/ "a" (&_argvec[0]) \
726 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS \
727 ); \
728 lval = (__typeof__(lval)) _res; \
729 } while (0)
730
731#define CALL_FN_W_10W(lval, orig, arg1,arg2,arg3,arg4,arg5,arg6, \
732 arg7,arg8,arg9,arg10) \
733 do { \
734 volatile OrigFn _orig = (orig); \
735 volatile unsigned long _argvec[11]; \
736 volatile unsigned long _res; \
737 _argvec[0] = (unsigned long)_orig.nraddr; \
738 _argvec[1] = (unsigned long)(arg1); \
739 _argvec[2] = (unsigned long)(arg2); \
740 _argvec[3] = (unsigned long)(arg3); \
741 _argvec[4] = (unsigned long)(arg4); \
742 _argvec[5] = (unsigned long)(arg5); \
743 _argvec[6] = (unsigned long)(arg6); \
744 _argvec[7] = (unsigned long)(arg7); \
745 _argvec[8] = (unsigned long)(arg8); \
746 _argvec[9] = (unsigned long)(arg9); \
747 _argvec[10] = (unsigned long)(arg10); \
748 __asm__ volatile( \
749 "pushl 40(%%eax)\n\t" \
750 "pushl 36(%%eax)\n\t" \
751 "pushl 32(%%eax)\n\t" \
752 "pushl 28(%%eax)\n\t" \
753 "pushl 24(%%eax)\n\t" \
754 "pushl 20(%%eax)\n\t" \
755 "pushl 16(%%eax)\n\t" \
756 "pushl 12(%%eax)\n\t" \
757 "pushl 8(%%eax)\n\t" \
758 "pushl 4(%%eax)\n\t" \
759 "movl (%%eax), %%eax\n\t" /* target->%eax */ \
760 VALGRIND_CALL_NOREDIR_EAX \
761 "addl $40, %%esp\n" \
762 : /*out*/ "=a" (_res) \
763 : /*in*/ "a" (&_argvec[0]) \
764 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS \
765 ); \
766 lval = (__typeof__(lval)) _res; \
767 } while (0)
768
sewardj5ce4b152006-03-11 12:57:41 +0000[diff] [blame]769#define CALL_FN_W_11W(lval, orig, arg1,arg2,arg3,arg4,arg5, \
770 arg6,arg7,arg8,arg9,arg10, \
771 arg11) \
772 do { \
773 volatile OrigFn _orig = (orig); \
774 volatile unsigned long _argvec[12]; \
775 volatile unsigned long _res; \
776 _argvec[0] = (unsigned long)_orig.nraddr; \
777 _argvec[1] = (unsigned long)(arg1); \
778 _argvec[2] = (unsigned long)(arg2); \
779 _argvec[3] = (unsigned long)(arg3); \
780 _argvec[4] = (unsigned long)(arg4); \
781 _argvec[5] = (unsigned long)(arg5); \
782 _argvec[6] = (unsigned long)(arg6); \
783 _argvec[7] = (unsigned long)(arg7); \
784 _argvec[8] = (unsigned long)(arg8); \
785 _argvec[9] = (unsigned long)(arg9); \
786 _argvec[10] = (unsigned long)(arg10); \
787 _argvec[11] = (unsigned long)(arg11); \
788 __asm__ volatile( \
789 "pushl 44(%%eax)\n\t" \
790 "pushl 40(%%eax)\n\t" \
791 "pushl 36(%%eax)\n\t" \
792 "pushl 32(%%eax)\n\t" \
793 "pushl 28(%%eax)\n\t" \
794 "pushl 24(%%eax)\n\t" \
795 "pushl 20(%%eax)\n\t" \
796 "pushl 16(%%eax)\n\t" \
797 "pushl 12(%%eax)\n\t" \
798 "pushl 8(%%eax)\n\t" \
799 "pushl 4(%%eax)\n\t" \
800 "movl (%%eax), %%eax\n\t" /* target->%eax */ \
801 VALGRIND_CALL_NOREDIR_EAX \
802 "addl $44, %%esp\n" \
803 : /*out*/ "=a" (_res) \
804 : /*in*/ "a" (&_argvec[0]) \
805 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS \
806 ); \
807 lval = (__typeof__(lval)) _res; \
808 } while (0)
809
sewardj66226cc2006-01-20 15:46:46 +0000[diff] [blame]810#define CALL_FN_W_12W(lval, orig, arg1,arg2,arg3,arg4,arg5, \
811 arg6,arg7,arg8,arg9,arg10, \
812 arg11,arg12) \
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]813 do { \
sewardj66226cc2006-01-20 15:46:46 +0000[diff] [blame]814 volatile OrigFn _orig = (orig); \
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]815 volatile unsigned long _argvec[13]; \
816 volatile unsigned long _res; \
sewardj66226cc2006-01-20 15:46:46 +0000[diff] [blame]817 _argvec[0] = (unsigned long)_orig.nraddr; \
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]818 _argvec[1] = (unsigned long)(arg1); \
819 _argvec[2] = (unsigned long)(arg2); \
820 _argvec[3] = (unsigned long)(arg3); \
821 _argvec[4] = (unsigned long)(arg4); \
822 _argvec[5] = (unsigned long)(arg5); \
823 _argvec[6] = (unsigned long)(arg6); \
824 _argvec[7] = (unsigned long)(arg7); \
825 _argvec[8] = (unsigned long)(arg8); \
826 _argvec[9] = (unsigned long)(arg9); \
827 _argvec[10] = (unsigned long)(arg10); \
828 _argvec[11] = (unsigned long)(arg11); \
829 _argvec[12] = (unsigned long)(arg12); \
830 __asm__ volatile( \
831 "pushl 48(%%eax)\n\t" \
832 "pushl 44(%%eax)\n\t" \
833 "pushl 40(%%eax)\n\t" \
834 "pushl 36(%%eax)\n\t" \
835 "pushl 32(%%eax)\n\t" \
836 "pushl 28(%%eax)\n\t" \
837 "pushl 24(%%eax)\n\t" \
838 "pushl 20(%%eax)\n\t" \
839 "pushl 16(%%eax)\n\t" \
840 "pushl 12(%%eax)\n\t" \
841 "pushl 8(%%eax)\n\t" \
842 "pushl 4(%%eax)\n\t" \
843 "movl (%%eax), %%eax\n\t" /* target->%eax */ \
844 VALGRIND_CALL_NOREDIR_EAX \
845 "addl $48, %%esp\n" \
846 : /*out*/ "=a" (_res) \
847 : /*in*/ "a" (&_argvec[0]) \
848 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS \
849 ); \
850 lval = (__typeof__(lval)) _res; \
851 } while (0)
852
853#endif /* ARCH_x86 */
854
855/* --------------------------- amd64 --------------------------- */
856
857#if defined(ARCH_amd64)
858
859/* ARGREGS: rdi rsi rdx rcx r8 r9 (the rest on stack in R-to-L order) */
860
861/* These regs are trashed by the hidden call. */
862#define __CALLER_SAVED_REGS /*"rax",*/ "rcx", "rdx", "rsi", \
863 "rdi", "r8", "r9", "r10", "r11"
864
865/* These CALL_FN_ macros assume that on amd64-linux, sizeof(unsigned
866 long) == 8. */
867
sewardjc8858442006-01-20 15:17:20 +0000[diff] [blame]868#define CALL_FN_W_v(lval, orig) \
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]869 do { \
sewardjc8858442006-01-20 15:17:20 +0000[diff] [blame]870 volatile OrigFn _orig = (orig); \
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]871 volatile unsigned long _argvec[1]; \
872 volatile unsigned long _res; \
sewardjc8858442006-01-20 15:17:20 +0000[diff] [blame]873 _argvec[0] = (unsigned long)_orig.nraddr; \
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]874 __asm__ volatile( \
875 "movq (%%rax), %%rax\n\t" /* target->%rax */ \
876 VALGRIND_CALL_NOREDIR_RAX \
877 : /*out*/ "=a" (_res) \
878 : /*in*/ "a" (&_argvec[0]) \
879 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS \
880 ); \
881 lval = (__typeof__(lval)) _res; \
882 } while (0)
883
sewardjc8858442006-01-20 15:17:20 +0000[diff] [blame]884#define CALL_FN_W_W(lval, orig, arg1) \
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]885 do { \
sewardjc8858442006-01-20 15:17:20 +0000[diff] [blame]886 volatile OrigFn _orig = (orig); \
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]887 volatile unsigned long _argvec[2]; \
888 volatile unsigned long _res; \
sewardjc8858442006-01-20 15:17:20 +0000[diff] [blame]889 _argvec[0] = (unsigned long)_orig.nraddr; \
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]890 _argvec[1] = (unsigned long)(arg1); \
891 __asm__ volatile( \
892 "movq 8(%%rax), %%rdi\n\t" \
893 "movq (%%rax), %%rax\n\t" /* target->%rax */ \
894 VALGRIND_CALL_NOREDIR_RAX \
895 : /*out*/ "=a" (_res) \
896 : /*in*/ "a" (&_argvec[0]) \
897 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS \
898 ); \
899 lval = (__typeof__(lval)) _res; \
900 } while (0)
901
sewardjc8858442006-01-20 15:17:20 +0000[diff] [blame]902#define CALL_FN_W_WW(lval, orig, arg1,arg2) \
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]903 do { \
sewardjc8858442006-01-20 15:17:20 +0000[diff] [blame]904 volatile OrigFn _orig = (orig); \
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]905 volatile unsigned long _argvec[3]; \
906 volatile unsigned long _res; \
sewardjc8858442006-01-20 15:17:20 +0000[diff] [blame]907 _argvec[0] = (unsigned long)_orig.nraddr; \
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]908 _argvec[1] = (unsigned long)(arg1); \
909 _argvec[2] = (unsigned long)(arg2); \
910 __asm__ volatile( \
911 "movq 16(%%rax), %%rsi\n\t" \
912 "movq 8(%%rax), %%rdi\n\t" \
913 "movq (%%rax), %%rax\n\t" /* target->%rax */ \
914 VALGRIND_CALL_NOREDIR_RAX \
915 : /*out*/ "=a" (_res) \
916 : /*in*/ "a" (&_argvec[0]) \
917 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS \
918 ); \
919 lval = (__typeof__(lval)) _res; \
920 } while (0)
921
sewardja50f9dc2006-03-11 16:19:14 +0000[diff] [blame]922#define CALL_FN_W_WWW(lval, orig, arg1,arg2,arg3) \
923 do { \
924 volatile OrigFn _orig = (orig); \
925 volatile unsigned long _argvec[4]; \
926 volatile unsigned long _res; \
927 _argvec[0] = (unsigned long)_orig.nraddr; \
928 _argvec[1] = (unsigned long)(arg1); \
929 _argvec[2] = (unsigned long)(arg2); \
930 _argvec[3] = (unsigned long)(arg3); \
931 __asm__ volatile( \
932 "movq 24(%%rax), %%rdx\n\t" \
933 "movq 16(%%rax), %%rsi\n\t" \
934 "movq 8(%%rax), %%rdi\n\t" \
935 "movq (%%rax), %%rax\n\t" /* target->%rax */ \
936 VALGRIND_CALL_NOREDIR_RAX \
937 : /*out*/ "=a" (_res) \
938 : /*in*/ "a" (&_argvec[0]) \
939 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS \
940 ); \
941 lval = (__typeof__(lval)) _res; \
942 } while (0)
943
944#define CALL_FN_W_WWWW(lval, orig, arg1,arg2,arg3,arg4) \
945 do { \
946 volatile OrigFn _orig = (orig); \
947 volatile unsigned long _argvec[5]; \
948 volatile unsigned long _res; \
949 _argvec[0] = (unsigned long)_orig.nraddr; \
950 _argvec[1] = (unsigned long)(arg1); \
951 _argvec[2] = (unsigned long)(arg2); \
952 _argvec[3] = (unsigned long)(arg3); \
953 _argvec[4] = (unsigned long)(arg4); \
954 __asm__ volatile( \
955 "movq 32(%%rax), %%rcx\n\t" \
956 "movq 24(%%rax), %%rdx\n\t" \
957 "movq 16(%%rax), %%rsi\n\t" \
958 "movq 8(%%rax), %%rdi\n\t" \
959 "movq (%%rax), %%rax\n\t" /* target->%rax */ \
960 VALGRIND_CALL_NOREDIR_RAX \
961 : /*out*/ "=a" (_res) \
962 : /*in*/ "a" (&_argvec[0]) \
963 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS \
964 ); \
965 lval = (__typeof__(lval)) _res; \
966 } while (0)
967
968#define CALL_FN_W_5W(lval, orig, arg1,arg2,arg3,arg4,arg5) \
969 do { \
970 volatile OrigFn _orig = (orig); \
971 volatile unsigned long _argvec[6]; \
972 volatile unsigned long _res; \
973 _argvec[0] = (unsigned long)_orig.nraddr; \
974 _argvec[1] = (unsigned long)(arg1); \
975 _argvec[2] = (unsigned long)(arg2); \
976 _argvec[3] = (unsigned long)(arg3); \
977 _argvec[4] = (unsigned long)(arg4); \
978 _argvec[5] = (unsigned long)(arg5); \
979 __asm__ volatile( \
980 "movq 40(%%rax), %%r8\n\t" \
981 "movq 32(%%rax), %%rcx\n\t" \
982 "movq 24(%%rax), %%rdx\n\t" \
983 "movq 16(%%rax), %%rsi\n\t" \
984 "movq 8(%%rax), %%rdi\n\t" \
985 "movq (%%rax), %%rax\n\t" /* target->%rax */ \
986 VALGRIND_CALL_NOREDIR_RAX \
987 : /*out*/ "=a" (_res) \
988 : /*in*/ "a" (&_argvec[0]) \
989 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS \
990 ); \
991 lval = (__typeof__(lval)) _res; \
992 } while (0)
993
994#define CALL_FN_W_6W(lval, orig, arg1,arg2,arg3,arg4,arg5,arg6) \
995 do { \
996 volatile OrigFn _orig = (orig); \
997 volatile unsigned long _argvec[7]; \
998 volatile unsigned long _res; \
999 _argvec[0] = (unsigned long)_orig.nraddr; \
1000 _argvec[1] = (unsigned long)(arg1); \
1001 _argvec[2] = (unsigned long)(arg2); \
1002 _argvec[3] = (unsigned long)(arg3); \
1003 _argvec[4] = (unsigned long)(arg4); \
1004 _argvec[5] = (unsigned long)(arg5); \
1005 _argvec[6] = (unsigned long)(arg6); \
1006 __asm__ volatile( \
1007 "movq 48(%%rax), %%r9\n\t" \
1008 "movq 40(%%rax), %%r8\n\t" \
1009 "movq 32(%%rax), %%rcx\n\t" \
1010 "movq 24(%%rax), %%rdx\n\t" \
1011 "movq 16(%%rax), %%rsi\n\t" \
1012 "movq 8(%%rax), %%rdi\n\t" \
1013 "movq (%%rax), %%rax\n\t" /* target->%rax */ \
1014 VALGRIND_CALL_NOREDIR_RAX \
1015 : /*out*/ "=a" (_res) \
1016 : /*in*/ "a" (&_argvec[0]) \
1017 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS \
1018 ); \
1019 lval = (__typeof__(lval)) _res; \
1020 } while (0)
1021
1022#define CALL_FN_W_7W(lval, orig, arg1,arg2,arg3,arg4,arg5,arg6, \
1023 arg7) \
1024 do { \
1025 volatile OrigFn _orig = (orig); \
1026 volatile unsigned long _argvec[8]; \
1027 volatile unsigned long _res; \
1028 _argvec[0] = (unsigned long)_orig.nraddr; \
1029 _argvec[1] = (unsigned long)(arg1); \
1030 _argvec[2] = (unsigned long)(arg2); \
1031 _argvec[3] = (unsigned long)(arg3); \
1032 _argvec[4] = (unsigned long)(arg4); \
1033 _argvec[5] = (unsigned long)(arg5); \
1034 _argvec[6] = (unsigned long)(arg6); \
1035 _argvec[7] = (unsigned long)(arg7); \
1036 __asm__ volatile( \
1037 "pushq 56(%%rax)\n\t" \
1038 "movq 48(%%rax), %%r9\n\t" \
1039 "movq 40(%%rax), %%r8\n\t" \
1040 "movq 32(%%rax), %%rcx\n\t" \
1041 "movq 24(%%rax), %%rdx\n\t" \
1042 "movq 16(%%rax), %%rsi\n\t" \
1043 "movq 8(%%rax), %%rdi\n\t" \
1044 "movq (%%rax), %%rax\n\t" /* target->%rax */ \
1045 VALGRIND_CALL_NOREDIR_RAX \
1046 "addq $8, %%rsp\n" \
1047 : /*out*/ "=a" (_res) \
1048 : /*in*/ "a" (&_argvec[0]) \
1049 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS \
1050 ); \
1051 lval = (__typeof__(lval)) _res; \
1052 } while (0)
1053
1054#define CALL_FN_W_8W(lval, orig, arg1,arg2,arg3,arg4,arg5,arg6, \
1055 arg7,arg8) \
1056 do { \
1057 volatile OrigFn _orig = (orig); \
1058 volatile unsigned long _argvec[9]; \
1059 volatile unsigned long _res; \
1060 _argvec[0] = (unsigned long)_orig.nraddr; \
1061 _argvec[1] = (unsigned long)(arg1); \
1062 _argvec[2] = (unsigned long)(arg2); \
1063 _argvec[3] = (unsigned long)(arg3); \
1064 _argvec[4] = (unsigned long)(arg4); \
1065 _argvec[5] = (unsigned long)(arg5); \
1066 _argvec[6] = (unsigned long)(arg6); \
1067 _argvec[7] = (unsigned long)(arg7); \
1068 _argvec[8] = (unsigned long)(arg8); \
1069 __asm__ volatile( \
1070 "pushq 64(%%rax)\n\t" \
1071 "pushq 56(%%rax)\n\t" \
1072 "movq 48(%%rax), %%r9\n\t" \
1073 "movq 40(%%rax), %%r8\n\t" \
1074 "movq 32(%%rax), %%rcx\n\t" \
1075 "movq 24(%%rax), %%rdx\n\t" \
1076 "movq 16(%%rax), %%rsi\n\t" \
1077 "movq 8(%%rax), %%rdi\n\t" \
1078 "movq (%%rax), %%rax\n\t" /* target->%rax */ \
1079 VALGRIND_CALL_NOREDIR_RAX \
1080 "addq $16, %%rsp\n" \
1081 : /*out*/ "=a" (_res) \
1082 : /*in*/ "a" (&_argvec[0]) \
1083 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS \
1084 ); \
1085 lval = (__typeof__(lval)) _res; \
1086 } while (0)
1087
1088#define CALL_FN_W_9W(lval, orig, arg1,arg2,arg3,arg4,arg5,arg6, \
1089 arg7,arg8,arg9) \
1090 do { \
1091 volatile OrigFn _orig = (orig); \
1092 volatile unsigned long _argvec[10]; \
1093 volatile unsigned long _res; \
1094 _argvec[0] = (unsigned long)_orig.nraddr; \
1095 _argvec[1] = (unsigned long)(arg1); \
1096 _argvec[2] = (unsigned long)(arg2); \
1097 _argvec[3] = (unsigned long)(arg3); \
1098 _argvec[4] = (unsigned long)(arg4); \
1099 _argvec[5] = (unsigned long)(arg5); \
1100 _argvec[6] = (unsigned long)(arg6); \
1101 _argvec[7] = (unsigned long)(arg7); \
1102 _argvec[8] = (unsigned long)(arg8); \
1103 _argvec[9] = (unsigned long)(arg9); \
1104 __asm__ volatile( \
1105 "pushq 72(%%rax)\n\t" \
1106 "pushq 64(%%rax)\n\t" \
1107 "pushq 56(%%rax)\n\t" \
1108 "movq 48(%%rax), %%r9\n\t" \
1109 "movq 40(%%rax), %%r8\n\t" \
1110 "movq 32(%%rax), %%rcx\n\t" \
1111 "movq 24(%%rax), %%rdx\n\t" \
1112 "movq 16(%%rax), %%rsi\n\t" \
1113 "movq 8(%%rax), %%rdi\n\t" \
1114 "movq (%%rax), %%rax\n\t" /* target->%rax */ \
1115 VALGRIND_CALL_NOREDIR_RAX \
1116 "addq $24, %%rsp\n" \
1117 : /*out*/ "=a" (_res) \
1118 : /*in*/ "a" (&_argvec[0]) \
1119 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS \
1120 ); \
1121 lval = (__typeof__(lval)) _res; \
1122 } while (0)
1123
1124#define CALL_FN_W_10W(lval, orig, arg1,arg2,arg3,arg4,arg5,arg6, \
1125 arg7,arg8,arg9,arg10) \
1126 do { \
1127 volatile OrigFn _orig = (orig); \
1128 volatile unsigned long _argvec[11]; \
1129 volatile unsigned long _res; \
1130 _argvec[0] = (unsigned long)_orig.nraddr; \
1131 _argvec[1] = (unsigned long)(arg1); \
1132 _argvec[2] = (unsigned long)(arg2); \
1133 _argvec[3] = (unsigned long)(arg3); \
1134 _argvec[4] = (unsigned long)(arg4); \
1135 _argvec[5] = (unsigned long)(arg5); \
1136 _argvec[6] = (unsigned long)(arg6); \
1137 _argvec[7] = (unsigned long)(arg7); \
1138 _argvec[8] = (unsigned long)(arg8); \
1139 _argvec[9] = (unsigned long)(arg9); \
1140 _argvec[10] = (unsigned long)(arg10); \
1141 __asm__ volatile( \
1142 "pushq 80(%%rax)\n\t" \
1143 "pushq 72(%%rax)\n\t" \
1144 "pushq 64(%%rax)\n\t" \
1145 "pushq 56(%%rax)\n\t" \
1146 "movq 48(%%rax), %%r9\n\t" \
1147 "movq 40(%%rax), %%r8\n\t" \
1148 "movq 32(%%rax), %%rcx\n\t" \
1149 "movq 24(%%rax), %%rdx\n\t" \
1150 "movq 16(%%rax), %%rsi\n\t" \
1151 "movq 8(%%rax), %%rdi\n\t" \
1152 "movq (%%rax), %%rax\n\t" /* target->%rax */ \
1153 VALGRIND_CALL_NOREDIR_RAX \
1154 "addq $32, %%rsp\n" \
1155 : /*out*/ "=a" (_res) \
1156 : /*in*/ "a" (&_argvec[0]) \
1157 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS \
1158 ); \
1159 lval = (__typeof__(lval)) _res; \
1160 } while (0)
1161
1162#define CALL_FN_W_11W(lval, orig, arg1,arg2,arg3,arg4,arg5,arg6, \
1163 arg7,arg8,arg9,arg10,arg11) \
1164 do { \
1165 volatile OrigFn _orig = (orig); \
1166 volatile unsigned long _argvec[12]; \
1167 volatile unsigned long _res; \
1168 _argvec[0] = (unsigned long)_orig.nraddr; \
1169 _argvec[1] = (unsigned long)(arg1); \
1170 _argvec[2] = (unsigned long)(arg2); \
1171 _argvec[3] = (unsigned long)(arg3); \
1172 _argvec[4] = (unsigned long)(arg4); \
1173 _argvec[5] = (unsigned long)(arg5); \
1174 _argvec[6] = (unsigned long)(arg6); \
1175 _argvec[7] = (unsigned long)(arg7); \
1176 _argvec[8] = (unsigned long)(arg8); \
1177 _argvec[9] = (unsigned long)(arg9); \
1178 _argvec[10] = (unsigned long)(arg10); \
1179 _argvec[11] = (unsigned long)(arg11); \
1180 __asm__ volatile( \
1181 "pushq 88(%%rax)\n\t" \
1182 "pushq 80(%%rax)\n\t" \
1183 "pushq 72(%%rax)\n\t" \
1184 "pushq 64(%%rax)\n\t" \
1185 "pushq 56(%%rax)\n\t" \
1186 "movq 48(%%rax), %%r9\n\t" \
1187 "movq 40(%%rax), %%r8\n\t" \
1188 "movq 32(%%rax), %%rcx\n\t" \
1189 "movq 24(%%rax), %%rdx\n\t" \
1190 "movq 16(%%rax), %%rsi\n\t" \
1191 "movq 8(%%rax), %%rdi\n\t" \
1192 "movq (%%rax), %%rax\n\t" /* target->%rax */ \
1193 VALGRIND_CALL_NOREDIR_RAX \
1194 "addq $40, %%rsp\n" \
1195 : /*out*/ "=a" (_res) \
1196 : /*in*/ "a" (&_argvec[0]) \
1197 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS \
1198 ); \
1199 lval = (__typeof__(lval)) _res; \
1200 } while (0)
1201
1202#define CALL_FN_W_12W(lval, orig, arg1,arg2,arg3,arg4,arg5,arg6, \
1203 arg7,arg8,arg9,arg10,arg11,arg12) \
1204 do { \
1205 volatile OrigFn _orig = (orig); \
1206 volatile unsigned long _argvec[13]; \
1207 volatile unsigned long _res; \
1208 _argvec[0] = (unsigned long)_orig.nraddr; \
1209 _argvec[1] = (unsigned long)(arg1); \
1210 _argvec[2] = (unsigned long)(arg2); \
1211 _argvec[3] = (unsigned long)(arg3); \
1212 _argvec[4] = (unsigned long)(arg4); \
1213 _argvec[5] = (unsigned long)(arg5); \
1214 _argvec[6] = (unsigned long)(arg6); \
1215 _argvec[7] = (unsigned long)(arg7); \
1216 _argvec[8] = (unsigned long)(arg8); \
1217 _argvec[9] = (unsigned long)(arg9); \
1218 _argvec[10] = (unsigned long)(arg10); \
1219 _argvec[11] = (unsigned long)(arg11); \
1220 _argvec[12] = (unsigned long)(arg12); \
1221 __asm__ volatile( \
1222 "pushq 96(%%rax)\n\t" \
1223 "pushq 88(%%rax)\n\t" \
1224 "pushq 80(%%rax)\n\t" \
1225 "pushq 72(%%rax)\n\t" \
1226 "pushq 64(%%rax)\n\t" \
1227 "pushq 56(%%rax)\n\t" \
1228 "movq 48(%%rax), %%r9\n\t" \
1229 "movq 40(%%rax), %%r8\n\t" \
1230 "movq 32(%%rax), %%rcx\n\t" \
1231 "movq 24(%%rax), %%rdx\n\t" \
1232 "movq 16(%%rax), %%rsi\n\t" \
1233 "movq 8(%%rax), %%rdi\n\t" \
1234 "movq (%%rax), %%rax\n\t" /* target->%rax */ \
1235 VALGRIND_CALL_NOREDIR_RAX \
1236 "addq $48, %%rsp\n" \
1237 : /*out*/ "=a" (_res) \
1238 : /*in*/ "a" (&_argvec[0]) \
1239 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS \
1240 ); \
1241 lval = (__typeof__(lval)) _res; \
1242 } while (0)
1243
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]1244#endif /* ARCH_amd64 */
1245
1246/* --------------------------- ppc32 --------------------------- */
1247
1248#if defined(ARCH_ppc32)
1249
sewardjead61df2006-03-12 13:39:15 +0000[diff] [blame^]1250/* This is useful for finding out about the on-stack stuff:
1251
1252 extern int f9 ( int,int,int,int,int,int,int,int,int );
1253 extern int f10 ( int,int,int,int,int,int,int,int,int,int );
1254 extern int f11 ( int,int,int,int,int,int,int,int,int,int,int );
1255 extern int f12 ( int,int,int,int,int,int,int,int,int,int,int,int );
1256
1257 int g9 ( void ) {
1258 return f9(11,22,33,44,55,66,77,88,99);
1259 }
1260 int g10 ( void ) {
1261 return f10(11,22,33,44,55,66,77,88,99,110);
1262 }
1263 int g11 ( void ) {
1264 return f11(11,22,33,44,55,66,77,88,99,110,121);
1265 }
1266 int g12 ( void ) {
1267 return f12(11,22,33,44,55,66,77,88,99,110,121,132);
1268 }
1269*/
1270
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]1271/* ARGREGS: r3 r4 r5 r6 r7 r8 r9 r10 (the rest on stack somewhere) */
1272
1273/* These regs are trashed by the hidden call. */
sewardjead61df2006-03-12 13:39:15 +0000[diff] [blame^]1274#define __CALLER_SAVED_REGS \
1275 "lr", "ctr", "xer", \
1276 "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7", \
1277 "r0", "r2", "r3", "r4", "r5", "r6", "r7", "r8", "r9", "r10", \
1278 "r11", "r12", "r13"
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]1279
sewardjead61df2006-03-12 13:39:15 +0000[diff] [blame^]1280/* These CALL_FN_ macros assume that on ppc32-linux,
1281 sizeof(unsigned long) == 4. */
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]1282
sewardj38de0992006-01-20 16:46:34 +0000[diff] [blame]1283#define CALL_FN_W_v(lval, orig) \
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]1284 do { \
sewardjd68ac3e2006-01-20 14:31:57 +0000[diff] [blame]1285 volatile OrigFn _orig = (orig); \
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]1286 volatile unsigned long _argvec[1]; \
1287 volatile unsigned long _res; \
sewardjd68ac3e2006-01-20 14:31:57 +0000[diff] [blame]1288 _argvec[0] = (unsigned long)_orig.nraddr; \
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]1289 __asm__ volatile( \
1290 "mr 11,%1\n\t" \
1291 "lwz 11,0(11)\n\t" /* target->r11 */ \
1292 VALGRIND_BRANCH_AND_LINK_TO_NOREDIR_R11 \
1293 "mr %0,3" \
1294 : /*out*/ "=r" (_res) \
1295 : /*in*/ "r" (&_argvec[0]) \
1296 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS \
1297 ); \
1298 lval = (__typeof__(lval)) _res; \
1299 } while (0)
1300
sewardj38de0992006-01-20 16:46:34 +0000[diff] [blame]1301#define CALL_FN_W_W(lval, orig, arg1) \
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]1302 do { \
sewardj38de0992006-01-20 16:46:34 +0000[diff] [blame]1303 volatile OrigFn _orig = (orig); \
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]1304 volatile unsigned long _argvec[2]; \
1305 volatile unsigned long _res; \
sewardj38de0992006-01-20 16:46:34 +0000[diff] [blame]1306 _argvec[0] = (unsigned long)_orig.nraddr; \
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]1307 _argvec[1] = (unsigned long)arg1; \
1308 __asm__ volatile( \
1309 "mr 11,%1\n\t" \
1310 "lwz 3,4(11)\n\t" /* arg1->r3 */ \
1311 "lwz 11,0(11)\n\t" /* target->r11 */ \
1312 VALGRIND_BRANCH_AND_LINK_TO_NOREDIR_R11 \
1313 "mr %0,3" \
1314 : /*out*/ "=r" (_res) \
1315 : /*in*/ "r" (&_argvec[0]) \
1316 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS \
1317 ); \
1318 lval = (__typeof__(lval)) _res; \
1319 } while (0)
1320
sewardj38de0992006-01-20 16:46:34 +0000[diff] [blame]1321#define CALL_FN_W_WW(lval, orig, arg1,arg2) \
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]1322 do { \
sewardj38de0992006-01-20 16:46:34 +0000[diff] [blame]1323 volatile OrigFn _orig = (orig); \
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]1324 volatile unsigned long _argvec[3]; \
1325 volatile unsigned long _res; \
sewardj38de0992006-01-20 16:46:34 +0000[diff] [blame]1326 _argvec[0] = (unsigned long)_orig.nraddr; \
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]1327 _argvec[1] = (unsigned long)arg1; \
1328 _argvec[2] = (unsigned long)arg2; \
1329 __asm__ volatile( \
1330 "mr 11,%1\n\t" \
1331 "lwz 3,4(11)\n\t" /* arg1->r3 */ \
1332 "lwz 4,8(11)\n\t" \
1333 "lwz 11,0(11)\n\t" /* target->r11 */ \
1334 VALGRIND_BRANCH_AND_LINK_TO_NOREDIR_R11 \
1335 "mr %0,3" \
1336 : /*out*/ "=r" (_res) \
1337 : /*in*/ "r" (&_argvec[0]) \
1338 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS \
1339 ); \
1340 lval = (__typeof__(lval)) _res; \
1341 } while (0)
1342
sewardjead61df2006-03-12 13:39:15 +0000[diff] [blame^]1343#define CALL_FN_W_WWW(lval, orig, arg1,arg2,arg3) \
1344 do { \
1345 volatile OrigFn _orig = (orig); \
1346 volatile unsigned long _argvec[4]; \
1347 volatile unsigned long _res; \
1348 _argvec[0] = (unsigned long)_orig.nraddr; \
1349 _argvec[1] = (unsigned long)arg1; \
1350 _argvec[2] = (unsigned long)arg2; \
1351 _argvec[3] = (unsigned long)arg3; \
1352 __asm__ volatile( \
1353 "mr 11,%1\n\t" \
1354 "lwz 3,4(11)\n\t" /* arg1->r3 */ \
1355 "lwz 4,8(11)\n\t" \
1356 "lwz 5,12(11)\n\t" \
1357 "lwz 11,0(11)\n\t" /* target->r11 */ \
1358 VALGRIND_BRANCH_AND_LINK_TO_NOREDIR_R11 \
1359 "mr %0,3" \
1360 : /*out*/ "=r" (_res) \
1361 : /*in*/ "r" (&_argvec[0]) \
1362 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS \
1363 ); \
1364 lval = (__typeof__(lval)) _res; \
1365 } while (0)
1366
1367#define CALL_FN_W_WWWW(lval, orig, arg1,arg2,arg3,arg4) \
1368 do { \
1369 volatile OrigFn _orig = (orig); \
1370 volatile unsigned long _argvec[5]; \
1371 volatile unsigned long _res; \
1372 _argvec[0] = (unsigned long)_orig.nraddr; \
1373 _argvec[1] = (unsigned long)arg1; \
1374 _argvec[2] = (unsigned long)arg2; \
1375 _argvec[3] = (unsigned long)arg3; \
1376 _argvec[4] = (unsigned long)arg4; \
1377 __asm__ volatile( \
1378 "mr 11,%1\n\t" \
1379 "lwz 3,4(11)\n\t" /* arg1->r3 */ \
1380 "lwz 4,8(11)\n\t" \
1381 "lwz 5,12(11)\n\t" \
1382 "lwz 6,16(11)\n\t" /* arg4->r6 */ \
1383 "lwz 11,0(11)\n\t" /* target->r11 */ \
1384 VALGRIND_BRANCH_AND_LINK_TO_NOREDIR_R11 \
1385 "mr %0,3" \
1386 : /*out*/ "=r" (_res) \
1387 : /*in*/ "r" (&_argvec[0]) \
1388 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS \
1389 ); \
1390 lval = (__typeof__(lval)) _res; \
1391 } while (0)
1392
1393#define CALL_FN_W_5W(lval, orig, arg1,arg2,arg3,arg4,arg5) \
1394 do { \
1395 volatile OrigFn _orig = (orig); \
1396 volatile unsigned long _argvec[6]; \
1397 volatile unsigned long _res; \
1398 _argvec[0] = (unsigned long)_orig.nraddr; \
1399 _argvec[1] = (unsigned long)arg1; \
1400 _argvec[2] = (unsigned long)arg2; \
1401 _argvec[3] = (unsigned long)arg3; \
1402 _argvec[4] = (unsigned long)arg4; \
1403 _argvec[5] = (unsigned long)arg5; \
1404 __asm__ volatile( \
1405 "mr 11,%1\n\t" \
1406 "lwz 3,4(11)\n\t" /* arg1->r3 */ \
1407 "lwz 4,8(11)\n\t" \
1408 "lwz 5,12(11)\n\t" \
1409 "lwz 6,16(11)\n\t" /* arg4->r6 */ \
1410 "lwz 7,20(11)\n\t" \
1411 "lwz 11,0(11)\n\t" /* target->r11 */ \
1412 VALGRIND_BRANCH_AND_LINK_TO_NOREDIR_R11 \
1413 "mr %0,3" \
1414 : /*out*/ "=r" (_res) \
1415 : /*in*/ "r" (&_argvec[0]) \
1416 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS \
1417 ); \
1418 lval = (__typeof__(lval)) _res; \
1419 } while (0)
1420
1421#define CALL_FN_W_6W(lval, orig, arg1,arg2,arg3,arg4,arg5,arg6) \
1422 do { \
1423 volatile OrigFn _orig = (orig); \
1424 volatile unsigned long _argvec[7]; \
1425 volatile unsigned long _res; \
1426 _argvec[0] = (unsigned long)_orig.nraddr; \
1427 _argvec[1] = (unsigned long)arg1; \
1428 _argvec[2] = (unsigned long)arg2; \
1429 _argvec[3] = (unsigned long)arg3; \
1430 _argvec[4] = (unsigned long)arg4; \
1431 _argvec[5] = (unsigned long)arg5; \
1432 _argvec[6] = (unsigned long)arg6; \
1433 __asm__ volatile( \
1434 "mr 11,%1\n\t" \
1435 "lwz 3,4(11)\n\t" /* arg1->r3 */ \
1436 "lwz 4,8(11)\n\t" \
1437 "lwz 5,12(11)\n\t" \
1438 "lwz 6,16(11)\n\t" /* arg4->r6 */ \
1439 "lwz 7,20(11)\n\t" \
1440 "lwz 8,24(11)\n\t" \
1441 "lwz 11,0(11)\n\t" /* target->r11 */ \
1442 VALGRIND_BRANCH_AND_LINK_TO_NOREDIR_R11 \
1443 "mr %0,3" \
1444 : /*out*/ "=r" (_res) \
1445 : /*in*/ "r" (&_argvec[0]) \
1446 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS \
1447 ); \
1448 lval = (__typeof__(lval)) _res; \
1449 } while (0)
1450
1451#define CALL_FN_W_7W(lval, orig, arg1,arg2,arg3,arg4,arg5,arg6, \
1452 arg7) \
1453 do { \
1454 volatile OrigFn _orig = (orig); \
1455 volatile unsigned long _argvec[8]; \
1456 volatile unsigned long _res; \
1457 _argvec[0] = (unsigned long)_orig.nraddr; \
1458 _argvec[1] = (unsigned long)arg1; \
1459 _argvec[2] = (unsigned long)arg2; \
1460 _argvec[3] = (unsigned long)arg3; \
1461 _argvec[4] = (unsigned long)arg4; \
1462 _argvec[5] = (unsigned long)arg5; \
1463 _argvec[6] = (unsigned long)arg6; \
1464 _argvec[7] = (unsigned long)arg7; \
1465 __asm__ volatile( \
1466 "mr 11,%1\n\t" \
1467 "lwz 3,4(11)\n\t" /* arg1->r3 */ \
1468 "lwz 4,8(11)\n\t" \
1469 "lwz 5,12(11)\n\t" \
1470 "lwz 6,16(11)\n\t" /* arg4->r6 */ \
1471 "lwz 7,20(11)\n\t" \
1472 "lwz 8,24(11)\n\t" \
1473 "lwz 9,28(11)\n\t" \
1474 "lwz 11,0(11)\n\t" /* target->r11 */ \
1475 VALGRIND_BRANCH_AND_LINK_TO_NOREDIR_R11 \
1476 "mr %0,3" \
1477 : /*out*/ "=r" (_res) \
1478 : /*in*/ "r" (&_argvec[0]) \
1479 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS \
1480 ); \
1481 lval = (__typeof__(lval)) _res; \
1482 } while (0)
1483
1484#define CALL_FN_W_8W(lval, orig, arg1,arg2,arg3,arg4,arg5,arg6, \
1485 arg7,arg8) \
1486 do { \
1487 volatile OrigFn _orig = (orig); \
1488 volatile unsigned long _argvec[9]; \
1489 volatile unsigned long _res; \
1490 _argvec[0] = (unsigned long)_orig.nraddr; \
1491 _argvec[1] = (unsigned long)arg1; \
1492 _argvec[2] = (unsigned long)arg2; \
1493 _argvec[3] = (unsigned long)arg3; \
1494 _argvec[4] = (unsigned long)arg4; \
1495 _argvec[5] = (unsigned long)arg5; \
1496 _argvec[6] = (unsigned long)arg6; \
1497 _argvec[7] = (unsigned long)arg7; \
1498 _argvec[8] = (unsigned long)arg8; \
1499 __asm__ volatile( \
1500 "mr 11,%1\n\t" \
1501 "lwz 3,4(11)\n\t" /* arg1->r3 */ \
1502 "lwz 4,8(11)\n\t" \
1503 "lwz 5,12(11)\n\t" \
1504 "lwz 6,16(11)\n\t" /* arg4->r6 */ \
1505 "lwz 7,20(11)\n\t" \
1506 "lwz 8,24(11)\n\t" \
1507 "lwz 9,28(11)\n\t" \
1508 "lwz 10,32(11)\n\t" /* arg8->r10 */ \
1509 "lwz 11,0(11)\n\t" /* target->r11 */ \
1510 VALGRIND_BRANCH_AND_LINK_TO_NOREDIR_R11 \
1511 "mr %0,3" \
1512 : /*out*/ "=r" (_res) \
1513 : /*in*/ "r" (&_argvec[0]) \
1514 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS \
1515 ); \
1516 lval = (__typeof__(lval)) _res; \
1517 } while (0)
1518
1519#define CALL_FN_W_9W(lval, orig, arg1,arg2,arg3,arg4,arg5,arg6, \
1520 arg7,arg8,arg9) \
1521 do { \
1522 volatile OrigFn _orig = (orig); \
1523 volatile unsigned long _argvec[10]; \
1524 volatile unsigned long _res; \
1525 _argvec[0] = (unsigned long)_orig.nraddr; \
1526 _argvec[1] = (unsigned long)arg1; \
1527 _argvec[2] = (unsigned long)arg2; \
1528 _argvec[3] = (unsigned long)arg3; \
1529 _argvec[4] = (unsigned long)arg4; \
1530 _argvec[5] = (unsigned long)arg5; \
1531 _argvec[6] = (unsigned long)arg6; \
1532 _argvec[7] = (unsigned long)arg7; \
1533 _argvec[8] = (unsigned long)arg8; \
1534 _argvec[9] = (unsigned long)arg9; \
1535 __asm__ volatile( \
1536 "mr 11,%1\n\t" \
1537 "addi 1,1,-16\n\t" \
1538 /* arg9 */ \
1539 "lwz 3,36(11)\n\t" \
1540 "stw 3,8(1)\n\t" \
1541 /* args1-8 */ \
1542 "lwz 3,4(11)\n\t" /* arg1->r3 */ \
1543 "lwz 4,8(11)\n\t" \
1544 "lwz 5,12(11)\n\t" \
1545 "lwz 6,16(11)\n\t" /* arg4->r6 */ \
1546 "lwz 7,20(11)\n\t" \
1547 "lwz 8,24(11)\n\t" \
1548 "lwz 9,28(11)\n\t" \
1549 "lwz 10,32(11)\n\t" /* arg8->r10 */ \
1550 "lwz 11,0(11)\n\t" /* target->r11 */ \
1551 VALGRIND_BRANCH_AND_LINK_TO_NOREDIR_R11 \
1552 "addi 1,1,16\n\t" \
1553 "mr %0,3" \
1554 : /*out*/ "=r" (_res) \
1555 : /*in*/ "r" (&_argvec[0]) \
1556 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS \
1557 ); \
1558 lval = (__typeof__(lval)) _res; \
1559 } while (0)
1560
1561#define CALL_FN_W_10W(lval, orig, arg1,arg2,arg3,arg4,arg5,arg6, \
1562 arg7,arg8,arg9,arg10) \
1563 do { \
1564 volatile OrigFn _orig = (orig); \
1565 volatile unsigned long _argvec[11]; \
1566 volatile unsigned long _res; \
1567 _argvec[0] = (unsigned long)_orig.nraddr; \
1568 _argvec[1] = (unsigned long)arg1; \
1569 _argvec[2] = (unsigned long)arg2; \
1570 _argvec[3] = (unsigned long)arg3; \
1571 _argvec[4] = (unsigned long)arg4; \
1572 _argvec[5] = (unsigned long)arg5; \
1573 _argvec[6] = (unsigned long)arg6; \
1574 _argvec[7] = (unsigned long)arg7; \
1575 _argvec[8] = (unsigned long)arg8; \
1576 _argvec[9] = (unsigned long)arg9; \
1577 _argvec[10] = (unsigned long)arg10; \
1578 __asm__ volatile( \
1579 "mr 11,%1\n\t" \
1580 "addi 1,1,-16\n\t" \
1581 /* arg10 */ \
1582 "lwz 3,40(11)\n\t" \
1583 "stw 3,12(1)\n\t" \
1584 /* arg9 */ \
1585 "lwz 3,36(11)\n\t" \
1586 "stw 3,8(1)\n\t" \
1587 /* args1-8 */ \
1588 "lwz 3,4(11)\n\t" /* arg1->r3 */ \
1589 "lwz 4,8(11)\n\t" \
1590 "lwz 5,12(11)\n\t" \
1591 "lwz 6,16(11)\n\t" /* arg4->r6 */ \
1592 "lwz 7,20(11)\n\t" \
1593 "lwz 8,24(11)\n\t" \
1594 "lwz 9,28(11)\n\t" \
1595 "lwz 10,32(11)\n\t" /* arg8->r10 */ \
1596 "lwz 11,0(11)\n\t" /* target->r11 */ \
1597 VALGRIND_BRANCH_AND_LINK_TO_NOREDIR_R11 \
1598 "addi 1,1,16\n\t" \
1599 "mr %0,3" \
1600 : /*out*/ "=r" (_res) \
1601 : /*in*/ "r" (&_argvec[0]) \
1602 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS \
1603 ); \
1604 lval = (__typeof__(lval)) _res; \
1605 } while (0)
1606
1607#define CALL_FN_W_11W(lval, orig, arg1,arg2,arg3,arg4,arg5,arg6, \
1608 arg7,arg8,arg9,arg10,arg11) \
1609 do { \
1610 volatile OrigFn _orig = (orig); \
1611 volatile unsigned long _argvec[12]; \
1612 volatile unsigned long _res; \
1613 _argvec[0] = (unsigned long)_orig.nraddr; \
1614 _argvec[1] = (unsigned long)arg1; \
1615 _argvec[2] = (unsigned long)arg2; \
1616 _argvec[3] = (unsigned long)arg3; \
1617 _argvec[4] = (unsigned long)arg4; \
1618 _argvec[5] = (unsigned long)arg5; \
1619 _argvec[6] = (unsigned long)arg6; \
1620 _argvec[7] = (unsigned long)arg7; \
1621 _argvec[8] = (unsigned long)arg8; \
1622 _argvec[9] = (unsigned long)arg9; \
1623 _argvec[10] = (unsigned long)arg10; \
1624 _argvec[11] = (unsigned long)arg11; \
1625 __asm__ volatile( \
1626 "mr 11,%1\n\t" \
1627 "addi 1,1,-32\n\t" \
1628 /* arg11 */ \
1629 "lwz 3,44(11)\n\t" \
1630 "stw 3,16(1)\n\t" \
1631 /* arg10 */ \
1632 "lwz 3,40(11)\n\t" \
1633 "stw 3,12(1)\n\t" \
1634 /* arg9 */ \
1635 "lwz 3,36(11)\n\t" \
1636 "stw 3,8(1)\n\t" \
1637 /* args1-8 */ \
1638 "lwz 3,4(11)\n\t" /* arg1->r3 */ \
1639 "lwz 4,8(11)\n\t" \
1640 "lwz 5,12(11)\n\t" \
1641 "lwz 6,16(11)\n\t" /* arg4->r6 */ \
1642 "lwz 7,20(11)\n\t" \
1643 "lwz 8,24(11)\n\t" \
1644 "lwz 9,28(11)\n\t" \
1645 "lwz 10,32(11)\n\t" /* arg8->r10 */ \
1646 "lwz 11,0(11)\n\t" /* target->r11 */ \
1647 VALGRIND_BRANCH_AND_LINK_TO_NOREDIR_R11 \
1648 "addi 1,1,32\n\t" \
1649 "mr %0,3" \
1650 : /*out*/ "=r" (_res) \
1651 : /*in*/ "r" (&_argvec[0]) \
1652 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS \
1653 ); \
1654 lval = (__typeof__(lval)) _res; \
1655 } while (0)
1656
1657#define CALL_FN_W_12W(lval, orig, arg1,arg2,arg3,arg4,arg5,arg6, \
1658 arg7,arg8,arg9,arg10,arg11,arg12) \
1659 do { \
1660 volatile OrigFn _orig = (orig); \
1661 volatile unsigned long _argvec[13]; \
1662 volatile unsigned long _res; \
1663 _argvec[0] = (unsigned long)_orig.nraddr; \
1664 _argvec[1] = (unsigned long)arg1; \
1665 _argvec[2] = (unsigned long)arg2; \
1666 _argvec[3] = (unsigned long)arg3; \
1667 _argvec[4] = (unsigned long)arg4; \
1668 _argvec[5] = (unsigned long)arg5; \
1669 _argvec[6] = (unsigned long)arg6; \
1670 _argvec[7] = (unsigned long)arg7; \
1671 _argvec[8] = (unsigned long)arg8; \
1672 _argvec[9] = (unsigned long)arg9; \
1673 _argvec[10] = (unsigned long)arg10; \
1674 _argvec[11] = (unsigned long)arg11; \
1675 _argvec[12] = (unsigned long)arg12; \
1676 __asm__ volatile( \
1677 "mr 11,%1\n\t" \
1678 "addi 1,1,-32\n\t" \
1679 /* arg12 */ \
1680 "lwz 3,48(11)\n\t" \
1681 "stw 3,20(1)\n\t" \
1682 /* arg11 */ \
1683 "lwz 3,44(11)\n\t" \
1684 "stw 3,16(1)\n\t" \
1685 /* arg10 */ \
1686 "lwz 3,40(11)\n\t" \
1687 "stw 3,12(1)\n\t" \
1688 /* arg9 */ \
1689 "lwz 3,36(11)\n\t" \
1690 "stw 3,8(1)\n\t" \
1691 /* args1-8 */ \
1692 "lwz 3,4(11)\n\t" /* arg1->r3 */ \
1693 "lwz 4,8(11)\n\t" \
1694 "lwz 5,12(11)\n\t" \
1695 "lwz 6,16(11)\n\t" /* arg4->r6 */ \
1696 "lwz 7,20(11)\n\t" \
1697 "lwz 8,24(11)\n\t" \
1698 "lwz 9,28(11)\n\t" \
1699 "lwz 10,32(11)\n\t" /* arg8->r10 */ \
1700 "lwz 11,0(11)\n\t" /* target->r11 */ \
1701 VALGRIND_BRANCH_AND_LINK_TO_NOREDIR_R11 \
1702 "addi 1,1,32\n\t" \
1703 "mr %0,3" \
1704 : /*out*/ "=r" (_res) \
1705 : /*in*/ "r" (&_argvec[0]) \
1706 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS \
1707 ); \
1708 lval = (__typeof__(lval)) _res; \
1709 } while (0)
1710
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]1711#endif /* ARCH_ppc32 */
1712
1713/* --------------------------- ppc64 --------------------------- */
1714
sewardj9734b202006-01-17 01:49:37 +0000[diff] [blame]1715#if defined(ARCH_ppc64)
1716
1717/* ARGREGS: r3 r4 r5 r6 r7 r8 r9 r10 (the rest on stack somewhere) */
1718
1719/* These regs are trashed by the hidden call. */
1720#define __CALLER_SAVED_REGS "lr", \
1721 "r0", "r2", "r3", "r4", "r5", "r6", \
1722 "r7", "r8", "r9", "r10", "r11", "r12"
1723
1724/* These CALL_FN_ macros assume that on ppc64-linux, sizeof(unsigned
1725 long) == 8. */
1726
sewardjd68ac3e2006-01-20 14:31:57 +0000[diff] [blame]1727#define CALL_FN_W_v(lval, orig) \
sewardj9734b202006-01-17 01:49:37 +0000[diff] [blame]1728 do { \
sewardjd68ac3e2006-01-20 14:31:57 +0000[diff] [blame]1729 volatile OrigFn _orig = (orig); \
1730 volatile unsigned long _argvec[3+0]; \
sewardj9734b202006-01-17 01:49:37 +0000[diff] [blame]1731 volatile unsigned long _res; \
sewardjd68ac3e2006-01-20 14:31:57 +0000[diff] [blame]1732 /* _argvec[0] holds current r2 across the call */ \
1733 _argvec[1] = (unsigned long)_orig.r2; \
1734 _argvec[2] = (unsigned long)_orig.nraddr; \
sewardj9734b202006-01-17 01:49:37 +0000[diff] [blame]1735 __asm__ volatile( \
1736 "mr 11,%1\n\t" \
sewardjd68ac3e2006-01-20 14:31:57 +0000[diff] [blame]1737 "std 2,-16(11)\n\t" /* save tocptr */ \
1738 "ld 2,-8(11)\n\t" /* use nraddr's tocptr */ \
1739 "ld 11, 0(11)\n\t" /* target->r11 */ \
sewardj9734b202006-01-17 01:49:37 +0000[diff] [blame]1740 VALGRIND_BRANCH_AND_LINK_TO_NOREDIR_R11 \
1741 "mr 11,%1\n\t" \
1742 "mr %0,3\n\t" \
sewardjd68ac3e2006-01-20 14:31:57 +0000[diff] [blame]1743 "ld 2,-16(11)" /* restore tocptr */ \
sewardj9734b202006-01-17 01:49:37 +0000[diff] [blame]1744 : /*out*/ "=r" (_res) \
sewardjd68ac3e2006-01-20 14:31:57 +0000[diff] [blame]1745 : /*in*/ "r" (&_argvec[2]) \
sewardj9734b202006-01-17 01:49:37 +0000[diff] [blame]1746 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS \
1747 ); \
1748 lval = (__typeof__(lval)) _res; \
1749 } while (0)
1750
sewardjd68ac3e2006-01-20 14:31:57 +0000[diff] [blame]1751#define CALL_FN_W_W(lval, orig, arg1) \
sewardj9734b202006-01-17 01:49:37 +0000[diff] [blame]1752 do { \
sewardjd68ac3e2006-01-20 14:31:57 +0000[diff] [blame]1753 volatile OrigFn _orig = (orig); \
1754 volatile unsigned long _argvec[3+1]; \
sewardj9734b202006-01-17 01:49:37 +0000[diff] [blame]1755 volatile unsigned long _res; \
sewardjd68ac3e2006-01-20 14:31:57 +0000[diff] [blame]1756 /* _argvec[0] holds current r2 across the call */ \
1757 _argvec[1] = (unsigned long)_orig.r2; \
1758 _argvec[2] = (unsigned long)_orig.nraddr; \
1759 _argvec[2+1] = (unsigned long)arg1; \
sewardj9734b202006-01-17 01:49:37 +0000[diff] [blame]1760 __asm__ volatile( \
1761 "mr 11,%1\n\t" \
sewardjd68ac3e2006-01-20 14:31:57 +0000[diff] [blame]1762 "std 2,-16(11)\n\t" /* save tocptr */ \
1763 "ld 2,-8(11)\n\t" /* use nraddr's tocptr */ \
1764 "ld 3, 8(11)\n\t" /* arg1->r3 */ \
1765 "ld 11, 0(11)\n\t" /* target->r11 */ \
sewardj9734b202006-01-17 01:49:37 +0000[diff] [blame]1766 VALGRIND_BRANCH_AND_LINK_TO_NOREDIR_R11 \
1767 "mr 11,%1\n\t" \
1768 "mr %0,3\n\t" \
sewardjd68ac3e2006-01-20 14:31:57 +0000[diff] [blame]1769 "ld 2,-16(11)" /* restore tocptr */ \
sewardj9734b202006-01-17 01:49:37 +0000[diff] [blame]1770 : /*out*/ "=r" (_res) \
sewardjd68ac3e2006-01-20 14:31:57 +0000[diff] [blame]1771 : /*in*/ "r" (&_argvec[2]) \
sewardj9734b202006-01-17 01:49:37 +0000[diff] [blame]1772 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS \
1773 ); \
1774 lval = (__typeof__(lval)) _res; \
1775 } while (0)
1776
sewardjd68ac3e2006-01-20 14:31:57 +0000[diff] [blame]1777#define CALL_FN_W_WW(lval, orig, arg1,arg2) \
sewardj9734b202006-01-17 01:49:37 +0000[diff] [blame]1778 do { \
sewardjd68ac3e2006-01-20 14:31:57 +0000[diff] [blame]1779 volatile OrigFn _orig = (orig); \
1780 volatile unsigned long _argvec[3+2]; \
sewardj9734b202006-01-17 01:49:37 +0000[diff] [blame]1781 volatile unsigned long _res; \
sewardjd68ac3e2006-01-20 14:31:57 +0000[diff] [blame]1782 /* _argvec[0] holds current r2 across the call */ \
1783 _argvec[1] = (unsigned long)_orig.r2; \
1784 _argvec[2] = (unsigned long)_orig.nraddr; \
1785 _argvec[2+1] = (unsigned long)arg1; \
1786 _argvec[2+2] = (unsigned long)arg2; \
sewardj9734b202006-01-17 01:49:37 +0000[diff] [blame]1787 __asm__ volatile( \
1788 "mr 11,%1\n\t" \
sewardjd68ac3e2006-01-20 14:31:57 +0000[diff] [blame]1789 "std 2,-16(11)\n\t" /* save tocptr */ \
1790 "ld 2,-8(11)\n\t" /* use nraddr's tocptr */ \
1791 "ld 3, 8(11)\n\t" /* arg1->r3 */ \
1792 "ld 4, 16(11)\n\t" /* arg1->r4 */ \
1793 "ld 11, 0(11)\n\t" /* target->r11 */ \
sewardj9734b202006-01-17 01:49:37 +0000[diff] [blame]1794 VALGRIND_BRANCH_AND_LINK_TO_NOREDIR_R11 \
1795 "mr 11,%1\n\t" \
1796 "mr %0,3\n\t" \
sewardjd68ac3e2006-01-20 14:31:57 +0000[diff] [blame]1797 "ld 2,-16(11)" /* restore tocptr */ \
sewardj9734b202006-01-17 01:49:37 +0000[diff] [blame]1798 : /*out*/ "=r" (_res) \
sewardjd68ac3e2006-01-20 14:31:57 +0000[diff] [blame]1799 : /*in*/ "r" (&_argvec[2]) \
sewardj9734b202006-01-17 01:49:37 +0000[diff] [blame]1800 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS \
1801 ); \
1802 lval = (__typeof__(lval)) _res; \
1803 } while (0)
1804
1805#endif /* ARCH_ppc64 */
1806
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]1807
1808/* ------------------------------------------------------------------ */
1809/* ARCHITECTURE INDEPENDENT MACROS for CLIENT REQUESTS. */
1810/* */
njn30d76c62005-06-18 15:07:39 +0000[diff] [blame]1811/* ------------------------------------------------------------------ */
1812
sewardj2e93c502002-04-12 11:12:52 +0000[diff] [blame]1813/* Some request codes. There are many more of these, but most are not
1814 exposed to end-user view. These are the public ones, all of the
njn25e49d8e72002-09-23 09:36:25 +0000[diff] [blame]1815 form 0x1000 + small_number.
njnd7994182003-10-02 13:44:04 +0000[diff] [blame]1816
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]1817 Core ones are in the range 0x00000000--0x0000ffff. The non-public
1818 ones start at 0x2000.
sewardj2e93c502002-04-12 11:12:52 +0000[diff] [blame]1819*/
1820
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]1821/* These macros are used by tools -- they must be public, but don't
1822 embed them into other programs. */
njnfc26ff92004-11-22 19:12:49 +0000[diff] [blame]1823#define VG_USERREQ_TOOL_BASE(a,b) \
njn4c791212003-05-02 17:53:54 +0000[diff] [blame]1824 ((unsigned int)(((a)&0xff) << 24 | ((b)&0xff) << 16))
njnfc26ff92004-11-22 19:12:49 +0000[diff] [blame]1825#define VG_IS_TOOL_USERREQ(a, b, v) \
1826 (VG_USERREQ_TOOL_BASE(a,b) == ((v) & 0xffff0000))
sewardj34042512002-10-22 04:14:35 +0000[diff] [blame]1827
sewardj5ce4b152006-03-11 12:57:41 +0000[diff] [blame]1828/* !! ABIWARNING !! ABIWARNING !! ABIWARNING !! ABIWARNING !!
1829 This enum comprises an ABI exported by Valgrind to programs
1830 which use client requests. DO NOT CHANGE THE ORDER OF THESE
1831 ENTRIES, NOR DELETE ANY -- add new ones at the end. */
njn25e49d8e72002-09-23 09:36:25 +0000[diff] [blame]1832typedef
njn4c791212003-05-02 17:53:54 +0000[diff] [blame]1833 enum { VG_USERREQ__RUNNING_ON_VALGRIND = 0x1001,
1834 VG_USERREQ__DISCARD_TRANSLATIONS = 0x1002,
njn3e884182003-04-15 13:03:23 +0000[diff] [blame]1835
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]1836 /* These allow any function to be called from the simulated
1837 CPU but run on the real CPU. Nb: the first arg passed to
1838 the function is always the ThreadId of the running
1839 thread! So CLIENT_CALL0 actually requires a 1 arg
njnd4795be2004-11-24 11:57:51 +0000[diff] [blame]1840 function, etc. */
njn4c791212003-05-02 17:53:54 +0000[diff] [blame]1841 VG_USERREQ__CLIENT_CALL0 = 0x1101,
1842 VG_USERREQ__CLIENT_CALL1 = 0x1102,
1843 VG_USERREQ__CLIENT_CALL2 = 0x1103,
1844 VG_USERREQ__CLIENT_CALL3 = 0x1104,
njn3e884182003-04-15 13:03:23 +0000[diff] [blame]1845
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]1846 /* Can be useful in regression testing suites -- eg. can
1847 send Valgrind's output to /dev/null and still count
1848 errors. */
njn4c791212003-05-02 17:53:54 +0000[diff] [blame]1849 VG_USERREQ__COUNT_ERRORS = 0x1201,
njn47363ab2003-04-21 13:24:40 +0000[diff] [blame]1850
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]1851 /* These are useful and can be interpreted by any tool that
1852 tracks malloc() et al, by using vg_replace_malloc.c. */
njnd7994182003-10-02 13:44:04 +0000[diff] [blame]1853 VG_USERREQ__MALLOCLIKE_BLOCK = 0x1301,
1854 VG_USERREQ__FREELIKE_BLOCK = 0x1302,
rjwalshbc0bb832004-06-19 18:12:36 +0000[diff] [blame]1855 /* Memory pool support. */
1856 VG_USERREQ__CREATE_MEMPOOL = 0x1303,
1857 VG_USERREQ__DESTROY_MEMPOOL = 0x1304,
1858 VG_USERREQ__MEMPOOL_ALLOC = 0x1305,
1859 VG_USERREQ__MEMPOOL_FREE = 0x1306,
njnd7994182003-10-02 13:44:04 +0000[diff] [blame]1860
fitzhardinge39de4b42003-10-31 07:12:21 +0000[diff] [blame]1861 /* Allow printfs to valgrind log. */
njn30d76c62005-06-18 15:07:39 +0000[diff] [blame]1862 VG_USERREQ__PRINTF = 0x1401,
rjwalsh0140af52005-06-04 20:42:33 +0000[diff] [blame]1863 VG_USERREQ__PRINTF_BACKTRACE = 0x1402,
1864
1865 /* Stack support. */
1866 VG_USERREQ__STACK_REGISTER = 0x1501,
1867 VG_USERREQ__STACK_DEREGISTER = 0x1502,
1868 VG_USERREQ__STACK_CHANGE = 0x1503,
njn25e49d8e72002-09-23 09:36:25 +0000[diff] [blame]1869 } Vg_ClientRequest;
sewardj2e93c502002-04-12 11:12:52 +0000[diff] [blame]1870
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]1871#if !defined(__GNUC__)
1872# define __extension__ /* */
muellerc9b36552003-12-31 14:32:23 +0000[diff] [blame]1873#endif
sewardj2e93c502002-04-12 11:12:52 +0000[diff] [blame]1874
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]1875/* Returns the number of Valgrinds this code is running under. That
1876 is, 0 if running natively, 1 if running under Valgrind, 2 if
1877 running under Valgrind which is running under another Valgrind,
1878 etc. */
1879#define RUNNING_ON_VALGRIND __extension__ \
1880 ({unsigned int _qzz_res; \
1881 VALGRIND_DO_CLIENT_REQUEST(_qzz_res, 0 /* if not */, \
1882 VG_USERREQ__RUNNING_ON_VALGRIND, \
sewardj9af10a12006-02-01 14:59:42 +0000[diff] [blame]1883 0, 0, 0, 0, 0); \
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]1884 _qzz_res; \
sewardjde4a1d02002-03-22 01:27:54 +0000[diff] [blame]1885 })
1886
1887
sewardj18d75132002-05-16 11:06:21 +0000[diff] [blame]1888/* Discard translation of code in the range [_qzz_addr .. _qzz_addr +
1889 _qzz_len - 1]. Useful if you are debugging a JITter or some such,
1890 since it provides a way to make sure valgrind will retranslate the
1891 invalidated area. Returns no value. */
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]1892#define VALGRIND_DISCARD_TRANSLATIONS(_qzz_addr,_qzz_len) \
1893 {unsigned int _qzz_res; \
1894 VALGRIND_DO_CLIENT_REQUEST(_qzz_res, 0, \
1895 VG_USERREQ__DISCARD_TRANSLATIONS, \
sewardj9af10a12006-02-01 14:59:42 +0000[diff] [blame]1896 _qzz_addr, _qzz_len, 0, 0, 0); \
sewardj18d75132002-05-16 11:06:21 +0000[diff] [blame]1897 }
1898
njn26aba4d2005-05-16 13:31:23 +0000[diff] [blame]1899
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]1900/* These requests are for getting Valgrind itself to print something.
1901 Possibly with a backtrace. This is a really ugly hack. */
1902
1903#if defined(NVALGRIND)
1904
1905# define VALGRIND_PRINTF(...)
1906# define VALGRIND_PRINTF_BACKTRACE(...)
njn26aba4d2005-05-16 13:31:23 +0000[diff] [blame]1907
1908#else /* NVALGRIND */
fitzhardinge39de4b42003-10-31 07:12:21 +0000[diff] [blame]1909
fitzhardingea09a1b52003-11-07 23:09:48 +0000[diff] [blame]1910int VALGRIND_PRINTF(const char *format, ...)
1911 __attribute__((format(__printf__, 1, 2)));
fitzhardinge39de4b42003-10-31 07:12:21 +0000[diff] [blame]1912__attribute__((weak))
1913int
fitzhardingea09a1b52003-11-07 23:09:48 +0000[diff] [blame]1914VALGRIND_PRINTF(const char *format, ...)
fitzhardinge39de4b42003-10-31 07:12:21 +0000[diff] [blame]1915{
njnc6168192004-11-29 13:54:10 +0000[diff] [blame]1916 unsigned long _qzz_res;
fitzhardinge39de4b42003-10-31 07:12:21 +0000[diff] [blame]1917 va_list vargs;
1918 va_start(vargs, format);
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]1919 VALGRIND_DO_CLIENT_REQUEST(_qzz_res, 0, VG_USERREQ__PRINTF,
sewardj9af10a12006-02-01 14:59:42 +0000[diff] [blame]1920 (unsigned long)format, (unsigned long)vargs,
1921 0, 0, 0);
fitzhardinge39de4b42003-10-31 07:12:21 +0000[diff] [blame]1922 va_end(vargs);
njnc6168192004-11-29 13:54:10 +0000[diff] [blame]1923 return (int)_qzz_res;
fitzhardinge39de4b42003-10-31 07:12:21 +0000[diff] [blame]1924}
1925
fitzhardingea09a1b52003-11-07 23:09:48 +0000[diff] [blame]1926int VALGRIND_PRINTF_BACKTRACE(const char *format, ...)
1927 __attribute__((format(__printf__, 1, 2)));
fitzhardinge39de4b42003-10-31 07:12:21 +0000[diff] [blame]1928__attribute__((weak))
1929int
fitzhardingea09a1b52003-11-07 23:09:48 +0000[diff] [blame]1930VALGRIND_PRINTF_BACKTRACE(const char *format, ...)
fitzhardinge39de4b42003-10-31 07:12:21 +0000[diff] [blame]1931{
njnc6168192004-11-29 13:54:10 +0000[diff] [blame]1932 unsigned long _qzz_res;
fitzhardinge39de4b42003-10-31 07:12:21 +0000[diff] [blame]1933 va_list vargs;
1934 va_start(vargs, format);
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]1935 VALGRIND_DO_CLIENT_REQUEST(_qzz_res, 0, VG_USERREQ__PRINTF_BACKTRACE,
sewardj9af10a12006-02-01 14:59:42 +0000[diff] [blame]1936 (unsigned long)format, (unsigned long)vargs,
1937 0, 0, 0);
fitzhardinge39de4b42003-10-31 07:12:21 +0000[diff] [blame]1938 va_end(vargs);
njnc6168192004-11-29 13:54:10 +0000[diff] [blame]1939 return (int)_qzz_res;
fitzhardinge39de4b42003-10-31 07:12:21 +0000[diff] [blame]1940}
1941
fitzhardinge39de4b42003-10-31 07:12:21 +0000[diff] [blame]1942#endif /* NVALGRIND */
sewardj18d75132002-05-16 11:06:21 +0000[diff] [blame]1943
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]1944
njn3e884182003-04-15 13:03:23 +0000[diff] [blame]1945/* These requests allow control to move from the simulated CPU to the
1946 real CPU, calling an arbitary function */
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]1947#define VALGRIND_NON_SIMD_CALL0(_qyy_fn) \
1948 ({unsigned long _qyy_res; \
1949 VALGRIND_DO_CLIENT_REQUEST(_qyy_res, 0 /* default return */, \
1950 VG_USERREQ__CLIENT_CALL0, \
1951 _qyy_fn, \
sewardj9af10a12006-02-01 14:59:42 +0000[diff] [blame]1952 0, 0, 0, 0); \
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]1953 _qyy_res; \
njn3e884182003-04-15 13:03:23 +0000[diff] [blame]1954 })
1955
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]1956#define VALGRIND_NON_SIMD_CALL1(_qyy_fn, _qyy_arg1) \
1957 ({unsigned long _qyy_res; \
1958 VALGRIND_DO_CLIENT_REQUEST(_qyy_res, 0 /* default return */, \
1959 VG_USERREQ__CLIENT_CALL1, \
1960 _qyy_fn, \
sewardj9af10a12006-02-01 14:59:42 +0000[diff] [blame]1961 _qyy_arg1, 0, 0, 0); \
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]1962 _qyy_res; \
njn3e884182003-04-15 13:03:23 +0000[diff] [blame]1963 })
1964
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]1965#define VALGRIND_NON_SIMD_CALL2(_qyy_fn, _qyy_arg1, _qyy_arg2) \
1966 ({unsigned long _qyy_res; \
1967 VALGRIND_DO_CLIENT_REQUEST(_qyy_res, 0 /* default return */, \
1968 VG_USERREQ__CLIENT_CALL2, \
1969 _qyy_fn, \
sewardj9af10a12006-02-01 14:59:42 +0000[diff] [blame]1970 _qyy_arg1, _qyy_arg2, 0, 0); \
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]1971 _qyy_res; \
njn3e884182003-04-15 13:03:23 +0000[diff] [blame]1972 })
1973
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]1974#define VALGRIND_NON_SIMD_CALL3(_qyy_fn, _qyy_arg1, _qyy_arg2, _qyy_arg3) \
1975 ({unsigned long _qyy_res; \
1976 VALGRIND_DO_CLIENT_REQUEST(_qyy_res, 0 /* default return */, \
1977 VG_USERREQ__CLIENT_CALL3, \
1978 _qyy_fn, \
sewardj9af10a12006-02-01 14:59:42 +0000[diff] [blame]1979 _qyy_arg1, _qyy_arg2, \
1980 _qyy_arg3, 0); \
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]1981 _qyy_res; \
njn3e884182003-04-15 13:03:23 +0000[diff] [blame]1982 })
1983
1984
nethercote7cc9c232004-01-21 15:08:04 +0000[diff] [blame]1985/* Counts the number of errors that have been recorded by a tool. Nb:
1986 the tool must record the errors with VG_(maybe_record_error)() or
njn47363ab2003-04-21 13:24:40 +0000[diff] [blame]1987 VG_(unique_error)() for them to be counted. */
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]1988#define VALGRIND_COUNT_ERRORS \
1989 ({unsigned int _qyy_res; \
1990 VALGRIND_DO_CLIENT_REQUEST(_qyy_res, 0 /* default return */, \
1991 VG_USERREQ__COUNT_ERRORS, \
sewardj9af10a12006-02-01 14:59:42 +0000[diff] [blame]1992 0, 0, 0, 0, 0); \
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]1993 _qyy_res; \
njn47363ab2003-04-21 13:24:40 +0000[diff] [blame]1994 })
1995
njnd7994182003-10-02 13:44:04 +0000[diff] [blame]1996/* Mark a block of memory as having been allocated by a malloc()-like
1997 function. `addr' is the start of the usable block (ie. after any
1998 redzone) `rzB' is redzone size if the allocator can apply redzones;
1999 use '0' if not. Adding redzones makes it more likely Valgrind will spot
2000 block overruns. `is_zeroed' indicates if the memory is zeroed, as it is
2001 for calloc(). Put it immediately after the point where a block is
2002 allocated.
2003
2004 If you're allocating memory via superblocks, and then handing out small
2005 chunks of each superblock, if you don't have redzones on your small
2006 blocks, it's worth marking the superblock with VALGRIND_MAKE_NOACCESS
2007 when it's created, so that block overruns are detected. But if you can
2008 put redzones on, it's probably better to not do this, so that messages
2009 for small overruns are described in terms of the small block rather than
2010 the superblock (but if you have a big overrun that skips over a redzone,
2011 you could miss an error this way). See memcheck/tests/custom_alloc.c
2012 for an example.
2013
2014 Nb: block must be freed via a free()-like function specified
2015 with VALGRIND_FREELIKE_BLOCK or mismatch errors will occur. */
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]2016#define VALGRIND_MALLOCLIKE_BLOCK(addr, sizeB, rzB, is_zeroed) \
2017 {unsigned int _qzz_res; \
2018 VALGRIND_DO_CLIENT_REQUEST(_qzz_res, 0, \
2019 VG_USERREQ__MALLOCLIKE_BLOCK, \
sewardj9af10a12006-02-01 14:59:42 +0000[diff] [blame]2020 addr, sizeB, rzB, is_zeroed, 0); \
njnd7994182003-10-02 13:44:04 +0000[diff] [blame]2021 }
2022
2023/* Mark a block of memory as having been freed by a free()-like function.
2024 `rzB' is redzone size; it must match that given to
2025 VALGRIND_MALLOCLIKE_BLOCK. Memory not freed will be detected by the leak
2026 checker. Put it immediately after the point where the block is freed. */
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]2027#define VALGRIND_FREELIKE_BLOCK(addr, rzB) \
2028 {unsigned int _qzz_res; \
2029 VALGRIND_DO_CLIENT_REQUEST(_qzz_res, 0, \
2030 VG_USERREQ__FREELIKE_BLOCK, \
sewardj9af10a12006-02-01 14:59:42 +0000[diff] [blame]2031 addr, rzB, 0, 0, 0); \
njnd7994182003-10-02 13:44:04 +0000[diff] [blame]2032 }
2033
rjwalshbc0bb832004-06-19 18:12:36 +0000[diff] [blame]2034/* Create a memory pool. */
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]2035#define VALGRIND_CREATE_MEMPOOL(pool, rzB, is_zeroed) \
2036 {unsigned int _qzz_res; \
2037 VALGRIND_DO_CLIENT_REQUEST(_qzz_res, 0, \
2038 VG_USERREQ__CREATE_MEMPOOL, \
sewardj9af10a12006-02-01 14:59:42 +0000[diff] [blame]2039 pool, rzB, is_zeroed, 0, 0); \
rjwalshbc0bb832004-06-19 18:12:36 +0000[diff] [blame]2040 }
2041
2042/* Destroy a memory pool. */
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]2043#define VALGRIND_DESTROY_MEMPOOL(pool) \
2044 {unsigned int _qzz_res; \
2045 VALGRIND_DO_CLIENT_REQUEST(_qzz_res, 0, \
2046 VG_USERREQ__DESTROY_MEMPOOL, \
sewardj9af10a12006-02-01 14:59:42 +0000[diff] [blame]2047 pool, 0, 0, 0, 0); \
rjwalshbc0bb832004-06-19 18:12:36 +0000[diff] [blame]2048 }
2049
2050/* Associate a piece of memory with a memory pool. */
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]2051#define VALGRIND_MEMPOOL_ALLOC(pool, addr, size) \
2052 {unsigned int _qzz_res; \
2053 VALGRIND_DO_CLIENT_REQUEST(_qzz_res, 0, \
2054 VG_USERREQ__MEMPOOL_ALLOC, \
sewardj9af10a12006-02-01 14:59:42 +0000[diff] [blame]2055 pool, addr, size, 0, 0); \
rjwalshbc0bb832004-06-19 18:12:36 +0000[diff] [blame]2056 }
2057
2058/* Disassociate a piece of memory from a memory pool. */
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]2059#define VALGRIND_MEMPOOL_FREE(pool, addr) \
2060 {unsigned int _qzz_res; \
2061 VALGRIND_DO_CLIENT_REQUEST(_qzz_res, 0, \
2062 VG_USERREQ__MEMPOOL_FREE, \
sewardj9af10a12006-02-01 14:59:42 +0000[diff] [blame]2063 pool, addr, 0, 0, 0); \
rjwalshbc0bb832004-06-19 18:12:36 +0000[diff] [blame]2064 }
2065
rjwalsh0140af52005-06-04 20:42:33 +0000[diff] [blame]2066/* Mark a piece of memory as being a stack. Returns a stack id. */
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]2067#define VALGRIND_STACK_REGISTER(start, end) \
2068 ({unsigned int _qzz_res; \
2069 VALGRIND_DO_CLIENT_REQUEST(_qzz_res, 0, \
2070 VG_USERREQ__STACK_REGISTER, \
sewardj9af10a12006-02-01 14:59:42 +0000[diff] [blame]2071 start, end, 0, 0, 0); \
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]2072 _qzz_res; \
rjwalsh0140af52005-06-04 20:42:33 +0000[diff] [blame]2073 })
2074
2075/* Unmark the piece of memory associated with a stack id as being a
2076 stack. */
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]2077#define VALGRIND_STACK_DEREGISTER(id) \
2078 {unsigned int _qzz_res; \
2079 VALGRIND_DO_CLIENT_REQUEST(_qzz_res, 0, \
2080 VG_USERREQ__STACK_DEREGISTER, \
sewardj9af10a12006-02-01 14:59:42 +0000[diff] [blame]2081 id, 0, 0, 0, 0); \
rjwalsh0140af52005-06-04 20:42:33 +0000[diff] [blame]2082 }
2083
2084/* Change the start and end address of the stack id. */
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]2085#define VALGRIND_STACK_CHANGE(id, start, end) \
2086 {unsigned int _qzz_res; \
2087 VALGRIND_DO_CLIENT_REQUEST(_qzz_res, 0, \
2088 VG_USERREQ__STACK_CHANGE, \
sewardj9af10a12006-02-01 14:59:42 +0000[diff] [blame]2089 id, start, end, 0, 0); \
rjwalsh0140af52005-06-04 20:42:33 +0000[diff] [blame]2090 }
2091
sewardj0ec07f32006-01-12 12:32:32 +0000[diff] [blame]2092
2093#undef ARCH_x86
2094#undef ARCH_amd64
2095#undef ARCH_ppc32
2096#undef ARCH_ppc64
2097
njn3e884182003-04-15 13:03:23 +0000[diff] [blame]2098#endif /* __VALGRIND_H */