| The Gaudi Framework v28r2p1 (f1a77ff4)

- Main Page
- Related Pages
- Modules
- Namespaces
- Classes
- Files

- File List
- File Members

local_valgrind.h
Go to the documentation of this file.
1 /* -*- c -*-
2 ----------------------------------------------------------------
3
4 Notice that the following BSD-style license applies to this one
5 file (valgrind.h) only. The rest of Valgrind is licensed under the
6 terms of the GNU General Public License, version 2, unless
7 otherwise indicated. See the COPYING file in the source
8 distribution for details.
9
10 ----------------------------------------------------------------
11
12 This file is part of Valgrind, a dynamic binary instrumentation
13 framework.
14
15 Copyright (C) 2000-2013 Julian Seward. All rights reserved.
16
17 Redistribution and use in source and binary forms, with or without
18 modification, are permitted provided that the following conditions
19 are met:
20
21 1. Redistributions of source code must retain the above copyright
22 notice, this list of conditions and the following disclaimer.
23
24 2. The origin of this software must not be misrepresented; you must
25 not claim that you wrote the original software. If you use this
26 software in a product, an acknowledgment in the product
27 documentation would be appreciated but is not required.
28
29 3. Altered source versions must be plainly marked as such, and must
30 not be misrepresented as being the original software.
31
32 4. The name of the author may not be used to endorse or promote
33 products derived from this software without specific prior written
34 permission.
35
36 THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
37 OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
38 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
39 ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
40 DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
41 DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
42 GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
43 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
44 WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
45 NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
46 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
47
48 ----------------------------------------------------------------
49
50 Notice that the above BSD-style license applies to this one file
51 (valgrind.h) only. The entire rest of Valgrind is licensed under
52 the terms of the GNU General Public License, version 2. See the
53 COPYING file in the source distribution for details.
54
55 ----------------------------------------------------------------
56 */
57
58
59 /* This file is for inclusion into client (your!) code.
60
61 You can use these macros to manipulate and query Valgrind's
62 execution inside your own programs.
63
64 The resulting executables will still run without Valgrind, just a
65 little bit more slowly than they otherwise would, but otherwise
66 unchanged. When not running on valgrind, each client request
67 consumes very few (eg. 7) instructions, so the resulting performance
68 loss is negligible unless you plan to execute client requests
69 millions of times per second. Nevertheless, if that is still a
70 problem, you can compile with the NVALGRIND symbol defined (gcc
71 -DNVALGRIND) so that client requests are not even compiled in. */
72
73 #ifndef __VALGRIND_H
74 #define __VALGRIND_H
75
76
77 /* ------------------------------------------------------------------ */
78 /* VERSION NUMBER OF VALGRIND */
79 /* ------------------------------------------------------------------ */
80
81 /* Specify Valgrind's version number, so that user code can
82 conditionally compile based on our version number. Note that these
83 were introduced at version 3.6 and so do not exist in version 3.5
84 or earlier. The recommended way to use them to check for "version
85 X.Y or later" is (eg)
86
87 #if defined(__VALGRIND_MAJOR__) && defined(__VALGRIND_MINOR__) \
88 && (__VALGRIND_MAJOR__ > 3 \
89 || (__VALGRIND_MAJOR__ == 3 && __VALGRIND_MINOR__ >= 6))
90 */
91 #define __VALGRIND_MAJOR__ 3
92 #define __VALGRIND_MINOR__ 8
93
94
95 #include <stdarg.h>
96
97 /* Nb: this file might be included in a file compiled with -ansi. So
98 we can't use C++ style "//" comments nor the "asm" keyword (instead
99 use "__asm__"). */
100
101 /* Derive some tags indicating what the target platform is. Note
102 that in this file we're using the compiler's CPP symbols for
103 identifying architectures, which are different to the ones we use
104 within the rest of Valgrind. Note, __powerpc__ is active for both
105 32 and 64-bit PPC, whereas __powerpc64__ is only active for the
106 latter (on Linux, that is).
107
108 Misc note: how to find out what's predefined in gcc by default:
109 gcc -Wp,-dM somefile.c
110 */
111 #undef PLAT_x86_darwin
112 #undef PLAT_amd64_darwin
113 #undef PLAT_x86_win32
114 #undef PLAT_amd64_win64
115 #undef PLAT_x86_linux
116 #undef PLAT_amd64_linux
117 #undef PLAT_ppc32_linux
118 #undef PLAT_ppc64_linux
119 #undef PLAT_arm_linux
120 #undef PLAT_s390x_linux
121 #undef PLAT_mips32_linux
122 #undef PLAT_mips64_linux
123
124
125 #if defined(__APPLE__) && defined(__i386__)
126 # define PLAT_x86_darwin 1
127 #elif defined(__APPLE__) && defined(__x86_64__)
128 # define PLAT_amd64_darwin 1
129 #elif defined(__MINGW32__) || defined(__CYGWIN32__) \
130 || (defined(_WIN32) && defined(_M_IX86))
131 # define PLAT_x86_win32 1
132 #elif defined(__MINGW64__) || (defined(_WIN64) && defined(_M_X64))
133 # define PLAT_amd64_win64 1
134 #elif defined(__linux__) && defined(__i386__)
135 # define PLAT_x86_linux 1
136 #elif defined(__linux__) && defined(__x86_64__)
137 # define PLAT_amd64_linux 1
138 #elif defined(__linux__) && defined(__powerpc__) && !defined(__powerpc64__)
139 # define PLAT_ppc32_linux 1
140 #elif defined(__linux__) && defined(__powerpc__) && defined(__powerpc64__)
141 # define PLAT_ppc64_linux 1
142 #elif defined(__linux__) && defined(__arm__)
143 # define PLAT_arm_linux 1
144 #elif defined(__linux__) && defined(__s390__) && defined(__s390x__)
145 # define PLAT_s390x_linux 1
146 #elif defined(__linux__) && defined(__mips__)
147 #if (__mips==64)
148 # define PLAT_mips64_linux 1
149 #else
150 # define PLAT_mips32_linux 1
151 #endif
152 #else
153 /* If we're not compiling for our target platform, don't generate
154 any inline asms. */
155 # if !defined(NVALGRIND)
156 # define NVALGRIND 1
157 # endif
158 #endif
159
160
161 /* ------------------------------------------------------------------ */
162 /* ARCHITECTURE SPECIFICS for SPECIAL INSTRUCTIONS. There is nothing */
163 /* in here of use to end-users -- skip to the next section. */
164 /* ------------------------------------------------------------------ */
165
166 /*
167 * VALGRIND_DO_CLIENT_REQUEST(): a statement that invokes a Valgrind client
168 * request. Accepts both pointers and integers as arguments.
169 *
170 * VALGRIND_DO_CLIENT_REQUEST_STMT(): a statement that invokes a Valgrind
171 * client request that does not return a value.
172
173 * VALGRIND_DO_CLIENT_REQUEST_EXPR(): a C expression that invokes a Valgrind
174 * client request and whose value equals the client request result. Accepts
175 * both pointers and integers as arguments. Note that such calls are not
176 * necessarily pure functions -- they may have side effects.
177 */
178
179 #define VALGRIND_DO_CLIENT_REQUEST(_zzq_rlval, _zzq_default, \
180 _zzq_request, _zzq_arg1, _zzq_arg2, \
181 _zzq_arg3, _zzq_arg4, _zzq_arg5) \
182 do { (_zzq_rlval) = VALGRIND_DO_CLIENT_REQUEST_EXPR((_zzq_default), \
183 (_zzq_request), (_zzq_arg1), (_zzq_arg2), \
184 (_zzq_arg3), (_zzq_arg4), (_zzq_arg5)); } while (0)
185
186 #define VALGRIND_DO_CLIENT_REQUEST_STMT(_zzq_request, _zzq_arg1, \
187 _zzq_arg2, _zzq_arg3, _zzq_arg4, _zzq_arg5) \
188 do { (void) VALGRIND_DO_CLIENT_REQUEST_EXPR(0, \
189 (_zzq_request), (_zzq_arg1), (_zzq_arg2), \
190 (_zzq_arg3), (_zzq_arg4), (_zzq_arg5)); } while (0)
191
192 #if defined(NVALGRIND)
193
194 /* Define NVALGRIND to completely remove the Valgrind magic sequence
195 from the compiled code (analogous to NDEBUG's effects on
196 assert()) */
197 #define VALGRIND_DO_CLIENT_REQUEST_EXPR( \
198 _zzq_default, _zzq_request, \
199 _zzq_arg1, _zzq_arg2, _zzq_arg3, _zzq_arg4, _zzq_arg5) \
200 (_zzq_default)
201
202 #else /* ! NVALGRIND */
203
204 /* The following defines the magic code sequences which the JITter
205 spots and handles magically. Don't look too closely at them as
206 they will rot your brain.
207
208 The assembly code sequences for all architectures is in this one
209 file. This is because this file must be stand-alone, and we don't
210 want to have multiple files.
211
212 For VALGRIND_DO_CLIENT_REQUEST, we must ensure that the default
213 value gets put in the return slot, so that everything works when
214 this is executed not under Valgrind. Args are passed in a memory
215 block, and so there's no intrinsic limit to the number that could
216 be passed, but it's currently five.
217
218 The macro args are:
219 _zzq_rlval result lvalue
220 _zzq_default default value (result returned when running on real CPU)
221 _zzq_request request code
222 _zzq_arg1..5 request params
223
224 The other two macros are used to support function wrapping, and are
225 a lot simpler. VALGRIND_GET_NR_CONTEXT returns the value of the
226 guest's NRADDR pseudo-register and whatever other information is
227 needed to safely run the call original from the wrapper: on
228 ppc64-linux, the R2 value at the divert point is also needed. This
229 information is abstracted into a user-visible type, OrigFn.
230
231 VALGRIND_CALL_NOREDIR_* behaves the same as the following on the
232 guest, but guarantees that the branch instruction will not be
233 redirected: x86: call *%eax, amd64: call *%rax, ppc32/ppc64:
234 branch-and-link-to-r11. VALGRIND_CALL_NOREDIR is just text, not a
235 complete inline asm, since it needs to be combined with more magic
236 inline asm stuff to be useful.
237 */
238
239 /* ------------------------- x86-{linux,darwin} ---------------- */
240
241 #if defined(PLAT_x86_linux) || defined(PLAT_x86_darwin) \
242 || (defined(PLAT_x86_win32) && defined(__GNUC__))
243
244 typedef
245 struct {
246 unsigned int nraddr; /* where's the code? */
247 }
248 OrigFn;
249
250 #define __SPECIAL_INSTRUCTION_PREAMBLE \
251 "roll $3, %%edi ; roll $13, %%edi\n\t" \
252 "roll $29, %%edi ; roll $19, %%edi\n\t"
253
254 #define VALGRIND_DO_CLIENT_REQUEST_EXPR( \
255 _zzq_default, _zzq_request, \
256 _zzq_arg1, _zzq_arg2, _zzq_arg3, _zzq_arg4, _zzq_arg5) \
257 __extension__ \
258 ({volatile unsigned int _zzq_args[6]; \
259 volatile unsigned int _zzq_result; \
260 _zzq_args[0] = (unsigned int)(_zzq_request); \
261 _zzq_args[1] = (unsigned int)(_zzq_arg1); \
262 _zzq_args[2] = (unsigned int)(_zzq_arg2); \
263 _zzq_args[3] = (unsigned int)(_zzq_arg3); \
264 _zzq_args[4] = (unsigned int)(_zzq_arg4); \
265 _zzq_args[5] = (unsigned int)(_zzq_arg5); \
266 __asm__ volatile(__SPECIAL_INSTRUCTION_PREAMBLE \
267 /* %EDX = client_request ( %EAX ) */ \
268 "xchgl %%ebx,%%ebx" \
269 : "=d" (_zzq_result) \
270 : "a" (&_zzq_args[0]), "0" (_zzq_default) \
271 : "cc", "memory" \
272 ); \
273 _zzq_result; \
274 })
275
276 #define VALGRIND_GET_NR_CONTEXT(_zzq_rlval) \
277 { volatile OrigFn* _zzq_orig = &(_zzq_rlval); \
278 volatile unsigned int __addr; \
279 __asm__ volatile(__SPECIAL_INSTRUCTION_PREAMBLE \
280 /* %EAX = guest_NRADDR */ \
281 "xchgl %%ecx,%%ecx" \
282 : "=a" (__addr) \
283 : \
284 : "cc", "memory" \
285 ); \
286 _zzq_orig->nraddr = __addr; \
287 }
288
289 #define VALGRIND_CALL_NOREDIR_EAX \
290 __SPECIAL_INSTRUCTION_PREAMBLE \
291 /* call-noredir *%EAX */ \
292 "xchgl %%edx,%%edx\n\t"
293
294 #define VALGRIND_VEX_INJECT_IR() \
295 do { \
296 __asm__ volatile(__SPECIAL_INSTRUCTION_PREAMBLE \
297 "xchgl %%edi,%%edi\n\t" \
298 : : : "cc", "memory" \
299 ); \
300 } while (0)
301
302 #endif /* PLAT_x86_linux || PLAT_x86_darwin || (PLAT_x86_win32 && __GNUC__) */
303
304 /* ------------------------- x86-Win32 ------------------------- */
305
306 #if defined(PLAT_x86_win32) && !defined(__GNUC__)
307
308 typedef
309 struct {
310 unsigned int nraddr; /* where's the code? */
311 }
312 OrigFn;
313
314 #if defined(_MSC_VER)
315
316 #define __SPECIAL_INSTRUCTION_PREAMBLE \
317 __asm rol edi, 3 __asm rol edi, 13 \
318 __asm rol edi, 29 __asm rol edi, 19
319
320 #define VALGRIND_DO_CLIENT_REQUEST_EXPR( \
321 _zzq_default, _zzq_request, \
322 _zzq_arg1, _zzq_arg2, _zzq_arg3, _zzq_arg4, _zzq_arg5) \
323 valgrind_do_client_request_expr((uintptr_t)(_zzq_default), \
324 (uintptr_t)(_zzq_request), (uintptr_t)(_zzq_arg1), \
325 (uintptr_t)(_zzq_arg2), (uintptr_t)(_zzq_arg3), \
326 (uintptr_t)(_zzq_arg4), (uintptr_t)(_zzq_arg5))
327
328 static __inline uintptr_t
329 valgrind_do_client_request_expr(uintptr_t _zzq_default, uintptr_t _zzq_request,
330 uintptr_t _zzq_arg1, uintptr_t _zzq_arg2,
331 uintptr_t _zzq_arg3, uintptr_t _zzq_arg4,
332 uintptr_t _zzq_arg5)
333 {
334 volatile uintptr_t _zzq_args[6];
335 volatile unsigned int _zzq_result;
336 _zzq_args[0] = (uintptr_t)(_zzq_request);
337 _zzq_args[1] = (uintptr_t)(_zzq_arg1);
338 _zzq_args[2] = (uintptr_t)(_zzq_arg2);
339 _zzq_args[3] = (uintptr_t)(_zzq_arg3);
340 _zzq_args[4] = (uintptr_t)(_zzq_arg4);
341 _zzq_args[5] = (uintptr_t)(_zzq_arg5);
342 __asm { __asm lea eax, _zzq_args __asm mov edx, _zzq_default
343 __SPECIAL_INSTRUCTION_PREAMBLE
344 /* %EDX = client_request ( %EAX ) */
345 __asm xchg ebx,ebx
346 __asm mov _zzq_result, edx
347 }
348 return _zzq_result;
349 }
350
351 #define VALGRIND_GET_NR_CONTEXT(_zzq_rlval) \
352 { volatile OrigFn* _zzq_orig = &(_zzq_rlval); \
353 volatile unsigned int __addr; \
354 __asm { __SPECIAL_INSTRUCTION_PREAMBLE \
355 /* %EAX = guest_NRADDR */ \
356 __asm xchg ecx,ecx \
357 __asm mov __addr, eax \
358 } \
359 _zzq_orig->nraddr = __addr; \
360 }
361
362 #define VALGRIND_CALL_NOREDIR_EAX ERROR
363
364 #define VALGRIND_VEX_INJECT_IR() \
365 do { \
366 __asm { __SPECIAL_INSTRUCTION_PREAMBLE \
367 __asm xchg edi,edi \
368 } \
369 } while (0)
370
371 #else
372 #error Unsupported compiler.
373 #endif
374
375 #endif /* PLAT_x86_win32 */
376
377 /* ------------------------ amd64-{linux,darwin} --------------- */
378
379 #if defined(PLAT_amd64_linux) || defined(PLAT_amd64_darwin)
380
381 typedef
382 struct {
383 unsigned long long int nraddr; /* where's the code? */
384 }
385 OrigFn;
386
387 #define __SPECIAL_INSTRUCTION_PREAMBLE \
388 "rolq $3, %%rdi ; rolq $13, %%rdi\n\t" \
389 "rolq $61, %%rdi ; rolq $51, %%rdi\n\t"
390
391 #define VALGRIND_DO_CLIENT_REQUEST_EXPR( \
392 _zzq_default, _zzq_request, \
393 _zzq_arg1, _zzq_arg2, _zzq_arg3, _zzq_arg4, _zzq_arg5) \
394 __extension__ \
395 ({ volatile unsigned long long int _zzq_args[6]; \
396 volatile unsigned long long int _zzq_result; \
397 _zzq_args[0] = (unsigned long long int)(_zzq_request); \
398 _zzq_args[1] = (unsigned long long int)(_zzq_arg1); \
399 _zzq_args[2] = (unsigned long long int)(_zzq_arg2); \
400 _zzq_args[3] = (unsigned long long int)(_zzq_arg3); \
401 _zzq_args[4] = (unsigned long long int)(_zzq_arg4); \
402 _zzq_args[5] = (unsigned long long int)(_zzq_arg5); \
403 __asm__ volatile(__SPECIAL_INSTRUCTION_PREAMBLE \
404 /* %RDX = client_request ( %RAX ) */ \
405 "xchgq %%rbx,%%rbx" \
406 : "=d" (_zzq_result) \
407 : "a" (&_zzq_args[0]), "0" (_zzq_default) \
408 : "cc", "memory" \
409 ); \
410 _zzq_result; \
411 })
412
413 #define VALGRIND_GET_NR_CONTEXT(_zzq_rlval) \
414 { volatile OrigFn* _zzq_orig = &(_zzq_rlval); \
415 volatile unsigned long long int __addr; \
416 __asm__ volatile(__SPECIAL_INSTRUCTION_PREAMBLE \
417 /* %RAX = guest_NRADDR */ \
418 "xchgq %%rcx,%%rcx" \
419 : "=a" (__addr) \
420 : \
421 : "cc", "memory" \
422 ); \
423 _zzq_orig->nraddr = __addr; \
424 }
425
426 #define VALGRIND_CALL_NOREDIR_RAX \
427 __SPECIAL_INSTRUCTION_PREAMBLE \
428 /* call-noredir *%RAX */ \
429 "xchgq %%rdx,%%rdx\n\t"
430
431 #define VALGRIND_VEX_INJECT_IR() \
432 do { \
433 __asm__ volatile(__SPECIAL_INSTRUCTION_PREAMBLE \
434 "xchgq %%rdi,%%rdi\n\t" \
435 : : : "cc", "memory" \
436 ); \
437 } while (0)
438
439 #endif /* PLAT_amd64_linux || PLAT_amd64_darwin */
440
441 /* ------------------------ ppc32-linux ------------------------ */
442
443 #if defined(PLAT_ppc32_linux)
444
445 typedef
446 struct {
447 unsigned int nraddr; /* where's the code? */
448 }
449 OrigFn;
450
451 #define __SPECIAL_INSTRUCTION_PREAMBLE \
452 "rlwinm 0,0,3,0,0 ; rlwinm 0,0,13,0,0\n\t" \
453 "rlwinm 0,0,29,0,0 ; rlwinm 0,0,19,0,0\n\t"
454
455 #define VALGRIND_DO_CLIENT_REQUEST_EXPR( \
456 _zzq_default, _zzq_request, \
457 _zzq_arg1, _zzq_arg2, _zzq_arg3, _zzq_arg4, _zzq_arg5) \
458 \
459 __extension__ \
460 ({ unsigned int _zzq_args[6]; \
461 unsigned int _zzq_result; \
462 unsigned int* _zzq_ptr; \
463 _zzq_args[0] = (unsigned int)(_zzq_request); \
464 _zzq_args[1] = (unsigned int)(_zzq_arg1); \
465 _zzq_args[2] = (unsigned int)(_zzq_arg2); \
466 _zzq_args[3] = (unsigned int)(_zzq_arg3); \
467 _zzq_args[4] = (unsigned int)(_zzq_arg4); \
468 _zzq_args[5] = (unsigned int)(_zzq_arg5); \
469 _zzq_ptr = _zzq_args; \
470 __asm__ volatile("mr 3,%1\n\t" /*default*/ \
471 "mr 4,%2\n\t" /*ptr*/ \
472 __SPECIAL_INSTRUCTION_PREAMBLE \
473 /* %R3 = client_request ( %R4 ) */ \
474 "or 1,1,1\n\t" \
475 "mr %0,3" /*result*/ \
476 : "=b" (_zzq_result) \
477 : "b" (_zzq_default), "b" (_zzq_ptr) \
478 : "cc", "memory", "r3", "r4"); \
479 _zzq_result; \
480 })
481
482 #define VALGRIND_GET_NR_CONTEXT(_zzq_rlval) \
483 { volatile OrigFn* _zzq_orig = &(_zzq_rlval); \
484 unsigned int __addr; \
485 __asm__ volatile(__SPECIAL_INSTRUCTION_PREAMBLE \
486 /* %R3 = guest_NRADDR */ \
487 "or 2,2,2\n\t" \
488 "mr %0,3" \
489 : "=b" (__addr) \
490 : \
491 : "cc", "memory", "r3" \
492 ); \
493 _zzq_orig->nraddr = __addr; \
494 }
495
496 #define VALGRIND_BRANCH_AND_LINK_TO_NOREDIR_R11 \
497 __SPECIAL_INSTRUCTION_PREAMBLE \
498 /* branch-and-link-to-noredir *%R11 */ \
499 "or 3,3,3\n\t"
500
501 #define VALGRIND_VEX_INJECT_IR() \
502 do { \
503 __asm__ volatile(__SPECIAL_INSTRUCTION_PREAMBLE \
504 "or 5,5,5\n\t" \
505 ); \
506 } while (0)
507
508 #endif /* PLAT_ppc32_linux */
509
510 /* ------------------------ ppc64-linux ------------------------ */
511
512 #if defined(PLAT_ppc64_linux)
513
514 typedef
515 struct {
516 unsigned long long int nraddr; /* where's the code? */
517 unsigned long long int r2; /* what tocptr do we need? */
518 }
519 OrigFn;
520
521 #define __SPECIAL_INSTRUCTION_PREAMBLE \
522 "rotldi 0,0,3 ; rotldi 0,0,13\n\t" \
523 "rotldi 0,0,61 ; rotldi 0,0,51\n\t"
524
525 #define VALGRIND_DO_CLIENT_REQUEST_EXPR( \
526 _zzq_default, _zzq_request, \
527 _zzq_arg1, _zzq_arg2, _zzq_arg3, _zzq_arg4, _zzq_arg5) \
528 \
529 __extension__ \
530 ({ unsigned long long int _zzq_args[6]; \
531 unsigned long long int _zzq_result; \
532 unsigned long long int* _zzq_ptr; \
533 _zzq_args[0] = (unsigned long long int)(_zzq_request); \
534 _zzq_args[1] = (unsigned long long int)(_zzq_arg1); \
535 _zzq_args[2] = (unsigned long long int)(_zzq_arg2); \
536 _zzq_args[3] = (unsigned long long int)(_zzq_arg3); \
537 _zzq_args[4] = (unsigned long long int)(_zzq_arg4); \
538 _zzq_args[5] = (unsigned long long int)(_zzq_arg5); \
539 _zzq_ptr = _zzq_args; \
540 __asm__ volatile("mr 3,%1\n\t" /*default*/ \
541 "mr 4,%2\n\t" /*ptr*/ \
542 __SPECIAL_INSTRUCTION_PREAMBLE \
543 /* %R3 = client_request ( %R4 ) */ \
544 "or 1,1,1\n\t" \
545 "mr %0,3" /*result*/ \
546 : "=b" (_zzq_result) \
547 : "b" (_zzq_default), "b" (_zzq_ptr) \
548 : "cc", "memory", "r3", "r4"); \
549 _zzq_result; \
550 })
551
552 #define VALGRIND_GET_NR_CONTEXT(_zzq_rlval) \
553 { volatile OrigFn* _zzq_orig = &(_zzq_rlval); \
554 unsigned long long int __addr; \
555 __asm__ volatile(__SPECIAL_INSTRUCTION_PREAMBLE \
556 /* %R3 = guest_NRADDR */ \
557 "or 2,2,2\n\t" \
558 "mr %0,3" \
559 : "=b" (__addr) \
560 : \
561 : "cc", "memory", "r3" \
562 ); \
563 _zzq_orig->nraddr = __addr; \
564 __asm__ volatile(__SPECIAL_INSTRUCTION_PREAMBLE \
565 /* %R3 = guest_NRADDR_GPR2 */ \
566 "or 4,4,4\n\t" \
567 "mr %0,3" \
568 : "=b" (__addr) \
569 : \
570 : "cc", "memory", "r3" \
571 ); \
572 _zzq_orig->r2 = __addr; \
573 }
574
575 #define VALGRIND_BRANCH_AND_LINK_TO_NOREDIR_R11 \
576 __SPECIAL_INSTRUCTION_PREAMBLE \
577 /* branch-and-link-to-noredir *%R11 */ \
578 "or 3,3,3\n\t"
579
580 #define VALGRIND_VEX_INJECT_IR() \
581 do { \
582 __asm__ volatile(__SPECIAL_INSTRUCTION_PREAMBLE \
583 "or 5,5,5\n\t" \
584 ); \
585 } while (0)
586
587 #endif /* PLAT_ppc64_linux */
588
589 /* ------------------------- arm-linux ------------------------- */
590
591 #if defined(PLAT_arm_linux)
592
593 typedef
594 struct {
595 unsigned int nraddr; /* where's the code? */
596 }
597 OrigFn;
598
599 #define __SPECIAL_INSTRUCTION_PREAMBLE \
600 "mov r12, r12, ror #3 ; mov r12, r12, ror #13 \n\t" \
601 "mov r12, r12, ror #29 ; mov r12, r12, ror #19 \n\t"
602
603 #define VALGRIND_DO_CLIENT_REQUEST_EXPR( \
604 _zzq_default, _zzq_request, \
605 _zzq_arg1, _zzq_arg2, _zzq_arg3, _zzq_arg4, _zzq_arg5) \
606 \
607 __extension__ \
608 ({volatile unsigned int _zzq_args[6]; \
609 volatile unsigned int _zzq_result; \
610 _zzq_args[0] = (unsigned int)(_zzq_request); \
611 _zzq_args[1] = (unsigned int)(_zzq_arg1); \
612 _zzq_args[2] = (unsigned int)(_zzq_arg2); \
613 _zzq_args[3] = (unsigned int)(_zzq_arg3); \
614 _zzq_args[4] = (unsigned int)(_zzq_arg4); \
615 _zzq_args[5] = (unsigned int)(_zzq_arg5); \
616 __asm__ volatile("mov r3, %1\n\t" /*default*/ \
617 "mov r4, %2\n\t" /*ptr*/ \
618 __SPECIAL_INSTRUCTION_PREAMBLE \
619 /* R3 = client_request ( R4 ) */ \
620 "orr r10, r10, r10\n\t" \
621 "mov %0, r3" /*result*/ \
622 : "=r" (_zzq_result) \
623 : "r" (_zzq_default), "r" (&_zzq_args[0]) \
624 : "cc","memory", "r3", "r4"); \
625 _zzq_result; \
626 })
627
628 #define VALGRIND_GET_NR_CONTEXT(_zzq_rlval) \
629 { volatile OrigFn* _zzq_orig = &(_zzq_rlval); \
630 unsigned int __addr; \
631 __asm__ volatile(__SPECIAL_INSTRUCTION_PREAMBLE \
632 /* R3 = guest_NRADDR */ \
633 "orr r11, r11, r11\n\t" \
634 "mov %0, r3" \
635 : "=r" (__addr) \
636 : \
637 : "cc", "memory", "r3" \
638 ); \
639 _zzq_orig->nraddr = __addr; \
640 }
641
642 #define VALGRIND_BRANCH_AND_LINK_TO_NOREDIR_R4 \
643 __SPECIAL_INSTRUCTION_PREAMBLE \
644 /* branch-and-link-to-noredir *%R4 */ \
645 "orr r12, r12, r12\n\t"
646
647 #define VALGRIND_VEX_INJECT_IR() \
648 do { \
649 __asm__ volatile(__SPECIAL_INSTRUCTION_PREAMBLE \
650 "orr r9, r9, r9\n\t" \
651 : : : "cc", "memory" \
652 ); \
653 } while (0)
654
655 #endif /* PLAT_arm_linux */
656
657 /* ------------------------ s390x-linux ------------------------ */
658
659 #if defined(PLAT_s390x_linux)
660
661 typedef
662 struct {
663 unsigned long long int nraddr; /* where's the code? */
664 }
665 OrigFn;
666
667 /* __SPECIAL_INSTRUCTION_PREAMBLE will be used to identify Valgrind specific
668 * code. This detection is implemented in platform specific toIR.c
669 * (e.g. VEX/priv/guest_s390_decoder.c).
670 */
671 #define __SPECIAL_INSTRUCTION_PREAMBLE \
672 "lr 15,15\n\t" \
673 "lr 1,1\n\t" \
674 "lr 2,2\n\t" \
675 "lr 3,3\n\t"
676
677 #define __CLIENT_REQUEST_CODE "lr 2,2\n\t"
678 #define __GET_NR_CONTEXT_CODE "lr 3,3\n\t"
679 #define __CALL_NO_REDIR_CODE "lr 4,4\n\t"
680 #define __VEX_INJECT_IR_CODE "lr 5,5\n\t"
681
682 #define VALGRIND_DO_CLIENT_REQUEST_EXPR( \
683 _zzq_default, _zzq_request, \
684 _zzq_arg1, _zzq_arg2, _zzq_arg3, _zzq_arg4, _zzq_arg5) \
685 __extension__ \
686 ({volatile unsigned long long int _zzq_args[6]; \
687 volatile unsigned long long int _zzq_result; \
688 _zzq_args[0] = (unsigned long long int)(_zzq_request); \
689 _zzq_args[1] = (unsigned long long int)(_zzq_arg1); \
690 _zzq_args[2] = (unsigned long long int)(_zzq_arg2); \
691 _zzq_args[3] = (unsigned long long int)(_zzq_arg3); \
692 _zzq_args[4] = (unsigned long long int)(_zzq_arg4); \
693 _zzq_args[5] = (unsigned long long int)(_zzq_arg5); \
694 __asm__ volatile(/* r2 = args */ \
695 "lgr 2,%1\n\t" \
696 /* r3 = default */ \
697 "lgr 3,%2\n\t" \
698 __SPECIAL_INSTRUCTION_PREAMBLE \
699 __CLIENT_REQUEST_CODE \
700 /* results = r3 */ \
701 "lgr %0, 3\n\t" \
702 : "=d" (_zzq_result) \
703 : "a" (&_zzq_args[0]), "0" (_zzq_default) \
704 : "cc", "2", "3", "memory" \
705 ); \
706 _zzq_result; \
707 })
708
709 #define VALGRIND_GET_NR_CONTEXT(_zzq_rlval) \
710 { volatile OrigFn* _zzq_orig = &(_zzq_rlval); \
711 volatile unsigned long long int __addr; \
712 __asm__ volatile(__SPECIAL_INSTRUCTION_PREAMBLE \
713 __GET_NR_CONTEXT_CODE \
714 "lgr %0, 3\n\t" \
715 : "=a" (__addr) \
716 : \
717 : "cc", "3", "memory" \
718 ); \
719 _zzq_orig->nraddr = __addr; \
720 }
721
722 #define VALGRIND_CALL_NOREDIR_R1 \
723 __SPECIAL_INSTRUCTION_PREAMBLE \
724 __CALL_NO_REDIR_CODE
725
726 #define VALGRIND_VEX_INJECT_IR() \
727 do { \
728 __asm__ volatile(__SPECIAL_INSTRUCTION_PREAMBLE \
729 __VEX_INJECT_IR_CODE); \
730 } while (0)
731
732 #endif /* PLAT_s390x_linux */
733
734 /* ------------------------- mips32-linux ---------------- */
735
736 #if defined(PLAT_mips32_linux)
737
738 typedef
739 struct {
740 unsigned int nraddr; /* where's the code? */
741 }
742 OrigFn;
743
744 /* .word 0x342
745 * .word 0x742
746 * .word 0xC2
747 * .word 0x4C2*/
748 #define __SPECIAL_INSTRUCTION_PREAMBLE \
749 "srl $0, $0, 13\n\t" \
750 "srl $0, $0, 29\n\t" \
751 "srl $0, $0, 3\n\t" \
752 "srl $0, $0, 19\n\t"
753
754 #define VALGRIND_DO_CLIENT_REQUEST_EXPR( \
755 _zzq_default, _zzq_request, \
756 _zzq_arg1, _zzq_arg2, _zzq_arg3, _zzq_arg4, _zzq_arg5) \
757 __extension__ \
758 ({ volatile unsigned int _zzq_args[6]; \
759 volatile unsigned int _zzq_result; \
760 _zzq_args[0] = (unsigned int)(_zzq_request); \
761 _zzq_args[1] = (unsigned int)(_zzq_arg1); \
762 _zzq_args[2] = (unsigned int)(_zzq_arg2); \
763 _zzq_args[3] = (unsigned int)(_zzq_arg3); \
764 _zzq_args[4] = (unsigned int)(_zzq_arg4); \
765 _zzq_args[5] = (unsigned int)(_zzq_arg5); \
766 __asm__ volatile("move $11, %1\n\t" /*default*/ \
767 "move $12, %2\n\t" /*ptr*/ \
768 __SPECIAL_INSTRUCTION_PREAMBLE \
769 /* T3 = client_request ( T4 ) */ \
770 "or $13, $13, $13\n\t" \
771 "move %0, $11\n\t" /*result*/ \
772 : "=r" (_zzq_result) \
773 : "r" (_zzq_default), "r" (&_zzq_args[0]) \
774 : "$11", "$12"); \
775 _zzq_result; \
776 })
777
778 #define VALGRIND_GET_NR_CONTEXT(_zzq_rlval) \
779 { volatile OrigFn* _zzq_orig = &(_zzq_rlval); \
780 volatile unsigned int __addr; \
781 __asm__ volatile(__SPECIAL_INSTRUCTION_PREAMBLE \
782 /* %t9 = guest_NRADDR */ \
783 "or $14, $14, $14\n\t" \
784 "move %0, $11" /*result*/ \
785 : "=r" (__addr) \
786 : \
787 : "$11" \
788 ); \
789 _zzq_orig->nraddr = __addr; \
790 }
791
792 #define VALGRIND_CALL_NOREDIR_T9 \
793 __SPECIAL_INSTRUCTION_PREAMBLE \
794 /* call-noredir *%t9 */ \
795 "or $15, $15, $15\n\t"
796
797 #define VALGRIND_VEX_INJECT_IR() \
798 do { \
799 __asm__ volatile(__SPECIAL_INSTRUCTION_PREAMBLE \
800 "or $11, $11, $11\n\t" \
801 ); \
802 } while (0)
803
804
805 #endif /* PLAT_mips32_linux */
806
807 /* ------------------------- mips64-linux ---------------- */
808
809 #if defined(PLAT_mips64_linux)
810
811 typedef
812 struct {
813 unsigned long long nraddr; /* where's the code? */
814 }
815 OrigFn;
816
817 /* dsll $0,$0, 3
818 * dsll $0,$0, 13
819 * dsll $0,$0, 29
820 * dsll $0,$0, 19*/
821 #define __SPECIAL_INSTRUCTION_PREAMBLE \
822 "dsll $0,$0, 3 ; dsll $0,$0,13\n\t" \
823 "dsll $0,$0,29 ; dsll $0,$0,19\n\t"
824
825 #define VALGRIND_DO_CLIENT_REQUEST_EXPR( \
826 _zzq_default, _zzq_request, \
827 _zzq_arg1, _zzq_arg2, _zzq_arg3, _zzq_arg4, _zzq_arg5) \
828 __extension__ \
829 ({ volatile unsigned long long int _zzq_args[6]; \
830 volatile unsigned long long int _zzq_result; \
831 _zzq_args[0] = (unsigned long long int)(_zzq_request); \
832 _zzq_args[1] = (unsigned long long int)(_zzq_arg1); \
833 _zzq_args[2] = (unsigned long long int)(_zzq_arg2); \
834 _zzq_args[3] = (unsigned long long int)(_zzq_arg3); \
835 _zzq_args[4] = (unsigned long long int)(_zzq_arg4); \
836 _zzq_args[5] = (unsigned long long int)(_zzq_arg5); \
837 __asm__ volatile("move $11, %1\n\t" /*default*/ \
838 "move $12, %2\n\t" /*ptr*/ \
839 __SPECIAL_INSTRUCTION_PREAMBLE \
840 /* $11 = client_request ( $12 ) */ \
841 "or $13, $13, $13\n\t" \
842 "move %0, $11\n\t" /*result*/ \
843 : "=r" (_zzq_result) \
844 : "r" (_zzq_default), "r" (&_zzq_args[0]) \
845 : "$11", "$12"); \
846 _zzq_result; \
847 })
848
849 #define VALGRIND_GET_NR_CONTEXT(_zzq_rlval) \
850 { volatile OrigFn* _zzq_orig = &(_zzq_rlval); \
851 volatile unsigned long long int __addr; \
852 __asm__ volatile(__SPECIAL_INSTRUCTION_PREAMBLE \
853 /* $11 = guest_NRADDR */ \
854 "or $14, $14, $14\n\t" \
855 "move %0, $11" /*result*/ \
856 : "=r" (__addr) \
857 : \
858 : "$11"); \
859 _zzq_orig->nraddr = __addr; \
860 }
861
862 #define VALGRIND_CALL_NOREDIR_T9 \
863 __SPECIAL_INSTRUCTION_PREAMBLE \
864 /* call-noredir $25 */ \
865 "or $15, $15, $15\n\t"
866
867 #define VALGRIND_VEX_INJECT_IR() \
868 do { \
869 __asm__ volatile(__SPECIAL_INSTRUCTION_PREAMBLE \
870 "or $11, $11, $11\n\t" \
871 ); \
872 } while (0)
873
874 #endif /* PLAT_mips64_linux */
875
876 /* Insert assembly code for other platforms here... */
877
878 #endif /* NVALGRIND */
879
880
881 /* ------------------------------------------------------------------ */
882 /* PLATFORM SPECIFICS for FUNCTION WRAPPING. This is all very */
883 /* ugly. It's the least-worst tradeoff I can think of. */
884 /* ------------------------------------------------------------------ */
885
886 /* This section defines magic (a.k.a appalling-hack) macros for doing
887 guaranteed-no-redirection macros, so as to get from function
888 wrappers to the functions they are wrapping. The whole point is to
889 construct standard call sequences, but to do the call itself with a
890 special no-redirect call pseudo-instruction that the JIT
891 understands and handles specially. This section is long and
892 repetitious, and I can't see a way to make it shorter.
893
894 The naming scheme is as follows:
895
896 CALL_FN_{W,v}_{v,W,WW,WWW,WWWW,5W,6W,7W,etc}
897
898 'W' stands for "word" and 'v' for "void". Hence there are
899 different macros for calling arity 0, 1, 2, 3, 4, etc, functions,
900 and for each, the possibility of returning a word-typed result, or
901 no result.
902 */
903
904 /* Use these to write the name of your wrapper. NOTE: duplicates
905 VG_WRAP_FUNCTION_Z{U,Z} in pub_tool_redir.h. NOTE also: inserts
906 the default behaviour equivalance class tag "0000" into the name.
907 See pub_tool_redir.h for details -- normally you don't need to
908 think about this, though. */
909
910 /* Use an extra level of macroisation so as to ensure the soname/fnname
911 args are fully macro-expanded before pasting them together. */
912 #define VG_CONCAT4(_aa,_bb,_cc,_dd) _aa##_bb##_cc##_dd
913
914 #define I_WRAP_SONAME_FNNAME_ZU(soname,fnname) \
915 VG_CONCAT4(_vgw00000ZU_,soname,_,fnname)
916
917 #define I_WRAP_SONAME_FNNAME_ZZ(soname,fnname) \
918 VG_CONCAT4(_vgw00000ZZ_,soname,_,fnname)
919
920 /* Use this macro from within a wrapper function to collect the
921 context (address and possibly other info) of the original function.
922 Once you have that you can then use it in one of the CALL_FN_
923 macros. The type of the argument _lval is OrigFn. */
924 #define VALGRIND_GET_ORIG_FN(_lval) VALGRIND_GET_NR_CONTEXT(_lval)
925
926 /* Also provide end-user facilities for function replacement, rather
927 than wrapping. A replacement function differs from a wrapper in
928 that it has no way to get hold of the original function being
929 called, and hence no way to call onwards to it. In a replacement
930 function, VALGRIND_GET_ORIG_FN always returns zero. */
931
932 #define I_REPLACE_SONAME_FNNAME_ZU(soname,fnname) \
933 VG_CONCAT4(_vgr00000ZU_,soname,_,fnname)
934
935 #define I_REPLACE_SONAME_FNNAME_ZZ(soname,fnname) \
936 VG_CONCAT4(_vgr00000ZZ_,soname,_,fnname)
937
938 /* Derivatives of the main macros below, for calling functions
939 returning void. */
940
941 #define CALL_FN_v_v(fnptr) \
942 do { volatile unsigned long _junk; \
943 CALL_FN_W_v(_junk,fnptr); } while (0)
944
945 #define CALL_FN_v_W(fnptr, arg1) \
946 do { volatile unsigned long _junk; \
947 CALL_FN_W_W(_junk,fnptr,arg1); } while (0)
948
949 #define CALL_FN_v_WW(fnptr, arg1,arg2) \
950 do { volatile unsigned long _junk; \
951 CALL_FN_W_WW(_junk,fnptr,arg1,arg2); } while (0)
952
953 #define CALL_FN_v_WWW(fnptr, arg1,arg2,arg3) \
954 do { volatile unsigned long _junk; \
955 CALL_FN_W_WWW(_junk,fnptr,arg1,arg2,arg3); } while (0)
956
957 #define CALL_FN_v_WWWW(fnptr, arg1,arg2,arg3,arg4) \
958 do { volatile unsigned long _junk; \
959 CALL_FN_W_WWWW(_junk,fnptr,arg1,arg2,arg3,arg4); } while (0)
960
961 #define CALL_FN_v_5W(fnptr, arg1,arg2,arg3,arg4,arg5) \
962 do { volatile unsigned long _junk; \
963 CALL_FN_W_5W(_junk,fnptr,arg1,arg2,arg3,arg4,arg5); } while (0)
964
965 #define CALL_FN_v_6W(fnptr, arg1,arg2,arg3,arg4,arg5,arg6) \
966 do { volatile unsigned long _junk; \
967 CALL_FN_W_6W(_junk,fnptr,arg1,arg2,arg3,arg4,arg5,arg6); } while (0)
968
969 #define CALL_FN_v_7W(fnptr, arg1,arg2,arg3,arg4,arg5,arg6,arg7) \
970 do { volatile unsigned long _junk; \
971 CALL_FN_W_7W(_junk,fnptr,arg1,arg2,arg3,arg4,arg5,arg6,arg7); } while (0)
972
973 /* ------------------------- x86-{linux,darwin} ---------------- */
974
975 #if defined(PLAT_x86_linux) || defined(PLAT_x86_darwin)
976
977 /* These regs are trashed by the hidden call. No need to mention eax
978 as gcc can already see that, plus causes gcc to bomb. */
979 #define __CALLER_SAVED_REGS /*"eax"*/ "ecx", "edx"
980
981 /* Macros to save and align the stack before making a function
982 call and restore it afterwards as gcc may not keep the stack
983 pointer aligned if it doesn't realise calls are being made
984 to other functions. */
985
986 #define VALGRIND_ALIGN_STACK \
987 "movl %%esp,%%edi\n\t" \
988 "andl $0xfffffff0,%%esp\n\t"
989 #define VALGRIND_RESTORE_STACK \
990 "movl %%edi,%%esp\n\t"
991
992 /* These CALL_FN_ macros assume that on x86-linux, sizeof(unsigned
993 long) == 4. */
994
995 #define CALL_FN_W_v(lval, orig) \
996 do { \
997 volatile OrigFn _orig = (orig); \
998 volatile unsigned long _argvec[1]; \
999 volatile unsigned long _res; \
1000 _argvec[0] = (unsigned long)_orig.nraddr; \
1001 __asm__ volatile( \
1002 VALGRIND_ALIGN_STACK \
1003 "movl (%%eax), %%eax\n\t" /* target->%eax */ \
1004 VALGRIND_CALL_NOREDIR_EAX \
1005 VALGRIND_RESTORE_STACK \
1006 : /*out*/ "=a" (_res) \
1007 : /*in*/ "a" (&_argvec[0]) \
1008 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS, "edi" \
1009 ); \
1010 lval = (__typeof__(lval)) _res; \
1011 } while (0)
1012
1013 #define CALL_FN_W_W(lval, orig, arg1) \
1014 do { \
1015 volatile OrigFn _orig = (orig); \
1016 volatile unsigned long _argvec[2]; \
1017 volatile unsigned long _res; \
1018 _argvec[0] = (unsigned long)_orig.nraddr; \
1019 _argvec[1] = (unsigned long)(arg1); \
1020 __asm__ volatile( \
1021 VALGRIND_ALIGN_STACK \
1022 "subl $12, %%esp\n\t" \
1023 "pushl 4(%%eax)\n\t" \
1024 "movl (%%eax), %%eax\n\t" /* target->%eax */ \
1025 VALGRIND_CALL_NOREDIR_EAX \
1026 VALGRIND_RESTORE_STACK \
1027 : /*out*/ "=a" (_res) \
1028 : /*in*/ "a" (&_argvec[0]) \
1029 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS, "edi" \
1030 ); \
1031 lval = (__typeof__(lval)) _res; \
1032 } while (0)
1033
1034 #define CALL_FN_W_WW(lval, orig, arg1,arg2) \
1035 do { \
1036 volatile OrigFn _orig = (orig); \
1037 volatile unsigned long _argvec[3]; \
1038 volatile unsigned long _res; \
1039 _argvec[0] = (unsigned long)_orig.nraddr; \
1040 _argvec[1] = (unsigned long)(arg1); \
1041 _argvec[2] = (unsigned long)(arg2); \
1042 __asm__ volatile( \
1043 VALGRIND_ALIGN_STACK \
1044 "subl $8, %%esp\n\t" \
1045 "pushl 8(%%eax)\n\t" \
1046 "pushl 4(%%eax)\n\t" \
1047 "movl (%%eax), %%eax\n\t" /* target->%eax */ \
1048 VALGRIND_CALL_NOREDIR_EAX \
1049 VALGRIND_RESTORE_STACK \
1050 : /*out*/ "=a" (_res) \
1051 : /*in*/ "a" (&_argvec[0]) \
1052 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS, "edi" \
1053 ); \
1054 lval = (__typeof__(lval)) _res; \
1055 } while (0)
1056
1057 #define CALL_FN_W_WWW(lval, orig, arg1,arg2,arg3) \
1058 do { \
1059 volatile OrigFn _orig = (orig); \
1060 volatile unsigned long _argvec[4]; \
1061 volatile unsigned long _res; \
1062 _argvec[0] = (unsigned long)_orig.nraddr; \
1063 _argvec[1] = (unsigned long)(arg1); \
1064 _argvec[2] = (unsigned long)(arg2); \
1065 _argvec[3] = (unsigned long)(arg3); \
1066 __asm__ volatile( \
1067 VALGRIND_ALIGN_STACK \
1068 "subl $4, %%esp\n\t" \
1069 "pushl 12(%%eax)\n\t" \
1070 "pushl 8(%%eax)\n\t" \
1071 "pushl 4(%%eax)\n\t" \
1072 "movl (%%eax), %%eax\n\t" /* target->%eax */ \
1073 VALGRIND_CALL_NOREDIR_EAX \
1074 VALGRIND_RESTORE_STACK \
1075 : /*out*/ "=a" (_res) \
1076 : /*in*/ "a" (&_argvec[0]) \
1077 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS, "edi" \
1078 ); \
1079 lval = (__typeof__(lval)) _res; \
1080 } while (0)
1081
1082 #define CALL_FN_W_WWWW(lval, orig, arg1,arg2,arg3,arg4) \
1083 do { \
1084 volatile OrigFn _orig = (orig); \
1085 volatile unsigned long _argvec[5]; \
1086 volatile unsigned long _res; \
1087 _argvec[0] = (unsigned long)_orig.nraddr; \
1088 _argvec[1] = (unsigned long)(arg1); \
1089 _argvec[2] = (unsigned long)(arg2); \
1090 _argvec[3] = (unsigned long)(arg3); \
1091 _argvec[4] = (unsigned long)(arg4); \
1092 __asm__ volatile( \
1093 VALGRIND_ALIGN_STACK \
1094 "pushl 16(%%eax)\n\t" \
1095 "pushl 12(%%eax)\n\t" \
1096 "pushl 8(%%eax)\n\t" \
1097 "pushl 4(%%eax)\n\t" \
1098 "movl (%%eax), %%eax\n\t" /* target->%eax */ \
1099 VALGRIND_CALL_NOREDIR_EAX \
1100 VALGRIND_RESTORE_STACK \
1101 : /*out*/ "=a" (_res) \
1102 : /*in*/ "a" (&_argvec[0]) \
1103 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS, "edi" \
1104 ); \
1105 lval = (__typeof__(lval)) _res; \
1106 } while (0)
1107
1108 #define CALL_FN_W_5W(lval, orig, arg1,arg2,arg3,arg4,arg5) \
1109 do { \
1110 volatile OrigFn _orig = (orig); \
1111 volatile unsigned long _argvec[6]; \
1112 volatile unsigned long _res; \
1113 _argvec[0] = (unsigned long)_orig.nraddr; \
1114 _argvec[1] = (unsigned long)(arg1); \
1115 _argvec[2] = (unsigned long)(arg2); \
1116 _argvec[3] = (unsigned long)(arg3); \
1117 _argvec[4] = (unsigned long)(arg4); \
1118 _argvec[5] = (unsigned long)(arg5); \
1119 __asm__ volatile( \
1120 VALGRIND_ALIGN_STACK \
1121 "subl $12, %%esp\n\t" \
1122 "pushl 20(%%eax)\n\t" \
1123 "pushl 16(%%eax)\n\t" \
1124 "pushl 12(%%eax)\n\t" \
1125 "pushl 8(%%eax)\n\t" \
1126 "pushl 4(%%eax)\n\t" \
1127 "movl (%%eax), %%eax\n\t" /* target->%eax */ \
1128 VALGRIND_CALL_NOREDIR_EAX \
1129 VALGRIND_RESTORE_STACK \
1130 : /*out*/ "=a" (_res) \
1131 : /*in*/ "a" (&_argvec[0]) \
1132 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS, "edi" \
1133 ); \
1134 lval = (__typeof__(lval)) _res; \
1135 } while (0)
1136
1137 #define CALL_FN_W_6W(lval, orig, arg1,arg2,arg3,arg4,arg5,arg6) \
1138 do { \
1139 volatile OrigFn _orig = (orig); \
1140 volatile unsigned long _argvec[7]; \
1141 volatile unsigned long _res; \
1142 _argvec[0] = (unsigned long)_orig.nraddr; \
1143 _argvec[1] = (unsigned long)(arg1); \
1144 _argvec[2] = (unsigned long)(arg2); \
1145 _argvec[3] = (unsigned long)(arg3); \
1146 _argvec[4] = (unsigned long)(arg4); \
1147 _argvec[5] = (unsigned long)(arg5); \
1148 _argvec[6] = (unsigned long)(arg6); \
1149 __asm__ volatile( \
1150 VALGRIND_ALIGN_STACK \
1151 "subl $8, %%esp\n\t" \
1152 "pushl 24(%%eax)\n\t" \
1153 "pushl 20(%%eax)\n\t" \
1154 "pushl 16(%%eax)\n\t" \
1155 "pushl 12(%%eax)\n\t" \
1156 "pushl 8(%%eax)\n\t" \
1157 "pushl 4(%%eax)\n\t" \
1158 "movl (%%eax), %%eax\n\t" /* target->%eax */ \
1159 VALGRIND_CALL_NOREDIR_EAX \
1160 VALGRIND_RESTORE_STACK \
1161 : /*out*/ "=a" (_res) \
1162 : /*in*/ "a" (&_argvec[0]) \
1163 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS, "edi" \
1164 ); \
1165 lval = (__typeof__(lval)) _res; \
1166 } while (0)
1167
1168 #define CALL_FN_W_7W(lval, orig, arg1,arg2,arg3,arg4,arg5,arg6, \
1169 arg7) \
1170 do { \
1171 volatile OrigFn _orig = (orig); \
1172 volatile unsigned long _argvec[8]; \
1173 volatile unsigned long _res; \
1174 _argvec[0] = (unsigned long)_orig.nraddr; \
1175 _argvec[1] = (unsigned long)(arg1); \
1176 _argvec[2] = (unsigned long)(arg2); \
1177 _argvec[3] = (unsigned long)(arg3); \
1178 _argvec[4] = (unsigned long)(arg4); \
1179 _argvec[5] = (unsigned long)(arg5); \
1180 _argvec[6] = (unsigned long)(arg6); \
1181 _argvec[7] = (unsigned long)(arg7); \
1182 __asm__ volatile( \
1183 VALGRIND_ALIGN_STACK \
1184 "subl $4, %%esp\n\t" \
1185 "pushl 28(%%eax)\n\t" \
1186 "pushl 24(%%eax)\n\t" \
1187 "pushl 20(%%eax)\n\t" \
1188 "pushl 16(%%eax)\n\t" \
1189 "pushl 12(%%eax)\n\t" \
1190 "pushl 8(%%eax)\n\t" \
1191 "pushl 4(%%eax)\n\t" \
1192 "movl (%%eax), %%eax\n\t" /* target->%eax */ \
1193 VALGRIND_CALL_NOREDIR_EAX \
1194 VALGRIND_RESTORE_STACK \
1195 : /*out*/ "=a" (_res) \
1196 : /*in*/ "a" (&_argvec[0]) \
1197 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS, "edi" \
1198 ); \
1199 lval = (__typeof__(lval)) _res; \
1200 } while (0)
1201
1202 #define CALL_FN_W_8W(lval, orig, arg1,arg2,arg3,arg4,arg5,arg6, \
1203 arg7,arg8) \
1204 do { \
1205 volatile OrigFn _orig = (orig); \
1206 volatile unsigned long _argvec[9]; \
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 __asm__ volatile( \
1218 VALGRIND_ALIGN_STACK \
1219 "pushl 32(%%eax)\n\t" \
1220 "pushl 28(%%eax)\n\t" \
1221 "pushl 24(%%eax)\n\t" \
1222 "pushl 20(%%eax)\n\t" \
1223 "pushl 16(%%eax)\n\t" \
1224 "pushl 12(%%eax)\n\t" \
1225 "pushl 8(%%eax)\n\t" \
1226 "pushl 4(%%eax)\n\t" \
1227 "movl (%%eax), %%eax\n\t" /* target->%eax */ \
1228 VALGRIND_CALL_NOREDIR_EAX \
1229 VALGRIND_RESTORE_STACK \
1230 : /*out*/ "=a" (_res) \
1231 : /*in*/ "a" (&_argvec[0]) \
1232 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS, "edi" \
1233 ); \
1234 lval = (__typeof__(lval)) _res; \
1235 } while (0)
1236
1237 #define CALL_FN_W_9W(lval, orig, arg1,arg2,arg3,arg4,arg5,arg6, \
1238 arg7,arg8,arg9) \
1239 do { \
1240 volatile OrigFn _orig = (orig); \
1241 volatile unsigned long _argvec[10]; \
1242 volatile unsigned long _res; \
1243 _argvec[0] = (unsigned long)_orig.nraddr; \
1244 _argvec[1] = (unsigned long)(arg1); \
1245 _argvec[2] = (unsigned long)(arg2); \
1246 _argvec[3] = (unsigned long)(arg3); \
1247 _argvec[4] = (unsigned long)(arg4); \
1248 _argvec[5] = (unsigned long)(arg5); \
1249 _argvec[6] = (unsigned long)(arg6); \
1250 _argvec[7] = (unsigned long)(arg7); \
1251 _argvec[8] = (unsigned long)(arg8); \
1252 _argvec[9] = (unsigned long)(arg9); \
1253 __asm__ volatile( \
1254 VALGRIND_ALIGN_STACK \
1255 "subl $12, %%esp\n\t" \
1256 "pushl 36(%%eax)\n\t" \
1257 "pushl 32(%%eax)\n\t" \
1258 "pushl 28(%%eax)\n\t" \
1259 "pushl 24(%%eax)\n\t" \
1260 "pushl 20(%%eax)\n\t" \
1261 "pushl 16(%%eax)\n\t" \
1262 "pushl 12(%%eax)\n\t" \
1263 "pushl 8(%%eax)\n\t" \
1264 "pushl 4(%%eax)\n\t" \
1265 "movl (%%eax), %%eax\n\t" /* target->%eax */ \
1266 VALGRIND_CALL_NOREDIR_EAX \
1267 VALGRIND_RESTORE_STACK \
1268 : /*out*/ "=a" (_res) \
1269 : /*in*/ "a" (&_argvec[0]) \
1270 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS, "edi" \
1271 ); \
1272 lval = (__typeof__(lval)) _res; \
1273 } while (0)
1274
1275 #define CALL_FN_W_10W(lval, orig, arg1,arg2,arg3,arg4,arg5,arg6, \
1276 arg7,arg8,arg9,arg10) \
1277 do { \
1278 volatile OrigFn _orig = (orig); \
1279 volatile unsigned long _argvec[11]; \
1280 volatile unsigned long _res; \
1281 _argvec[0] = (unsigned long)_orig.nraddr; \
1282 _argvec[1] = (unsigned long)(arg1); \
1283 _argvec[2] = (unsigned long)(arg2); \
1284 _argvec[3] = (unsigned long)(arg3); \
1285 _argvec[4] = (unsigned long)(arg4); \
1286 _argvec[5] = (unsigned long)(arg5); \
1287 _argvec[6] = (unsigned long)(arg6); \
1288 _argvec[7] = (unsigned long)(arg7); \
1289 _argvec[8] = (unsigned long)(arg8); \
1290 _argvec[9] = (unsigned long)(arg9); \
1291 _argvec[10] = (unsigned long)(arg10); \
1292 __asm__ volatile( \
1293 VALGRIND_ALIGN_STACK \
1294 "subl $8, %%esp\n\t" \
1295 "pushl 40(%%eax)\n\t" \
1296 "pushl 36(%%eax)\n\t" \
1297 "pushl 32(%%eax)\n\t" \
1298 "pushl 28(%%eax)\n\t" \
1299 "pushl 24(%%eax)\n\t" \
1300 "pushl 20(%%eax)\n\t" \
1301 "pushl 16(%%eax)\n\t" \
1302 "pushl 12(%%eax)\n\t" \
1303 "pushl 8(%%eax)\n\t" \
1304 "pushl 4(%%eax)\n\t" \
1305 "movl (%%eax), %%eax\n\t" /* target->%eax */ \
1306 VALGRIND_CALL_NOREDIR_EAX \
1307 VALGRIND_RESTORE_STACK \
1308 : /*out*/ "=a" (_res) \
1309 : /*in*/ "a" (&_argvec[0]) \
1310 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS, "edi" \
1311 ); \
1312 lval = (__typeof__(lval)) _res; \
1313 } while (0)
1314
1315 #define CALL_FN_W_11W(lval, orig, arg1,arg2,arg3,arg4,arg5, \
1316 arg6,arg7,arg8,arg9,arg10, \
1317 arg11) \
1318 do { \
1319 volatile OrigFn _orig = (orig); \
1320 volatile unsigned long _argvec[12]; \
1321 volatile unsigned long _res; \
1322 _argvec[0] = (unsigned long)_orig.nraddr; \
1323 _argvec[1] = (unsigned long)(arg1); \
1324 _argvec[2] = (unsigned long)(arg2); \
1325 _argvec[3] = (unsigned long)(arg3); \
1326 _argvec[4] = (unsigned long)(arg4); \
1327 _argvec[5] = (unsigned long)(arg5); \
1328 _argvec[6] = (unsigned long)(arg6); \
1329 _argvec[7] = (unsigned long)(arg7); \
1330 _argvec[8] = (unsigned long)(arg8); \
1331 _argvec[9] = (unsigned long)(arg9); \
1332 _argvec[10] = (unsigned long)(arg10); \
1333 _argvec[11] = (unsigned long)(arg11); \
1334 __asm__ volatile( \
1335 VALGRIND_ALIGN_STACK \
1336 "subl $4, %%esp\n\t" \
1337 "pushl 44(%%eax)\n\t" \
1338 "pushl 40(%%eax)\n\t" \
1339 "pushl 36(%%eax)\n\t" \
1340 "pushl 32(%%eax)\n\t" \
1341 "pushl 28(%%eax)\n\t" \
1342 "pushl 24(%%eax)\n\t" \
1343 "pushl 20(%%eax)\n\t" \
1344 "pushl 16(%%eax)\n\t" \
1345 "pushl 12(%%eax)\n\t" \
1346 "pushl 8(%%eax)\n\t" \
1347 "pushl 4(%%eax)\n\t" \
1348 "movl (%%eax), %%eax\n\t" /* target->%eax */ \
1349 VALGRIND_CALL_NOREDIR_EAX \
1350 VALGRIND_RESTORE_STACK \
1351 : /*out*/ "=a" (_res) \
1352 : /*in*/ "a" (&_argvec[0]) \
1353 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS, "edi" \
1354 ); \
1355 lval = (__typeof__(lval)) _res; \
1356 } while (0)
1357
1358 #define CALL_FN_W_12W(lval, orig, arg1,arg2,arg3,arg4,arg5, \
1359 arg6,arg7,arg8,arg9,arg10, \
1360 arg11,arg12) \
1361 do { \
1362 volatile OrigFn _orig = (orig); \
1363 volatile unsigned long _argvec[13]; \
1364 volatile unsigned long _res; \
1365 _argvec[0] = (unsigned long)_orig.nraddr; \
1366 _argvec[1] = (unsigned long)(arg1); \
1367 _argvec[2] = (unsigned long)(arg2); \
1368 _argvec[3] = (unsigned long)(arg3); \
1369 _argvec[4] = (unsigned long)(arg4); \
1370 _argvec[5] = (unsigned long)(arg5); \
1371 _argvec[6] = (unsigned long)(arg6); \
1372 _argvec[7] = (unsigned long)(arg7); \
1373 _argvec[8] = (unsigned long)(arg8); \
1374 _argvec[9] = (unsigned long)(arg9); \
1375 _argvec[10] = (unsigned long)(arg10); \
1376 _argvec[11] = (unsigned long)(arg11); \
1377 _argvec[12] = (unsigned long)(arg12); \
1378 __asm__ volatile( \
1379 VALGRIND_ALIGN_STACK \
1380 "pushl 48(%%eax)\n\t" \
1381 "pushl 44(%%eax)\n\t" \
1382 "pushl 40(%%eax)\n\t" \
1383 "pushl 36(%%eax)\n\t" \
1384 "pushl 32(%%eax)\n\t" \
1385 "pushl 28(%%eax)\n\t" \
1386 "pushl 24(%%eax)\n\t" \
1387 "pushl 20(%%eax)\n\t" \
1388 "pushl 16(%%eax)\n\t" \
1389 "pushl 12(%%eax)\n\t" \
1390 "pushl 8(%%eax)\n\t" \
1391 "pushl 4(%%eax)\n\t" \
1392 "movl (%%eax), %%eax\n\t" /* target->%eax */ \
1393 VALGRIND_CALL_NOREDIR_EAX \
1394 VALGRIND_RESTORE_STACK \
1395 : /*out*/ "=a" (_res) \
1396 : /*in*/ "a" (&_argvec[0]) \
1397 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS, "edi" \
1398 ); \
1399 lval = (__typeof__(lval)) _res; \
1400 } while (0)
1401
1402 #endif /* PLAT_x86_linux || PLAT_x86_darwin */
1403
1404 /* ------------------------ amd64-{linux,darwin} --------------- */
1405
1406 #if defined(PLAT_amd64_linux) || defined(PLAT_amd64_darwin)
1407
1408 /* ARGREGS: rdi rsi rdx rcx r8 r9 (the rest on stack in R-to-L order) */
1409
1410 /* These regs are trashed by the hidden call. */
1411 #define __CALLER_SAVED_REGS /*"rax",*/ "rcx", "rdx", "rsi", \
1412 "rdi", "r8", "r9", "r10", "r11"
1413
1414 /* This is all pretty complex. It's so as to make stack unwinding
1415 work reliably. See bug 243270. The basic problem is the sub and
1416 add of 128 of %rsp in all of the following macros. If gcc believes
1417 the CFA is in %rsp, then unwinding may fail, because what's at the
1418 CFA is not what gcc "expected" when it constructs the CFIs for the
1419 places where the macros are instantiated.
1420
1421 But we can't just add a CFI annotation to increase the CFA offset
1422 by 128, to match the sub of 128 from %rsp, because we don't know
1423 whether gcc has chosen %rsp as the CFA at that point, or whether it
1424 has chosen some other register (eg, %rbp). In the latter case,
1425 adding a CFI annotation to change the CFA offset is simply wrong.
1426
1427 So the solution is to get hold of the CFA using
1428 __builtin_dwarf_cfa(), put it in a known register, and add a
1429 CFI annotation to say what the register is. We choose %rbp for
1430 this (perhaps perversely), because:
1431
1432 (1) %rbp is already subject to unwinding. If a new register was
1433 chosen then the unwinder would have to unwind it in all stack
1434 traces, which is expensive, and
1435
1436 (2) %rbp is already subject to precise exception updates in the
1437 JIT. If a new register was chosen, we'd have to have precise
1438 exceptions for it too, which reduces performance of the
1439 generated code.
1440
1441 However .. one extra complication. We can't just whack the result
1442 of __builtin_dwarf_cfa() into %rbp and then add %rbp to the
1443 list of trashed registers at the end of the inline assembly
1444 fragments; gcc won't allow %rbp to appear in that list. Hence
1445 instead we need to stash %rbp in %r15 for the duration of the asm,
1446 and say that %r15 is trashed instead. gcc seems happy to go with
1447 that.
1448
1449 Oh .. and this all needs to be conditionalised so that it is
1450 unchanged from before this commit, when compiled with older gccs
1451 that don't support __builtin_dwarf_cfa. Furthermore, since
1452 this header file is freestanding, it has to be independent of
1453 config.h, and so the following conditionalisation cannot depend on
1454 configure time checks.
1455
1456 Although it's not clear from
1457 'defined(__GNUC__) && defined(__GCC_HAVE_DWARF2_CFI_ASM)',
1458 this expression excludes Darwin.
1459 .cfi directives in Darwin assembly appear to be completely
1460 different and I haven't investigated how they work.
1461
1462 For even more entertainment value, note we have to use the
1463 completely undocumented __builtin_dwarf_cfa(), which appears to
1464 really compute the CFA, whereas __builtin_frame_address(0) claims
1465 to but actually doesn't. See
1466 https://bugs.kde.org/show_bug.cgi?id=243270#c47
1467 */
1468 #if defined(__GNUC__) && defined(__GCC_HAVE_DWARF2_CFI_ASM)
1469 # define __FRAME_POINTER \
1470 ,"r"(__builtin_dwarf_cfa())
1471 # define VALGRIND_CFI_PROLOGUE \
1472 "movq %%rbp, %%r15\n\t" \
1473 "movq %2, %%rbp\n\t" \
1474 ".cfi_remember_state\n\t" \
1475 ".cfi_def_cfa rbp, 0\n\t"
1476 # define VALGRIND_CFI_EPILOGUE \
1477 "movq %%r15, %%rbp\n\t" \
1478 ".cfi_restore_state\n\t"
1479 #else
1480 # define __FRAME_POINTER
1481 # define VALGRIND_CFI_PROLOGUE
1482 # define VALGRIND_CFI_EPILOGUE
1483 #endif
1484
1485 /* Macros to save and align the stack before making a function
1486 call and restore it afterwards as gcc may not keep the stack
1487 pointer aligned if it doesn't realise calls are being made
1488 to other functions. */
1489
1490 #define VALGRIND_ALIGN_STACK \
1491 "movq %%rsp,%%r14\n\t" \
1492 "andq $0xfffffffffffffff0,%%rsp\n\t"
1493 #define VALGRIND_RESTORE_STACK \
1494 "movq %%r14,%%rsp\n\t"
1495
1496 /* These CALL_FN_ macros assume that on amd64-linux, sizeof(unsigned
1497 long) == 8. */
1498
1499 /* NB 9 Sept 07. There is a nasty kludge here in all these CALL_FN_
1500 macros. In order not to trash the stack redzone, we need to drop
1501 %rsp by 128 before the hidden call, and restore afterwards. The
1502 nastyness is that it is only by luck that the stack still appears
1503 to be unwindable during the hidden call - since then the behaviour
1504 of any routine using this macro does not match what the CFI data
1505 says. Sigh.
1506
1507 Why is this important? Imagine that a wrapper has a stack
1508 allocated local, and passes to the hidden call, a pointer to it.
1509 Because gcc does not know about the hidden call, it may allocate
1510 that local in the redzone. Unfortunately the hidden call may then
1511 trash it before it comes to use it. So we must step clear of the
1512 redzone, for the duration of the hidden call, to make it safe.
1513
1514 Probably the same problem afflicts the other redzone-style ABIs too
1515 (ppc64-linux); but for those, the stack is
1516 self describing (none of this CFI nonsense) so at least messing
1517 with the stack pointer doesn't give a danger of non-unwindable
1518 stack. */
1519
1520 #define CALL_FN_W_v(lval, orig) \
1521 do { \
1522 volatile OrigFn _orig = (orig); \
1523 volatile unsigned long _argvec[1]; \
1524 volatile unsigned long _res; \
1525 _argvec[0] = (unsigned long)_orig.nraddr; \
1526 __asm__ volatile( \
1527 VALGRIND_CFI_PROLOGUE \
1528 VALGRIND_ALIGN_STACK \
1529 "subq $128,%%rsp\n\t" \
1530 "movq (%%rax), %%rax\n\t" /* target->%rax */ \
1531 VALGRIND_CALL_NOREDIR_RAX \
1532 VALGRIND_RESTORE_STACK \
1533 VALGRIND_CFI_EPILOGUE \
1534 : /*out*/ "=a" (_res) \
1535 : /*in*/ "a" (&_argvec[0]) __FRAME_POINTER \
1536 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS, "r14", "r15" \
1537 ); \
1538 lval = (__typeof__(lval)) _res; \
1539 } while (0)
1540
1541 #define CALL_FN_W_W(lval, orig, arg1) \
1542 do { \
1543 volatile OrigFn _orig = (orig); \
1544 volatile unsigned long _argvec[2]; \
1545 volatile unsigned long _res; \
1546 _argvec[0] = (unsigned long)_orig.nraddr; \
1547 _argvec[1] = (unsigned long)(arg1); \
1548 __asm__ volatile( \
1549 VALGRIND_CFI_PROLOGUE \
1550 VALGRIND_ALIGN_STACK \
1551 "subq $128,%%rsp\n\t" \
1552 "movq 8(%%rax), %%rdi\n\t" \
1553 "movq (%%rax), %%rax\n\t" /* target->%rax */ \
1554 VALGRIND_CALL_NOREDIR_RAX \
1555 VALGRIND_RESTORE_STACK \
1556 VALGRIND_CFI_EPILOGUE \
1557 : /*out*/ "=a" (_res) \
1558 : /*in*/ "a" (&_argvec[0]) __FRAME_POINTER \
1559 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS, "r14", "r15" \
1560 ); \
1561 lval = (__typeof__(lval)) _res; \
1562 } while (0)
1563
1564 #define CALL_FN_W_WW(lval, orig, arg1,arg2) \
1565 do { \
1566 volatile OrigFn _orig = (orig); \
1567 volatile unsigned long _argvec[3]; \
1568 volatile unsigned long _res; \
1569 _argvec[0] = (unsigned long)_orig.nraddr; \
1570 _argvec[1] = (unsigned long)(arg1); \
1571 _argvec[2] = (unsigned long)(arg2); \
1572 __asm__ volatile( \
1573 VALGRIND_CFI_PROLOGUE \
1574 VALGRIND_ALIGN_STACK \
1575 "subq $128,%%rsp\n\t" \
1576 "movq 16(%%rax), %%rsi\n\t" \
1577 "movq 8(%%rax), %%rdi\n\t" \
1578 "movq (%%rax), %%rax\n\t" /* target->%rax */ \
1579 VALGRIND_CALL_NOREDIR_RAX \
1580 VALGRIND_RESTORE_STACK \
1581 VALGRIND_CFI_EPILOGUE \
1582 : /*out*/ "=a" (_res) \
1583 : /*in*/ "a" (&_argvec[0]) __FRAME_POINTER \
1584 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS, "r14", "r15" \
1585 ); \
1586 lval = (__typeof__(lval)) _res; \
1587 } while (0)
1588
1589 #define CALL_FN_W_WWW(lval, orig, arg1,arg2,arg3) \
1590 do { \
1591 volatile OrigFn _orig = (orig); \
1592 volatile unsigned long _argvec[4]; \
1593 volatile unsigned long _res; \
1594 _argvec[0] = (unsigned long)_orig.nraddr; \
1595 _argvec[1] = (unsigned long)(arg1); \
1596 _argvec[2] = (unsigned long)(arg2); \
1597 _argvec[3] = (unsigned long)(arg3); \
1598 __asm__ volatile( \
1599 VALGRIND_CFI_PROLOGUE \
1600 VALGRIND_ALIGN_STACK \
1601 "subq $128,%%rsp\n\t" \
1602 "movq 24(%%rax), %%rdx\n\t" \
1603 "movq 16(%%rax), %%rsi\n\t" \
1604 "movq 8(%%rax), %%rdi\n\t" \
1605 "movq (%%rax), %%rax\n\t" /* target->%rax */ \
1606 VALGRIND_CALL_NOREDIR_RAX \
1607 VALGRIND_RESTORE_STACK \
1608 VALGRIND_CFI_EPILOGUE \
1609 : /*out*/ "=a" (_res) \
1610 : /*in*/ "a" (&_argvec[0]) __FRAME_POINTER \
1611 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS, "r14", "r15" \
1612 ); \
1613 lval = (__typeof__(lval)) _res; \
1614 } while (0)
1615
1616 #define CALL_FN_W_WWWW(lval, orig, arg1,arg2,arg3,arg4) \
1617 do { \
1618 volatile OrigFn _orig = (orig); \
1619 volatile unsigned long _argvec[5]; \
1620 volatile unsigned long _res; \
1621 _argvec[0] = (unsigned long)_orig.nraddr; \
1622 _argvec[1] = (unsigned long)(arg1); \
1623 _argvec[2] = (unsigned long)(arg2); \
1624 _argvec[3] = (unsigned long)(arg3); \
1625 _argvec[4] = (unsigned long)(arg4); \
1626 __asm__ volatile( \
1627 VALGRIND_CFI_PROLOGUE \
1628 VALGRIND_ALIGN_STACK \
1629 "subq $128,%%rsp\n\t" \
1630 "movq 32(%%rax), %%rcx\n\t" \
1631 "movq 24(%%rax), %%rdx\n\t" \
1632 "movq 16(%%rax), %%rsi\n\t" \
1633 "movq 8(%%rax), %%rdi\n\t" \
1634 "movq (%%rax), %%rax\n\t" /* target->%rax */ \
1635 VALGRIND_CALL_NOREDIR_RAX \
1636 VALGRIND_RESTORE_STACK \
1637 VALGRIND_CFI_EPILOGUE \
1638 : /*out*/ "=a" (_res) \
1639 : /*in*/ "a" (&_argvec[0]) __FRAME_POINTER \
1640 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS, "r14", "r15" \
1641 ); \
1642 lval = (__typeof__(lval)) _res; \
1643 } while (0)
1644
1645 #define CALL_FN_W_5W(lval, orig, arg1,arg2,arg3,arg4,arg5) \
1646 do { \
1647 volatile OrigFn _orig = (orig); \
1648 volatile unsigned long _argvec[6]; \
1649 volatile unsigned long _res; \
1650 _argvec[0] = (unsigned long)_orig.nraddr; \
1651 _argvec[1] = (unsigned long)(arg1); \
1652 _argvec[2] = (unsigned long)(arg2); \
1653 _argvec[3] = (unsigned long)(arg3); \
1654 _argvec[4] = (unsigned long)(arg4); \
1655 _argvec[5] = (unsigned long)(arg5); \
1656 __asm__ volatile( \
1657 VALGRIND_CFI_PROLOGUE \
1658 VALGRIND_ALIGN_STACK \
1659 "subq $128,%%rsp\n\t" \
1660 "movq 40(%%rax), %%r8\n\t" \
1661 "movq 32(%%rax), %%rcx\n\t" \
1662 "movq 24(%%rax), %%rdx\n\t" \
1663 "movq 16(%%rax), %%rsi\n\t" \
1664 "movq 8(%%rax), %%rdi\n\t" \
1665 "movq (%%rax), %%rax\n\t" /* target->%rax */ \
1666 VALGRIND_CALL_NOREDIR_RAX \
1667 VALGRIND_RESTORE_STACK \
1668 VALGRIND_CFI_EPILOGUE \
1669 : /*out*/ "=a" (_res) \
1670 : /*in*/ "a" (&_argvec[0]) __FRAME_POINTER \
1671 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS, "r14", "r15" \
1672 ); \
1673 lval = (__typeof__(lval)) _res; \
1674 } while (0)
1675
1676 #define CALL_FN_W_6W(lval, orig, arg1,arg2,arg3,arg4,arg5,arg6) \
1677 do { \
1678 volatile OrigFn _orig = (orig); \
1679 volatile unsigned long _argvec[7]; \
1680 volatile unsigned long _res; \
1681 _argvec[0] = (unsigned long)_orig.nraddr; \
1682 _argvec[1] = (unsigned long)(arg1); \
1683 _argvec[2] = (unsigned long)(arg2); \
1684 _argvec[3] = (unsigned long)(arg3); \
1685 _argvec[4] = (unsigned long)(arg4); \
1686 _argvec[5] = (unsigned long)(arg5); \
1687 _argvec[6] = (unsigned long)(arg6); \
1688 __asm__ volatile( \
1689 VALGRIND_CFI_PROLOGUE \
1690 VALGRIND_ALIGN_STACK \
1691 "subq $128,%%rsp\n\t" \
1692 "movq 48(%%rax), %%r9\n\t" \
1693 "movq 40(%%rax), %%r8\n\t" \
1694 "movq 32(%%rax), %%rcx\n\t" \
1695 "movq 24(%%rax), %%rdx\n\t" \
1696 "movq 16(%%rax), %%rsi\n\t" \
1697 "movq 8(%%rax), %%rdi\n\t" \
1698 "movq (%%rax), %%rax\n\t" /* target->%rax */ \
1699 VALGRIND_CALL_NOREDIR_RAX \
1700 VALGRIND_RESTORE_STACK \
1701 VALGRIND_CFI_EPILOGUE \
1702 : /*out*/ "=a" (_res) \
1703 : /*in*/ "a" (&_argvec[0]) __FRAME_POINTER \
1704 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS, "r14", "r15" \
1705 ); \
1706 lval = (__typeof__(lval)) _res; \
1707 } while (0)
1708
1709 #define CALL_FN_W_7W(lval, orig, arg1,arg2,arg3,arg4,arg5,arg6, \
1710 arg7) \
1711 do { \
1712 volatile OrigFn _orig = (orig); \
1713 volatile unsigned long _argvec[8]; \
1714 volatile unsigned long _res; \
1715 _argvec[0] = (unsigned long)_orig.nraddr; \
1716 _argvec[1] = (unsigned long)(arg1); \
1717 _argvec[2] = (unsigned long)(arg2); \
1718 _argvec[3] = (unsigned long)(arg3); \
1719 _argvec[4] = (unsigned long)(arg4); \
1720 _argvec[5] = (unsigned long)(arg5); \
1721 _argvec[6] = (unsigned long)(arg6); \
1722 _argvec[7] = (unsigned long)(arg7); \
1723 __asm__ volatile( \
1724 VALGRIND_CFI_PROLOGUE \
1725 VALGRIND_ALIGN_STACK \
1726 "subq $136,%%rsp\n\t" \
1727 "pushq 56(%%rax)\n\t" \
1728 "movq 48(%%rax), %%r9\n\t" \
1729 "movq 40(%%rax), %%r8\n\t" \
1730 "movq 32(%%rax), %%rcx\n\t" \
1731 "movq 24(%%rax), %%rdx\n\t" \
1732 "movq 16(%%rax), %%rsi\n\t" \
1733 "movq 8(%%rax), %%rdi\n\t" \
1734 "movq (%%rax), %%rax\n\t" /* target->%rax */ \
1735 VALGRIND_CALL_NOREDIR_RAX \
1736 VALGRIND_RESTORE_STACK \
1737 VALGRIND_CFI_EPILOGUE \
1738 : /*out*/ "=a" (_res) \
1739 : /*in*/ "a" (&_argvec[0]) __FRAME_POINTER \
1740 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS, "r14", "r15" \
1741 ); \
1742 lval = (__typeof__(lval)) _res; \
1743 } while (0)
1744
1745 #define CALL_FN_W_8W(lval, orig, arg1,arg2,arg3,arg4,arg5,arg6, \
1746 arg7,arg8) \
1747 do { \
1748 volatile OrigFn _orig = (orig); \
1749 volatile unsigned long _argvec[9]; \
1750 volatile unsigned long _res; \
1751 _argvec[0] = (unsigned long)_orig.nraddr; \
1752 _argvec[1] = (unsigned long)(arg1); \
1753 _argvec[2] = (unsigned long)(arg2); \
1754 _argvec[3] = (unsigned long)(arg3); \
1755 _argvec[4] = (unsigned long)(arg4); \
1756 _argvec[5] = (unsigned long)(arg5); \
1757 _argvec[6] = (unsigned long)(arg6); \
1758 _argvec[7] = (unsigned long)(arg7); \
1759 _argvec[8] = (unsigned long)(arg8); \
1760 __asm__ volatile( \
1761 VALGRIND_CFI_PROLOGUE \
1762 VALGRIND_ALIGN_STACK \
1763 "subq $128,%%rsp\n\t" \
1764 "pushq 64(%%rax)\n\t" \
1765 "pushq 56(%%rax)\n\t" \
1766 "movq 48(%%rax), %%r9\n\t" \
1767 "movq 40(%%rax), %%r8\n\t" \
1768 "movq 32(%%rax), %%rcx\n\t" \
1769 "movq 24(%%rax), %%rdx\n\t" \
1770 "movq 16(%%rax), %%rsi\n\t" \
1771 "movq 8(%%rax), %%rdi\n\t" \
1772 "movq (%%rax), %%rax\n\t" /* target->%rax */ \
1773 VALGRIND_CALL_NOREDIR_RAX \
1774 VALGRIND_RESTORE_STACK \
1775 VALGRIND_CFI_EPILOGUE \
1776 : /*out*/ "=a" (_res) \
1777 : /*in*/ "a" (&_argvec[0]) __FRAME_POINTER \
1778 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS, "r14", "r15" \
1779 ); \
1780 lval = (__typeof__(lval)) _res; \
1781 } while (0)
1782
1783 #define CALL_FN_W_9W(lval, orig, arg1,arg2,arg3,arg4,arg5,arg6, \
1784 arg7,arg8,arg9) \
1785 do { \
1786 volatile OrigFn _orig = (orig); \
1787 volatile unsigned long _argvec[10]; \
1788 volatile unsigned long _res; \
1789 _argvec[0] = (unsigned long)_orig.nraddr; \
1790 _argvec[1] = (unsigned long)(arg1); \
1791 _argvec[2] = (unsigned long)(arg2); \
1792 _argvec[3] = (unsigned long)(arg3); \
1793 _argvec[4] = (unsigned long)(arg4); \
1794 _argvec[5] = (unsigned long)(arg5); \
1795 _argvec[6] = (unsigned long)(arg6); \
1796 _argvec[7] = (unsigned long)(arg7); \
1797 _argvec[8] = (unsigned long)(arg8); \
1798 _argvec[9] = (unsigned long)(arg9); \
1799 __asm__ volatile( \
1800 VALGRIND_CFI_PROLOGUE \
1801 VALGRIND_ALIGN_STACK \
1802 "subq $136,%%rsp\n\t" \
1803 "pushq 72(%%rax)\n\t" \
1804 "pushq 64(%%rax)\n\t" \
1805 "pushq 56(%%rax)\n\t" \
1806 "movq 48(%%rax), %%r9\n\t" \
1807 "movq 40(%%rax), %%r8\n\t" \
1808 "movq 32(%%rax), %%rcx\n\t" \
1809 "movq 24(%%rax), %%rdx\n\t" \
1810 "movq 16(%%rax), %%rsi\n\t" \
1811 "movq 8(%%rax), %%rdi\n\t" \
1812 "movq (%%rax), %%rax\n\t" /* target->%rax */ \
1813 VALGRIND_CALL_NOREDIR_RAX \
1814 VALGRIND_RESTORE_STACK \
1815 VALGRIND_CFI_EPILOGUE \
1816 : /*out*/ "=a" (_res) \
1817 : /*in*/ "a" (&_argvec[0]) __FRAME_POINTER \
1818 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS, "r14", "r15" \
1819 ); \
1820 lval = (__typeof__(lval)) _res; \
1821 } while (0)
1822
1823 #define CALL_FN_W_10W(lval, orig, arg1,arg2,arg3,arg4,arg5,arg6, \
1824 arg7,arg8,arg9,arg10) \
1825 do { \
1826 volatile OrigFn _orig = (orig); \
1827 volatile unsigned long _argvec[11]; \
1828 volatile unsigned long _res; \
1829 _argvec[0] = (unsigned long)_orig.nraddr; \
1830 _argvec[1] = (unsigned long)(arg1); \
1831 _argvec[2] = (unsigned long)(arg2); \
1832 _argvec[3] = (unsigned long)(arg3); \
1833 _argvec[4] = (unsigned long)(arg4); \
1834 _argvec[5] = (unsigned long)(arg5); \
1835 _argvec[6] = (unsigned long)(arg6); \
1836 _argvec[7] = (unsigned long)(arg7); \
1837 _argvec[8] = (unsigned long)(arg8); \
1838 _argvec[9] = (unsigned long)(arg9); \
1839 _argvec[10] = (unsigned long)(arg10); \
1840 __asm__ volatile( \
1841 VALGRIND_CFI_PROLOGUE \
1842 VALGRIND_ALIGN_STACK \
1843 "subq $128,%%rsp\n\t" \
1844 "pushq 80(%%rax)\n\t" \
1845 "pushq 72(%%rax)\n\t" \
1846 "pushq 64(%%rax)\n\t" \
1847 "pushq 56(%%rax)\n\t" \
1848 "movq 48(%%rax), %%r9\n\t" \
1849 "movq 40(%%rax), %%r8\n\t" \
1850 "movq 32(%%rax), %%rcx\n\t" \
1851 "movq 24(%%rax), %%rdx\n\t" \
1852 "movq 16(%%rax), %%rsi\n\t" \
1853 "movq 8(%%rax), %%rdi\n\t" \
1854 "movq (%%rax), %%rax\n\t" /* target->%rax */ \
1855 VALGRIND_CALL_NOREDIR_RAX \
1856 VALGRIND_RESTORE_STACK \
1857 VALGRIND_CFI_EPILOGUE \
1858 : /*out*/ "=a" (_res) \
1859 : /*in*/ "a" (&_argvec[0]) __FRAME_POINTER \
1860 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS, "r14", "r15" \
1861 ); \
1862 lval = (__typeof__(lval)) _res; \
1863 } while (0)
1864
1865 #define CALL_FN_W_11W(lval, orig, arg1,arg2,arg3,arg4,arg5,arg6, \
1866 arg7,arg8,arg9,arg10,arg11) \
1867 do { \
1868 volatile OrigFn _orig = (orig); \
1869 volatile unsigned long _argvec[12]; \
1870 volatile unsigned long _res; \
1871 _argvec[0] = (unsigned long)_orig.nraddr; \
1872 _argvec[1] = (unsigned long)(arg1); \
1873 _argvec[2] = (unsigned long)(arg2); \
1874 _argvec[3] = (unsigned long)(arg3); \
1875 _argvec[4] = (unsigned long)(arg4); \
1876 _argvec[5] = (unsigned long)(arg5); \
1877 _argvec[6] = (unsigned long)(arg6); \
1878 _argvec[7] = (unsigned long)(arg7); \
1879 _argvec[8] = (unsigned long)(arg8); \
1880 _argvec[9] = (unsigned long)(arg9); \
1881 _argvec[10] = (unsigned long)(arg10); \
1882 _argvec[11] = (unsigned long)(arg11); \
1883 __asm__ volatile( \
1884 VALGRIND_CFI_PROLOGUE \
1885 VALGRIND_ALIGN_STACK \
1886 "subq $136,%%rsp\n\t" \
1887 "pushq 88(%%rax)\n\t" \
1888 "pushq 80(%%rax)\n\t" \
1889 "pushq 72(%%rax)\n\t" \
1890 "pushq 64(%%rax)\n\t" \
1891 "pushq 56(%%rax)\n\t" \
1892 "movq 48(%%rax), %%r9\n\t" \
1893 "movq 40(%%rax), %%r8\n\t" \
1894 "movq 32(%%rax), %%rcx\n\t" \
1895 "movq 24(%%rax), %%rdx\n\t" \
1896 "movq 16(%%rax), %%rsi\n\t" \
1897 "movq 8(%%rax), %%rdi\n\t" \
1898 "movq (%%rax), %%rax\n\t" /* target->%rax */ \
1899 VALGRIND_CALL_NOREDIR_RAX \
1900 VALGRIND_RESTORE_STACK \
1901 VALGRIND_CFI_EPILOGUE \
1902 : /*out*/ "=a" (_res) \
1903 : /*in*/ "a" (&_argvec[0]) __FRAME_POINTER \
1904 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS, "r14", "r15" \
1905 ); \
1906 lval = (__typeof__(lval)) _res; \
1907 } while (0)
1908
1909 #define CALL_FN_W_12W(lval, orig, arg1,arg2,arg3,arg4,arg5,arg6, \
1910 arg7,arg8,arg9,arg10,arg11,arg12) \
1911 do { \
1912 volatile OrigFn _orig = (orig); \
1913 volatile unsigned long _argvec[13]; \
1914 volatile unsigned long _res; \
1915 _argvec[0] = (unsigned long)_orig.nraddr; \
1916 _argvec[1] = (unsigned long)(arg1); \
1917 _argvec[2] = (unsigned long)(arg2); \
1918 _argvec[3] = (unsigned long)(arg3); \
1919 _argvec[4] = (unsigned long)(arg4); \
1920 _argvec[5] = (unsigned long)(arg5); \
1921 _argvec[6] = (unsigned long)(arg6); \
1922 _argvec[7] = (unsigned long)(arg7); \
1923 _argvec[8] = (unsigned long)(arg8); \
1924 _argvec[9] = (unsigned long)(arg9); \
1925 _argvec[10] = (unsigned long)(arg10); \
1926 _argvec[11] = (unsigned long)(arg11); \
1927 _argvec[12] = (unsigned long)(arg12); \
1928 __asm__ volatile( \
1929 VALGRIND_CFI_PROLOGUE \
1930 VALGRIND_ALIGN_STACK \
1931 "subq $128,%%rsp\n\t" \
1932 "pushq 96(%%rax)\n\t" \
1933 "pushq 88(%%rax)\n\t" \
1934 "pushq 80(%%rax)\n\t" \
1935 "pushq 72(%%rax)\n\t" \
1936 "pushq 64(%%rax)\n\t" \
1937 "pushq 56(%%rax)\n\t" \
1938 "movq 48(%%rax), %%r9\n\t" \
1939 "movq 40(%%rax), %%r8\n\t" \
1940 "movq 32(%%rax), %%rcx\n\t" \
1941 "movq 24(%%rax), %%rdx\n\t" \
1942 "movq 16(%%rax), %%rsi\n\t" \
1943 "movq 8(%%rax), %%rdi\n\t" \
1944 "movq (%%rax), %%rax\n\t" /* target->%rax */ \
1945 VALGRIND_CALL_NOREDIR_RAX \
1946 VALGRIND_RESTORE_STACK \
1947 VALGRIND_CFI_EPILOGUE \
1948 : /*out*/ "=a" (_res) \
1949 : /*in*/ "a" (&_argvec[0]) __FRAME_POINTER \
1950 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS, "r14", "r15" \
1951 ); \
1952 lval = (__typeof__(lval)) _res; \
1953 } while (0)
1954
1955 #endif /* PLAT_amd64_linux || PLAT_amd64_darwin */
1956
1957 /* ------------------------ ppc32-linux ------------------------ */
1958
1959 #if defined(PLAT_ppc32_linux)
1960
1961 /* This is useful for finding out about the on-stack stuff:
1962
1963 extern int f9 ( int,int,int,int,int,int,int,int,int );
1964 extern int f10 ( int,int,int,int,int,int,int,int,int,int );
1965 extern int f11 ( int,int,int,int,int,int,int,int,int,int,int );
1966 extern int f12 ( int,int,int,int,int,int,int,int,int,int,int,int );
1967
1968 int g9 ( void ) {
1969 return f9(11,22,33,44,55,66,77,88,99);
1970 }
1971 int g10 ( void ) {
1972 return f10(11,22,33,44,55,66,77,88,99,110);
1973 }
1974 int g11 ( void ) {
1975 return f11(11,22,33,44,55,66,77,88,99,110,121);
1976 }
1977 int g12 ( void ) {
1978 return f12(11,22,33,44,55,66,77,88,99,110,121,132);
1979 }
1980 */
1981
1982 /* ARGREGS: r3 r4 r5 r6 r7 r8 r9 r10 (the rest on stack somewhere) */
1983
1984 /* These regs are trashed by the hidden call. */
1985 #define __CALLER_SAVED_REGS \
1986 "lr", "ctr", "xer", \
1987 "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7", \
1988 "r0", "r2", "r3", "r4", "r5", "r6", "r7", "r8", "r9", "r10", \
1989 "r11", "r12", "r13"
1990
1991 /* Macros to save and align the stack before making a function
1992 call and restore it afterwards as gcc may not keep the stack
1993 pointer aligned if it doesn't realise calls are being made
1994 to other functions. */
1995
1996 #define VALGRIND_ALIGN_STACK \
1997 "mr 28,1\n\t" \
1998 "rlwinm 1,1,0,0,27\n\t"
1999 #define VALGRIND_RESTORE_STACK \
2000 "mr 1,28\n\t"
2001
2002 /* These CALL_FN_ macros assume that on ppc32-linux,
2003 sizeof(unsigned long) == 4. */
2004
2005 #define CALL_FN_W_v(lval, orig) \
2006 do { \
2007 volatile OrigFn _orig = (orig); \
2008 volatile unsigned long _argvec[1]; \
2009 volatile unsigned long _res; \
2010 _argvec[0] = (unsigned long)_orig.nraddr; \
2011 __asm__ volatile( \
2012 VALGRIND_ALIGN_STACK \
2013 "mr 11,%1\n\t" \
2014 "lwz 11,0(11)\n\t" /* target->r11 */ \
2015 VALGRIND_BRANCH_AND_LINK_TO_NOREDIR_R11 \
2016 VALGRIND_RESTORE_STACK \
2017 "mr %0,3" \
2018 : /*out*/ "=r" (_res) \
2019 : /*in*/ "r" (&_argvec[0]) \
2020 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS, "r28" \
2021 ); \
2022 lval = (__typeof__(lval)) _res; \
2023 } while (0)
2024
2025 #define CALL_FN_W_W(lval, orig, arg1) \
2026 do { \
2027 volatile OrigFn _orig = (orig); \
2028 volatile unsigned long _argvec[2]; \
2029 volatile unsigned long _res; \
2030 _argvec[0] = (unsigned long)_orig.nraddr; \
2031 _argvec[1] = (unsigned long)arg1; \
2032 __asm__ volatile( \
2033 VALGRIND_ALIGN_STACK \
2034 "mr 11,%1\n\t" \
2035 "lwz 3,4(11)\n\t" /* arg1->r3 */ \
2036 "lwz 11,0(11)\n\t" /* target->r11 */ \
2037 VALGRIND_BRANCH_AND_LINK_TO_NOREDIR_R11 \
2038 VALGRIND_RESTORE_STACK \
2039 "mr %0,3" \
2040 : /*out*/ "=r" (_res) \
2041 : /*in*/ "r" (&_argvec[0]) \
2042 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS, "r28" \
2043 ); \
2044 lval = (__typeof__(lval)) _res; \
2045 } while (0)
2046
2047 #define CALL_FN_W_WW(lval, orig, arg1,arg2) \
2048 do { \
2049 volatile OrigFn _orig = (orig); \
2050 volatile unsigned long _argvec[3]; \
2051 volatile unsigned long _res; \
2052 _argvec[0] = (unsigned long)_orig.nraddr; \
2053 _argvec[1] = (unsigned long)arg1; \
2054 _argvec[2] = (unsigned long)arg2; \
2055 __asm__ volatile( \
2056 VALGRIND_ALIGN_STACK \
2057 "mr 11,%1\n\t" \
2058 "lwz 3,4(11)\n\t" /* arg1->r3 */ \
2059 "lwz 4,8(11)\n\t" \
2060 "lwz 11,0(11)\n\t" /* target->r11 */ \
2061 VALGRIND_BRANCH_AND_LINK_TO_NOREDIR_R11 \
2062 VALGRIND_RESTORE_STACK \
2063 "mr %0,3" \
2064 : /*out*/ "=r" (_res) \
2065 : /*in*/ "r" (&_argvec[0]) \
2066 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS, "r28" \
2067 ); \
2068 lval = (__typeof__(lval)) _res; \
2069 } while (0)
2070
2071 #define CALL_FN_W_WWW(lval, orig, arg1,arg2,arg3) \
2072 do { \
2073 volatile OrigFn _orig = (orig); \
2074 volatile unsigned long _argvec[4]; \
2075 volatile unsigned long _res; \
2076 _argvec[0] = (unsigned long)_orig.nraddr; \
2077 _argvec[1] = (unsigned long)arg1; \
2078 _argvec[2] = (unsigned long)arg2; \
2079 _argvec[3] = (unsigned long)arg3; \
2080 __asm__ volatile( \
2081 VALGRIND_ALIGN_STACK \
2082 "mr 11,%1\n\t" \
2083 "lwz 3,4(11)\n\t" /* arg1->r3 */ \
2084 "lwz 4,8(11)\n\t" \
2085 "lwz 5,12(11)\n\t" \
2086 "lwz 11,0(11)\n\t" /* target->r11 */ \
2087 VALGRIND_BRANCH_AND_LINK_TO_NOREDIR_R11 \
2088 VALGRIND_RESTORE_STACK \
2089 "mr %0,3" \
2090 : /*out*/ "=r" (_res) \
2091 : /*in*/ "r" (&_argvec[0]) \
2092 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS, "r28" \
2093 ); \
2094 lval = (__typeof__(lval)) _res; \
2095 } while (0)
2096
2097 #define CALL_FN_W_WWWW(lval, orig, arg1,arg2,arg3,arg4) \
2098 do { \
2099 volatile OrigFn _orig = (orig); \
2100 volatile unsigned long _argvec[5]; \
2101 volatile unsigned long _res; \
2102 _argvec[0] = (unsigned long)_orig.nraddr; \
2103 _argvec[1] = (unsigned long)arg1; \
2104 _argvec[2] = (unsigned long)arg2; \
2105 _argvec[3] = (unsigned long)arg3; \
2106 _argvec[4] = (unsigned long)arg4; \
2107 __asm__ volatile( \
2108 VALGRIND_ALIGN_STACK \
2109 "mr 11,%1\n\t" \
2110 "lwz 3,4(11)\n\t" /* arg1->r3 */ \
2111 "lwz 4,8(11)\n\t" \
2112 "lwz 5,12(11)\n\t" \
2113 "lwz 6,16(11)\n\t" /* arg4->r6 */ \
2114 "lwz 11,0(11)\n\t" /* target->r11 */ \
2115 VALGRIND_BRANCH_AND_LINK_TO_NOREDIR_R11 \
2116 VALGRIND_RESTORE_STACK \
2117 "mr %0,3" \
2118 : /*out*/ "=r" (_res) \
2119 : /*in*/ "r" (&_argvec[0]) \
2120 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS, "r28" \
2121 ); \
2122 lval = (__typeof__(lval)) _res; \
2123 } while (0)
2124
2125 #define CALL_FN_W_5W(lval, orig, arg1,arg2,arg3,arg4,arg5) \
2126 do { \
2127 volatile OrigFn _orig = (orig); \
2128 volatile unsigned long _argvec[6]; \
2129 volatile unsigned long _res; \
2130 _argvec[0] = (unsigned long)_orig.nraddr; \
2131 _argvec[1] = (unsigned long)arg1; \
2132 _argvec[2] = (unsigned long)arg2; \
2133 _argvec[3] = (unsigned long)arg3; \
2134 _argvec[4] = (unsigned long)arg4; \
2135 _argvec[5] = (unsigned long)arg5; \
2136 __asm__ volatile( \
2137 VALGRIND_ALIGN_STACK \
2138 "mr 11,%1\n\t" \
2139 "lwz 3,4(11)\n\t" /* arg1->r3 */ \
2140 "lwz 4,8(11)\n\t" \
2141 "lwz 5,12(11)\n\t" \
2142 "lwz 6,16(11)\n\t" /* arg4->r6 */ \
2143 "lwz 7,20(11)\n\t" \
2144 "lwz 11,0(11)\n\t" /* target->r11 */ \
2145 VALGRIND_BRANCH_AND_LINK_TO_NOREDIR_R11 \
2146 VALGRIND_RESTORE_STACK \
2147 "mr %0,3" \
2148 : /*out*/ "=r" (_res) \
2149 : /*in*/ "r" (&_argvec[0]) \
2150 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS, "r28" \
2151 ); \
2152 lval = (__typeof__(lval)) _res; \
2153 } while (0)
2154
2155 #define CALL_FN_W_6W(lval, orig, arg1,arg2,arg3,arg4,arg5,arg6) \
2156 do { \
2157 volatile OrigFn _orig = (orig); \
2158 volatile unsigned long _argvec[7]; \
2159 volatile unsigned long _res; \
2160 _argvec[0] = (unsigned long)_orig.nraddr; \
2161 _argvec[1] = (unsigned long)arg1; \
2162 _argvec[2] = (unsigned long)arg2; \
2163 _argvec[3] = (unsigned long)arg3; \
2164 _argvec[4] = (unsigned long)arg4; \
2165 _argvec[5] = (unsigned long)arg5; \
2166 _argvec[6] = (unsigned long)arg6; \
2167 __asm__ volatile( \
2168 VALGRIND_ALIGN_STACK \
2169 "mr 11,%1\n\t" \
2170 "lwz 3,4(11)\n\t" /* arg1->r3 */ \
2171 "lwz 4,8(11)\n\t" \
2172 "lwz 5,12(11)\n\t" \
2173 "lwz 6,16(11)\n\t" /* arg4->r6 */ \
2174 "lwz 7,20(11)\n\t" \
2175 "lwz 8,24(11)\n\t" \
2176 "lwz 11,0(11)\n\t" /* target->r11 */ \
2177 VALGRIND_BRANCH_AND_LINK_TO_NOREDIR_R11 \
2178 VALGRIND_RESTORE_STACK \
2179 "mr %0,3" \
2180 : /*out*/ "=r" (_res) \
2181 : /*in*/ "r" (&_argvec[0]) \
2182 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS, "r28" \
2183 ); \
2184 lval = (__typeof__(lval)) _res; \
2185 } while (0)
2186
2187 #define CALL_FN_W_7W(lval, orig, arg1,arg2,arg3,arg4,arg5,arg6, \
2188 arg7) \
2189 do { \
2190 volatile OrigFn _orig = (orig); \
2191 volatile unsigned long _argvec[8]; \
2192 volatile unsigned long _res; \
2193 _argvec[0] = (unsigned long)_orig.nraddr; \
2194 _argvec[1] = (unsigned long)arg1; \
2195 _argvec[2] = (unsigned long)arg2; \
2196 _argvec[3] = (unsigned long)arg3; \
2197 _argvec[4] = (unsigned long)arg4; \
2198 _argvec[5] = (unsigned long)arg5; \
2199 _argvec[6] = (unsigned long)arg6; \
2200 _argvec[7] = (unsigned long)arg7; \
2201 __asm__ volatile( \
2202 VALGRIND_ALIGN_STACK \
2203 "mr 11,%1\n\t" \
2204 "lwz 3,4(11)\n\t" /* arg1->r3 */ \
2205 "lwz 4,8(11)\n\t" \
2206 "lwz 5,12(11)\n\t" \
2207 "lwz 6,16(11)\n\t" /* arg4->r6 */ \
2208 "lwz 7,20(11)\n\t" \
2209 "lwz 8,24(11)\n\t" \
2210 "lwz 9,28(11)\n\t" \
2211 "lwz 11,0(11)\n\t" /* target->r11 */ \
2212 VALGRIND_BRANCH_AND_LINK_TO_NOREDIR_R11 \
2213 VALGRIND_RESTORE_STACK \
2214 "mr %0,3" \
2215 : /*out*/ "=r" (_res) \
2216 : /*in*/ "r" (&_argvec[0]) \
2217 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS, "r28" \
2218 ); \
2219 lval = (__typeof__(lval)) _res; \
2220 } while (0)
2221
2222 #define CALL_FN_W_8W(lval, orig, arg1,arg2,arg3,arg4,arg5,arg6, \
2223 arg7,arg8) \
2224 do { \
2225 volatile OrigFn _orig = (orig); \
2226 volatile unsigned long _argvec[9]; \
2227 volatile unsigned long _res; \
2228 _argvec[0] = (unsigned long)_orig.nraddr; \
2229 _argvec[1] = (unsigned long)arg1; \
2230 _argvec[2] = (unsigned long)arg2; \
2231 _argvec[3] = (unsigned long)arg3; \
2232 _argvec[4] = (unsigned long)arg4; \
2233 _argvec[5] = (unsigned long)arg5; \
2234 _argvec[6] = (unsigned long)arg6; \
2235 _argvec[7] = (unsigned long)arg7; \
2236 _argvec[8] = (unsigned long)arg8; \
2237 __asm__ volatile( \
2238 VALGRIND_ALIGN_STACK \
2239 "mr 11,%1\n\t" \
2240 "lwz 3,4(11)\n\t" /* arg1->r3 */ \
2241 "lwz 4,8(11)\n\t" \
2242 "lwz 5,12(11)\n\t" \
2243 "lwz 6,16(11)\n\t" /* arg4->r6 */ \
2244 "lwz 7,20(11)\n\t" \
2245 "lwz 8,24(11)\n\t" \
2246 "lwz 9,28(11)\n\t" \
2247 "lwz 10,32(11)\n\t" /* arg8->r10 */ \
2248 "lwz 11,0(11)\n\t" /* target->r11 */ \
2249 VALGRIND_BRANCH_AND_LINK_TO_NOREDIR_R11 \
2250 VALGRIND_RESTORE_STACK \
2251 "mr %0,3" \
2252 : /*out*/ "=r" (_res) \
2253 : /*in*/ "r" (&_argvec[0]) \
2254 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS, "r28" \
2255 ); \
2256 lval = (__typeof__(lval)) _res; \
2257 } while (0)
2258
2259 #define CALL_FN_W_9W(lval, orig, arg1,arg2,arg3,arg4,arg5,arg6, \
2260 arg7,arg8,arg9) \
2261 do { \
2262 volatile OrigFn _orig = (orig); \
2263 volatile unsigned long _argvec[10]; \
2264 volatile unsigned long _res; \
2265 _argvec[0] = (unsigned long)_orig.nraddr; \
2266 _argvec[1] = (unsigned long)arg1; \
2267 _argvec[2] = (unsigned long)arg2; \
2268 _argvec[3] = (unsigned long)arg3; \
2269 _argvec[4] = (unsigned long)arg4; \
2270 _argvec[5] = (unsigned long)arg5; \
2271 _argvec[6] = (unsigned long)arg6; \
2272 _argvec[7] = (unsigned long)arg7; \
2273 _argvec[8] = (unsigned long)arg8; \
2274 _argvec[9] = (unsigned long)arg9; \
2275 __asm__ volatile( \
2276 VALGRIND_ALIGN_STACK \
2277 "mr 11,%1\n\t" \
2278 "addi 1,1,-16\n\t" \
2279 /* arg9 */ \
2280 "lwz 3,36(11)\n\t" \
2281 "stw 3,8(1)\n\t" \
2282 /* args1-8 */ \
2283 "lwz 3,4(11)\n\t" /* arg1->r3 */ \
2284 "lwz 4,8(11)\n\t" \
2285 "lwz 5,12(11)\n\t" \
2286 "lwz 6,16(11)\n\t" /* arg4->r6 */ \
2287 "lwz 7,20(11)\n\t" \
2288 "lwz 8,24(11)\n\t" \
2289 "lwz 9,28(11)\n\t" \
2290 "lwz 10,32(11)\n\t" /* arg8->r10 */ \
2291 "lwz 11,0(11)\n\t" /* target->r11 */ \
2292 VALGRIND_BRANCH_AND_LINK_TO_NOREDIR_R11 \
2293 VALGRIND_RESTORE_STACK \
2294 "mr %0,3" \
2295 : /*out*/ "=r" (_res) \
2296 : /*in*/ "r" (&_argvec[0]) \
2297 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS, "r28" \
2298 ); \
2299 lval = (__typeof__(lval)) _res; \
2300 } while (0)
2301
2302 #define CALL_FN_W_10W(lval, orig, arg1,arg2,arg3,arg4,arg5,arg6, \
2303 arg7,arg8,arg9,arg10) \
2304 do { \
2305 volatile OrigFn _orig = (orig); \
2306 volatile unsigned long _argvec[11]; \
2307 volatile unsigned long _res; \
2308 _argvec[0] = (unsigned long)_orig.nraddr; \
2309 _argvec[1] = (unsigned long)arg1; \
2310 _argvec[2] = (unsigned long)arg2; \
2311 _argvec[3] = (unsigned long)arg3; \
2312 _argvec[4] = (unsigned long)arg4; \
2313 _argvec[5] = (unsigned long)arg5; \
2314 _argvec[6] = (unsigned long)arg6; \
2315 _argvec[7] = (unsigned long)arg7; \
2316 _argvec[8] = (unsigned long)arg8; \
2317 _argvec[9] = (unsigned long)arg9; \
2318 _argvec[10] = (unsigned long)arg10; \
2319 __asm__ volatile( \
2320 VALGRIND_ALIGN_STACK \
2321 "mr 11,%1\n\t" \
2322 "addi 1,1,-16\n\t" \
2323 /* arg10 */ \
2324 "lwz 3,40(11)\n\t" \
2325 "stw 3,12(1)\n\t" \
2326 /* arg9 */ \
2327 "lwz 3,36(11)\n\t" \
2328 "stw 3,8(1)\n\t" \
2329 /* args1-8 */ \
2330 "lwz 3,4(11)\n\t" /* arg1->r3 */ \
2331 "lwz 4,8(11)\n\t" \
2332 "lwz 5,12(11)\n\t" \
2333 "lwz 6,16(11)\n\t" /* arg4->r6 */ \
2334 "lwz 7,20(11)\n\t" \
2335 "lwz 8,24(11)\n\t" \
2336 "lwz 9,28(11)\n\t" \
2337 "lwz 10,32(11)\n\t" /* arg8->r10 */ \
2338 "lwz 11,0(11)\n\t" /* target->r11 */ \
2339 VALGRIND_BRANCH_AND_LINK_TO_NOREDIR_R11 \
2340 VALGRIND_RESTORE_STACK \
2341 "mr %0,3" \
2342 : /*out*/ "=r" (_res) \
2343 : /*in*/ "r" (&_argvec[0]) \
2344 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS, "r28" \
2345 ); \
2346 lval = (__typeof__(lval)) _res; \
2347 } while (0)
2348
2349 #define CALL_FN_W_11W(lval, orig, arg1,arg2,arg3,arg4,arg5,arg6, \
2350 arg7,arg8,arg9,arg10,arg11) \
2351 do { \
2352 volatile OrigFn _orig = (orig); \
2353 volatile unsigned long _argvec[12]; \
2354 volatile unsigned long _res; \
2355 _argvec[0] = (unsigned long)_orig.nraddr; \
2356 _argvec[1] = (unsigned long)arg1; \
2357 _argvec[2] = (unsigned long)arg2; \
2358 _argvec[3] = (unsigned long)arg3; \
2359 _argvec[4] = (unsigned long)arg4; \
2360 _argvec[5] = (unsigned long)arg5; \
2361 _argvec[6] = (unsigned long)arg6; \
2362 _argvec[7] = (unsigned long)arg7; \
2363 _argvec[8] = (unsigned long)arg8; \
2364 _argvec[9] = (unsigned long)arg9; \
2365 _argvec[10] = (unsigned long)arg10; \
2366 _argvec[11] = (unsigned long)arg11; \
2367 __asm__ volatile( \
2368 VALGRIND_ALIGN_STACK \
2369 "mr 11,%1\n\t" \
2370 "addi 1,1,-32\n\t" \
2371 /* arg11 */ \
2372 "lwz 3,44(11)\n\t" \
2373 "stw 3,16(1)\n\t" \
2374 /* arg10 */ \
2375 "lwz 3,40(11)\n\t" \
2376 "stw 3,12(1)\n\t" \
2377 /* arg9 */ \
2378 "lwz 3,36(11)\n\t" \
2379 "stw 3,8(1)\n\t" \
2380 /* args1-8 */ \
2381 "lwz 3,4(11)\n\t" /* arg1->r3 */ \
2382 "lwz 4,8(11)\n\t" \
2383 "lwz 5,12(11)\n\t" \
2384 "lwz 6,16(11)\n\t" /* arg4->r6 */ \
2385 "lwz 7,20(11)\n\t" \
2386 "lwz 8,24(11)\n\t" \
2387 "lwz 9,28(11)\n\t" \
2388 "lwz 10,32(11)\n\t" /* arg8->r10 */ \
2389 "lwz 11,0(11)\n\t" /* target->r11 */ \
2390 VALGRIND_BRANCH_AND_LINK_TO_NOREDIR_R11 \
2391 VALGRIND_RESTORE_STACK \
2392 "mr %0,3" \
2393 : /*out*/ "=r" (_res) \
2394 : /*in*/ "r" (&_argvec[0]) \
2395 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS, "r28" \
2396 ); \
2397 lval = (__typeof__(lval)) _res; \
2398 } while (0)
2399
2400 #define CALL_FN_W_12W(lval, orig, arg1,arg2,arg3,arg4,arg5,arg6, \
2401 arg7,arg8,arg9,arg10,arg11,arg12) \
2402 do { \
2403 volatile OrigFn _orig = (orig); \
2404 volatile unsigned long _argvec[13]; \
2405 volatile unsigned long _res; \
2406 _argvec[0] = (unsigned long)_orig.nraddr; \
2407 _argvec[1] = (unsigned long)arg1; \
2408 _argvec[2] = (unsigned long)arg2; \
2409 _argvec[3] = (unsigned long)arg3; \
2410 _argvec[4] = (unsigned long)arg4; \
2411 _argvec[5] = (unsigned long)arg5; \
2412 _argvec[6] = (unsigned long)arg6; \
2413 _argvec[7] = (unsigned long)arg7; \
2414 _argvec[8] = (unsigned long)arg8; \
2415 _argvec[9] = (unsigned long)arg9; \
2416 _argvec[10] = (unsigned long)arg10; \
2417 _argvec[11] = (unsigned long)arg11; \
2418 _argvec[12] = (unsigned long)arg12; \
2419 __asm__ volatile( \
2420 VALGRIND_ALIGN_STACK \
2421 "mr 11,%1\n\t" \
2422 "addi 1,1,-32\n\t" \
2423 /* arg12 */ \
2424 "lwz 3,48(11)\n\t" \
2425 "stw 3,20(1)\n\t" \
2426 /* arg11 */ \
2427 "lwz 3,44(11)\n\t" \
2428 "stw 3,16(1)\n\t" \
2429 /* arg10 */ \
2430 "lwz 3,40(11)\n\t" \
2431 "stw 3,12(1)\n\t" \
2432 /* arg9 */ \
2433 "lwz 3,36(11)\n\t" \
2434 "stw 3,8(1)\n\t" \
2435 /* args1-8 */ \
2436 "lwz 3,4(11)\n\t" /* arg1->r3 */ \
2437 "lwz 4,8(11)\n\t" \
2438 "lwz 5,12(11)\n\t" \
2439 "lwz 6,16(11)\n\t" /* arg4->r6 */ \
2440 "lwz 7,20(11)\n\t" \
2441 "lwz 8,24(11)\n\t" \
2442 "lwz 9,28(11)\n\t" \
2443 "lwz 10,32(11)\n\t" /* arg8->r10 */ \
2444 "lwz 11,0(11)\n\t" /* target->r11 */ \
2445 VALGRIND_BRANCH_AND_LINK_TO_NOREDIR_R11 \
2446 VALGRIND_RESTORE_STACK \
2447 "mr %0,3" \
2448 : /*out*/ "=r" (_res) \
2449 : /*in*/ "r" (&_argvec[0]) \
2450 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS, "r28" \
2451 ); \
2452 lval = (__typeof__(lval)) _res; \
2453 } while (0)
2454
2455 #endif /* PLAT_ppc32_linux */
2456
2457 /* ------------------------ ppc64-linux ------------------------ */
2458
2459 #if defined(PLAT_ppc64_linux)
2460
2461 /* ARGREGS: r3 r4 r5 r6 r7 r8 r9 r10 (the rest on stack somewhere) */
2462
2463 /* These regs are trashed by the hidden call. */
2464 #define __CALLER_SAVED_REGS \
2465 "lr", "ctr", "xer", \
2466 "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7", \
2467 "r0", "r2", "r3", "r4", "r5", "r6", "r7", "r8", "r9", "r10", \
2468 "r11", "r12", "r13"
2469
2470 /* Macros to save and align the stack before making a function
2471 call and restore it afterwards as gcc may not keep the stack
2472 pointer aligned if it doesn't realise calls are being made
2473 to other functions. */
2474
2475 #define VALGRIND_ALIGN_STACK \
2476 "mr 28,1\n\t" \
2477 "rldicr 1,1,0,59\n\t"
2478 #define VALGRIND_RESTORE_STACK \
2479 "mr 1,28\n\t"
2480
2481 /* These CALL_FN_ macros assume that on ppc64-linux, sizeof(unsigned
2482 long) == 8. */
2483
2484 #define CALL_FN_W_v(lval, orig) \
2485 do { \
2486 volatile OrigFn _orig = (orig); \
2487 volatile unsigned long _argvec[3+0]; \
2488 volatile unsigned long _res; \
2489 /* _argvec[0] holds current r2 across the call */ \
2490 _argvec[1] = (unsigned long)_orig.r2; \
2491 _argvec[2] = (unsigned long)_orig.nraddr; \
2492 __asm__ volatile( \
2493 VALGRIND_ALIGN_STACK \
2494 "mr 11,%1\n\t" \
2495 "std 2,-16(11)\n\t" /* save tocptr */ \
2496 "ld 2,-8(11)\n\t" /* use nraddr's tocptr */ \
2497 "ld 11, 0(11)\n\t" /* target->r11 */ \
2498 VALGRIND_BRANCH_AND_LINK_TO_NOREDIR_R11 \
2499 "mr 11,%1\n\t" \
2500 "mr %0,3\n\t" \
2501 "ld 2,-16(11)\n\t" /* restore tocptr */ \
2502 VALGRIND_RESTORE_STACK \
2503 : /*out*/ "=r" (_res) \
2504 : /*in*/ "r" (&_argvec[2]) \
2505 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS, "r28" \
2506 ); \
2507 lval = (__typeof__(lval)) _res; \
2508 } while (0)
2509
2510 #define CALL_FN_W_W(lval, orig, arg1) \
2511 do { \
2512 volatile OrigFn _orig = (orig); \
2513 volatile unsigned long _argvec[3+1]; \
2514 volatile unsigned long _res; \
2515 /* _argvec[0] holds current r2 across the call */ \
2516 _argvec[1] = (unsigned long)_orig.r2; \
2517 _argvec[2] = (unsigned long)_orig.nraddr; \
2518 _argvec[2+1] = (unsigned long)arg1; \
2519 __asm__ volatile( \
2520 VALGRIND_ALIGN_STACK \
2521 "mr 11,%1\n\t" \
2522 "std 2,-16(11)\n\t" /* save tocptr */ \
2523 "ld 2,-8(11)\n\t" /* use nraddr's tocptr */ \
2524 "ld 3, 8(11)\n\t" /* arg1->r3 */ \
2525 "ld 11, 0(11)\n\t" /* target->r11 */ \
2526 VALGRIND_BRANCH_AND_LINK_TO_NOREDIR_R11 \
2527 "mr 11,%1\n\t" \
2528 "mr %0,3\n\t" \
2529 "ld 2,-16(11)\n\t" /* restore tocptr */ \
2530 VALGRIND_RESTORE_STACK \
2531 : /*out*/ "=r" (_res) \
2532 : /*in*/ "r" (&_argvec[2]) \
2533 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS, "r28" \
2534 ); \
2535 lval = (__typeof__(lval)) _res; \
2536 } while (0)
2537
2538 #define CALL_FN_W_WW(lval, orig, arg1,arg2) \
2539 do { \
2540 volatile OrigFn _orig = (orig); \
2541 volatile unsigned long _argvec[3+2]; \
2542 volatile unsigned long _res; \
2543 /* _argvec[0] holds current r2 across the call */ \
2544 _argvec[1] = (unsigned long)_orig.r2; \
2545 _argvec[2] = (unsigned long)_orig.nraddr; \
2546 _argvec[2+1] = (unsigned long)arg1; \
2547 _argvec[2+2] = (unsigned long)arg2; \
2548 __asm__ volatile( \
2549 VALGRIND_ALIGN_STACK \
2550 "mr 11,%1\n\t" \
2551 "std 2,-16(11)\n\t" /* save tocptr */ \
2552 "ld 2,-8(11)\n\t" /* use nraddr's tocptr */ \
2553 "ld 3, 8(11)\n\t" /* arg1->r3 */ \
2554 "ld 4, 16(11)\n\t" /* arg2->r4 */ \
2555 "ld 11, 0(11)\n\t" /* target->r11 */ \
2556 VALGRIND_BRANCH_AND_LINK_TO_NOREDIR_R11 \
2557 "mr 11,%1\n\t" \
2558 "mr %0,3\n\t" \
2559 "ld 2,-16(11)\n\t" /* restore tocptr */ \
2560 VALGRIND_RESTORE_STACK \
2561 : /*out*/ "=r" (_res) \
2562 : /*in*/ "r" (&_argvec[2]) \
2563 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS, "r28" \
2564 ); \
2565 lval = (__typeof__(lval)) _res; \
2566 } while (0)
2567
2568 #define CALL_FN_W_WWW(lval, orig, arg1,arg2,arg3) \
2569 do { \
2570 volatile OrigFn _orig = (orig); \
2571 volatile unsigned long _argvec[3+3]; \
2572 volatile unsigned long _res; \
2573 /* _argvec[0] holds current r2 across the call */ \
2574 _argvec[1] = (unsigned long)_orig.r2; \
2575 _argvec[2] = (unsigned long)_orig.nraddr; \
2576 _argvec[2+1] = (unsigned long)arg1; \
2577 _argvec[2+2] = (unsigned long)arg2; \
2578 _argvec[2+3] = (unsigned long)arg3; \
2579 __asm__ volatile( \
2580 VALGRIND_ALIGN_STACK \
2581 "mr 11,%1\n\t" \
2582 "std 2,-16(11)\n\t" /* save tocptr */ \
2583 "ld 2,-8(11)\n\t" /* use nraddr's tocptr */ \
2584 "ld 3, 8(11)\n\t" /* arg1->r3 */ \
2585 "ld 4, 16(11)\n\t" /* arg2->r4 */ \
2586 "ld 5, 24(11)\n\t" /* arg3->r5 */ \
2587 "ld 11, 0(11)\n\t" /* target->r11 */ \
2588 VALGRIND_BRANCH_AND_LINK_TO_NOREDIR_R11 \
2589 "mr 11,%1\n\t" \
2590 "mr %0,3\n\t" \
2591 "ld 2,-16(11)\n\t" /* restore tocptr */ \
2592 VALGRIND_RESTORE_STACK \
2593 : /*out*/ "=r" (_res) \
2594 : /*in*/ "r" (&_argvec[2]) \
2595 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS, "r28" \
2596 ); \
2597 lval = (__typeof__(lval)) _res; \
2598 } while (0)
2599
2600 #define CALL_FN_W_WWWW(lval, orig, arg1,arg2,arg3,arg4) \
2601 do { \
2602 volatile OrigFn _orig = (orig); \
2603 volatile unsigned long _argvec[3+4]; \
2604 volatile unsigned long _res; \
2605 /* _argvec[0] holds current r2 across the call */ \
2606 _argvec[1] = (unsigned long)_orig.r2; \
2607 _argvec[2] = (unsigned long)_orig.nraddr; \
2608 _argvec[2+1] = (unsigned long)arg1; \
2609 _argvec[2+2] = (unsigned long)arg2; \
2610 _argvec[2+3] = (unsigned long)arg3; \
2611 _argvec[2+4] = (unsigned long)arg4; \
2612 __asm__ volatile( \
2613 VALGRIND_ALIGN_STACK \
2614 "mr 11,%1\n\t" \
2615 "std 2,-16(11)\n\t" /* save tocptr */ \
2616 "ld 2,-8(11)\n\t" /* use nraddr's tocptr */ \
2617 "ld 3, 8(11)\n\t" /* arg1->r3 */ \
2618 "ld 4, 16(11)\n\t" /* arg2->r4 */ \
2619 "ld 5, 24(11)\n\t" /* arg3->r5 */ \
2620 "ld 6, 32(11)\n\t" /* arg4->r6 */ \
2621 "ld 11, 0(11)\n\t" /* target->r11 */ \
2622 VALGRIND_BRANCH_AND_LINK_TO_NOREDIR_R11 \
2623 "mr 11,%1\n\t" \
2624 "mr %0,3\n\t" \
2625 "ld 2,-16(11)\n\t" /* restore tocptr */ \
2626 VALGRIND_RESTORE_STACK \
2627 : /*out*/ "=r" (_res) \
2628 : /*in*/ "r" (&_argvec[2]) \
2629 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS, "r28" \
2630 ); \
2631 lval = (__typeof__(lval)) _res; \
2632 } while (0)
2633
2634 #define CALL_FN_W_5W(lval, orig, arg1,arg2,arg3,arg4,arg5) \
2635 do { \
2636 volatile OrigFn _orig = (orig); \
2637 volatile unsigned long _argvec[3+5]; \
2638 volatile unsigned long _res; \
2639 /* _argvec[0] holds current r2 across the call */ \
2640 _argvec[1] = (unsigned long)_orig.r2; \
2641 _argvec[2] = (unsigned long)_orig.nraddr; \
2642 _argvec[2+1] = (unsigned long)arg1; \
2643 _argvec[2+2] = (unsigned long)arg2; \
2644 _argvec[2+3] = (unsigned long)arg3; \
2645 _argvec[2+4] = (unsigned long)arg4; \
2646 _argvec[2+5] = (unsigned long)arg5; \
2647 __asm__ volatile( \
2648 VALGRIND_ALIGN_STACK \
2649 "mr 11,%1\n\t" \
2650 "std 2,-16(11)\n\t" /* save tocptr */ \
2651 "ld 2,-8(11)\n\t" /* use nraddr's tocptr */ \
2652 "ld 3, 8(11)\n\t" /* arg1->r3 */ \
2653 "ld 4, 16(11)\n\t" /* arg2->r4 */ \
2654 "ld 5, 24(11)\n\t" /* arg3->r5 */ \
2655 "ld 6, 32(11)\n\t" /* arg4->r6 */ \
2656 "ld 7, 40(11)\n\t" /* arg5->r7 */ \
2657 "ld 11, 0(11)\n\t" /* target->r11 */ \
2658 VALGRIND_BRANCH_AND_LINK_TO_NOREDIR_R11 \
2659 "mr 11,%1\n\t" \
2660 "mr %0,3\n\t" \
2661 "ld 2,-16(11)\n\t" /* restore tocptr */ \
2662 VALGRIND_RESTORE_STACK \
2663 : /*out*/ "=r" (_res) \
2664 : /*in*/ "r" (&_argvec[2]) \
2665 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS, "r28" \
2666 ); \
2667 lval = (__typeof__(lval)) _res; \
2668 } while (0)
2669
2670 #define CALL_FN_W_6W(lval, orig, arg1,arg2,arg3,arg4,arg5,arg6) \
2671 do { \
2672 volatile OrigFn _orig = (orig); \
2673 volatile unsigned long _argvec[3+6]; \
2674 volatile unsigned long _res; \
2675 /* _argvec[0] holds current r2 across the call */ \
2676 _argvec[1] = (unsigned long)_orig.r2; \
2677 _argvec[2] = (unsigned long)_orig.nraddr; \
2678 _argvec[2+1] = (unsigned long)arg1; \
2679 _argvec[2+2] = (unsigned long)arg2; \
2680 _argvec[2+3] = (unsigned long)arg3; \
2681 _argvec[2+4] = (unsigned long)arg4; \
2682 _argvec[2+5] = (unsigned long)arg5; \
2683 _argvec[2+6] = (unsigned long)arg6; \
2684 __asm__ volatile( \
2685 VALGRIND_ALIGN_STACK \
2686 "mr 11,%1\n\t" \
2687 "std 2,-16(11)\n\t" /* save tocptr */ \
2688 "ld 2,-8(11)\n\t" /* use nraddr's tocptr */ \
2689 "ld 3, 8(11)\n\t" /* arg1->r3 */ \
2690 "ld 4, 16(11)\n\t" /* arg2->r4 */ \
2691 "ld 5, 24(11)\n\t" /* arg3->r5 */ \
2692 "ld 6, 32(11)\n\t" /* arg4->r6 */ \
2693 "ld 7, 40(11)\n\t" /* arg5->r7 */ \
2694 "ld 8, 48(11)\n\t" /* arg6->r8 */ \
2695 "ld 11, 0(11)\n\t" /* target->r11 */ \
2696 VALGRIND_BRANCH_AND_LINK_TO_NOREDIR_R11 \
2697 "mr 11,%1\n\t" \
2698 "mr %0,3\n\t" \
2699 "ld 2,-16(11)\n\t" /* restore tocptr */ \
2700 VALGRIND_RESTORE_STACK \
2701 : /*out*/ "=r" (_res) \
2702 : /*in*/ "r" (&_argvec[2]) \
2703 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS, "r28" \
2704 ); \
2705 lval = (__typeof__(lval)) _res; \
2706 } while (0)
2707
2708 #define CALL_FN_W_7W(lval, orig, arg1,arg2,arg3,arg4,arg5,arg6, \
2709 arg7) \
2710 do { \
2711 volatile OrigFn _orig = (orig); \
2712 volatile unsigned long _argvec[3+7]; \
2713 volatile unsigned long _res; \
2714 /* _argvec[0] holds current r2 across the call */ \
2715 _argvec[1] = (unsigned long)_orig.r2; \
2716 _argvec[2] = (unsigned long)_orig.nraddr; \
2717 _argvec[2+1] = (unsigned long)arg1; \
2718 _argvec[2+2] = (unsigned long)arg2; \
2719 _argvec[2+3] = (unsigned long)arg3; \
2720 _argvec[2+4] = (unsigned long)arg4; \
2721 _argvec[2+5] = (unsigned long)arg5; \
2722 _argvec[2+6] = (unsigned long)arg6; \
2723 _argvec[2+7] = (unsigned long)arg7; \
2724 __asm__ volatile( \
2725 VALGRIND_ALIGN_STACK \
2726 "mr 11,%1\n\t" \
2727 "std 2,-16(11)\n\t" /* save tocptr */ \
2728 "ld 2,-8(11)\n\t" /* use nraddr's tocptr */ \
2729 "ld 3, 8(11)\n\t" /* arg1->r3 */ \
2730 "ld 4, 16(11)\n\t" /* arg2->r4 */ \
2731 "ld 5, 24(11)\n\t" /* arg3->r5 */ \
2732 "ld 6, 32(11)\n\t" /* arg4->r6 */ \
2733 "ld 7, 40(11)\n\t" /* arg5->r7 */ \
2734 "ld 8, 48(11)\n\t" /* arg6->r8 */ \
2735 "ld 9, 56(11)\n\t" /* arg7->r9 */ \
2736 "ld 11, 0(11)\n\t" /* target->r11 */ \
2737 VALGRIND_BRANCH_AND_LINK_TO_NOREDIR_R11 \
2738 "mr 11,%1\n\t" \
2739 "mr %0,3\n\t" \
2740 "ld 2,-16(11)\n\t" /* restore tocptr */ \
2741 VALGRIND_RESTORE_STACK \
2742 : /*out*/ "=r" (_res) \
2743 : /*in*/ "r" (&_argvec[2]) \
2744 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS, "r28" \
2745 ); \
2746 lval = (__typeof__(lval)) _res; \
2747 } while (0)
2748
2749 #define CALL_FN_W_8W(lval, orig, arg1,arg2,arg3,arg4,arg5,arg6, \
2750 arg7,arg8) \
2751 do { \
2752 volatile OrigFn _orig = (orig); \
2753 volatile unsigned long _argvec[3+8]; \
2754 volatile unsigned long _res; \
2755 /* _argvec[0] holds current r2 across the call */ \
2756 _argvec[1] = (unsigned long)_orig.r2; \
2757 _argvec[2] = (unsigned long)_orig.nraddr; \
2758 _argvec[2+1] = (unsigned long)arg1; \
2759 _argvec[2+2] = (unsigned long)arg2; \
2760 _argvec[2+3] = (unsigned long)arg3; \
2761 _argvec[2+4] = (unsigned long)arg4; \
2762 _argvec[2+5] = (unsigned long)arg5; \
2763 _argvec[2+6] = (unsigned long)arg6; \
2764 _argvec[2+7] = (unsigned long)arg7; \
2765 _argvec[2+8] = (unsigned long)arg8; \
2766 __asm__ volatile( \
2767 VALGRIND_ALIGN_STACK \
2768 "mr 11,%1\n\t" \
2769 "std 2,-16(11)\n\t" /* save tocptr */ \
2770 "ld 2,-8(11)\n\t" /* use nraddr's tocptr */ \
2771 "ld 3, 8(11)\n\t" /* arg1->r3 */ \
2772 "ld 4, 16(11)\n\t" /* arg2->r4 */ \
2773 "ld 5, 24(11)\n\t" /* arg3->r5 */ \
2774 "ld 6, 32(11)\n\t" /* arg4->r6 */ \
2775 "ld 7, 40(11)\n\t" /* arg5->r7 */ \
2776 "ld 8, 48(11)\n\t" /* arg6->r8 */ \
2777 "ld 9, 56(11)\n\t" /* arg7->r9 */ \
2778 "ld 10, 64(11)\n\t" /* arg8->r10 */ \
2779 "ld 11, 0(11)\n\t" /* target->r11 */ \
2780 VALGRIND_BRANCH_AND_LINK_TO_NOREDIR_R11 \
2781 "mr 11,%1\n\t" \
2782 "mr %0,3\n\t" \
2783 "ld 2,-16(11)\n\t" /* restore tocptr */ \
2784 VALGRIND_RESTORE_STACK \
2785 : /*out*/ "=r" (_res) \
2786 : /*in*/ "r" (&_argvec[2]) \
2787 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS, "r28" \
2788 ); \
2789 lval = (__typeof__(lval)) _res; \
2790 } while (0)
2791
2792 #define CALL_FN_W_9W(lval, orig, arg1,arg2,arg3,arg4,arg5,arg6, \
2793 arg7,arg8,arg9) \
2794 do { \
2795 volatile OrigFn _orig = (orig); \
2796 volatile unsigned long _argvec[3+9]; \
2797 volatile unsigned long _res; \
2798 /* _argvec[0] holds current r2 across the call */ \
2799 _argvec[1] = (unsigned long)_orig.r2; \
2800 _argvec[2] = (unsigned long)_orig.nraddr; \
2801 _argvec[2+1] = (unsigned long)arg1; \
2802 _argvec[2+2] = (unsigned long)arg2; \
2803 _argvec[2+3] = (unsigned long)arg3; \
2804 _argvec[2+4] = (unsigned long)arg4; \
2805 _argvec[2+5] = (unsigned long)arg5; \
2806 _argvec[2+6] = (unsigned long)arg6; \
2807 _argvec[2+7] = (unsigned long)arg7; \
2808 _argvec[2+8] = (unsigned long)arg8; \
2809 _argvec[2+9] = (unsigned long)arg9; \
2810 __asm__ volatile( \
2811 VALGRIND_ALIGN_STACK \
2812 "mr 11,%1\n\t" \
2813 "std 2,-16(11)\n\t" /* save tocptr */ \
2814 "ld 2,-8(11)\n\t" /* use nraddr's tocptr */ \
2815 "addi 1,1,-128\n\t" /* expand stack frame */ \
2816 /* arg9 */ \
2817 "ld 3,72(11)\n\t" \
2818 "std 3,112(1)\n\t" \
2819 /* args1-8 */ \
2820 "ld 3, 8(11)\n\t" /* arg1->r3 */ \
2821 "ld 4, 16(11)\n\t" /* arg2->r4 */ \
2822 "ld 5, 24(11)\n\t" /* arg3->r5 */ \
2823 "ld 6, 32(11)\n\t" /* arg4->r6 */ \
2824 "ld 7, 40(11)\n\t" /* arg5->r7 */ \
2825 "ld 8, 48(11)\n\t" /* arg6->r8 */ \
2826 "ld 9, 56(11)\n\t" /* arg7->r9 */ \
2827 "ld 10, 64(11)\n\t" /* arg8->r10 */ \
2828 "ld 11, 0(11)\n\t" /* target->r11 */ \
2829 VALGRIND_BRANCH_AND_LINK_TO_NOREDIR_R11 \
2830 "mr 11,%1\n\t" \
2831 "mr %0,3\n\t" \
2832 "ld 2,-16(11)\n\t" /* restore tocptr */ \
2833 VALGRIND_RESTORE_STACK \
2834 : /*out*/ "=r" (_res) \
2835 : /*in*/ "r" (&_argvec[2]) \
2836 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS, "r28" \
2837 ); \
2838 lval = (__typeof__(lval)) _res; \
2839 } while (0)
2840
2841 #define CALL_FN_W_10W(lval, orig, arg1,arg2,arg3,arg4,arg5,arg6, \
2842 arg7,arg8,arg9,arg10) \
2843 do { \
2844 volatile OrigFn _orig = (orig); \
2845 volatile unsigned long _argvec[3+10]; \
2846 volatile unsigned long _res; \
2847 /* _argvec[0] holds current r2 across the call */ \
2848 _argvec[1] = (unsigned long)_orig.r2; \
2849 _argvec[2] = (unsigned long)_orig.nraddr; \
2850 _argvec[2+1] = (unsigned long)arg1; \
2851 _argvec[2+2] = (unsigned long)arg2; \
2852 _argvec[2+3] = (unsigned long)arg3; \
2853 _argvec[2+4] = (unsigned long)arg4; \
2854 _argvec[2+5] = (unsigned long)arg5; \
2855 _argvec[2+6] = (unsigned long)arg6; \
2856 _argvec[2+7] = (unsigned long)arg7; \
2857 _argvec[2+8] = (unsigned long)arg8; \
2858 _argvec[2+9] = (unsigned long)arg9; \
2859 _argvec[2+10] = (unsigned long)arg10; \
2860 __asm__ volatile( \
2861 VALGRIND_ALIGN_STACK \
2862 "mr 11,%1\n\t" \
2863 "std 2,-16(11)\n\t" /* save tocptr */ \
2864 "ld 2,-8(11)\n\t" /* use nraddr's tocptr */ \
2865 "addi 1,1,-128\n\t" /* expand stack frame */ \
2866 /* arg10 */ \
2867 "ld 3,80(11)\n\t" \
2868 "std 3,120(1)\n\t" \
2869 /* arg9 */ \
2870 "ld 3,72(11)\n\t" \
2871 "std 3,112(1)\n\t" \
2872 /* args1-8 */ \
2873 "ld 3, 8(11)\n\t" /* arg1->r3 */ \
2874 "ld 4, 16(11)\n\t" /* arg2->r4 */ \
2875 "ld 5, 24(11)\n\t" /* arg3->r5 */ \
2876 "ld 6, 32(11)\n\t" /* arg4->r6 */ \
2877 "ld 7, 40(11)\n\t" /* arg5->r7 */ \
2878 "ld 8, 48(11)\n\t" /* arg6->r8 */ \
2879 "ld 9, 56(11)\n\t" /* arg7->r9 */ \
2880 "ld 10, 64(11)\n\t" /* arg8->r10 */ \
2881 "ld 11, 0(11)\n\t" /* target->r11 */ \
2882 VALGRIND_BRANCH_AND_LINK_TO_NOREDIR_R11 \
2883 "mr 11,%1\n\t" \
2884 "mr %0,3\n\t" \
2885 "ld 2,-16(11)\n\t" /* restore tocptr */ \
2886 VALGRIND_RESTORE_STACK \
2887 : /*out*/ "=r" (_res) \
2888 : /*in*/ "r" (&_argvec[2]) \
2889 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS, "r28" \
2890 ); \
2891 lval = (__typeof__(lval)) _res; \
2892 } while (0)
2893
2894 #define CALL_FN_W_11W(lval, orig, arg1,arg2,arg3,arg4,arg5,arg6, \
2895 arg7,arg8,arg9,arg10,arg11) \
2896 do { \
2897 volatile OrigFn _orig = (orig); \
2898 volatile unsigned long _argvec[3+11]; \
2899 volatile unsigned long _res; \
2900 /* _argvec[0] holds current r2 across the call */ \
2901 _argvec[1] = (unsigned long)_orig.r2; \
2902 _argvec[2] = (unsigned long)_orig.nraddr; \
2903 _argvec[2+1] = (unsigned long)arg1; \
2904 _argvec[2+2] = (unsigned long)arg2; \
2905 _argvec[2+3] = (unsigned long)arg3; \
2906 _argvec[2+4] = (unsigned long)arg4; \
2907 _argvec[2+5] = (unsigned long)arg5; \
2908 _argvec[2+6] = (unsigned long)arg6; \
2909 _argvec[2+7] = (unsigned long)arg7; \
2910 _argvec[2+8] = (unsigned long)arg8; \
2911 _argvec[2+9] = (unsigned long)arg9; \
2912 _argvec[2+10] = (unsigned long)arg10; \
2913 _argvec[2+11] = (unsigned long)arg11; \
2914 __asm__ volatile( \
2915 VALGRIND_ALIGN_STACK \
2916 "mr 11,%1\n\t" \
2917 "std 2,-16(11)\n\t" /* save tocptr */ \
2918 "ld 2,-8(11)\n\t" /* use nraddr's tocptr */ \
2919 "addi 1,1,-144\n\t" /* expand stack frame */ \
2920 /* arg11 */ \
2921 "ld 3,88(11)\n\t" \
2922 "std 3,128(1)\n\t" \
2923 /* arg10 */ \
2924 "ld 3,80(11)\n\t" \
2925 "std 3,120(1)\n\t" \
2926 /* arg9 */ \
2927 "ld 3,72(11)\n\t" \
2928 "std 3,112(1)\n\t" \
2929 /* args1-8 */ \
2930 "ld 3, 8(11)\n\t" /* arg1->r3 */ \
2931 "ld 4, 16(11)\n\t" /* arg2->r4 */ \
2932 "ld 5, 24(11)\n\t" /* arg3->r5 */ \
2933 "ld 6, 32(11)\n\t" /* arg4->r6 */ \
2934 "ld 7, 40(11)\n\t" /* arg5->r7 */ \
2935 "ld 8, 48(11)\n\t" /* arg6->r8 */ \
2936 "ld 9, 56(11)\n\t" /* arg7->r9 */ \
2937 "ld 10, 64(11)\n\t" /* arg8->r10 */ \
2938 "ld 11, 0(11)\n\t" /* target->r11 */ \
2939 VALGRIND_BRANCH_AND_LINK_TO_NOREDIR_R11 \
2940 "mr 11,%1\n\t" \
2941 "mr %0,3\n\t" \
2942 "ld 2,-16(11)\n\t" /* restore tocptr */ \
2943 VALGRIND_RESTORE_STACK \
2944 : /*out*/ "=r" (_res) \
2945 : /*in*/ "r" (&_argvec[2]) \
2946 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS, "r28" \
2947 ); \
2948 lval = (__typeof__(lval)) _res; \
2949 } while (0)
2950
2951 #define CALL_FN_W_12W(lval, orig, arg1,arg2,arg3,arg4,arg5,arg6, \
2952 arg7,arg8,arg9,arg10,arg11,arg12) \
2953 do { \
2954 volatile OrigFn _orig = (orig); \
2955 volatile unsigned long _argvec[3+12]; \
2956 volatile unsigned long _res; \
2957 /* _argvec[0] holds current r2 across the call */ \
2958 _argvec[1] = (unsigned long)_orig.r2; \
2959 _argvec[2] = (unsigned long)_orig.nraddr; \
2960 _argvec[2+1] = (unsigned long)arg1; \
2961 _argvec[2+2] = (unsigned long)arg2; \
2962 _argvec[2+3] = (unsigned long)arg3; \
2963 _argvec[2+4] = (unsigned long)arg4; \
2964 _argvec[2+5] = (unsigned long)arg5; \
2965 _argvec[2+6] = (unsigned long)arg6; \
2966 _argvec[2+7] = (unsigned long)arg7; \
2967 _argvec[2+8] = (unsigned long)arg8; \
2968 _argvec[2+9] = (unsigned long)arg9; \
2969 _argvec[2+10] = (unsigned long)arg10; \
2970 _argvec[2+11] = (unsigned long)arg11; \
2971 _argvec[2+12] = (unsigned long)arg12; \
2972 __asm__ volatile( \
2973 VALGRIND_ALIGN_STACK \
2974 "mr 11,%1\n\t" \
2975 "std 2,-16(11)\n\t" /* save tocptr */ \
2976 "ld 2,-8(11)\n\t" /* use nraddr's tocptr */ \
2977 "addi 1,1,-144\n\t" /* expand stack frame */ \
2978 /* arg12 */ \
2979 "ld 3,96(11)\n\t" \
2980 "std 3,136(1)\n\t" \
2981 /* arg11 */ \
2982 "ld 3,88(11)\n\t" \
2983 "std 3,128(1)\n\t" \
2984 /* arg10 */ \
2985 "ld 3,80(11)\n\t" \
2986 "std 3,120(1)\n\t" \
2987 /* arg9 */ \
2988 "ld 3,72(11)\n\t" \
2989 "std 3,112(1)\n\t" \
2990 /* args1-8 */ \
2991 "ld 3, 8(11)\n\t" /* arg1->r3 */ \
2992 "ld 4, 16(11)\n\t" /* arg2->r4 */ \
2993 "ld 5, 24(11)\n\t" /* arg3->r5 */ \
2994 "ld 6, 32(11)\n\t" /* arg4->r6 */ \
2995 "ld 7, 40(11)\n\t" /* arg5->r7 */ \
2996 "ld 8, 48(11)\n\t" /* arg6->r8 */ \
2997 "ld 9, 56(11)\n\t" /* arg7->r9 */ \
2998 "ld 10, 64(11)\n\t" /* arg8->r10 */ \
2999 "ld 11, 0(11)\n\t" /* target->r11 */ \
3000 VALGRIND_BRANCH_AND_LINK_TO_NOREDIR_R11 \
3001 "mr 11,%1\n\t" \
3002 "mr %0,3\n\t" \
3003 "ld 2,-16(11)\n\t" /* restore tocptr */ \
3004 VALGRIND_RESTORE_STACK \
3005 : /*out*/ "=r" (_res) \
3006 : /*in*/ "r" (&_argvec[2]) \
3007 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS, "r28" \
3008 ); \
3009 lval = (__typeof__(lval)) _res; \
3010 } while (0)
3011
3012 #endif /* PLAT_ppc64_linux */
3013
3014 /* ------------------------- arm-linux ------------------------- */
3015
3016 #if defined(PLAT_arm_linux)
3017
3018 /* These regs are trashed by the hidden call. */
3019 #define __CALLER_SAVED_REGS "r0", "r1", "r2", "r3","r4","r14"
3020
3021 /* Macros to save and align the stack before making a function
3022 call and restore it afterwards as gcc may not keep the stack
3023 pointer aligned if it doesn't realise calls are being made
3024 to other functions. */
3025
3026 /* This is a bit tricky. We store the original stack pointer in r10
3027 as it is callee-saves. gcc doesn't allow the use of r11 for some
3028 reason. Also, we can't directly "bic" the stack pointer in thumb
3029 mode since r13 isn't an allowed register number in that context.
3030 So use r4 as a temporary, since that is about to get trashed
3031 anyway, just after each use of this macro. Side effect is we need
3032 to be very careful about any future changes, since
3033 VALGRIND_ALIGN_STACK simply assumes r4 is usable. */
3034 #define VALGRIND_ALIGN_STACK \
3035 "mov r10, sp\n\t" \
3036 "mov r4, sp\n\t" \
3037 "bic r4, r4, #7\n\t" \
3038 "mov sp, r4\n\t"
3039 #define VALGRIND_RESTORE_STACK \
3040 "mov sp, r10\n\t"
3041
3042 /* These CALL_FN_ macros assume that on arm-linux, sizeof(unsigned
3043 long) == 4. */
3044
3045 #define CALL_FN_W_v(lval, orig) \
3046 do { \
3047 volatile OrigFn _orig = (orig); \
3048 volatile unsigned long _argvec[1]; \
3049 volatile unsigned long _res; \
3050 _argvec[0] = (unsigned long)_orig.nraddr; \
3051 __asm__ volatile( \
3052 VALGRIND_ALIGN_STACK \
3053 "ldr r4, [%1] \n\t" /* target->r4 */ \
3054 VALGRIND_BRANCH_AND_LINK_TO_NOREDIR_R4 \
3055 VALGRIND_RESTORE_STACK \
3056 "mov %0, r0\n" \
3057 : /*out*/ "=r" (_res) \
3058 : /*in*/ "0" (&_argvec[0]) \
3059 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS, "r10" \
3060 ); \
3061 lval = (__typeof__(lval)) _res; \
3062 } while (0)
3063
3064 #define CALL_FN_W_W(lval, orig, arg1) \
3065 do { \
3066 volatile OrigFn _orig = (orig); \
3067 volatile unsigned long _argvec[2]; \
3068 volatile unsigned long _res; \
3069 _argvec[0] = (unsigned long)_orig.nraddr; \
3070 _argvec[1] = (unsigned long)(arg1); \
3071 __asm__ volatile( \
3072 VALGRIND_ALIGN_STACK \
3073 "ldr r0, [%1, #4] \n\t" \
3074 "ldr r4, [%1] \n\t" /* target->r4 */ \
3075 VALGRIND_BRANCH_AND_LINK_TO_NOREDIR_R4 \
3076 VALGRIND_RESTORE_STACK \
3077 "mov %0, r0\n" \
3078 : /*out*/ "=r" (_res) \
3079 : /*in*/ "0" (&_argvec[0]) \
3080 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS, "r10" \
3081 ); \
3082 lval = (__typeof__(lval)) _res; \
3083 } while (0)
3084
3085 #define CALL_FN_W_WW(lval, orig, arg1,arg2) \
3086 do { \
3087 volatile OrigFn _orig = (orig); \
3088 volatile unsigned long _argvec[3]; \
3089 volatile unsigned long _res; \
3090 _argvec[0] = (unsigned long)_orig.nraddr; \
3091 _argvec[1] = (unsigned long)(arg1); \
3092 _argvec[2] = (unsigned long)(arg2); \
3093 __asm__ volatile( \
3094 VALGRIND_ALIGN_STACK \
3095 "ldr r0, [%1, #4] \n\t" \
3096 "ldr r1, [%1, #8] \n\t" \
3097 "ldr r4, [%1] \n\t" /* target->r4 */ \
3098 VALGRIND_BRANCH_AND_LINK_TO_NOREDIR_R4 \
3099 VALGRIND_RESTORE_STACK \
3100 "mov %0, r0\n" \
3101 : /*out*/ "=r" (_res) \
3102 : /*in*/ "0" (&_argvec[0]) \
3103 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS, "r10" \
3104 ); \
3105 lval = (__typeof__(lval)) _res; \
3106 } while (0)
3107
3108 #define CALL_FN_W_WWW(lval, orig, arg1,arg2,arg3) \
3109 do { \
3110 volatile OrigFn _orig = (orig); \
3111 volatile unsigned long _argvec[4]; \
3112 volatile unsigned long _res; \
3113 _argvec[0] = (unsigned long)_orig.nraddr; \
3114 _argvec[1] = (unsigned long)(arg1); \
3115 _argvec[2] = (unsigned long)(arg2); \
3116 _argvec[3] = (unsigned long)(arg3); \
3117 __asm__ volatile( \
3118 VALGRIND_ALIGN_STACK \
3119 "ldr r0, [%1, #4] \n\t" \
3120 "ldr r1, [%1, #8] \n\t" \
3121 "ldr r2, [%1, #12] \n\t" \
3122 "ldr r4, [%1] \n\t" /* target->r4 */ \
3123 VALGRIND_BRANCH_AND_LINK_TO_NOREDIR_R4 \
3124 VALGRIND_RESTORE_STACK \
3125 "mov %0, r0\n" \
3126 : /*out*/ "=r" (_res) \
3127 : /*in*/ "0" (&_argvec[0]) \
3128 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS, "r10" \
3129 ); \
3130 lval = (__typeof__(lval)) _res; \
3131 } while (0)
3132
3133 #define CALL_FN_W_WWWW(lval, orig, arg1,arg2,arg3,arg4) \
3134 do { \
3135 volatile OrigFn _orig = (orig); \
3136 volatile unsigned long _argvec[5]; \
3137 volatile unsigned long _res; \
3138 _argvec[0] = (unsigned long)_orig.nraddr; \
3139 _argvec[1] = (unsigned long)(arg1); \
3140 _argvec[2] = (unsigned long)(arg2); \
3141 _argvec[3] = (unsigned long)(arg3); \
3142 _argvec[4] = (unsigned long)(arg4); \
3143 __asm__ volatile( \
3144 VALGRIND_ALIGN_STACK \
3145 "ldr r0, [%1, #4] \n\t" \
3146 "ldr r1, [%1, #8] \n\t" \
3147 "ldr r2, [%1, #12] \n\t" \
3148 "ldr r3, [%1, #16] \n\t" \
3149 "ldr r4, [%1] \n\t" /* target->r4 */ \
3150 VALGRIND_BRANCH_AND_LINK_TO_NOREDIR_R4 \
3151 VALGRIND_RESTORE_STACK \
3152 "mov %0, r0" \
3153 : /*out*/ "=r" (_res) \
3154 : /*in*/ "0" (&_argvec[0]) \
3155 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS, "r10" \
3156 ); \
3157 lval = (__typeof__(lval)) _res; \
3158 } while (0)
3159
3160 #define CALL_FN_W_5W(lval, orig, arg1,arg2,arg3,arg4,arg5) \
3161 do { \
3162 volatile OrigFn _orig = (orig); \
3163 volatile unsigned long _argvec[6]; \
3164 volatile unsigned long _res; \
3165 _argvec[0] = (unsigned long)_orig.nraddr; \
3166 _argvec[1] = (unsigned long)(arg1); \
3167 _argvec[2] = (unsigned long)(arg2); \
3168 _argvec[3] = (unsigned long)(arg3); \
3169 _argvec[4] = (unsigned long)(arg4); \
3170 _argvec[5] = (unsigned long)(arg5); \
3171 __asm__ volatile( \
3172 VALGRIND_ALIGN_STACK \
3173 "sub sp, sp, #4 \n\t" \
3174 "ldr r0, [%1, #20] \n\t" \
3175 "push {r0} \n\t" \
3176 "ldr r0, [%1, #4] \n\t" \
3177 "ldr r1, [%1, #8] \n\t" \
3178 "ldr r2, [%1, #12] \n\t" \
3179 "ldr r3, [%1, #16] \n\t" \
3180 "ldr r4, [%1] \n\t" /* target->r4 */ \
3181 VALGRIND_BRANCH_AND_LINK_TO_NOREDIR_R4 \
3182 VALGRIND_RESTORE_STACK \
3183 "mov %0, r0" \
3184 : /*out*/ "=r" (_res) \
3185 : /*in*/ "0" (&_argvec[0]) \
3186 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS, "r10" \
3187 ); \
3188 lval = (__typeof__(lval)) _res; \
3189 } while (0)
3190
3191 #define CALL_FN_W_6W(lval, orig, arg1,arg2,arg3,arg4,arg5,arg6) \
3192 do { \
3193 volatile OrigFn _orig = (orig); \
3194 volatile unsigned long _argvec[7]; \
3195 volatile unsigned long _res; \
3196 _argvec[0] = (unsigned long)_orig.nraddr; \
3197 _argvec[1] = (unsigned long)(arg1); \
3198 _argvec[2] = (unsigned long)(arg2); \
3199 _argvec[3] = (unsigned long)(arg3); \
3200 _argvec[4] = (unsigned long)(arg4); \
3201 _argvec[5] = (unsigned long)(arg5); \
3202 _argvec[6] = (unsigned long)(arg6); \
3203 __asm__ volatile( \
3204 VALGRIND_ALIGN_STACK \
3205 "ldr r0, [%1, #20] \n\t" \
3206 "ldr r1, [%1, #24] \n\t" \
3207 "push {r0, r1} \n\t" \
3208 "ldr r0, [%1, #4] \n\t" \
3209 "ldr r1, [%1, #8] \n\t" \
3210 "ldr r2, [%1, #12] \n\t" \
3211 "ldr r3, [%1, #16] \n\t" \
3212 "ldr r4, [%1] \n\t" /* target->r4 */ \
3213 VALGRIND_BRANCH_AND_LINK_TO_NOREDIR_R4 \
3214 VALGRIND_RESTORE_STACK \
3215 "mov %0, r0" \
3216 : /*out*/ "=r" (_res) \
3217 : /*in*/ "0" (&_argvec[0]) \
3218 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS, "r10" \
3219 ); \
3220 lval = (__typeof__(lval)) _res; \
3221 } while (0)
3222
3223 #define CALL_FN_W_7W(lval, orig, arg1,arg2,arg3,arg4,arg5,arg6, \
3224 arg7) \
3225 do { \
3226 volatile OrigFn _orig = (orig); \
3227 volatile unsigned long _argvec[8]; \
3228 volatile unsigned long _res; \
3229 _argvec[0] = (unsigned long)_orig.nraddr; \
3230 _argvec[1] = (unsigned long)(arg1); \
3231 _argvec[2] = (unsigned long)(arg2); \
3232 _argvec[3] = (unsigned long)(arg3); \
3233 _argvec[4] = (unsigned long)(arg4); \
3234 _argvec[5] = (unsigned long)(arg5); \
3235 _argvec[6] = (unsigned long)(arg6); \
3236 _argvec[7] = (unsigned long)(arg7); \
3237 __asm__ volatile( \
3238 VALGRIND_ALIGN_STACK \
3239 "sub sp, sp, #4 \n\t" \
3240 "ldr r0, [%1, #20] \n\t" \
3241 "ldr r1, [%1, #24] \n\t" \
3242 "ldr r2, [%1, #28] \n\t" \
3243 "push {r0, r1, r2} \n\t" \
3244 "ldr r0, [%1, #4] \n\t" \
3245 "ldr r1, [%1, #8] \n\t" \
3246 "ldr r2, [%1, #12] \n\t" \
3247 "ldr r3, [%1, #16] \n\t" \
3248 "ldr r4, [%1] \n\t" /* target->r4 */ \
3249 VALGRIND_BRANCH_AND_LINK_TO_NOREDIR_R4 \
3250 VALGRIND_RESTORE_STACK \
3251 "mov %0, r0" \
3252 : /*out*/ "=r" (_res) \
3253 : /*in*/ "0" (&_argvec[0]) \
3254 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS, "r10" \
3255 ); \
3256 lval = (__typeof__(lval)) _res; \
3257 } while (0)
3258
3259 #define CALL_FN_W_8W(lval, orig, arg1,arg2,arg3,arg4,arg5,arg6, \
3260 arg7,arg8) \
3261 do { \
3262 volatile OrigFn _orig = (orig); \
3263 volatile unsigned long _argvec[9]; \
3264 volatile unsigned long _res; \
3265 _argvec[0] = (unsigned long)_orig.nraddr; \
3266 _argvec[1] = (unsigned long)(arg1); \
3267 _argvec[2] = (unsigned long)(arg2); \
3268 _argvec[3] = (unsigned long)(arg3); \
3269 _argvec[4] = (unsigned long)(arg4); \
3270 _argvec[5] = (unsigned long)(arg5); \
3271 _argvec[6] = (unsigned long)(arg6); \
3272 _argvec[7] = (unsigned long)(arg7); \
3273 _argvec[8] = (unsigned long)(arg8); \
3274 __asm__ volatile( \
3275 VALGRIND_ALIGN_STACK \
3276 "ldr r0, [%1, #20] \n\t" \
3277 "ldr r1, [%1, #24] \n\t" \
3278 "ldr r2, [%1, #28] \n\t" \
3279 "ldr r3, [%1, #32] \n\t" \
3280 "push {r0, r1, r2, r3} \n\t" \
3281 "ldr r0, [%1, #4] \n\t" \
3282 "ldr r1, [%1, #8] \n\t" \
3283 "ldr r2, [%1, #12] \n\t" \
3284 "ldr r3, [%1, #16] \n\t" \
3285 "ldr r4, [%1] \n\t" /* target->r4 */ \
3286 VALGRIND_BRANCH_AND_LINK_TO_NOREDIR_R4 \
3287 VALGRIND_RESTORE_STACK \
3288 "mov %0, r0" \
3289 : /*out*/ "=r" (_res) \
3290 : /*in*/ "0" (&_argvec[0]) \
3291 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS, "r10" \
3292 ); \
3293 lval = (__typeof__(lval)) _res; \
3294 } while (0)
3295
3296 #define CALL_FN_W_9W(lval, orig, arg1,arg2,arg3,arg4,arg5,arg6, \
3297 arg7,arg8,arg9) \
3298 do { \
3299 volatile OrigFn _orig = (orig); \
3300 volatile unsigned long _argvec[10]; \
3301 volatile unsigned long _res; \
3302 _argvec[0] = (unsigned long)_orig.nraddr; \
3303 _argvec[1] = (unsigned long)(arg1); \
3304 _argvec[2] = (unsigned long)(arg2); \
3305 _argvec[3] = (unsigned long)(arg3); \
3306 _argvec[4] = (unsigned long)(arg4); \
3307 _argvec[5] = (unsigned long)(arg5); \
3308 _argvec[6] = (unsigned long)(arg6); \
3309 _argvec[7] = (unsigned long)(arg7); \
3310 _argvec[8] = (unsigned long)(arg8); \
3311 _argvec[9] = (unsigned long)(arg9); \
3312 __asm__ volatile( \
3313 VALGRIND_ALIGN_STACK \
3314 "sub sp, sp, #4 \n\t" \
3315 "ldr r0, [%1, #20] \n\t" \
3316 "ldr r1, [%1, #24] \n\t" \
3317 "ldr r2, [%1, #28] \n\t" \
3318 "ldr r3, [%1, #32] \n\t" \
3319 "ldr r4, [%1, #36] \n\t" \
3320 "push {r0, r1, r2, r3, r4} \n\t" \
3321 "ldr r0, [%1, #4] \n\t" \
3322 "ldr r1, [%1, #8] \n\t" \
3323 "ldr r2, [%1, #12] \n\t" \
3324 "ldr r3, [%1, #16] \n\t" \
3325 "ldr r4, [%1] \n\t" /* target->r4 */ \
3326 VALGRIND_BRANCH_AND_LINK_TO_NOREDIR_R4 \
3327 VALGRIND_RESTORE_STACK \
3328 "mov %0, r0" \
3329 : /*out*/ "=r" (_res) \
3330 : /*in*/ "0" (&_argvec[0]) \
3331 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS, "r10" \
3332 ); \
3333 lval = (__typeof__(lval)) _res; \
3334 } while (0)
3335
3336 #define CALL_FN_W_10W(lval, orig, arg1,arg2,arg3,arg4,arg5,arg6, \
3337 arg7,arg8,arg9,arg10) \
3338 do { \
3339 volatile OrigFn _orig = (orig); \
3340 volatile unsigned long _argvec[11]; \
3341 volatile unsigned long _res; \
3342 _argvec[0] = (unsigned long)_orig.nraddr; \
3343 _argvec[1] = (unsigned long)(arg1); \
3344 _argvec[2] = (unsigned long)(arg2); \
3345 _argvec[3] = (unsigned long)(arg3); \
3346 _argvec[4] = (unsigned long)(arg4); \
3347 _argvec[5] = (unsigned long)(arg5); \
3348 _argvec[6] = (unsigned long)(arg6); \
3349 _argvec[7] = (unsigned long)(arg7); \
3350 _argvec[8] = (unsigned long)(arg8); \
3351 _argvec[9] = (unsigned long)(arg9); \
3352 _argvec[10] = (unsigned long)(arg10); \
3353 __asm__ volatile( \
3354 VALGRIND_ALIGN_STACK \
3355 "ldr r0, [%1, #40] \n\t" \
3356 "push {r0} \n\t" \
3357 "ldr r0, [%1, #20] \n\t" \
3358 "ldr r1, [%1, #24] \n\t" \
3359 "ldr r2, [%1, #28] \n\t" \
3360 "ldr r3, [%1, #32] \n\t" \
3361 "ldr r4, [%1, #36] \n\t" \
3362 "push {r0, r1, r2, r3, r4} \n\t" \
3363 "ldr r0, [%1, #4] \n\t" \
3364 "ldr r1, [%1, #8] \n\t" \
3365 "ldr r2, [%1, #12] \n\t" \
3366 "ldr r3, [%1, #16] \n\t" \
3367 "ldr r4, [%1] \n\t" /* target->r4 */ \
3368 VALGRIND_BRANCH_AND_LINK_TO_NOREDIR_R4 \
3369 VALGRIND_RESTORE_STACK \
3370 "mov %0, r0" \
3371 : /*out*/ "=r" (_res) \
3372 : /*in*/ "0" (&_argvec[0]) \
3373 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS, "r10" \
3374 ); \
3375 lval = (__typeof__(lval)) _res; \
3376 } while (0)
3377
3378 #define CALL_FN_W_11W(lval, orig, arg1,arg2,arg3,arg4,arg5, \
3379 arg6,arg7,arg8,arg9,arg10, \
3380 arg11) \
3381 do { \
3382 volatile OrigFn _orig = (orig); \
3383 volatile unsigned long _argvec[12]; \
3384 volatile unsigned long _res; \
3385 _argvec[0] = (unsigned long)_orig.nraddr; \
3386 _argvec[1] = (unsigned long)(arg1); \
3387 _argvec[2] = (unsigned long)(arg2); \
3388 _argvec[3] = (unsigned long)(arg3); \
3389 _argvec[4] = (unsigned long)(arg4); \
3390 _argvec[5] = (unsigned long)(arg5); \
3391 _argvec[6] = (unsigned long)(arg6); \
3392 _argvec[7] = (unsigned long)(arg7); \
3393 _argvec[8] = (unsigned long)(arg8); \
3394 _argvec[9] = (unsigned long)(arg9); \
3395 _argvec[10] = (unsigned long)(arg10); \
3396 _argvec[11] = (unsigned long)(arg11); \
3397 __asm__ volatile( \
3398 VALGRIND_ALIGN_STACK \
3399 "sub sp, sp, #4 \n\t" \
3400 "ldr r0, [%1, #40] \n\t" \
3401 "ldr r1, [%1, #44] \n\t" \
3402 "push {r0, r1} \n\t" \
3403 "ldr r0, [%1, #20] \n\t" \
3404 "ldr r1, [%1, #24] \n\t" \
3405 "ldr r2, [%1, #28] \n\t" \
3406 "ldr r3, [%1, #32] \n\t" \
3407 "ldr r4, [%1, #36] \n\t" \
3408 "push {r0, r1, r2, r3, r4} \n\t" \
3409 "ldr r0, [%1, #4] \n\t" \
3410 "ldr r1, [%1, #8] \n\t" \
3411 "ldr r2, [%1, #12] \n\t" \
3412 "ldr r3, [%1, #16] \n\t" \
3413 "ldr r4, [%1] \n\t" /* target->r4 */ \
3414 VALGRIND_BRANCH_AND_LINK_TO_NOREDIR_R4 \
3415 VALGRIND_RESTORE_STACK \
3416 "mov %0, r0" \
3417 : /*out*/ "=r" (_res) \
3418 : /*in*/ "0" (&_argvec[0]) \
3419 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS, "r10" \
3420 ); \
3421 lval = (__typeof__(lval)) _res; \
3422 } while (0)
3423
3424 #define CALL_FN_W_12W(lval, orig, arg1,arg2,arg3,arg4,arg5, \
3425 arg6,arg7,arg8,arg9,arg10, \
3426 arg11,arg12) \
3427 do { \
3428 volatile OrigFn _orig = (orig); \
3429 volatile unsigned long _argvec[13]; \
3430 volatile unsigned long _res; \
3431 _argvec[0] = (unsigned long)_orig.nraddr; \
3432 _argvec[1] = (unsigned long)(arg1); \
3433 _argvec[2] = (unsigned long)(arg2); \
3434 _argvec[3] = (unsigned long)(arg3); \
3435 _argvec[4] = (unsigned long)(arg4); \
3436 _argvec[5] = (unsigned long)(arg5); \
3437 _argvec[6] = (unsigned long)(arg6); \
3438 _argvec[7] = (unsigned long)(arg7); \
3439 _argvec[8] = (unsigned long)(arg8); \
3440 _argvec[9] = (unsigned long)(arg9); \
3441 _argvec[10] = (unsigned long)(arg10); \
3442 _argvec[11] = (unsigned long)(arg11); \
3443 _argvec[12] = (unsigned long)(arg12); \
3444 __asm__ volatile( \
3445 VALGRIND_ALIGN_STACK \
3446 "ldr r0, [%1, #40] \n\t" \
3447 "ldr r1, [%1, #44] \n\t" \
3448 "ldr r2, [%1, #48] \n\t" \
3449 "push {r0, r1, r2} \n\t" \
3450 "ldr r0, [%1, #20] \n\t" \
3451 "ldr r1, [%1, #24] \n\t" \
3452 "ldr r2, [%1, #28] \n\t" \
3453 "ldr r3, [%1, #32] \n\t" \
3454 "ldr r4, [%1, #36] \n\t" \
3455 "push {r0, r1, r2, r3, r4} \n\t" \
3456 "ldr r0, [%1, #4] \n\t" \
3457 "ldr r1, [%1, #8] \n\t" \
3458 "ldr r2, [%1, #12] \n\t" \
3459 "ldr r3, [%1, #16] \n\t" \
3460 "ldr r4, [%1] \n\t" /* target->r4 */ \
3461 VALGRIND_BRANCH_AND_LINK_TO_NOREDIR_R4 \
3462 VALGRIND_RESTORE_STACK \
3463 "mov %0, r0" \
3464 : /*out*/ "=r" (_res) \
3465 : /*in*/ "0" (&_argvec[0]) \
3466 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS, "r10" \
3467 ); \
3468 lval = (__typeof__(lval)) _res; \
3469 } while (0)
3470
3471 #endif /* PLAT_arm_linux */
3472
3473 /* ------------------------- s390x-linux ------------------------- */
3474
3475 #if defined(PLAT_s390x_linux)
3476
3477 /* Similar workaround as amd64 (see above), but we use r11 as frame
3478 pointer and save the old r11 in r7. r11 might be used for
3479 argvec, therefore we copy argvec in r1 since r1 is clobbered
3480 after the call anyway. */
3481 #if defined(__GNUC__) && defined(__GCC_HAVE_DWARF2_CFI_ASM)
3482 # define __FRAME_POINTER \
3483 ,"d"(__builtin_dwarf_cfa())
3484 # define VALGRIND_CFI_PROLOGUE \
3485 ".cfi_remember_state\n\t" \
3486 "lgr 1,%1\n\t" /* copy the argvec pointer in r1 */ \
3487 "lgr 7,11\n\t" \
3488 "lgr 11,%2\n\t" \
3489 ".cfi_def_cfa r11, 0\n\t"
3490 # define VALGRIND_CFI_EPILOGUE \
3491 "lgr 11, 7\n\t" \
3492 ".cfi_restore_state\n\t"
3493 #else
3494 # define __FRAME_POINTER
3495 # define VALGRIND_CFI_PROLOGUE \
3496 "lgr 1,%1\n\t"
3497 # define VALGRIND_CFI_EPILOGUE
3498 #endif
3499
3500 /* Nb: On s390 the stack pointer is properly aligned *at all times*
3501 according to the s390 GCC maintainer. (The ABI specification is not
3502 precise in this regard.) Therefore, VALGRIND_ALIGN_STACK and
3503 VALGRIND_RESTORE_STACK are not defined here. */
3504
3505 /* These regs are trashed by the hidden call. Note that we overwrite
3506 r14 in s390_irgen_noredir (VEX/priv/guest_s390_irgen.c) to give the
3507 function a proper return address. All others are ABI defined call
3508 clobbers. */
3509 #define __CALLER_SAVED_REGS "0","1","2","3","4","5","14", \
3510 "f0","f1","f2","f3","f4","f5","f6","f7"
3511
3512 /* Nb: Although r11 is modified in the asm snippets below (inside
3513 VALGRIND_CFI_PROLOGUE) it is not listed in the clobber section, for
3514 two reasons:
3515 (1) r11 is restored in VALGRIND_CFI_EPILOGUE, so effectively it is not
3516 modified
3517 (2) GCC will complain that r11 cannot appear inside a clobber section,
3518 when compiled with -O -fno-omit-frame-pointer
3519 */
3520
3521 #define CALL_FN_W_v(lval, orig) \
3522 do { \
3523 volatile OrigFn _orig = (orig); \
3524 volatile unsigned long _argvec[1]; \
3525 volatile unsigned long _res; \
3526 _argvec[0] = (unsigned long)_orig.nraddr; \
3527 __asm__ volatile( \
3528 VALGRIND_CFI_PROLOGUE \
3529 "aghi 15,-160\n\t" \
3530 "lg 1, 0(1)\n\t" /* target->r1 */ \
3531 VALGRIND_CALL_NOREDIR_R1 \
3532 "lgr %0, 2\n\t" \
3533 "aghi 15,160\n\t" \
3534 VALGRIND_CFI_EPILOGUE \
3535 : /*out*/ "=d" (_res) \
3536 : /*in*/ "d" (&_argvec[0]) __FRAME_POINTER \
3537 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS,"7" \
3538 ); \
3539 lval = (__typeof__(lval)) _res; \
3540 } while (0)
3541
3542 /* The call abi has the arguments in r2-r6 and stack */
3543 #define CALL_FN_W_W(lval, orig, arg1) \
3544 do { \
3545 volatile OrigFn _orig = (orig); \
3546 volatile unsigned long _argvec[2]; \
3547 volatile unsigned long _res; \
3548 _argvec[0] = (unsigned long)_orig.nraddr; \
3549 _argvec[1] = (unsigned long)arg1; \
3550 __asm__ volatile( \
3551 VALGRIND_CFI_PROLOGUE \
3552 "aghi 15,-160\n\t" \
3553 "lg 2, 8(1)\n\t" \
3554 "lg 1, 0(1)\n\t" \
3555 VALGRIND_CALL_NOREDIR_R1 \
3556 "lgr %0, 2\n\t" \
3557 "aghi 15,160\n\t" \
3558 VALGRIND_CFI_EPILOGUE \
3559 : /*out*/ "=d" (_res) \
3560 : /*in*/ "a" (&_argvec[0]) __FRAME_POINTER \
3561 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS,"7" \
3562 ); \
3563 lval = (__typeof__(lval)) _res; \
3564 } while (0)
3565
3566 #define CALL_FN_W_WW(lval, orig, arg1, arg2) \
3567 do { \
3568 volatile OrigFn _orig = (orig); \
3569 volatile unsigned long _argvec[3]; \
3570 volatile unsigned long _res; \
3571 _argvec[0] = (unsigned long)_orig.nraddr; \
3572 _argvec[1] = (unsigned long)arg1; \
3573 _argvec[2] = (unsigned long)arg2; \
3574 __asm__ volatile( \
3575 VALGRIND_CFI_PROLOGUE \
3576 "aghi 15,-160\n\t" \
3577 "lg 2, 8(1)\n\t" \
3578 "lg 3,16(1)\n\t" \
3579 "lg 1, 0(1)\n\t" \
3580 VALGRIND_CALL_NOREDIR_R1 \
3581 "lgr %0, 2\n\t" \
3582 "aghi 15,160\n\t" \
3583 VALGRIND_CFI_EPILOGUE \
3584 : /*out*/ "=d" (_res) \
3585 : /*in*/ "a" (&_argvec[0]) __FRAME_POINTER \
3586 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS,"7" \
3587 ); \
3588 lval = (__typeof__(lval)) _res; \
3589 } while (0)
3590
3591 #define CALL_FN_W_WWW(lval, orig, arg1, arg2, arg3) \
3592 do { \
3593 volatile OrigFn _orig = (orig); \
3594 volatile unsigned long _argvec[4]; \
3595 volatile unsigned long _res; \
3596 _argvec[0] = (unsigned long)_orig.nraddr; \
3597 _argvec[1] = (unsigned long)arg1; \
3598 _argvec[2] = (unsigned long)arg2; \
3599 _argvec[3] = (unsigned long)arg3; \
3600 __asm__ volatile( \
3601 VALGRIND_CFI_PROLOGUE \
3602 "aghi 15,-160\n\t" \
3603 "lg 2, 8(1)\n\t" \
3604 "lg 3,16(1)\n\t" \
3605 "lg 4,24(1)\n\t" \
3606 "lg 1, 0(1)\n\t" \
3607 VALGRIND_CALL_NOREDIR_R1 \
3608 "lgr %0, 2\n\t" \
3609 "aghi 15,160\n\t" \
3610 VALGRIND_CFI_EPILOGUE \
3611 : /*out*/ "=d" (_res) \
3612 : /*in*/ "a" (&_argvec[0]) __FRAME_POINTER \
3613 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS,"7" \
3614 ); \
3615 lval = (__typeof__(lval)) _res; \
3616 } while (0)
3617
3618 #define CALL_FN_W_WWWW(lval, orig, arg1, arg2, arg3, arg4) \
3619 do { \
3620 volatile OrigFn _orig = (orig); \
3621 volatile unsigned long _argvec[5]; \
3622 volatile unsigned long _res; \
3623 _argvec[0] = (unsigned long)_orig.nraddr; \
3624 _argvec[1] = (unsigned long)arg1; \
3625 _argvec[2] = (unsigned long)arg2; \
3626 _argvec[3] = (unsigned long)arg3; \
3627 _argvec[4] = (unsigned long)arg4; \
3628 __asm__ volatile( \
3629 VALGRIND_CFI_PROLOGUE \
3630 "aghi 15,-160\n\t" \
3631 "lg 2, 8(1)\n\t" \
3632 "lg 3,16(1)\n\t" \
3633 "lg 4,24(1)\n\t" \
3634 "lg 5,32(1)\n\t" \
3635 "lg 1, 0(1)\n\t" \
3636 VALGRIND_CALL_NOREDIR_R1 \
3637 "lgr %0, 2\n\t" \
3638 "aghi 15,160\n\t" \
3639 VALGRIND_CFI_EPILOGUE \
3640 : /*out*/ "=d" (_res) \
3641 : /*in*/ "a" (&_argvec[0]) __FRAME_POINTER \
3642 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS,"7" \
3643 ); \
3644 lval = (__typeof__(lval)) _res; \
3645 } while (0)
3646
3647 #define CALL_FN_W_5W(lval, orig, arg1, arg2, arg3, arg4, arg5) \
3648 do { \
3649 volatile OrigFn _orig = (orig); \
3650 volatile unsigned long _argvec[6]; \
3651 volatile unsigned long _res; \
3652 _argvec[0] = (unsigned long)_orig.nraddr; \
3653 _argvec[1] = (unsigned long)arg1; \
3654 _argvec[2] = (unsigned long)arg2; \
3655 _argvec[3] = (unsigned long)arg3; \
3656 _argvec[4] = (unsigned long)arg4; \
3657 _argvec[5] = (unsigned long)arg5; \
3658 __asm__ volatile( \
3659 VALGRIND_CFI_PROLOGUE \
3660 "aghi 15,-160\n\t" \
3661 "lg 2, 8(1)\n\t" \
3662 "lg 3,16(1)\n\t" \
3663 "lg 4,24(1)\n\t" \
3664 "lg 5,32(1)\n\t" \
3665 "lg 6,40(1)\n\t" \
3666 "lg 1, 0(1)\n\t" \
3667 VALGRIND_CALL_NOREDIR_R1 \
3668 "lgr %0, 2\n\t" \
3669 "aghi 15,160\n\t" \
3670 VALGRIND_CFI_EPILOGUE \
3671 : /*out*/ "=d" (_res) \
3672 : /*in*/ "a" (&_argvec[0]) __FRAME_POINTER \
3673 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS,"6","7" \
3674 ); \
3675 lval = (__typeof__(lval)) _res; \
3676 } while (0)
3677
3678 #define CALL_FN_W_6W(lval, orig, arg1, arg2, arg3, arg4, arg5, \
3679 arg6) \
3680 do { \
3681 volatile OrigFn _orig = (orig); \
3682 volatile unsigned long _argvec[7]; \
3683 volatile unsigned long _res; \
3684 _argvec[0] = (unsigned long)_orig.nraddr; \
3685 _argvec[1] = (unsigned long)arg1; \
3686 _argvec[2] = (unsigned long)arg2; \
3687 _argvec[3] = (unsigned long)arg3; \
3688 _argvec[4] = (unsigned long)arg4; \
3689 _argvec[5] = (unsigned long)arg5; \
3690 _argvec[6] = (unsigned long)arg6; \
3691 __asm__ volatile( \
3692 VALGRIND_CFI_PROLOGUE \
3693 "aghi 15,-168\n\t" \
3694 "lg 2, 8(1)\n\t" \
3695 "lg 3,16(1)\n\t" \
3696 "lg 4,24(1)\n\t" \
3697 "lg 5,32(1)\n\t" \
3698 "lg 6,40(1)\n\t" \
3699 "mvc 160(8,15), 48(1)\n\t" \
3700 "lg 1, 0(1)\n\t" \
3701 VALGRIND_CALL_NOREDIR_R1 \
3702 "lgr %0, 2\n\t" \
3703 "aghi 15,168\n\t" \
3704 VALGRIND_CFI_EPILOGUE \
3705 : /*out*/ "=d" (_res) \
3706 : /*in*/ "a" (&_argvec[0]) __FRAME_POINTER \
3707 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS,"6","7" \
3708 ); \
3709 lval = (__typeof__(lval)) _res; \
3710 } while (0)
3711
3712 #define CALL_FN_W_7W(lval, orig, arg1, arg2, arg3, arg4, arg5, \
3713 arg6, arg7) \
3714 do { \
3715 volatile OrigFn _orig = (orig); \
3716 volatile unsigned long _argvec[8]; \
3717 volatile unsigned long _res; \
3718 _argvec[0] = (unsigned long)_orig.nraddr; \
3719 _argvec[1] = (unsigned long)arg1; \
3720 _argvec[2] = (unsigned long)arg2; \
3721 _argvec[3] = (unsigned long)arg3; \
3722 _argvec[4] = (unsigned long)arg4; \
3723 _argvec[5] = (unsigned long)arg5; \
3724 _argvec[6] = (unsigned long)arg6; \
3725 _argvec[7] = (unsigned long)arg7; \
3726 __asm__ volatile( \
3727 VALGRIND_CFI_PROLOGUE \
3728 "aghi 15,-176\n\t" \
3729 "lg 2, 8(1)\n\t" \
3730 "lg 3,16(1)\n\t" \
3731 "lg 4,24(1)\n\t" \
3732 "lg 5,32(1)\n\t" \
3733 "lg 6,40(1)\n\t" \
3734 "mvc 160(8,15), 48(1)\n\t" \
3735 "mvc 168(8,15), 56(1)\n\t" \
3736 "lg 1, 0(1)\n\t" \
3737 VALGRIND_CALL_NOREDIR_R1 \
3738 "lgr %0, 2\n\t" \
3739 "aghi 15,176\n\t" \
3740 VALGRIND_CFI_EPILOGUE \
3741 : /*out*/ "=d" (_res) \
3742 : /*in*/ "a" (&_argvec[0]) __FRAME_POINTER \
3743 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS,"6","7" \
3744 ); \
3745 lval = (__typeof__(lval)) _res; \
3746 } while (0)
3747
3748 #define CALL_FN_W_8W(lval, orig, arg1, arg2, arg3, arg4, arg5, \
3749 arg6, arg7 ,arg8) \
3750 do { \
3751 volatile OrigFn _orig = (orig); \
3752 volatile unsigned long _argvec[9]; \
3753 volatile unsigned long _res; \
3754 _argvec[0] = (unsigned long)_orig.nraddr; \
3755 _argvec[1] = (unsigned long)arg1; \
3756 _argvec[2] = (unsigned long)arg2; \
3757 _argvec[3] = (unsigned long)arg3; \
3758 _argvec[4] = (unsigned long)arg4; \
3759 _argvec[5] = (unsigned long)arg5; \
3760 _argvec[6] = (unsigned long)arg6; \
3761 _argvec[7] = (unsigned long)arg7; \
3762 _argvec[8] = (unsigned long)arg8; \
3763 __asm__ volatile( \
3764 VALGRIND_CFI_PROLOGUE \
3765 "aghi 15,-184\n\t" \
3766 "lg 2, 8(1)\n\t" \
3767 "lg 3,16(1)\n\t" \
3768 "lg 4,24(1)\n\t" \
3769 "lg 5,32(1)\n\t" \
3770 "lg 6,40(1)\n\t" \
3771 "mvc 160(8,15), 48(1)\n\t" \
3772 "mvc 168(8,15), 56(1)\n\t" \
3773 "mvc 176(8,15), 64(1)\n\t" \
3774 "lg 1, 0(1)\n\t" \
3775 VALGRIND_CALL_NOREDIR_R1 \
3776 "lgr %0, 2\n\t" \
3777 "aghi 15,184\n\t" \
3778 VALGRIND_CFI_EPILOGUE \
3779 : /*out*/ "=d" (_res) \
3780 : /*in*/ "a" (&_argvec[0]) __FRAME_POINTER \
3781 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS,"6","7" \
3782 ); \
3783 lval = (__typeof__(lval)) _res; \
3784 } while (0)
3785
3786 #define CALL_FN_W_9W(lval, orig, arg1, arg2, arg3, arg4, arg5, \
3787 arg6, arg7 ,arg8, arg9) \
3788 do { \
3789 volatile OrigFn _orig = (orig); \
3790 volatile unsigned long _argvec[10]; \
3791 volatile unsigned long _res; \
3792 _argvec[0] = (unsigned long)_orig.nraddr; \
3793 _argvec[1] = (unsigned long)arg1; \
3794 _argvec[2] = (unsigned long)arg2; \
3795 _argvec[3] = (unsigned long)arg3; \
3796 _argvec[4] = (unsigned long)arg4; \
3797 _argvec[5] = (unsigned long)arg5; \
3798 _argvec[6] = (unsigned long)arg6; \
3799 _argvec[7] = (unsigned long)arg7; \
3800 _argvec[8] = (unsigned long)arg8; \
3801 _argvec[9] = (unsigned long)arg9; \
3802 __asm__ volatile( \
3803 VALGRIND_CFI_PROLOGUE \
3804 "aghi 15,-192\n\t" \
3805 "lg 2, 8(1)\n\t" \
3806 "lg 3,16(1)\n\t" \
3807 "lg 4,24(1)\n\t" \
3808 "lg 5,32(1)\n\t" \
3809 "lg 6,40(1)\n\t" \
3810 "mvc 160(8,15), 48(1)\n\t" \
3811 "mvc 168(8,15), 56(1)\n\t" \
3812 "mvc 176(8,15), 64(1)\n\t" \
3813 "mvc 184(8,15), 72(1)\n\t" \
3814 "lg 1, 0(1)\n\t" \
3815 VALGRIND_CALL_NOREDIR_R1 \
3816 "lgr %0, 2\n\t" \
3817 "aghi 15,192\n\t" \
3818 VALGRIND_CFI_EPILOGUE \
3819 : /*out*/ "=d" (_res) \
3820 : /*in*/ "a" (&_argvec[0]) __FRAME_POINTER \
3821 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS,"6","7" \
3822 ); \
3823 lval = (__typeof__(lval)) _res; \
3824 } while (0)
3825
3826 #define CALL_FN_W_10W(lval, orig, arg1, arg2, arg3, arg4, arg5, \
3827 arg6, arg7 ,arg8, arg9, arg10) \
3828 do { \
3829 volatile OrigFn _orig = (orig); \
3830 volatile unsigned long _argvec[11]; \
3831 volatile unsigned long _res; \
3832 _argvec[0] = (unsigned long)_orig.nraddr; \
3833 _argvec[1] = (unsigned long)arg1; \
3834 _argvec[2] = (unsigned long)arg2; \
3835 _argvec[3] = (unsigned long)arg3; \
3836 _argvec[4] = (unsigned long)arg4; \
3837 _argvec[5] = (unsigned long)arg5; \
3838 _argvec[6] = (unsigned long)arg6; \
3839 _argvec[7] = (unsigned long)arg7; \
3840 _argvec[8] = (unsigned long)arg8; \
3841 _argvec[9] = (unsigned long)arg9; \
3842 _argvec[10] = (unsigned long)arg10; \
3843 __asm__ volatile( \
3844 VALGRIND_CFI_PROLOGUE \
3845 "aghi 15,-200\n\t" \
3846 "lg 2, 8(1)\n\t" \
3847 "lg 3,16(1)\n\t" \
3848 "lg 4,24(1)\n\t" \
3849 "lg 5,32(1)\n\t" \
3850 "lg 6,40(1)\n\t" \
3851 "mvc 160(8,15), 48(1)\n\t" \
3852 "mvc 168(8,15), 56(1)\n\t" \
3853 "mvc 176(8,15), 64(1)\n\t" \
3854 "mvc 184(8,15), 72(1)\n\t" \
3855 "mvc 192(8,15), 80(1)\n\t" \
3856 "lg 1, 0(1)\n\t" \
3857 VALGRIND_CALL_NOREDIR_R1 \
3858 "lgr %0, 2\n\t" \
3859 "aghi 15,200\n\t" \
3860 VALGRIND_CFI_EPILOGUE \
3861 : /*out*/ "=d" (_res) \
3862 : /*in*/ "a" (&_argvec[0]) __FRAME_POINTER \
3863 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS,"6","7" \
3864 ); \
3865 lval = (__typeof__(lval)) _res; \
3866 } while (0)
3867
3868 #define CALL_FN_W_11W(lval, orig, arg1, arg2, arg3, arg4, arg5, \
3869 arg6, arg7 ,arg8, arg9, arg10, arg11) \
3870 do { \
3871 volatile OrigFn _orig = (orig); \
3872 volatile unsigned long _argvec[12]; \
3873 volatile unsigned long _res; \
3874 _argvec[0] = (unsigned long)_orig.nraddr; \
3875 _argvec[1] = (unsigned long)arg1; \
3876 _argvec[2] = (unsigned long)arg2; \
3877 _argvec[3] = (unsigned long)arg3; \
3878 _argvec[4] = (unsigned long)arg4; \
3879 _argvec[5] = (unsigned long)arg5; \
3880 _argvec[6] = (unsigned long)arg6; \
3881 _argvec[7] = (unsigned long)arg7; \
3882 _argvec[8] = (unsigned long)arg8; \
3883 _argvec[9] = (unsigned long)arg9; \
3884 _argvec[10] = (unsigned long)arg10; \
3885 _argvec[11] = (unsigned long)arg11; \
3886 __asm__ volatile( \
3887 VALGRIND_CFI_PROLOGUE \
3888 "aghi 15,-208\n\t" \
3889 "lg 2, 8(1)\n\t" \
3890 "lg 3,16(1)\n\t" \
3891 "lg 4,24(1)\n\t" \
3892 "lg 5,32(1)\n\t" \
3893 "lg 6,40(1)\n\t" \
3894 "mvc 160(8,15), 48(1)\n\t" \
3895 "mvc 168(8,15), 56(1)\n\t" \
3896 "mvc 176(8,15), 64(1)\n\t" \
3897 "mvc 184(8,15), 72(1)\n\t" \
3898 "mvc 192(8,15), 80(1)\n\t" \
3899 "mvc 200(8,15), 88(1)\n\t" \
3900 "lg 1, 0(1)\n\t" \
3901 VALGRIND_CALL_NOREDIR_R1 \
3902 "lgr %0, 2\n\t" \
3903 "aghi 15,208\n\t" \
3904 VALGRIND_CFI_EPILOGUE \
3905 : /*out*/ "=d" (_res) \
3906 : /*in*/ "a" (&_argvec[0]) __FRAME_POINTER \
3907 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS,"6","7" \
3908 ); \
3909 lval = (__typeof__(lval)) _res; \
3910 } while (0)
3911
3912 #define CALL_FN_W_12W(lval, orig, arg1, arg2, arg3, arg4, arg5, \
3913 arg6, arg7 ,arg8, arg9, arg10, arg11, arg12)\
3914 do { \
3915 volatile OrigFn _orig = (orig); \
3916 volatile unsigned long _argvec[13]; \
3917 volatile unsigned long _res; \
3918 _argvec[0] = (unsigned long)_orig.nraddr; \
3919 _argvec[1] = (unsigned long)arg1; \
3920 _argvec[2] = (unsigned long)arg2; \
3921 _argvec[3] = (unsigned long)arg3; \
3922 _argvec[4] = (unsigned long)arg4; \
3923 _argvec[5] = (unsigned long)arg5; \
3924 _argvec[6] = (unsigned long)arg6; \
3925 _argvec[7] = (unsigned long)arg7; \
3926 _argvec[8] = (unsigned long)arg8; \
3927 _argvec[9] = (unsigned long)arg9; \
3928 _argvec[10] = (unsigned long)arg10; \
3929 _argvec[11] = (unsigned long)arg11; \
3930 _argvec[12] = (unsigned long)arg12; \
3931 __asm__ volatile( \
3932 VALGRIND_CFI_PROLOGUE \
3933 "aghi 15,-216\n\t" \
3934 "lg 2, 8(1)\n\t" \
3935 "lg 3,16(1)\n\t" \
3936 "lg 4,24(1)\n\t" \
3937 "lg 5,32(1)\n\t" \
3938 "lg 6,40(1)\n\t" \
3939 "mvc 160(8,15), 48(1)\n\t" \
3940 "mvc 168(8,15), 56(1)\n\t" \
3941 "mvc 176(8,15), 64(1)\n\t" \
3942 "mvc 184(8,15), 72(1)\n\t" \
3943 "mvc 192(8,15), 80(1)\n\t" \
3944 "mvc 200(8,15), 88(1)\n\t" \
3945 "mvc 208(8,15), 96(1)\n\t" \
3946 "lg 1, 0(1)\n\t" \
3947 VALGRIND_CALL_NOREDIR_R1 \
3948 "lgr %0, 2\n\t" \
3949 "aghi 15,216\n\t" \
3950 VALGRIND_CFI_EPILOGUE \
3951 : /*out*/ "=d" (_res) \
3952 : /*in*/ "a" (&_argvec[0]) __FRAME_POINTER \
3953 : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS,"6","7" \
3954 ); \
3955 lval = (__typeof__(lval)) _res; \
3956 } while (0)
3957
3958
3959 #endif /* PLAT_s390x_linux */
3960
3961 /* ------------------------- mips32-linux ----------------------- */
3962
3963 #if defined(PLAT_mips32_linux)
3964
3965 /* These regs are trashed by the hidden call. */
3966 #define __CALLER_SAVED_REGS "$2", "$3", "$4", "$5", "$6", \
3967 "$7", "$8", "$9", "$10", "$11", "$12", "$13", "$14", "$15", "$24", \
3968 "$25", "$31"
3969
3970 /* These CALL_FN_ macros assume that on mips-linux, sizeof(unsigned
3971 long) == 4. */
3972
3973 #define CALL_FN_W_v(lval, orig) \
3974 do { \
3975 volatile OrigFn _orig = (orig); \
3976 volatile unsigned long _argvec[1]; \
3977 volatile unsigned long _res; \
3978 _argvec[0] = (unsigned long)_orig.nraddr; \
3979 __asm__ volatile( \
3980 "subu $29, $29, 8 \n\t" \
3981 "sw $28, 0($29) \n\t" \
3982 "sw $31, 4($29) \n\t" \
3983 "subu $29, $29, 16 \n\t" \
3984 "lw $25, 0(%1) \n\t" /* target->t9 */ \
3985 VALGRIND_CALL_NOREDIR_T9 \
3986 "addu $29, $29, 16\n\t" \
3987 "lw $28, 0($29) \n\t" \
3988 "lw $31, 4($29) \n\t" \
3989 "addu $29, $29, 8 \n\t" \
3990 "move %0, $2\n" \
3991 : /*out*/ "=r" (_res) \
3992 : /*in*/ "0" (&_argvec[0]) \
3993 : /*trash*/ "memory", __CALLER_SAVED_REGS \
3994 ); \
3995 lval = (__typeof__(lval)) _res; \
3996 } while (0)
3997
3998 #define CALL_FN_W_W(lval, orig, arg1) \
3999 do { \
4000 volatile OrigFn _orig = (orig); \
4001 volatile unsigned long _argvec[2]; \
4002 volatile unsigned long _res; \
4003 _argvec[0] = (unsigned long)_orig.nraddr; \
4004 _argvec[1] = (unsigned long)(arg1); \
4005 __asm__ volatile( \
4006 "subu $29, $29, 8 \n\t" \
4007 "sw $28, 0($29) \n\t" \
4008 "sw $31, 4($29) \n\t" \
4009 "subu $29, $29, 16 \n\t" \
4010 "lw $4, 4(%1) \n\t" /* arg1*/ \
4011 "lw $25, 0(%1) \n\t" /* target->t9 */ \
4012 VALGRIND_CALL_NOREDIR_T9 \
4013 "addu $29, $29, 16 \n\t" \
4014 "lw $28, 0($29) \n\t" \
4015 "lw $31, 4($29) \n\t" \
4016 "addu $29, $29, 8 \n\t" \
4017 "move %0, $2\n" \
4018 : /*out*/ "=r" (_res) \
4019 : /*in*/ "0" (&_argvec[0]) \
4020 : /*trash*/ "memory", __CALLER_SAVED_REGS \
4021 ); \
4022 lval = (__typeof__(lval)) _res; \
4023 } while (0)
4024
4025 #define CALL_FN_W_WW(lval, orig, arg1,arg2) \
4026 do { \
4027 volatile OrigFn _orig = (orig); \
4028 volatile unsigned long _argvec[3]; \
4029 volatile unsigned long _res; \
4030 _argvec[0] = (unsigned long)_orig.nraddr; \
4031 _argvec[1] = (unsigned long)(arg1); \
4032 _argvec[2] = (unsigned long)(arg2); \
4033 __asm__ volatile( \
4034 "subu $29, $29, 8 \n\t" \
4035 "sw $28, 0($29) \n\t" \
4036 "sw $31, 4($29) \n\t" \
4037 "subu $29, $29, 16 \n\t" \
4038 "lw $4, 4(%1) \n\t" \
4039 "lw $5, 8(%1) \n\t" \
4040 "lw $25, 0(%1) \n\t" /* target->t9 */ \
4041 VALGRIND_CALL_NOREDIR_T9 \
4042 "addu $29, $29, 16 \n\t" \
4043 "lw $28, 0($29) \n\t" \
4044 "lw $31, 4($29) \n\t" \
4045 "addu $29, $29, 8 \n\t" \
4046 "move %0, $2\n" \
4047 : /*out*/ "=r" (_res) \
4048 : /*in*/ "0" (&_argvec[0]) \
4049 : /*trash*/ "memory", __CALLER_SAVED_REGS \
4050 ); \
4051 lval = (__typeof__(lval)) _res; \
4052 } while (0)
4053
4054 #define CALL_FN_W_WWW(lval, orig, arg1,arg2,arg3) \
4055 do { \
4056 volatile OrigFn _orig = (orig); \
4057 volatile unsigned long _argvec[4]; \
4058 volatile unsigned long _res; \
4059 _argvec[0] = (unsigned long)_orig.nraddr; \
4060 _argvec[1] = (unsigned long)(arg1); \
4061 _argvec[2] = (unsigned long)(arg2); \
4062 _argvec[3] = (unsigned long)(arg3); \
4063 __asm__ volatile( \
4064 "subu $29, $29, 8 \n\t" \
4065 "sw $28, 0($29) \n\t" \
4066 "sw $31, 4($29) \n\t" \
4067 "subu $29, $29, 16 \n\t" \
4068 "lw $4, 4(%1) \n\t" \
4069 "lw $5, 8(%1) \n\t" \
4070 "lw $6, 12(%1) \n\t" \
4071 "lw $25, 0(%1) \n\t" /* target->t9 */ \
4072 VALGRIND_CALL_NOREDIR_T9 \
4073 "addu $29, $29, 16 \n\t" \
4074 "lw $28, 0($29) \n\t" \
4075 "lw $31, 4($29) \n\t" \
4076 "addu $29, $29, 8 \n\t" \
4077 "move %0, $2\n" \
4078 : /*out*/ "=r" (_res) \
4079 : /*in*/ "0" (&_argvec[0]) \
4080 : /*trash*/ "memory", __CALLER_SAVED_REGS \
4081 ); \
4082 lval = (__typeof__(lval)) _res; \
4083 } while (0)
4084
4085 #define CALL_FN_W_WWWW(lval, orig, arg1,arg2,arg3,arg4) \
4086 do { \
4087 volatile OrigFn _orig = (orig); \
4088 volatile unsigned long _argvec[5]; \
4089 volatile unsigned long _res; \
4090 _argvec[0] = (unsigned long)_orig.nraddr; \
4091 _argvec[1] = (unsigned long)(arg1); \
4092 _argvec[2] = (unsigned long)(arg2); \
4093 _argvec[3] = (unsigned long)(arg3); \
4094 _argvec[4] = (unsigned long)(arg4); \
4095 __asm__ volatile( \
4096 "subu $29, $29, 8 \n\t" \
4097 "sw $28, 0($29) \n\t" \
4098 "sw $31, 4($29) \n\t" \
4099 "subu $29, $29, 16 \n\t" \
4100 "lw $4, 4(%1) \n\t" \
4101 "lw $5, 8(%1) \n\t" \
4102 "lw $6, 12(%1) \n\t" \
4103 "lw $7, 16(%1) \n\t" \
4104 "lw $25, 0(%1) \n\t" /* target->t9 */ \
4105 VALGRIND_CALL_NOREDIR_T9 \
4106 "addu $29, $29, 16 \n\t" \
4107 "lw $28, 0($29) \n\t" \
4108 "lw $31, 4($29) \n\t" \
4109 "addu $29, $29, 8 \n\t" \
4110 "move %0, $2\n" \
4111 : /*out*/ "=r" (_res) \
4112 : /*in*/ "0" (&_argvec[0]) \
4113 : /*trash*/ "memory", __CALLER_SAVED_REGS \
4114 ); \
4115 lval = (__typeof__(lval)) _res; \
4116 } while (0)
4117
4118 #define CALL_FN_W_5W(lval, orig, arg1,arg2,arg3,arg4,arg5) \
4119 do { \
4120 volatile OrigFn _orig = (orig); \
4121 volatile unsigned long _argvec[6]; \
4122 volatile unsigned long _res; \
4123 _argvec[0] = (unsigned long)_orig.nraddr; \
4124 _argvec[1] = (unsigned long)(arg1); \
4125 _argvec[2] = (unsigned long)(arg2); \
4126 _argvec[3] = (unsigned long)(arg3); \
4127 _argvec[4] = (unsigned long)(arg4); \
4128 _argvec[5] = (unsigned long)(arg5); \
4129 __asm__ volatile( \
4130 "subu $29, $29, 8 \n\t" \
4131 "sw $28, 0($29) \n\t" \
4132 "sw $31, 4($29) \n\t" \
4133 "lw $4, 20(%1) \n\t" \
4134 "subu $29, $29, 24\n\t" \
4135 "sw $4, 16($29) \n\t" \
4136 "lw $4, 4(%1) \n\t" \
4137 "lw $5, 8(%1) \n\t" \
4138 "lw $6, 12(%1) \n\t" \
4139 "lw $7, 16(%1) \n\t" \
4140 "lw $25, 0(%1) \n\t" /* target->t9 */ \
4141 VALGRIND_CALL_NOREDIR_T9 \
4142 "addu $29, $29, 24 \n\t" \
4143 "lw $28, 0($29) \n\t" \
4144 "lw $31, 4($29) \n\t" \
4145 "addu $29, $29, 8 \n\t" \
4146 "move %0, $2\n" \
4147 : /*out*/ "=r" (_res) \
4148 : /*in*/ "0" (&_argvec[0]) \
4149 : /*trash*/ "memory", __CALLER_SAVED_REGS \
4150 ); \
4151 lval = (__typeof__(lval)) _res; \
4152 } while (0)
4153 #define CALL_FN_W_6W(lval, orig, arg1,arg2,arg3,arg4,arg5,arg6) \
4154 do { \
4155 volatile OrigFn _orig = (orig); \
4156 volatile unsigned long _argvec[7]; \
4157 volatile unsigned long _res; \
4158 _argvec[0] = (unsigned long)_orig.nraddr; \
4159 _argvec[1] = (unsigned long)(arg1); \
4160 _argvec[2] = (unsigned long)(arg2); \
4161 _argvec[3] = (unsigned long)(arg3); \
4162 _argvec[4] = (unsigned long)(arg4); \
4163 _argvec[5] = (unsigned long)(arg5); \
4164 _argvec[6] = (unsigned long)(arg6); \
4165 __asm__ volatile( \
4166 "subu $29, $29, 8 \n\t" \
4167 "sw $28, 0($29) \n\t" \
4168 "sw $31, 4($29) \n\t" \
4169 "lw $4, 20(%1) \n\t" \
4170 "subu $29, $29, 32\n\t" \
4171 "sw $4, 16($29) \n\t" \
4172 "lw $4, 24(%1) \n\t" \
4173 "nop\n\t" \
4174 "sw $4, 20($29) \n\t" \
4175 "lw $4, 4(%1) \n\t" \
4176 "lw $5, 8(%1) \n\t" \
4177 "lw $6, 12(%1) \n\t" \
4178 "lw $7, 16(%1) \n\t" \
4179 "lw $25, 0(%1) \n\t" /* target->t9 */ \
4180 VALGRIND_CALL_NOREDIR_T9 \
4181 "addu $29, $29, 32 \n\t" \
4182 "lw $28, 0($29) \n\t" \
4183 "lw $31, 4($29) \n\t" \
4184 "addu $29, $29, 8 \n\t" \
4185 "move %0, $2\n" \
4186 : /*out*/ "=r" (_res) \
4187 : /*in*/ "0" (&_argvec[0]) \
4188 : /*trash*/ "memory", __CALLER_SAVED_REGS \
4189 ); \
4190 lval = (__typeof__(lval)) _res; \
4191 } while (0)
4192
4193 #define CALL_FN_W_7W(lval, orig, arg1,arg2,arg3,arg4,arg5,arg6, \
4194 arg7) \
4195 do { \
4196 volatile OrigFn _orig = (orig); \
4197 volatile unsigned long _argvec[8]; \
4198 volatile unsigned long _res; \
4199 _argvec[0] = (unsigned long)_orig.nraddr; \
4200 _argvec[1] = (unsigned long)(arg1); \
4201 _argvec[2] = (unsigned long)(arg2); \
4202 _argvec[3] = (unsigned long)(arg3); \
4203 _argvec[4] = (unsigned long)(arg4); \
4204 _argvec[5] = (unsigned long)(arg5); \
4205 _argvec[6] = (unsigned long)(arg6); \
4206 _argvec[7] = (unsigned long)(arg7); \
4207 __asm__ volatile( \
4208 "subu $29, $29, 8 \n\t" \
4209 "sw $28, 0($29) \n\t" \
4210 "sw $31, 4($29) \n\t" \
4211 "lw $4, 20(%1) \n\t" \
4212 "subu $29, $29, 32\n\t" \
4213 "sw $4, 16($29) \n\t" \
4214 "lw $4, 24(%1) \n\t" \
4215 "sw $4, 20($29) \n\t" \
4216 "lw $4, 28(%1) \n\t" \
4217 "sw $4, 24($29) \n\t" \
4218 "lw $4, 4(%1) \n\t" \
4219 "lw $5, 8(%1) \n\t" \
4220 "lw $6, 12(%1) \n\t" \
4221 "lw $7, 16(%1) \n\t" \
4222 "lw $25, 0(%1) \n\t" /* target->t9 */ \
4223 VALGRIND_CALL_NOREDIR_T9 \
4224 "addu $29, $29, 32 \n\t" \
4225 "lw $28, 0($29) \n\t" \
4226 "lw $31, 4($29) \n\t" \
4227 "addu $29, $29, 8 \n\t" \
4228 "move %0, $2\n" \
4229 : /*out*/ "=r" (_res) \
4230 : /*in*/ "0" (&_argvec[0]) \
4231 : /*trash*/ "memory", __CALLER_SAVED_REGS \
4232 ); \
4233 lval = (__typeof__(lval)) _res; \
4234 } while (0)
4235
4236 #define CALL_FN_W_8W(lval, orig, arg1,arg2,arg3,arg4,arg5,arg6, \
4237 arg7,arg8) \
4238 do { \
4239 volatile OrigFn _orig = (orig); \
4240 volatile unsigned long _argvec[9]; \
4241 volatile unsigned long _res; \
4242 _argvec[0] = (unsigned long)_orig.nraddr; \
4243 _argvec[1] = (unsigned long)(arg1); \
4244 _argvec[2] = (unsigned long)(arg2); \
4245 _argvec[3] = (unsigned long)(arg3); \
4246 _argvec[4] = (unsigned long)(arg4); \
4247 _argvec[5] = (unsigned long)(arg5); \
4248 _argvec[6] = (unsigned long)(arg6); \
4249 _argvec[7] = (unsigned long)(arg7); \
4250 _argvec[8] = (unsigned long)(arg8); \
4251 __asm__ volatile( \
4252 "subu $29, $29, 8 \n\t" \
4253 "sw $28, 0($29) \n\t" \
4254 "sw $31, 4($29) \n\t" \
4255 "lw $4, 20(%1) \n\t" \
4256 "subu $29, $29, 40\n\t" \
4257 "sw $4, 16($29) \n\t" \
4258 "lw $4, 24(%1) \n\t" \
4259 "sw $4, 20($29) \n\t" \
4260 "lw $4, 28(%1) \n\t" \
4261 "sw $4, 24($29) \n\t" \
4262 "lw $4, 32(%1) \n\t" \
4263 "sw $4, 28($29) \n\t" \
4264 "lw $4, 4(%1) \n\t" \
4265 "lw $5, 8(%1) \n\t" \
4266 "lw $6, 12(%1) \n\t" \
4267 "lw $7, 16(%1) \n\t" \
4268 "lw $25, 0(%1) \n\t" /* target->t9 */ \
4269 VALGRIND_CALL_NOREDIR_T9 \
4270 "addu $29, $29, 40 \n\t" \
4271 "lw $28, 0($29) \n\t" \
4272 "lw $31, 4($29) \n\t" \
4273 "addu $29, $29, 8 \n\t" \
4274 "move %0, $2\n" \
4275 : /*out*/ "=r" (_res) \
4276 : /*in*/ "0" (&_argvec[0]) \
4277 : /*trash*/ "memory", __CALLER_SAVED_REGS \
4278 ); \
4279 lval = (__typeof__(lval)) _res; \
4280 } while (0)
4281
4282 #define CALL_FN_W_9W(lval, orig, arg1,arg2,arg3,arg4,arg5,arg6, \
4283 arg7,arg8,arg9) \
4284 do { \
4285 volatile OrigFn _orig = (orig); \
4286 volatile unsigned long _argvec[10]; \
4287 volatile unsigned long _res; \
4288 _argvec[0] = (unsigned long)_orig.nraddr; \
4289 _argvec[1] = (unsigned long)(arg1); \
4290 _argvec[2] = (unsigned long)(arg2); \
4291 _argvec[3] = (unsigned long)(arg3); \
4292 _argvec[4] = (unsigned long)(arg4); \
4293 _argvec[5] = (unsigned long)(arg5); \
4294 _argvec[6] = (unsigned long)(arg6); \
4295 _argvec[7] = (unsigned long)(arg7); \
4296 _argvec[8] = (unsigned long)(arg8); \
4297 _argvec[9] = (unsigned long)(arg9); \
4298 __asm__ volatile( \
4299 "subu $29, $29, 8 \n\t" \
4300 "sw $28, 0($29) \n\t" \
4301 "sw $31, 4($29) \n\t" \
4302 "lw $4, 20(%1) \n\t" \
4303 "subu $29, $29, 40\n\t" \
4304 "sw $4, 16($29) \n\t" \
4305 "lw $4, 24(%1) \n\t" \
4306 "sw $4, 20($29) \n\t" \
4307 "lw $4, 28(%1) \n\t" \
4308 "sw $4, 24($29) \n\t" \
4309 "lw $4, 32(%1) \n\t" \
4310 "sw $4, 28($29) \n\t" \
4311 "lw $4, 36(%1) \n\t" \
4312 "sw $4, 32($29) \n\t" \
4313 "lw $4, 4(%1) \n\t" \
4314 "lw $5, 8(%1) \n\t" \
4315 "lw $6, 12(%1) \n\t" \
4316 "lw $7, 16(%1) \n\t" \
4317 "lw $25, 0(%1) \n\t" /* target->t9 */ \
4318 VALGRIND_CALL_NOREDIR_T9 \
4319 "addu $29, $29, 40 \n\t" \
4320 "lw $28, 0($29) \n\t" \
4321 "lw $31, 4($29) \n\t" \
4322 "addu $29, $29, 8 \n\t" \
4323 "move %0, $2\n" \
4324 : /*out*/ "=r" (_res) \
4325 : /*in*/ "0" (&_argvec[0]) \
4326 : /*trash*/ "memory", __CALLER_SAVED_REGS \
4327 ); \
4328 lval = (__typeof__(lval)) _res; \
4329 } while (0)
4330
4331 #define CALL_FN_W_10W(lval, orig, arg1,arg2,arg3,arg4,arg5,arg6, \
4332 arg7,arg8,arg9,arg10) \
4333 do { \
4334 volatile OrigFn _orig = (orig); \
4335 volatile unsigned long _argvec[11]; \
4336 volatile unsigned long _res; \
4337 _argvec[0] = (unsigned long)_orig.nraddr; \
4338 _argvec[1] = (unsigned long)(arg1); \
4339 _argvec[2] = (unsigned long)(arg2); \
4340 _argvec[3] = (unsigned long)(arg3); \
4341 _argvec[4] = (unsigned long)(arg4); \
4342 _argvec[5] = (unsigned long)(arg5); \
4343 _argvec[6] = (unsigned long)(arg6); \
4344 _argvec[7] = (unsigned long)(arg7); \
4345 _argvec[8] = (unsigned long)(arg8); \
4346 _argvec[9] = (unsigned long)(arg9); \
4347 _argvec[10] = (unsigned long)(arg10); \
4348 __asm__ volatile( \
4349 "subu $29, $29, 8 \n\t" \
4350 "sw $28, 0($29) \n\t" \
4351 "sw $31, 4($29) \n\t" \
4352 "lw $4, 20(%1) \n\t" \
4353 "subu $29, $29, 48\n\t" \
4354 "sw $4, 16($29) \n\t" \
4355 "lw $4, 24(%1) \n\t" \
4356 "sw $4, 20($29) \n\t" \
4357 "lw $4, 28(%1) \n\t" \
4358 "sw $4, 24($29) \n\t" \
4359 "lw $4, 32(%1) \n\t" \
4360 "sw $4, 28($29) \n\t" \
4361 "lw $4, 36(%1) \n\t" \
4362 "sw $4, 32($29) \n\t" \
4363 "lw $4, 40(%1) \n\t" \
4364 "sw $4, 36($29) \n\t" \
4365 "lw $4, 4(%1) \n\t" \
4366 "lw $5, 8(%1) \n\t" \
4367 "lw $6, 12(%1) \n\t" \
4368 "lw $7, 16(%1) \n\t" \
4369 "lw $25, 0(%1) \n\t" /* target->t9 */ \
4370 VALGRIND_CALL_NOREDIR_T9 \
4371 "addu $29, $29, 48 \n\t" \
4372 "lw $28, 0($29) \n\t" \
4373 "lw $31, 4($29) \n\t" \
4374 "addu $29, $29, 8 \n\t" \
4375 "move %0, $2\n" \
4376 : /*out*/ "=r" (_res) \
4377 : /*in*/ "0" (&_argvec[0]) \
4378 : /*trash*/ "memory", __CALLER_SAVED_REGS \
4379 ); \
4380 lval = (__typeof__(lval)) _res; \
4381 } while (0)
4382
4383 #define CALL_FN_W_11W(lval, orig, arg1,arg2,arg3,arg4,arg5, \
4384 arg6,arg7,arg8,arg9,arg10, \
4385 arg11) \
4386 do { \
4387 volatile OrigFn _orig = (orig); \
4388 volatile unsigned long _argvec[12]; \
4389 volatile unsigned long _res; \
4390 _argvec[0] = (unsigned long)_orig.nraddr; \
4391 _argvec[1] = (unsigned long)(arg1); \
4392 _argvec[2] = (unsigned long)(arg2); \
4393 _argvec[3] = (unsigned long)(arg3); \
4394 _argvec[4] = (unsigned long)(arg4); \
4395 _argvec[5] = (unsigned long)(arg5); \
4396 _argvec[6] = (unsigned long)(arg6); \
4397 _argvec[7] = (unsigned long)(arg7); \
4398 _argvec[8] = (unsigned long)(arg8); \
4399 _argvec[9] = (unsigned long)(arg9); \
4400 _argvec[10] = (unsigned long)(arg10); \
4401 _argvec[11] = (unsigned long)(arg11); \
4402 __asm__ volatile( \
4403 "subu $29, $29, 8 \n\t" \
4404 "sw $28, 0($29) \n\t" \
4405 "sw $31, 4($29) \n\t" \
4406 "lw $4, 20(%1) \n\t" \
4407 "subu $29, $29, 48\n\t" \
4408 "sw $4, 16($29) \n\t" \
4409 "lw $4, 24(%1) \n\t" \
4410 "sw $4, 20($29) \n\t" \
4411 "lw $4, 28(%1) \n\t" \
4412 "sw $4, 24($29) \n\t" \
4413 "lw $4, 32(%1) \n\t" \
4414 "sw $4, 28($29) \n\t" \
4415 "lw $4, 36(%1) \n\t" \
4416 "sw $4, 32($29) \n\t" \
4417 "lw $4, 40(%1) \n\t" \
4418 "sw $4, 36($29) \n\t" \
4419 "lw $4, 44(%1) \n\t" \
4420 "sw $4, 40($29) \n\t" \
4421 "lw $4, 4(%1) \n\t" \
4422 "lw $5, 8(%1) \n\t" \
4423 "lw $6, 12(%1) \n\t" \
4424 "lw $7, 16(%1) \n\t" \
4425 "lw $25, 0(%1) \n\t" /* target->t9 */ \
4426 VALGRIND_CALL_NOREDIR_T9 \
4427 "addu $29, $29, 48 \n\t" \
4428 "lw $28, 0($29) \n\t" \
4429 "lw $31, 4($29) \n\t" \
4430 "addu $29, $29, 8 \n\t" \
4431 "move %0, $2\n" \
4432 : /*out*/ "=r" (_res) \
4433 : /*in*/ "0" (&_argvec[0]) \
4434 : /*trash*/ "memory", __CALLER_SAVED_REGS \
4435 ); \
4436 lval = (__typeof__(lval)) _res; \
4437 } while (0)
4438
4439 #define CALL_FN_W_12W(lval, orig, arg1,arg2,arg3,arg4,arg5, \
4440 arg6,arg7,arg8,arg9,arg10, \
4441 arg11,arg12) \
4442 do { \
4443 volatile OrigFn _orig = (orig); \
4444 volatile unsigned long _argvec[13]; \
4445 volatile unsigned long _res; \
4446 _argvec[0] = (unsigned long)_orig.nraddr; \
4447 _argvec[1] = (unsigned long)(arg1); \
4448 _argvec[2] = (unsigned long)(arg2); \
4449 _argvec[3] = (unsigned long)(arg3); \
4450 _argvec[4] = (unsigned long)(arg4); \
4451 _argvec[5] = (unsigned long)(arg5); \
4452 _argvec[6] = (unsigned long)(arg6); \
4453 _argvec[7] = (unsigned long)(arg7); \
4454 _argvec[8] = (unsigned long)(arg8); \
4455 _argvec[9] = (unsigned long)(arg9); \
4456 _argvec[10] = (unsigned long)(arg10); \
4457 _argvec[11] = (unsigned long)(arg11); \
4458 _argvec[12] = (unsigned long)(arg12); \
4459 __asm__ volatile( \
4460 "subu $29, $29, 8 \n\t" \
4461 "sw $28, 0($29) \n\t" \
4462 "sw $31, 4($29) \n\t" \
4463 "lw $4, 20(%1) \n\t" \
4464 "subu $29, $29, 56\n\t" \
4465 "sw $4, 16($29) \n\t" \
4466 "lw $4, 24(%1) \n\t" \
4467 "sw $4, 20($29) \n\t" \
4468 "lw $4, 28(%1) \n\t" \
4469 "sw $4, 24($29) \n\t" \
4470 "lw $4, 32(%1) \n\t" \
4471 "sw $4, 28($29) \n\t" \
4472 "lw $4, 36(%1) \n\t" \
4473 "sw $4, 32($29) \n\t" \
4474 "lw $4, 40(%1) \n\t" \
4475 "sw $4, 36($29) \n\t" \
4476 "lw $4, 44(%1) \n\t" \
4477 "sw $4, 40($29) \n\t" \
4478 "lw $4, 48(%1) \n\t" \
4479 "sw $4, 44($29) \n\t" \
4480 "lw $4, 4(%1) \n\t" \
4481 "lw $5, 8(%1) \n\t" \
4482 "lw $6, 12(%1) \n\t" \
4483 "lw $7, 16(%1) \n\t" \
4484 "lw $25, 0(%1) \n\t" /* target->t9 */ \
4485 VALGRIND_CALL_NOREDIR_T9 \
4486 "addu $29, $29, 56 \n\t" \
4487 "lw $28, 0($29) \n\t" \
4488 "lw $31, 4($29) \n\t" \
4489 "addu $29, $29, 8 \n\t" \
4490 "move %0, $2\n" \
4491 : /*out*/ "=r" (_res) \
4492 : /*in*/ "r" (&_argvec[0]) \
4493 : /*trash*/ "memory", __CALLER_SAVED_REGS \
4494 ); \
4495 lval = (__typeof__(lval)) _res; \
4496 } while (0)
4497
4498 #endif /* PLAT_mips32_linux */
4499
4500 /* ------------------------- mips64-linux ------------------------- */
4501
4502 #if defined(PLAT_mips64_linux)
4503
4504 /* These regs are trashed by the hidden call. */
4505 #define __CALLER_SAVED_REGS "$2", "$3", "$4", "$5", "$6", \
4506 "$7", "$8", "$9", "$10", "$11", "$12", "$13", "$14", "$15", "$24", \
4507 "$25", "$31"
4508
4509 /* These CALL_FN_ macros assume that on mips-linux, sizeof(unsigned
4510 long) == 4. */
4511
4512 #define CALL_FN_W_v(lval, orig) \
4513 do { \
4514 volatile OrigFn _orig = (orig); \
4515 volatile unsigned long _argvec[1]; \
4516 volatile unsigned long _res; \
4517 _argvec[0] = (unsigned long)_orig.nraddr; \
4518 __asm__ volatile( \
4519 "ld $25, 0(%1)\n\t" /* target->t9 */ \
4520 VALGRIND_CALL_NOREDIR_T9 \
4521 "move %0, $2\n" \
4522 : /*out*/ "=r" (_res) \
4523 : /*in*/ "0" (&_argvec[0]) \
4524 : /*trash*/ "memory", __CALLER_SAVED_REGS \
4525 ); \
4526 lval = (__typeof__(lval)) _res; \
4527 } while (0)
4528
4529 #define CALL_FN_W_W(lval, orig, arg1) \
4530 do { \
4531 volatile OrigFn _orig = (orig); \
4532 volatile unsigned long _argvec[2]; \
4533 volatile unsigned long _res; \
4534 _argvec[0] = (unsigned long)_orig.nraddr; \
4535 _argvec[1] = (unsigned long)(arg1); \
4536 __asm__ volatile( \
4537 "ld $4, 8(%1)\n\t" /* arg1*/ \
4538 "ld $25, 0(%1)\n\t" /* target->t9 */ \
4539 VALGRIND_CALL_NOREDIR_T9 \
4540 "move %0, $2\n" \
4541 : /*out*/ "=r" (_res) \
4542 : /*in*/ "r" (&_argvec[0]) \
4543 : /*trash*/ "memory", __CALLER_SAVED_REGS \
4544 ); \
4545 lval = (__typeof__(lval)) _res; \
4546 } while (0)
4547
4548 #define CALL_FN_W_WW(lval, orig, arg1,arg2) \
4549 do { \
4550 volatile OrigFn _orig = (orig); \
4551 volatile unsigned long _argvec[3]; \
4552 volatile unsigned long _res; \
4553 _argvec[0] = (unsigned long)_orig.nraddr; \
4554 _argvec[1] = (unsigned long)(arg1); \
4555 _argvec[2] = (unsigned long)(arg2); \
4556 __asm__ volatile( \
4557 "ld $4, 8(%1)\n\t" \
4558 "ld $5, 16(%1)\n\t" \
4559 "ld $25, 0(%1)\n\t" /* target->t9 */ \
4560 VALGRIND_CALL_NOREDIR_T9 \
4561 "move %0, $2\n" \
4562 : /*out*/ "=r" (_res) \
4563 : /*in*/ "r" (&_argvec[0]) \
4564 : /*trash*/ "memory", __CALLER_SAVED_REGS \
4565 ); \
4566 lval = (__typeof__(lval)) _res; \
4567 } while (0)
4568
4569 #define CALL_FN_W_WWW(lval, orig, arg1,arg2,arg3) \
4570 do { \
4571 volatile OrigFn _orig = (orig); \
4572 volatile unsigned long _argvec[4]; \
4573 volatile unsigned long _res; \
4574 _argvec[0] = (unsigned long)_orig.nraddr; \
4575 _argvec[1] = (unsigned long)(arg1); \
4576 _argvec[2] = (unsigned long)(arg2); \
4577 _argvec[3] = (unsigned long)(arg3); \
4578 __asm__ volatile( \
4579 "ld $4, 8(%1)\n\t" \
4580 "ld $5, 16(%1)\n\t" \
4581 "ld $6, 24(%1)\n\t" \
4582 "ld $25, 0(%1)\n\t" /* target->t9 */ \
4583 VALGRIND_CALL_NOREDIR_T9 \
4584 "move %0, $2\n" \
4585 : /*out*/ "=r" (_res) \
4586 : /*in*/ "r" (&_argvec[0]) \
4587 : /*trash*/ "memory", __CALLER_SAVED_REGS \
4588 ); \
4589 lval = (__typeof__(lval)) _res; \
4590 } while (0)
4591
4592 #define CALL_FN_W_WWWW(lval, orig, arg1,arg2,arg3,arg4) \
4593 do { \
4594 volatile OrigFn _orig = (orig); \
4595 volatile unsigned long _argvec[5]; \
4596 volatile unsigned long _res; \
4597 _argvec[0] = (unsigned long)_orig.nraddr; \
4598 _argvec[1] = (unsigned long)(arg1); \
4599 _argvec[2] = (unsigned long)(arg2); \
4600 _argvec[3] = (unsigned long)(arg3); \
4601 _argvec[4] = (unsigned long)(arg4); \
4602 __asm__ volatile( \
4603 "ld $4, 8(%1)\n\t" \
4604 "ld $5, 16(%1)\n\t" \
4605 "ld $6, 24(%1)\n\t" \
4606 "ld $7, 32(%1)\n\t" \
4607 "ld $25, 0(%1)\n\t" /* target->t9 */ \
4608 VALGRIND_CALL_NOREDIR_T9 \
4609 "move %0, $2\n" \
4610 : /*out*/ "=r" (_res) \
4611 : /*in*/ "r" (&_argvec[0]) \
4612 : /*trash*/ "memory", __CALLER_SAVED_REGS \
4613 ); \
4614 lval = (__typeof__(lval)) _res; \
4615 } while (0)
4616
4617 #define CALL_FN_W_5W(lval, orig, arg1,arg2,arg3,arg4,arg5) \
4618 do { \
4619 volatile OrigFn _orig = (orig); \
4620 volatile unsigned long _argvec[6]; \
4621 volatile unsigned long _res; \
4622 _argvec[0] = (unsigned long)_orig.nraddr; \
4623 _argvec[1] = (unsigned long)(arg1); \
4624 _argvec[2] = (unsigned long)(arg2); \
4625 _argvec[3] = (unsigned long)(arg3); \
4626 _argvec[4] = (unsigned long)(arg4); \
4627 _argvec[5] = (unsigned long)(arg5); \
4628 __asm__ volatile( \
4629 "ld $4, 8(%1)\n\t" \
4630 "ld $5, 16(%1)\n\t" \
4631 "ld $6, 24(%1)\n\t" \
4632 "ld $7, 32(%1)\n\t" \
4633 "ld $8, 40(%1)\n\t" \
4634 "ld $25, 0(%1)\n\t" /* target->t9 */ \
4635 VALGRIND_CALL_NOREDIR_T9 \
4636 "move %0, $2\n" \
4637 : /*out*/ "=r" (_res) \
4638 : /*in*/ "r" (&_argvec[0]) \
4639 : /*trash*/ "memory", __CALLER_SAVED_REGS \
4640 ); \
4641 lval = (__typeof__(lval)) _res; \
4642 } while (0)
4643
4644 #define CALL_FN_W_6W(lval, orig, arg1,arg2,arg3,arg4,arg5,arg6) \
4645 do { \
4646 volatile OrigFn _orig = (orig); \
4647 volatile unsigned long _argvec[7]; \
4648 volatile unsigned long _res; \
4649 _argvec[0] = (unsigned long)_orig.nraddr; \
4650 _argvec[1] = (unsigned long)(arg1); \
4651 _argvec[2] = (unsigned long)(arg2); \
4652 _argvec[3] = (unsigned long)(arg3); \
4653 _argvec[4] = (unsigned long)(arg4); \
4654 _argvec[5] = (unsigned long)(arg5); \
4655 _argvec[6] = (unsigned long)(arg6); \
4656 __asm__ volatile( \
4657 "ld $4, 8(%1)\n\t" \
4658 "ld $5, 16(%1)\n\t" \
4659 "ld $6, 24(%1)\n\t" \
4660 "ld $7, 32(%1)\n\t" \
4661 "ld $8, 40(%1)\n\t" \
4662 "ld $9, 48(%1)\n\t" \
4663 "ld $25, 0(%1)\n\t" /* target->t9 */ \
4664 VALGRIND_CALL_NOREDIR_T9 \
4665 "move %0, $2\n" \
4666 : /*out*/ "=r" (_res) \
4667 : /*in*/ "r" (&_argvec[0]) \
4668 : /*trash*/ "memory", __CALLER_SAVED_REGS \
4669 ); \
4670 lval = (__typeof__(lval)) _res; \
4671 } while (0)
4672
4673 #define CALL_FN_W_7W(lval, orig, arg1,arg2,arg3,arg4,arg5,arg6, \
4674 arg7) \
4675 do { \
4676 volatile OrigFn _orig = (orig); \
4677 volatile unsigned long _argvec[8]; \
4678 volatile unsigned long _res; \
4679 _argvec[0] = (unsigned long)_orig.nraddr; \
4680 _argvec[1] = (unsigned long)(arg1); \
4681 _argvec[2] = (unsigned long)(arg2); \
4682 _argvec[3] = (unsigned long)(arg3); \
4683 _argvec[4] = (unsigned long)(arg4); \
4684 _argvec[5] = (unsigned long)(arg5); \
4685 _argvec[6] = (unsigned long)(arg6); \
4686 _argvec[7] = (unsigned long)(arg7); \
4687 __asm__ volatile( \
4688 "ld $4, 8(%1)\n\t" \
4689 "ld $5, 16(%1)\n\t" \
4690 "ld $6, 24(%1)\n\t" \
4691 "ld $7, 32(%1)\n\t" \
4692 "ld $8, 40(%1)\n\t" \
4693 "ld $9, 48(%1)\n\t" \
4694 "ld $10, 56(%1)\n\t" \
4695 "ld $25, 0(%1) \n\t" /* target->t9 */ \
4696 VALGRIND_CALL_NOREDIR_T9 \
4697 "move %0, $2\n" \
4698 : /*out*/ "=r" (_res) \
4699 : /*in*/ "r" (&_argvec[0]) \
4700 : /*trash*/ "memory", __CALLER_SAVED_REGS \
4701 ); \
4702 lval = (__typeof__(lval)) _res; \
4703 } while (0)
4704
4705 #define CALL_FN_W_8W(lval, orig, arg1,arg2,arg3,arg4,arg5,arg6, \
4706 arg7,arg8) \
4707 do { \
4708 volatile OrigFn _orig = (orig); \
4709 volatile unsigned long _argvec[9]; \
4710 volatile unsigned long _res; \
4711 _argvec[0] = (unsigned long)_orig.nraddr; \
4712 _argvec[1] = (unsigned long)(arg1); \
4713 _argvec[2] = (unsigned long)(arg2); \
4714 _argvec[3] = (unsigned long)(arg3); \
4715 _argvec[4] = (unsigned long)(arg4); \
4716 _argvec[5] = (unsigned long)(arg5); \
4717 _argvec[6] = (unsigned long)(arg6); \
4718 _argvec[7] = (unsigned long)(arg7); \
4719 _argvec[8] = (unsigned long)(arg8); \
4720 __asm__ volatile( \
4721 "ld $4, 8(%1)\n\t" \
4722 "ld $5, 16(%1)\n\t" \
4723 "ld $6, 24(%1)\n\t" \
4724 "ld $7, 32(%1)\n\t" \
4725 "ld $8, 40(%1)\n\t" \
4726 "ld $9, 48(%1)\n\t" \
4727 "ld $10, 56(%1)\n\t" \
4728 "ld $11, 64(%1)\n\t" \
4729 "ld $25, 0(%1) \n\t" /* target->t9 */ \
4730 VALGRIND_CALL_NOREDIR_T9 \
4731 "move %0, $2\n" \
4732 : /*out*/ "=r" (_res) \
4733 : /*in*/ "r" (&_argvec[0]) \
4734 : /*trash*/ "memory", __CALLER_SAVED_REGS \
4735 ); \
4736 lval = (__typeof__(lval)) _res; \
4737 } while (0)
4738
4739 #define CALL_FN_W_9W(lval, orig, arg1,arg2,arg3,arg4,arg5,arg6, \
4740 arg7,arg8,arg9) \
4741 do { \
4742 volatile OrigFn _orig = (orig); \
4743 volatile unsigned long _argvec[10]; \
4744 volatile unsigned long _res; \
4745 _argvec[0] = (unsigned long)_orig.nraddr; \
4746 _argvec[1] = (unsigned long)(arg1); \
4747 _argvec[2] = (unsigned long)(arg2); \
4748 _argvec[3] = (unsigned long)(arg3); \
4749 _argvec[4] = (unsigned long)(arg4); \
4750 _argvec[5] = (unsigned long)(arg5); \
4751 _argvec[6] = (unsigned long)(arg6); \
4752 _argvec[7] = (unsigned long)(arg7); \
4753 _argvec[8] = (unsigned long)(arg8); \
4754 _argvec[9] = (unsigned long)(arg9); \
4755 __asm__ volatile( \
4756 "dsubu $29, $29, 8\n\t" \
4757 "ld $4, 72(%1)\n\t" \
4758 "sd $4, 0($29)\n\t" \
4759 "ld $4, 8(%1)\n\t" \
4760 "ld $5, 16(%1)\n\t" \
4761 "ld $6, 24(%1)\n\t" \
4762 "ld $7, 32(%1)\n\t" \
4763 "ld $8, 40(%1)\n\t" \
4764 "ld $9, 48(%1)\n\t" \
4765 "ld $10, 56(%1)\n\t" \
4766 "ld $11, 64(%1)\n\t" \
4767 "ld $25, 0(%1)\n\t" /* target->t9 */ \
4768 VALGRIND_CALL_NOREDIR_T9 \
4769 "daddu $29, $29, 8\n\t" \
4770 "move %0, $2\n" \
4771 : /*out*/ "=r" (_res) \
4772 : /*in*/ "r" (&_argvec[0]) \
4773 : /*trash*/ "memory", __CALLER_SAVED_REGS \
4774 ); \
4775 lval = (__typeof__(lval)) _res; \
4776 } while (0)
4777
4778 #define CALL_FN_W_10W(lval, orig, arg1,arg2,arg3,arg4,arg5,arg6, \
4779 arg7,arg8,arg9,arg10) \
4780 do { \
4781 volatile OrigFn _orig = (orig); \
4782 volatile unsigned long _argvec[11]; \
4783 volatile unsigned long _res; \
4784 _argvec[0] = (unsigned long)_orig.nraddr; \
4785 _argvec[1] = (unsigned long)(arg1); \
4786 _argvec[2] = (unsigned long)(arg2); \
4787 _argvec[3] = (unsigned long)(arg3); \
4788 _argvec[4] = (unsigned long)(arg4); \
4789 _argvec[5] = (unsigned long)(arg5); \
4790 _argvec[6] = (unsigned long)(arg6); \
4791 _argvec[7] = (unsigned long)(arg7); \
4792 _argvec[8] = (unsigned long)(arg8); \
4793 _argvec[9] = (unsigned long)(arg9); \
4794 _argvec[10] = (unsigned long)(arg10); \
4795 __asm__ volatile( \
4796 "dsubu $29, $29, 16\n\t" \
4797 "ld $4, 72(%1)\n\t" \
4798 "sd $4, 0($29)\n\t" \
4799 "ld $4, 80(%1)\n\t" \
4800 "sd $4, 8($29)\n\t" \
4801 "ld $4, 8(%1)\n\t" \
4802 "ld $5, 16(%1)\n\t" \
4803 "ld $6, 24(%1)\n\t" \
4804 "ld $7, 32(%1)\n\t" \
4805 "ld $8, 40(%1)\n\t" \
4806 "ld $9, 48(%1)\n\t" \
4807 "ld $10, 56(%1)\n\t" \
4808 "ld $11, 64(%1)\n\t" \
4809 "ld $25, 0(%1)\n\t" /* target->t9 */ \
4810 VALGRIND_CALL_NOREDIR_T9 \
4811 "daddu $29, $29, 16\n\t" \
4812 "move %0, $2\n" \
4813 : /*out*/ "=r" (_res) \
4814 : /*in*/ "r" (&_argvec[0]) \
4815 : /*trash*/ "memory", __CALLER_SAVED_REGS \
4816 ); \
4817 lval = (__typeof__(lval)) _res; \
4818 } while (0)
4819
4820 #define CALL_FN_W_11W(lval, orig, arg1,arg2,arg3,arg4,arg5, \
4821 arg6,arg7,arg8,arg9,arg10, \
4822 arg11) \
4823 do { \
4824 volatile OrigFn _orig = (orig); \
4825 volatile unsigned long _argvec[12]; \
4826 volatile unsigned long _res; \
4827 _argvec[0] = (unsigned long)_orig.nraddr; \
4828 _argvec[1] = (unsigned long)(arg1); \
4829 _argvec[2] = (unsigned long)(arg2); \
4830 _argvec[3] = (unsigned long)(arg3); \
4831 _argvec[4] = (unsigned long)(arg4); \
4832 _argvec[5] = (unsigned long)(arg5); \
4833 _argvec[6] = (unsigned long)(arg6); \
4834 _argvec[7] = (unsigned long)(arg7); \
4835 _argvec[8] = (unsigned long)(arg8); \
4836 _argvec[9] = (unsigned long)(arg9); \
4837 _argvec[10] = (unsigned long)(arg10); \
4838 _argvec[11] = (unsigned long)(arg11); \
4839 __asm__ volatile( \
4840 "dsubu $29, $29, 24\n\t" \
4841 "ld $4, 72(%1)\n\t" \
4842 "sd $4, 0($29)\n\t" \
4843 "ld $4, 80(%1)\n\t" \
4844 "sd $4, 8($29)\n\t" \
4845 "ld $4, 88(%1)\n\t" \
4846 "sd $4, 16($29)\n\t" \
4847 "ld $4, 8(%1)\n\t" \
4848 "ld $5, 16(%1)\n\t" \
4849 "ld $6, 24(%1)\n\t" \
4850 "ld $7, 32(%1)\n\t" \
4851 "ld $8, 40(%1)\n\t" \
4852 "ld $9, 48(%1)\n\t" \
4853 "ld $10, 56(%1)\n\t" \
4854 "ld $11, 64(%1)\n\t" \
4855 "ld $25, 0(%1)\n\t" /* target->t9 */ \
4856 VALGRIND_CALL_NOREDIR_T9 \
4857 "daddu $29, $29, 24\n\t" \
4858 "move %0, $2\n" \
4859 : /*out*/ "=r" (_res) \
4860 : /*in*/ "r" (&_argvec[0]) \
4861 : /*trash*/ "memory", __CALLER_SAVED_REGS \
4862 ); \
4863 lval = (__typeof__(lval)) _res; \
4864 } while (0)
4865
4866 #define CALL_FN_W_12W(lval, orig, arg1,arg2,arg3,arg4,arg5, \
4867 arg6,arg7,arg8,arg9,arg10, \
4868 arg11,arg12) \
4869 do { \
4870 volatile OrigFn _orig = (orig); \
4871 volatile unsigned long _argvec[13]; \
4872 volatile unsigned long _res; \
4873 _argvec[0] = (unsigned long)_orig.nraddr; \
4874 _argvec[1] = (unsigned long)(arg1); \
4875 _argvec[2] = (unsigned long)(arg2); \
4876 _argvec[3] = (unsigned long)(arg3); \
4877 _argvec[4] = (unsigned long)(arg4); \
4878 _argvec[5] = (unsigned long)(arg5); \
4879 _argvec[6] = (unsigned long)(arg6); \
4880 _argvec[7] = (unsigned long)(arg7); \
4881 _argvec[8] = (unsigned long)(arg8); \
4882 _argvec[9] = (unsigned long)(arg9); \
4883 _argvec[10] = (unsigned long)(arg10); \
4884 _argvec[11] = (unsigned long)(arg11); \
4885 _argvec[12] = (unsigned long)(arg12); \
4886 __asm__ volatile( \
4887 "dsubu $29, $29, 32\n\t" \
4888 "ld $4, 72(%1)\n\t" \
4889 "sd $4, 0($29)\n\t" \
4890 "ld $4, 80(%1)\n\t" \
4891 "sd $4, 8($29)\n\t" \
4892 "ld $4, 88(%1)\n\t" \
4893 "sd $4, 16($29)\n\t" \
4894 "ld $4, 96(%1)\n\t" \
4895 "sd $4, 24($29)\n\t" \
4896 "ld $4, 8(%1)\n\t" \
4897 "ld $5, 16(%1)\n\t" \
4898 "ld $6, 24(%1)\n\t" \
4899 "ld $7, 32(%1)\n\t" \
4900 "ld $8, 40(%1)\n\t" \
4901 "ld $9, 48(%1)\n\t" \
4902 "ld $10, 56(%1)\n\t" \
4903 "ld $11, 64(%1)\n\t" \
4904 "ld $25, 0(%1)\n\t" /* target->t9 */ \
4905 VALGRIND_CALL_NOREDIR_T9 \
4906 "daddu $29, $29, 32\n\t" \
4907 "move %0, $2\n" \
4908 : /*out*/ "=r" (_res) \
4909 : /*in*/ "r" (&_argvec[0]) \
4910 : /*trash*/ "memory", __CALLER_SAVED_REGS \
4911 ); \
4912 lval = (__typeof__(lval)) _res; \
4913 } while (0)
4914
4915 #endif /* PLAT_mips64_linux */
4916
4917
4918 /* ------------------------------------------------------------------ */
4919 /* ARCHITECTURE INDEPENDENT MACROS for CLIENT REQUESTS. */
4920 /* */
4921 /* ------------------------------------------------------------------ */
4922
4923 /* Some request codes. There are many more of these, but most are not
4924 exposed to end-user view. These are the public ones, all of the
4925 form 0x1000 + small_number.
4926
4927 Core ones are in the range 0x00000000--0x0000ffff. The non-public
4928 ones start at 0x2000.
4929 */
4930
4931 /* These macros are used by tools -- they must be public, but don't
4932 embed them into other programs. */
4933 #define VG_USERREQ_TOOL_BASE(a,b) \
4934 ((unsigned int)(((a)&0xff) << 24 | ((b)&0xff) << 16))
4935 #define VG_IS_TOOL_USERREQ(a, b, v) \
4936 (VG_USERREQ_TOOL_BASE(a,b) == ((v) & 0xffff0000))
4937
4938 /* !! ABIWARNING !! ABIWARNING !! ABIWARNING !! ABIWARNING !!
4939 This enum comprises an ABI exported by Valgrind to programs
4940 which use client requests. DO NOT CHANGE THE ORDER OF THESE
4941 ENTRIES, NOR DELETE ANY -- add new ones at the end. */
4942 typedef
4943 enum { VG_USERREQ__RUNNING_ON_VALGRIND = 0x1001,
4944 VG_USERREQ__DISCARD_TRANSLATIONS = 0x1002,
4945
4946 /* These allow any function to be called from the simulated
4947 CPU but run on the real CPU. Nb: the first arg passed to
4948 the function is always the ThreadId of the running
4949 thread! So CLIENT_CALL0 actually requires a 1 arg
4950 function, etc. */
4951 VG_USERREQ__CLIENT_CALL0 = 0x1101,
4952 VG_USERREQ__CLIENT_CALL1 = 0x1102,
4953 VG_USERREQ__CLIENT_CALL2 = 0x1103,
4954 VG_USERREQ__CLIENT_CALL3 = 0x1104,
4955
4956 /* Can be useful in regression testing suites -- eg. can
4957 send Valgrind's output to /dev/null and still count
4958 errors. */
4959 VG_USERREQ__COUNT_ERRORS = 0x1201,
4960
4961 /* Allows the client program and/or gdbserver to execute a monitor
4962 command. */
4963 VG_USERREQ__GDB_MONITOR_COMMAND = 0x1202,
4964
4965 /* These are useful and can be interpreted by any tool that
4966 tracks malloc() et al, by using vg_replace_malloc.c. */
4967 VG_USERREQ__MALLOCLIKE_BLOCK = 0x1301,
4968 VG_USERREQ__RESIZEINPLACE_BLOCK = 0x130b,
4969 VG_USERREQ__FREELIKE_BLOCK = 0x1302,
4970 /* Memory pool support. */
4971 VG_USERREQ__CREATE_MEMPOOL = 0x1303,
4972 VG_USERREQ__DESTROY_MEMPOOL = 0x1304,
4973 VG_USERREQ__MEMPOOL_ALLOC = 0x1305,
4974 VG_USERREQ__MEMPOOL_FREE = 0x1306,
4975 VG_USERREQ__MEMPOOL_TRIM = 0x1307,
4976 VG_USERREQ__MOVE_MEMPOOL = 0x1308,
4977 VG_USERREQ__MEMPOOL_CHANGE = 0x1309,
4978 VG_USERREQ__MEMPOOL_EXISTS = 0x130a,
4979
4980 /* Allow printfs to valgrind log. */
4981 /* The first two pass the va_list argument by value, which
4982 assumes it is the same size as or smaller than a UWord,
4983 which generally isn't the case. Hence are deprecated.
4984 The second two pass the vargs by reference and so are
4985 immune to this problem. */
4986 /* both :: char* fmt, va_list vargs (DEPRECATED) */
4987 VG_USERREQ__PRINTF = 0x1401,
4988 VG_USERREQ__PRINTF_BACKTRACE = 0x1402,
4989 /* both :: char* fmt, va_list* vargs */
4990 VG_USERREQ__PRINTF_VALIST_BY_REF = 0x1403,
4991 VG_USERREQ__PRINTF_BACKTRACE_VALIST_BY_REF = 0x1404,
4992
4993 /* Stack support. */
4994 VG_USERREQ__STACK_REGISTER = 0x1501,
4995 VG_USERREQ__STACK_DEREGISTER = 0x1502,
4996 VG_USERREQ__STACK_CHANGE = 0x1503,
4997
4998 /* Wine support */
4999 VG_USERREQ__LOAD_PDB_DEBUGINFO = 0x1601,
5000
5001 /* Querying of debug info. */
5002 VG_USERREQ__MAP_IP_TO_SRCLOC = 0x1701,
5003
5004 /* Disable/enable error reporting level. Takes a single
5005 Word arg which is the delta to this thread's error
5006 disablement indicator. Hence 1 disables or further
5007 disables errors, and -1 moves back towards enablement.
5008 Other values are not allowed. */
5009 VG_USERREQ__CHANGE_ERR_DISABLEMENT = 0x1801,
5010
5011 /* Initialise IR injection */
5012 VG_USERREQ__VEX_INIT_FOR_IRI = 0x1901
5013 } Vg_ClientRequest;
5014
5015 #if !defined(__GNUC__)
5016 # define __extension__ /* */
5017 #endif
5018
5019
5020 /* Returns the number of Valgrinds this code is running under. That
5021 is, 0 if running natively, 1 if running under Valgrind, 2 if
5022 running under Valgrind which is running under another Valgrind,
5023 etc. */
5024 #define RUNNING_ON_VALGRIND \
5025 (unsigned)VALGRIND_DO_CLIENT_REQUEST_EXPR(0 /* if not */, \
5026 VG_USERREQ__RUNNING_ON_VALGRIND, \
5027 0, 0, 0, 0, 0) \
5028
5029
5030 /* Discard translation of code in the range [_qzz_addr .. _qzz_addr +
5031 _qzz_len - 1]. Useful if you are debugging a JITter or some such,
5032 since it provides a way to make sure valgrind will retranslate the
5033 invalidated area. Returns no value. */
5034 #define VALGRIND_DISCARD_TRANSLATIONS(_qzz_addr,_qzz_len) \
5035 VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__DISCARD_TRANSLATIONS, \
5036 _qzz_addr, _qzz_len, 0, 0, 0)
5037
5038
5039 /* These requests are for getting Valgrind itself to print something.
5040 Possibly with a backtrace. This is a really ugly hack. The return value
5041 is the number of characters printed, excluding the "**<pid>** " part at the
5042 start and the backtrace (if present). */
5043
5044 #if defined(__GNUC__) || defined(__INTEL_COMPILER) && !defined(_MSC_VER)
5045 /* Modern GCC will optimize the static routine out if unused,
5046 and unused attribute will shut down warnings about it. */
5047 static int VALGRIND_PRINTF(const char *format, ...)
5048 __attribute__((format(__printf__, 1, 2), __unused__));
5049 #endif
5050 static int
5051 #if defined(_MSC_VER)
5052 __inline
5053 #endif
5054 VALGRIND_PRINTF(const char *format, ...)
5055 {
5056 #if defined(NVALGRIND)
5057 return 0;
5058 #else /* NVALGRIND */
5059 #if defined(_MSC_VER) || defined(__MINGW64__)
5060 uintptr_t _qzz_res;
5061 #else
5062 unsigned long _qzz_res;
5063 #endif
5064 va_list vargs;
5065 va_start(vargs, format);
5066 #if defined(_MSC_VER) || defined(__MINGW64__)
5067 _qzz_res = VALGRIND_DO_CLIENT_REQUEST_EXPR(0,
5068 VG_USERREQ__PRINTF_VALIST_BY_REF,
5069 (uintptr_t)format,
5070 (uintptr_t)&vargs,
5071 0, 0, 0);
5072 #else
5073 _qzz_res = VALGRIND_DO_CLIENT_REQUEST_EXPR(0,
5074 VG_USERREQ__PRINTF_VALIST_BY_REF,
5075 (unsigned long)format,
5076 (unsigned long)&vargs,
5077 0, 0, 0);
5078 #endif
5079 va_end(vargs);
5080 return (int)_qzz_res;
5081 #endif /* NVALGRIND */
5082 }
5083
5084 #if defined(__GNUC__) || defined(__INTEL_COMPILER) && !defined(_MSC_VER)
5085 static int VALGRIND_PRINTF_BACKTRACE(const char *format, ...)
5086 __attribute__((format(__printf__, 1, 2), __unused__));
5087 #endif
5088 static int
5089 #if defined(_MSC_VER)
5090 __inline
5091 #endif
5092 VALGRIND_PRINTF_BACKTRACE(const char *format, ...)
5093 {
5094 #if defined(NVALGRIND)
5095 return 0;
5096 #else /* NVALGRIND */
5097 #if defined(_MSC_VER) || defined(__MINGW64__)
5098 uintptr_t _qzz_res;
5099 #else
5100 unsigned long _qzz_res;
5101 #endif
5102 va_list vargs;
5103 va_start(vargs, format);
5104 #if defined(_MSC_VER) || defined(__MINGW64__)
5105 _qzz_res = VALGRIND_DO_CLIENT_REQUEST_EXPR(0,
5106 VG_USERREQ__PRINTF_BACKTRACE_VALIST_BY_REF,
5107 (uintptr_t)format,
5108 (uintptr_t)&vargs,
5109 0, 0, 0);
5110 #else
5111 _qzz_res = VALGRIND_DO_CLIENT_REQUEST_EXPR(0,
5112 VG_USERREQ__PRINTF_BACKTRACE_VALIST_BY_REF,
5113 (unsigned long)format,
5114 (unsigned long)&vargs,
5115 0, 0, 0);
5116 #endif
5117 va_end(vargs);
5118 return (int)_qzz_res;
5119 #endif /* NVALGRIND */
5120 }
5121
5122
5123 /* These requests allow control to move from the simulated CPU to the
5124 real CPU, calling an arbitary function.
5125
5126 Note that the current ThreadId is inserted as the first argument.
5127 So this call:
5128
5129 VALGRIND_NON_SIMD_CALL2(f, arg1, arg2)
5130
5131 requires f to have this signature:
5132
5133 Word f(Word tid, Word arg1, Word arg2)
5134
5135 where "Word" is a word-sized type.
5136
5137 Note that these client requests are not entirely reliable. For example,
5138 if you call a function with them that subsequently calls printf(),
5139 there's a high chance Valgrind will crash. Generally, your prospects of
5140 these working are made higher if the called function does not refer to
5141 any global variables, and does not refer to any libc or other functions
5142 (printf et al). Any kind of entanglement with libc or dynamic linking is
5143 likely to have a bad outcome, for tricky reasons which we've grappled
5144 with a lot in the past.
5145 */
5146 #define VALGRIND_NON_SIMD_CALL0(_qyy_fn) \
5147 VALGRIND_DO_CLIENT_REQUEST_EXPR(0 /* default return */, \
5148 VG_USERREQ__CLIENT_CALL0, \
5149 _qyy_fn, \
5150 0, 0, 0, 0)
5151
5152 #define VALGRIND_NON_SIMD_CALL1(_qyy_fn, _qyy_arg1) \
5153 VALGRIND_DO_CLIENT_REQUEST_EXPR(0 /* default return */, \
5154 VG_USERREQ__CLIENT_CALL1, \
5155 _qyy_fn, \
5156 _qyy_arg1, 0, 0, 0)
5157
5158 #define VALGRIND_NON_SIMD_CALL2(_qyy_fn, _qyy_arg1, _qyy_arg2) \
5159 VALGRIND_DO_CLIENT_REQUEST_EXPR(0 /* default return */, \
5160 VG_USERREQ__CLIENT_CALL2, \
5161 _qyy_fn, \
5162 _qyy_arg1, _qyy_arg2, 0, 0)
5163
5164 #define VALGRIND_NON_SIMD_CALL3(_qyy_fn, _qyy_arg1, _qyy_arg2, _qyy_arg3) \
5165 VALGRIND_DO_CLIENT_REQUEST_EXPR(0 /* default return */, \
5166 VG_USERREQ__CLIENT_CALL3, \
5167 _qyy_fn, \
5168 _qyy_arg1, _qyy_arg2, \
5169 _qyy_arg3, 0)
5170
5171
5172 /* Counts the number of errors that have been recorded by a tool. Nb:
5173 the tool must record the errors with VG_(maybe_record_error)() or
5174 VG_(unique_error)() for them to be counted. */
5175 #define VALGRIND_COUNT_ERRORS \
5176 (unsigned)VALGRIND_DO_CLIENT_REQUEST_EXPR( \
5177 0 /* default return */, \
5178 VG_USERREQ__COUNT_ERRORS, \
5179 0, 0, 0, 0, 0)
5180
5181 /* Several Valgrind tools (Memcheck, Massif, Helgrind, DRD) rely on knowing
5182 when heap blocks are allocated in order to give accurate results. This
5183 happens automatically for the standard allocator functions such as
5184 malloc(), calloc(), realloc(), memalign(), new, new[], free(), delete,
5185 delete[], etc.
5186
5187 But if your program uses a custom allocator, this doesn't automatically
5188 happen, and Valgrind will not do as well. For example, if you allocate
5189 superblocks with mmap() and then allocates chunks of the superblocks, all
5190 Valgrind's observations will be at the mmap() level and it won't know that
5191 the chunks should be considered separate entities. In Memcheck's case,
5192 that means you probably won't get heap block overrun detection (because
5193 there won't be redzones marked as unaddressable) and you definitely won't
5194 get any leak detection.
5195
5196 The following client requests allow a custom allocator to be annotated so
5197 that it can be handled accurately by Valgrind.
5198
5199 VALGRIND_MALLOCLIKE_BLOCK marks a region of memory as having been allocated
5200 by a malloc()-like function. For Memcheck (an illustrative case), this
5201 does two things:
5202
5203 - It records that the block has been allocated. This means any addresses
5204 within the block mentioned in error messages will be
5205 identified as belonging to the block. It also means that if the block
5206 isn't freed it will be detected by the leak checker.
5207
5208 - It marks the block as being addressable and undefined (if 'is_zeroed' is
5209 not set), or addressable and defined (if 'is_zeroed' is set). This
5210 controls how accesses to the block by the program are handled.
5211
5212 'addr' is the start of the usable block (ie. after any
5213 redzone), 'sizeB' is its size. 'rzB' is the redzone size if the allocator
5214 can apply redzones -- these are blocks of padding at the start and end of
5215 each block. Adding redzones is recommended as it makes it much more likely
5216 Valgrind will spot block overruns. `is_zeroed' indicates if the memory is
5217 zeroed (or filled with another predictable value), as is the case for
5218 calloc().
5219
5220 VALGRIND_MALLOCLIKE_BLOCK should be put immediately after the point where a
5221 heap block -- that will be used by the client program -- is allocated.
5222 It's best to put it at the outermost level of the allocator if possible;
5223 for example, if you have a function my_alloc() which calls
5224 internal_alloc(), and the client request is put inside internal_alloc(),
5225 stack traces relating to the heap block will contain entries for both
5226 my_alloc() and internal_alloc(), which is probably not what you want.
5227
5228 For Memcheck users: if you use VALGRIND_MALLOCLIKE_BLOCK to carve out
5229 custom blocks from within a heap block, B, that has been allocated with
5230 malloc/calloc/new/etc, then block B will be *ignored* during leak-checking
5231 -- the custom blocks will take precedence.
5232
5233 VALGRIND_FREELIKE_BLOCK is the partner to VALGRIND_MALLOCLIKE_BLOCK. For
5234 Memcheck, it does two things:
5235
5236 - It records that the block has been deallocated. This assumes that the
5237 block was annotated as having been allocated via
5238 VALGRIND_MALLOCLIKE_BLOCK. Otherwise, an error will be issued.
5239
5240 - It marks the block as being unaddressable.
5241
5242 VALGRIND_FREELIKE_BLOCK should be put immediately after the point where a
5243 heap block is deallocated.
5244
5245 VALGRIND_RESIZEINPLACE_BLOCK informs a tool about reallocation. For
5246 Memcheck, it does four things:
5247
5248 - It records that the size of a block has been changed. This assumes that
5249 the block was annotated as having been allocated via
5250 VALGRIND_MALLOCLIKE_BLOCK. Otherwise, an error will be issued.
5251
5252 - If the block shrunk, it marks the freed memory as being unaddressable.
5253
5254 - If the block grew, it marks the new area as undefined and defines a red
5255 zone past the end of the new block.
5256
5257 - The V-bits of the overlap between the old and the new block are preserved.
5258
5259 VALGRIND_RESIZEINPLACE_BLOCK should be put after allocation of the new block
5260 and before deallocation of the old block.
5261
5262 In many cases, these three client requests will not be enough to get your
5263 allocator working well with Memcheck. More specifically, if your allocator
5264 writes to freed blocks in any way then a VALGRIND_MAKE_MEM_UNDEFINED call
5265 will be necessary to mark the memory as addressable just before the zeroing
5266 occurs, otherwise you'll get a lot of invalid write errors. For example,
5267 you'll need to do this if your allocator recycles freed blocks, but it
5268 zeroes them before handing them back out (via VALGRIND_MALLOCLIKE_BLOCK).
5269 Alternatively, if your allocator reuses freed blocks for allocator-internal
5270 data structures, VALGRIND_MAKE_MEM_UNDEFINED calls will also be necessary.
5271
5272 Really, what's happening is a blurring of the lines between the client
5273 program and the allocator... after VALGRIND_FREELIKE_BLOCK is called, the
5274 memory should be considered unaddressable to the client program, but the
5275 allocator knows more than the rest of the client program and so may be able
5276 to safely access it. Extra client requests are necessary for Valgrind to
5277 understand the distinction between the allocator and the rest of the
5278 program.
5279
5280 Ignored if addr == 0.
5281 */
5282 #define VALGRIND_MALLOCLIKE_BLOCK(addr, sizeB, rzB, is_zeroed) \
5283 VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__MALLOCLIKE_BLOCK, \
5284 addr, sizeB, rzB, is_zeroed, 0)
5285
5286 /* See the comment for VALGRIND_MALLOCLIKE_BLOCK for details.
5287 Ignored if addr == 0.
5288 */
5289 #define VALGRIND_RESIZEINPLACE_BLOCK(addr, oldSizeB, newSizeB, rzB) \
5290 VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__RESIZEINPLACE_BLOCK, \
5291 addr, oldSizeB, newSizeB, rzB, 0)
5292
5293 /* See the comment for VALGRIND_MALLOCLIKE_BLOCK for details.
5294 Ignored if addr == 0.
5295 */
5296 #define VALGRIND_FREELIKE_BLOCK(addr, rzB) \
5297 VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__FREELIKE_BLOCK, \
5298 addr, rzB, 0, 0, 0)
5299
5300 /* Create a memory pool. */
5301 #define VALGRIND_CREATE_MEMPOOL(pool, rzB, is_zeroed) \
5302 VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__CREATE_MEMPOOL, \
5303 pool, rzB, is_zeroed, 0, 0)
5304
5305 /* Destroy a memory pool. */
5306 #define VALGRIND_DESTROY_MEMPOOL(pool) \
5307 VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__DESTROY_MEMPOOL, \
5308 pool, 0, 0, 0, 0)
5309
5310 /* Associate a piece of memory with a memory pool. */
5311 #define VALGRIND_MEMPOOL_ALLOC(pool, addr, size) \
5312 VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__MEMPOOL_ALLOC, \
5313 pool, addr, size, 0, 0)
5314
5315 /* Disassociate a piece of memory from a memory pool. */
5316 #define VALGRIND_MEMPOOL_FREE(pool, addr) \
5317 VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__MEMPOOL_FREE, \
5318 pool, addr, 0, 0, 0)
5319
5320 /* Disassociate any pieces outside a particular range. */
5321 #define VALGRIND_MEMPOOL_TRIM(pool, addr, size) \
5322 VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__MEMPOOL_TRIM, \
5323 pool, addr, size, 0, 0)
5324
5325 /* Resize and/or move a piece associated with a memory pool. */
5326 #define VALGRIND_MOVE_MEMPOOL(poolA, poolB) \
5327 VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__MOVE_MEMPOOL, \
5328 poolA, poolB, 0, 0, 0)
5329
5330 /* Resize and/or move a piece associated with a memory pool. */
5331 #define VALGRIND_MEMPOOL_CHANGE(pool, addrA, addrB, size) \
5332 VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__MEMPOOL_CHANGE, \
5333 pool, addrA, addrB, size, 0)
5334
5335 /* Return 1 if a mempool exists, else 0. */
5336 #define VALGRIND_MEMPOOL_EXISTS(pool) \
5337 (unsigned)VALGRIND_DO_CLIENT_REQUEST_EXPR(0, \
5338 VG_USERREQ__MEMPOOL_EXISTS, \
5339 pool, 0, 0, 0, 0)
5340
5341 /* Mark a piece of memory as being a stack. Returns a stack id. */
5342 #define VALGRIND_STACK_REGISTER(start, end) \
5343 (unsigned)VALGRIND_DO_CLIENT_REQUEST_EXPR(0, \
5344 VG_USERREQ__STACK_REGISTER, \
5345 start, end, 0, 0, 0)
5346
5347 /* Unmark the piece of memory associated with a stack id as being a
5348 stack. */
5349 #define VALGRIND_STACK_DEREGISTER(id) \
5350 VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__STACK_DEREGISTER, \
5351 id, 0, 0, 0, 0)
5352
5353 /* Change the start and end address of the stack id. */
5354 #define VALGRIND_STACK_CHANGE(id, start, end) \
5355 VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__STACK_CHANGE, \
5356 id, start, end, 0, 0)
5357
5358 /* Load PDB debug info for Wine PE image_map. */
5359 #define VALGRIND_LOAD_PDB_DEBUGINFO(fd, ptr, total_size, delta) \
5360 VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__LOAD_PDB_DEBUGINFO, \
5361 fd, ptr, total_size, delta, 0)
5362
5363 /* Map a code address to a source file name and line number. buf64
5364 must point to a 64-byte buffer in the caller's address space. The
5365 result will be dumped in there and is guaranteed to be zero
5366 terminated. If no info is found, the first byte is set to zero. */
5367 #define VALGRIND_MAP_IP_TO_SRCLOC(addr, buf64) \
5368 (unsigned)VALGRIND_DO_CLIENT_REQUEST_EXPR(0, \
5369 VG_USERREQ__MAP_IP_TO_SRCLOC, \
5370 addr, buf64, 0, 0, 0)
5371
5372 /* Disable error reporting for this thread. Behaves in a stack like
5373 way, so you can safely call this multiple times provided that
5374 VALGRIND_ENABLE_ERROR_REPORTING is called the same number of times
5375 to re-enable reporting. The first call of this macro disables
5376 reporting. Subsequent calls have no effect except to increase the
5377 number of VALGRIND_ENABLE_ERROR_REPORTING calls needed to re-enable
5378 reporting. Child threads do not inherit this setting from their
5379 parents -- they are always created with reporting enabled. */
5380 #define VALGRIND_DISABLE_ERROR_REPORTING \
5381 VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__CHANGE_ERR_DISABLEMENT, \
5382 1, 0, 0, 0, 0)
5383
5384 /* Re-enable error reporting, as per comments on
5385 VALGRIND_DISABLE_ERROR_REPORTING. */
5386 #define VALGRIND_ENABLE_ERROR_REPORTING \
5387 VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__CHANGE_ERR_DISABLEMENT, \
5388 -1, 0, 0, 0, 0)
5389
5390 /* Execute a monitor command from the client program.
5391 If a connection is opened with GDB, the output will be sent
5392 according to the output mode set for vgdb.
5393 If no connection is opened, output will go to the log output.
5394 Returns 1 if command not recognised, 0 otherwise. */
5395 #define VALGRIND_MONITOR_COMMAND(command) \
5396 VALGRIND_DO_CLIENT_REQUEST_EXPR(0, VG_USERREQ__GDB_MONITOR_COMMAND, \
5397 command, 0, 0, 0, 0)
5398
5399
5400 #undef PLAT_x86_darwin
5401 #undef PLAT_amd64_darwin
5402 #undef PLAT_x86_win32
5403 #undef PLAT_amd64_win64
5404 #undef PLAT_x86_linux
5405 #undef PLAT_amd64_linux
5406 #undef PLAT_ppc32_linux
5407 #undef PLAT_ppc64_linux
5408 #undef PLAT_arm_linux
5409 #undef PLAT_s390x_linux
5410 #undef PLAT_mips32_linux
5411 #undef PLAT_mips64_linux
5412
5413 #endif /* __VALGRIND_H */
VG_USERREQ__MAP_IP_TO_SRCLOC
Definition: local_valgrind.h:5002
__attribute__
#define __attribute__(x)
Definition: System.cpp:72
format
GAUDI_API std::string format(const char *,...)
MsgStream format utility "a la sprintf(...)".
Definition: MsgStream.cpp:119
VG_USERREQ__DESTROY_MEMPOOL
Definition: local_valgrind.h:4972
VG_USERREQ__MEMPOOL_TRIM
Definition: local_valgrind.h:4975
VG_USERREQ__STACK_DEREGISTER
Definition: local_valgrind.h:4995
VG_USERREQ__DISCARD_TRANSLATIONS
Definition: local_valgrind.h:4944
VG_USERREQ__CLIENT_CALL3
Definition: local_valgrind.h:4954
VG_USERREQ__MALLOCLIKE_BLOCK
Definition: local_valgrind.h:4967
VG_USERREQ__PRINTF_VALIST_BY_REF
Definition: local_valgrind.h:4990
VG_USERREQ__FREELIKE_BLOCK
Definition: local_valgrind.h:4969
VG_USERREQ__CLIENT_CALL2
Definition: local_valgrind.h:4953
VG_USERREQ__MEMPOOL_CHANGE
Definition: local_valgrind.h:4977
VG_USERREQ__PRINTF_BACKTRACE_VALIST_BY_REF
Definition: local_valgrind.h:4991
VG_USERREQ__STACK_REGISTER
Definition: local_valgrind.h:4994
VG_USERREQ__CREATE_MEMPOOL
Definition: local_valgrind.h:4971
VG_USERREQ__COUNT_ERRORS
Definition: local_valgrind.h:4959
VG_USERREQ__LOAD_PDB_DEBUGINFO
Definition: local_valgrind.h:4999
VG_USERREQ__CLIENT_CALL0
Definition: local_valgrind.h:4951
VG_USERREQ__MOVE_MEMPOOL
Definition: local_valgrind.h:4976
VG_USERREQ__PRINTF
Definition: local_valgrind.h:4987
VG_USERREQ__CHANGE_ERR_DISABLEMENT
Definition: local_valgrind.h:5009
VALGRIND_DO_CLIENT_REQUEST_EXPR
#define VALGRIND_DO_CLIENT_REQUEST_EXPR( _zzq_default, _zzq_request, _zzq_arg1, _zzq_arg2, _zzq_arg3, _zzq_arg4, _zzq_arg5)
Definition: local_valgrind.h:197
VG_USERREQ__PRINTF_BACKTRACE
Definition: local_valgrind.h:4988
VG_USERREQ__MEMPOOL_FREE
Definition: local_valgrind.h:4974
VG_USERREQ__RUNNING_ON_VALGRIND
Definition: local_valgrind.h:4943
Vg_ClientRequest
Vg_ClientRequest
Definition: local_valgrind.h:4942
VG_USERREQ__MEMPOOL_EXISTS
Definition: local_valgrind.h:4978
VG_USERREQ__MEMPOOL_ALLOC
Definition: local_valgrind.h:4973
VG_USERREQ__RESIZEINPLACE_BLOCK
Definition: local_valgrind.h:4968
va_list
VG_USERREQ__CLIENT_CALL1
Definition: local_valgrind.h:4952
VG_USERREQ__STACK_CHANGE
Definition: local_valgrind.h:4996
VG_USERREQ__GDB_MONITOR_COMMAND
Definition: local_valgrind.h:4963
VG_USERREQ__VEX_INIT_FOR_IRI
Definition: local_valgrind.h:5012