1
2 /*--------------------------------------------------------------------*/
3 /*--- Types and macros for writing syscall wrappers. ---*/
4 /*--- priv_types_n_macros.h ---*/
5 /*--------------------------------------------------------------------*/
6
7 /*
8 This file is part of Valgrind, a dynamic binary instrumentation
9 framework.
10
11 Copyright (C) 2000-2012 Julian Seward
12 jseward@acm.org
13
14 This program is free software; you can redistribute it and/or
15 modify it under the terms of the GNU General Public License as
16 published by the Free Software Foundation; either version 2 of the
17 License, or (at your option) any later version.
18
19 This program is distributed in the hope that it will be useful, but
20 WITHOUT ANY WARRANTY; without even the implied warranty of
21 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
22 General Public License for more details.
23
24 You should have received a copy of the GNU General Public License
25 along with this program; if not, write to the Free Software
26 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
27 02111-1307, USA.
28
29 The GNU General Public License is contained in the file COPYING.
30 */
31
32 #ifndef __PRIV_TYPES_N_MACROS_H
33 #define __PRIV_TYPES_N_MACROS_H
34
35 /* requires #include "pub_core_options.h" */
36 /* requires #include "pub_core_signals.h" */
37
38 /* This header defines types and macros which are useful for writing
39 syscall wrappers. It does not give prototypes for any such
40 headers, though: that is the job of the priv_syswrap-*.h headers.
41 This header gets included in any file which defines or declares
42 wrappers, and as such should only contain stuff which is relevant
43 to all such files.
44 */
45
46 /* ---------------------------------------------------------------------
47 Types that are used in syscall wrappers.
48 ------------------------------------------------------------------ */
49
50 /* Arguments for a syscall. */
51 typedef
52 struct SyscallArgs {
53 Word sysno;
54 UWord arg1;
55 UWord arg2;
56 UWord arg3;
57 UWord arg4;
58 UWord arg5;
59 UWord arg6;
60 UWord arg7;
61 UWord arg8;
62 }
63 SyscallArgs;
64
65 /* Current status of a syscall being done on behalf of the client. */
66 typedef
67 struct SyscallStatus {
68 enum {
69 /* call is complete, result is in 'res' */
70 SsComplete=1,
71 /* syscall not yet completed; must be handed to the kernel */
72 SsHandToKernel,
73 /* not currently handling a syscall for this thread */
74 SsIdle
75 } what;
76 SysRes sres; /* only meaningful for .what == SsComplete */
77 }
78 SyscallStatus;
79
80 /* Guest state layout info for syscall args. */
81 typedef
82 struct {
83 // Note that, depending on the platform, arguments may be found in
84 // registers or on the stack. (See the comment at the top of
85 // syswrap-main.c for per-platform details.) For register arguments
86 // (which have o_arg field names) the o_arg value is the offset into
87 // the vex register state. For stack arguments (which have s_arg
88 // field names), the s_arg value is the offset from the stack pointer.
89 Int o_sysno;
90 # if defined(VGP_x86_linux) || defined(VGP_amd64_linux) \
91 || defined(VGP_ppc32_linux) || defined(VGP_ppc64_linux) \
92 || defined(VGP_arm_linux) || defined(VGP_s390x_linux)
93 Int o_arg1;
94 Int o_arg2;
95 Int o_arg3;
96 Int o_arg4;
97 Int o_arg5;
98 Int o_arg6;
99 Int uu_arg7;
100 Int uu_arg8;
101 # elif defined(VGP_mips32_linux)
102 Int o_arg1;
103 Int o_arg2;
104 Int o_arg3;
105 Int o_arg4;
106 Int s_arg5;
107 Int s_arg6;
108 Int uu_arg7;
109 Int uu_arg8;
110 # elif defined(VGP_x86_darwin)
111 Int s_arg1;
112 Int s_arg2;
113 Int s_arg3;
114 Int s_arg4;
115 Int s_arg5;
116 Int s_arg6;
117 Int s_arg7;
118 Int s_arg8;
119 # elif defined(VGP_amd64_darwin)
120 Int o_arg1;
121 Int o_arg2;
122 Int o_arg3;
123 Int o_arg4;
124 Int o_arg5;
125 Int o_arg6;
126 Int s_arg7;
127 Int s_arg8;
128 # else
129 # error "Unknown platform"
130 # endif
131 }
132 SyscallArgLayout;
133
134 /* Flags describing syscall wrappers */
135 #define SfMayBlock (1 << 1) /* may block */
136 #define SfPostOnFail (1 << 2) /* call POST() function on failure */
137 #define SfPollAfter (1 << 3) /* poll for signals on completion */
138 #define SfYieldAfter (1 << 4) /* yield on completion */
139 #define SfNoWriteResult (1 << 5) /* don't write result to guest state */
140
141
142 /* ---------------------------------------------------------------------
143 The syscall table.
144 ------------------------------------------------------------------ */
145
146 typedef
147 struct {
148 void (*before) ( ThreadId,
149 SyscallArgLayout*,
150 /*MOD*/SyscallArgs*,
151 /*OUT*/SyscallStatus*,
152 /*OUT*/UWord*
153 );
154
155 void (*after) ( ThreadId,
156 SyscallArgs*,
157 SyscallStatus*
158 );
159 }
160 SyscallTableEntry;
161
162 /* Syscall table entries bind __NR_xxx syscall numbers to the PRE/POST
163 wrappers for the relevant syscall used in the OS kernel for that
164 number. Note that the constant names don't always match the
165 wrapper names in a straightforward way. For example, on x86/Linux:
166
167 __NR_lchown --> sys_lchown16()
168 __NR_lchown32 --> sys_lchown()
169 __NR_select --> old_select()
170 __NR__newselect --> sys_select()
171 */
172
173
174 /* A function to find the syscall table entry for a given sysno. If
175 none is found, return NULL. This used to be done with a single
176 fixed sized table exposed to the caller, but that's too inflexible;
177 hence now use a function which can do arbitrary messing around to
178 find the required entry. */
179 #if defined(VGP_mips32_linux)
180 /* Up to 6 parameters, 4 in registers 2 on stack. */
181 # define PRA1(s,t,a) PRRAn(1,s,t,a)
182 # define PRA2(s,t,a) PRRAn(2,s,t,a)
183 # define PRA3(s,t,a) PRRAn(3,s,t,a)
184 # define PRA4(s,t,a) PRRAn(4,s,t,a)
185 # define PRA5(s,t,a) PSRAn(5,s,t,a)
186 # define PRA6(s,t,a) PSRAn(6,s,t,a)
187
188 #endif
189 #if defined(VGO_linux)
190 extern
191 SyscallTableEntry* ML_(get_linux_syscall_entry)( UInt sysno );
192
193 #elif defined(VGO_darwin)
194 /* XXX: Darwin still uses the old scheme of exposing the table
195 array(s) and size(s) directly to syswrap-main.c. This should be
196 fixed. */
197
198 extern const SyscallTableEntry ML_(syscall_table)[];
199 extern const UInt ML_(syscall_table_size);
200
201 #else
202 # error Unknown OS
203 #endif
204
205 /* ---------------------------------------------------------------------
206 Declaring and defining wrappers.
207 ------------------------------------------------------------------ */
208
209 /* Templates for generating the PRE and POST macros -- that is, the
210 formal parameter lists for the definitions of wrapper functions.
211
212 Since these names exist in the global namespace, 'auxstr' should
213 give an auxiliary string, eg, "generic", "x86_linux", "linux", etc,
214 that ensures the names won't clash with other wrappers.
215
216 You should create corresponding global declarations using
217 DECL_TEMPLATE (indirectly) below.
218
219 Note. The silly name "arrghs" is used rather than just "args"
220 because a few wrappers declare the name "args" themselves, and
221 renaming those decls can change the name that comes out in error
222 messages (on scalar arg checks). Hence rename this instead.
223 */
224
225 #define DEFN_PRE_TEMPLATE(auxstr, name) \
226 void vgSysWrap_##auxstr##_##name##_before \
227 ( ThreadId tid, \
228 SyscallArgLayout* layout, \
229 /*MOD*/SyscallArgs* arrghs, \
230 /*OUT*/SyscallStatus* status, \
231 /*OUT*/UWord* flags \
232 )
233
234 #define DEFN_POST_TEMPLATE(auxstr, name) \
235 void vgSysWrap_##auxstr##_##name##_after \
236 ( ThreadId tid, \
237 SyscallArgs* arrghs, \
238 SyscallStatus* status \
239 )
240
241
242 /* This macro generates declarations (prototypes) for wrappers. It
243 declares both the pre-wrapper and the post-wrapper, even though the
244 post-wrapper may not actually exist.
245 */
246 #define DECL_TEMPLATE(auxstr, name) \
247 extern \
248 void vgSysWrap_##auxstr##_##name##_before \
249 ( ThreadId tid, \
250 SyscallArgLayout* layout, \
251 /*MOD*/SyscallArgs* arrghs, \
252 /*OUT*/SyscallStatus* status, \
253 /*OUT*/UWord* flags \
254 ); \
255 extern \
256 void vgSysWrap_##auxstr##_##name##_after \
257 ( ThreadId tid, \
258 SyscallArgs* arrghs, \
259 SyscallStatus* status \
260 );
261
262
263
264 /* Macros for conveniently generating entries in the syscall
265 tables. This first pair are not used directly. */
266
267 #define WRAPPER_ENTRY_X_(auxstr, sysno, name) \
268 [sysno] = { vgSysWrap_##auxstr##_##name##_before, NULL }
269 #define WRAPPER_ENTRY_XY(auxstr, sysno, name) \
270 [sysno] = { vgSysWrap_##auxstr##_##name##_before, \
271 vgSysWrap_##auxstr##_##name##_after }
272
273 #define WRAPPER_PRE_NAME(auxstr, name) \
274 vgSysWrap_##auxstr##_##name##_before
275 #define WRAPPER_POST_NAME(auxstr, name) \
276 vgSysWrap_##auxstr##_##name##_after
277
278 /* Add a generic wrapper to a syscall table. */
279 #if defined(VGO_linux)
280 # define GENX_(sysno, name) WRAPPER_ENTRY_X_(generic, sysno, name)
281 # define GENXY(sysno, name) WRAPPER_ENTRY_XY(generic, sysno, name)
282 #elif defined(VGO_darwin)
283 # define GENX_(sysno, name) WRAPPER_ENTRY_X_(generic, VG_DARWIN_SYSNO_INDEX(sysno), name)
284 # define GENXY(sysno, name) WRAPPER_ENTRY_XY(generic, VG_DARWIN_SYSNO_INDEX(sysno), name)
285 #else
286 # error Unknown OS
287 #endif
288
289 /* Add a Linux-specific, arch-independent wrapper to a syscall
290 table. */
291 #define LINX_(sysno, name) WRAPPER_ENTRY_X_(linux, sysno, name)
292 #define LINXY(sysno, name) WRAPPER_ENTRY_XY(linux, sysno, name)
293
294
295 /* ---------------------------------------------------------------------
296 Macros useful for writing wrappers concisely. These refer to the
297 parameters declared by DEFN_{PRE,POST}_TEMPLATE and so in a way do
298 not help clarity of understanding. But they are just too useful to
299 omit.
300 ------------------------------------------------------------------ */
301
302 /* Reference to the syscall's arguments -- the ones which the
303 pre-wrapper may have modified, not the original copy. */
304 #define SYSNO (arrghs->sysno)
305 #define ARG1 (arrghs->arg1)
306 #define ARG2 (arrghs->arg2)
307 #define ARG3 (arrghs->arg3)
308 #define ARG4 (arrghs->arg4)
309 #define ARG5 (arrghs->arg5)
310 #define ARG6 (arrghs->arg6)
311 #define ARG7 (arrghs->arg7)
312 #define ARG8 (arrghs->arg8)
313
314 /* Reference to the syscall's current result status/value. General
315 paranoia all round. */
316 #define SUCCESS (status->what == SsComplete && !sr_isError(status->sres))
317 #define FAILURE (status->what == SsComplete && sr_isError(status->sres))
318 #define SWHAT (status->what)
319 #define RES (getRES(status))
320 #define RESHI (getRESHI(status))
321 #define ERR (getERR(status))
322
getRES(SyscallStatus * st)323 static inline UWord getRES ( SyscallStatus* st ) {
324 vg_assert(st->what == SsComplete);
325 vg_assert(!sr_isError(st->sres));
326 return sr_Res(st->sres);
327 }
328
getRESHI(SyscallStatus * st)329 static inline UWord getRESHI ( SyscallStatus* st ) {
330 vg_assert(st->what == SsComplete);
331 vg_assert(!sr_isError(st->sres));
332 return sr_ResHI(st->sres);
333 }
334
getERR(SyscallStatus * st)335 static inline UWord getERR ( SyscallStatus* st ) {
336 vg_assert(st->what == SsComplete);
337 vg_assert(sr_isError(st->sres));
338 return sr_Err(st->sres);
339 }
340
341
342 /* Set the current result status/value in various ways. */
343 #define SET_STATUS_Success(zzz) \
344 do { status->what = SsComplete; \
345 status->sres = VG_(mk_SysRes_Success)(zzz); \
346 } while (0)
347
348 #define SET_STATUS_Failure(zzz) \
349 do { Word wzz = (Word)(zzz); \
350 /* Catch out wildly bogus error values. */ \
351 vg_assert(wzz >= 0 && wzz < 10000); \
352 status->what = SsComplete; \
353 status->sres = VG_(mk_SysRes_Error)(wzz); \
354 } while (0)
355
356 #define SET_STATUS_from_SysRes(zzz) \
357 do { \
358 status->what = SsComplete; \
359 status->sres = (zzz); \
360 } while (0)
361
362
363 #define PRINT(format, args...) \
364 if (VG_(clo_trace_syscalls)) \
365 VG_(printf)(format, ## args)
366
367 #define FUSE_COMPATIBLE_MAY_BLOCK() \
368 if (VG_(strstr)(VG_(clo_sim_hints),"fuse-compatible")) \
369 *flags |= SfMayBlock
370
371
372 /* Macros used to tell tools about uses of scalar arguments. Note,
373 these assume little-endianness. These can only be used in
374 pre-wrappers, and they refer to the layout parameter passed in. */
375 /* PRRSN == "pre-register-read-sysno"
376 PRRAn == "pre-register-read-argument"
377 PSRAn == "pre-stack-read-argument"
378 PRAn == "pre-read-argument"
379 */
380
381 #if defined(VGP_mips32_linux)
382 /* Up to 6 parameters, 4 in registers 2 on stack. */
383 # define PRA1(s,t,a) PRRAn(1,s,t,a)
384 # define PRA2(s,t,a) PRRAn(2,s,t,a)
385 # define PRA3(s,t,a) PRRAn(3,s,t,a)
386 # define PRA4(s,t,a) PRRAn(4,s,t,a)
387 # define PRA5(s,t,a) PSRAn(5,s,t,a)
388 # define PRA6(s,t,a) PSRAn(6,s,t,a)
389
390 #elif defined(VGO_linux) && !defined(VGP_mips32_linux)
391 /* Up to 6 parameters, all in registers. */
392 # define PRA1(s,t,a) PRRAn(1,s,t,a)
393 # define PRA2(s,t,a) PRRAn(2,s,t,a)
394 # define PRA3(s,t,a) PRRAn(3,s,t,a)
395 # define PRA4(s,t,a) PRRAn(4,s,t,a)
396 # define PRA5(s,t,a) PRRAn(5,s,t,a)
397 # define PRA6(s,t,a) PRRAn(6,s,t,a)
398
399 #elif defined(VGP_x86_darwin)
400 /* Up to 8 parameters, all on the stack. */
401 # define PRA1(s,t,a) PSRAn(1,s,t,a)
402 # define PRA2(s,t,a) PSRAn(2,s,t,a)
403 # define PRA3(s,t,a) PSRAn(3,s,t,a)
404 # define PRA4(s,t,a) PSRAn(4,s,t,a)
405 # define PRA5(s,t,a) PSRAn(5,s,t,a)
406 # define PRA6(s,t,a) PSRAn(6,s,t,a)
407 # define PRA7(s,t,a) PSRAn(7,s,t,a)
408 # define PRA8(s,t,a) PSRAn(8,s,t,a)
409
410 #elif defined(VGP_amd64_darwin)
411 /* Up to 8 parameters, 6 in registers, 2 on the stack. */
412 # define PRA1(s,t,a) PRRAn(1,s,t,a)
413 # define PRA2(s,t,a) PRRAn(2,s,t,a)
414 # define PRA3(s,t,a) PRRAn(3,s,t,a)
415 # define PRA4(s,t,a) PRRAn(4,s,t,a)
416 # define PRA5(s,t,a) PRRAn(5,s,t,a)
417 # define PRA6(s,t,a) PRRAn(6,s,t,a)
418 # define PRA7(s,t,a) PSRAn(7,s,t,a)
419 # define PRA8(s,t,a) PSRAn(8,s,t,a)
420
421 #else
422 # error Unknown platform
423 #endif
424
425
426 /* Tell the tool that the syscall number is being read. */
427 #define PRRSN \
428 VG_(tdict).track_pre_reg_read(Vg_CoreSysCall, tid, "(syscallno)", \
429 layout->o_sysno, sizeof(UWord));
430
431 /* REGISTER PARAMETERS */
432
433 /* PRRAn: Tell the tool that the register holding the n-th syscall
434 argument is being read, at type 't' which must be at most the size
435 of a register but can be smaller. In the latter case we need to be
436 careful about endianness. */
437
438 /* little-endian: the part of the guest state being read is
439 let here = offset_of_reg
440 in [here .. here + sizeof(t) - 1]
441 since the least significant parts of the guest register are stored
442 in memory at the lowest address.
443 */
444 #define PRRAn_LE(n,s,t,a) \
445 do { \
446 Int here = layout->o_arg##n; \
447 vg_assert(sizeof(t) <= sizeof(UWord)); \
448 vg_assert(here >= 0); \
449 VG_(tdict).track_pre_reg_read( \
450 Vg_CoreSysCall, tid, s"("#a")", \
451 here, sizeof(t) \
452 ); \
453 } while (0)
454
455 /* big-endian: the part of the guest state being read is
456 let next = offset_of_reg + sizeof(reg)
457 in [next - sizeof(t) .. next - 1]
458 since the least significant parts of the guest register are stored
459 in memory at the highest address.
460 */
461 #define PRRAn_BE(n,s,t,a) \
462 do { \
463 Int here = layout->o_arg##n; \
464 Int next = layout->o_arg##n + sizeof(UWord); \
465 vg_assert(sizeof(t) <= sizeof(UWord)); \
466 vg_assert(here >= 0); \
467 VG_(tdict).track_pre_reg_read( \
468 Vg_CoreSysCall, tid, s"("#a")", \
469 next-sizeof(t), sizeof(t) \
470 ); \
471 } while (0)
472
473 #if defined(VG_BIGENDIAN)
474 # define PRRAn(n,s,t,a) PRRAn_BE(n,s,t,a)
475 #elif defined(VG_LITTLEENDIAN)
476 # define PRRAn(n,s,t,a) PRRAn_LE(n,s,t,a)
477 #else
478 # error "Unknown endianness"
479 #endif
480
481
482 /* STACK PARAMETERS */
483
484 /* PSRAn: Tell the tool that the memory holding the n-th syscall
485 argument is being read, at type 't' which must be at most the size
486 of a register but can be smaller. In the latter case we need to be
487 careful about endianness. */
488
489 /* little-endian: the part of the guest state being read is
490 let here = offset_of_reg
491 in [here .. here + sizeof(t) - 1]
492 since the least significant parts of the guest register are stored
493 in memory at the lowest address.
494 */
495 #define PSRAn_LE(n,s,t,a) \
496 do { \
497 Addr here = layout->s_arg##n + VG_(get_SP)(tid); \
498 vg_assert(sizeof(t) <= sizeof(UWord)); \
499 VG_(tdict).track_pre_mem_read( \
500 Vg_CoreSysCallArgInMem, tid, s"("#a")", \
501 here, sizeof(t) \
502 ); \
503 } while (0)
504
505 /* big-endian: the part of the guest state being read is
506 let next = offset_of_reg + sizeof(reg)
507 in [next - sizeof(t) .. next - 1]
508 since the least significant parts of the guest register are stored
509 in memory at the highest address.
510 */
511 #if (defined(VGP_mips32_linux) && defined (_MIPSEB))
512 #define PSRAn_BE(n,s,t,a) \
513 do { \
514 Addr next = layout->s_arg##n + sizeof(UWord) + \
515 VG_(get_SP)(tid); \
516 vg_assert(sizeof(t) <= sizeof(UWord)); \
517 VG_(tdict).track_pre_mem_read( \
518 Vg_CoreSysCallArgInMem, tid, s"("#a")", \
519 next-sizeof(t), sizeof(t) \
520 ); \
521 } while (0)
522 #else
523 #define PSRAn_BE(n,s,t,a) \
524 do { \
525 Addr next = layout->o_arg##n + sizeof(UWord) + \
526 VG_(threads)[tid].arch.vex.VG_STACK_PTR; \
527 vg_assert(sizeof(t) <= sizeof(UWord)); \
528 VG_(tdict).track_pre_mem_read( \
529 Vg_CoreSysCallArgInMem, tid, s"("#a")", \
530 next-sizeof(t), sizeof(t) \
531 ); \
532 } while (0)
533 #endif
534
535 #if defined(VG_BIGENDIAN)
536 # define PSRAn(n,s,t,a) PSRAn_BE(n,s,t,a)
537 #elif defined(VG_LITTLEENDIAN)
538 # define PSRAn(n,s,t,a) PSRAn_LE(n,s,t,a)
539 #else
540 # error "Unknown endianness"
541 #endif
542
543
544 #define PRE_REG_READ0(tr, s) \
545 if (VG_(tdict).track_pre_reg_read) { \
546 PRRSN; \
547 }
548 #define PRE_REG_READ1(tr, s, t1, a1) \
549 if (VG_(tdict).track_pre_reg_read) { \
550 PRRSN; \
551 PRA1(s,t1,a1); \
552 }
553 #define PRE_REG_READ2(tr, s, t1, a1, t2, a2) \
554 if (VG_(tdict).track_pre_reg_read) { \
555 PRRSN; \
556 PRA1(s,t1,a1); PRA2(s,t2,a2); \
557 }
558 #define PRE_REG_READ3(tr, s, t1, a1, t2, a2, t3, a3) \
559 if (VG_(tdict).track_pre_reg_read) { \
560 PRRSN; \
561 PRA1(s,t1,a1); PRA2(s,t2,a2); PRA3(s,t3,a3); \
562 }
563 #define PRE_REG_READ4(tr, s, t1, a1, t2, a2, t3, a3, t4, a4) \
564 if (VG_(tdict).track_pre_reg_read) { \
565 PRRSN; \
566 PRA1(s,t1,a1); PRA2(s,t2,a2); PRA3(s,t3,a3); \
567 PRA4(s,t4,a4); \
568 }
569 #define PRE_REG_READ5(tr, s, t1, a1, t2, a2, t3, a3, t4, a4, t5, a5) \
570 if (VG_(tdict).track_pre_reg_read) { \
571 PRRSN; \
572 PRA1(s,t1,a1); PRA2(s,t2,a2); PRA3(s,t3,a3); \
573 PRA4(s,t4,a4); PRA5(s,t5,a5); \
574 }
575 #define PRE_REG_READ6(tr, s, t1, a1, t2, a2, t3, a3, t4, a4, t5, a5, t6, a6) \
576 if (VG_(tdict).track_pre_reg_read) { \
577 PRRSN; \
578 PRA1(s,t1,a1); PRA2(s,t2,a2); PRA3(s,t3,a3); \
579 PRA4(s,t4,a4); PRA5(s,t5,a5); PRA6(s,t6,a6); \
580 }
581 #define PRE_REG_READ7(tr, s, t1, a1, t2, a2, t3, a3, t4, a4, t5, a5, t6, a6, t7, a7) \
582 if (VG_(tdict).track_pre_reg_read) { \
583 PRRSN; \
584 PRA1(s,t1,a1); PRA2(s,t2,a2); PRA3(s,t3,a3); \
585 PRA4(s,t4,a4); PRA5(s,t5,a5); PRA6(s,t6,a6); \
586 PRA7(s,t7,a7); \
587 }
588
589 #define PRE_REG_READ8(tr, s, t1, a1, t2, a2, t3, a3, t4, a4, t5, a5, t6, a6, t7, a7, t8, a8) \
590 if (VG_(tdict).track_pre_reg_read) { \
591 PRRSN; \
592 PRA1(s,t1,a1); PRA2(s,t2,a2); PRA3(s,t3,a3); \
593 PRA4(s,t4,a4); PRA5(s,t5,a5); PRA6(s,t6,a6); \
594 PRA7(s,t7,a7); PRA8(s,t8,a8); \
595 }
596
597 #define PRE_MEM_READ(zzname, zzaddr, zzlen) \
598 VG_TRACK( pre_mem_read, Vg_CoreSysCall, tid, zzname, zzaddr, zzlen)
599
600 #define PRE_MEM_RASCIIZ(zzname, zzaddr) \
601 VG_TRACK( pre_mem_read_asciiz, Vg_CoreSysCall, tid, zzname, zzaddr)
602
603 #define PRE_MEM_WRITE(zzname, zzaddr, zzlen) \
604 VG_TRACK( pre_mem_write, Vg_CoreSysCall, tid, zzname, zzaddr, zzlen)
605
606 #define POST_MEM_WRITE(zzaddr, zzlen) \
607 VG_TRACK( post_mem_write, Vg_CoreSysCall, tid, zzaddr, zzlen)
608
609
610 #define PRE_FIELD_READ(zzname, zzfield) \
611 PRE_MEM_READ(zzname, (UWord)&zzfield, sizeof(zzfield))
612
613 #define PRE_FIELD_WRITE(zzname, zzfield) \
614 PRE_MEM_WRITE(zzname, (UWord)&zzfield, sizeof(zzfield))
615
616 #define POST_FIELD_WRITE(zzfield) \
617 POST_MEM_WRITE((UWord)&zzfield, sizeof(zzfield))
618
619
620 #endif // __PRIV_TYPES_N_MACROS_H
621
622 /*--------------------------------------------------------------------*/
623 /*--- end ---*/
624 /*--------------------------------------------------------------------*/
625