Little updates to quiet down 'make regtest'. Oh, and a revamp of the
syscall args checking so that Valgrind should be much more immune to
segfaulting itself.


 corecheck/tests/as_mmap.stderr.exp     |    2 
 corecheck/tests/fdleak_cmsg.c          |    4 
 corecheck/tests/fdleak_cmsg.stderr.exp |   14 
 coregrind/core.h                       |   33 +
 coregrind/linux/syscalls.c             |  105 ++-
 coregrind/vg_memory.c                  |   59 --
 coregrind/vg_scheduler.c               |    8 
 coregrind/vg_signals.c                 |   40 +
 coregrind/vg_symtab2.c                 |   11 
 coregrind/vg_syscalls.c                |  904 +++++++++++++++++----------------
 coregrind/vg_translate.c               |    2 
 coregrind/x86-linux/syscalls.c         |   48 +
 coregrind/x86/signal.c                 |   46 -
 glibc-2.3.supp                         |   71 ++
 include/tool.h.base                    |    2 
 massif/ms_main.c                       |    1 
 memcheck/tests/scalar.c                |    2 
 memcheck/tests/scalar.stderr.exp       |   13 
 memcheck/tests/zeropage.stderr.exp     |    3 
 memcheck/tests/zeropage.stdout.exp     |    3 
 none/tests/cmdline1.stdout.exp         |    1 
 none/tests/cmdline2.stdout.exp         |    2 
 none/tests/exec-sigmask.c              |   68 ++
 none/tests/exec-sigmask.stderr.exp     |    1 
 none/tests/exec-sigmask.stdout.exp     |    1 
 none/tests/pth_blockedsig.c            |    3 
 none/tests/yield.c                     |   36 -
 tests/toobig-allocs.c                  |    2 
 28 files changed, 852 insertions(+), 633 deletions(-)

diff -puN corecheck/tests/as_mmap.stderr.exp~update-regtest corecheck/tests/as_mmap.stderr.exp
--- valgrind/corecheck/tests/as_mmap.stderr.exp~update-regtest	2005-01-12 13:54:43.000000000 -0800
+++ valgrind-jeremy/corecheck/tests/as_mmap.stderr.exp	2005-01-12 13:54:43.000000000 -0800
@@ -1,7 +1,5 @@
 
 1
-Warning: client syscall mmap2 tried to modify addresses 0x........-0x........
-mmap @ 0x........
 2
 3
 4
diff -puN massif/ms_main.c~update-regtest massif/ms_main.c
--- valgrind/massif/ms_main.c~update-regtest	2005-01-12 13:54:43.000000000 -0800
+++ valgrind-jeremy/massif/ms_main.c	2005-01-12 13:54:43.000000000 -0800
@@ -850,6 +850,7 @@ static UInt   curr_census = 0;
 // Must return False so that all stacks are traversed
 static Bool count_stack_size( Addr stack_min, Addr stack_max, void *cp )
 {
+   VG_(printf)("stack_max=%p stack_min=%p delta=%d\n", stack_max, stack_min, stack_max-stack_min);
    *(UInt *)cp  += (stack_max - stack_min);
    return False;
 }
diff -puN tests/toobig-allocs.c~update-regtest tests/toobig-allocs.c
--- valgrind/tests/toobig-allocs.c~update-regtest	2005-01-12 13:54:43.000000000 -0800
+++ valgrind-jeremy/tests/toobig-allocs.c	2005-01-12 13:54:43.000000000 -0800
@@ -6,7 +6,7 @@ int main(void)
 {
    void *p;
 
-   int size = 2 * 1023 * 1024 * 1024;     // just under 2^31 (2GB)
+   unsigned long size = 2ul * 1023ul * 1024ul * 1024ul;     // just under 2^31 (4GB)
  
    fprintf(stderr, "Attempting too-big malloc()...\n");
    p = malloc(size);          // way too big!
diff -puN none/tests/cmdline1.stdout.exp~update-regtest none/tests/cmdline1.stdout.exp
--- valgrind/none/tests/cmdline1.stdout.exp~update-regtest	2005-01-12 13:54:43.000000000 -0800
+++ valgrind-jeremy/none/tests/cmdline1.stdout.exp	2005-01-12 13:54:43.000000000 -0800
@@ -14,7 +14,6 @@ usage: valgrind --tool=<toolname> [optio
   uncommon user options for all Valgrind tools:
     --run-libc-freeres=no|yes free up glibc memory at exit? [yes]
     --weird-hacks=hack1,hack2,...  recognised hacks: lax-ioctls [none]
-    --signal-polltime=<time>  signal poll period (mS) for older kernels [50]
     --lowlat-signals=no|yes   improve thread signal wake-up latency [no]
     --lowlat-syscalls=no|yes  improve thread syscall wake-up latency [no]
     --pointercheck=no|yes     enforce client address space limits [yes]
diff -puN none/tests/cmdline2.stdout.exp~update-regtest none/tests/cmdline2.stdout.exp
--- valgrind/none/tests/cmdline2.stdout.exp~update-regtest	2005-01-12 13:54:43.000000000 -0800
+++ valgrind-jeremy/none/tests/cmdline2.stdout.exp	2005-01-12 13:54:43.000000000 -0800
@@ -14,7 +14,6 @@ usage: valgrind --tool=<toolname> [optio
   uncommon user options for all Valgrind tools:
     --run-libc-freeres=no|yes free up glibc memory at exit? [yes]
     --weird-hacks=hack1,hack2,...  recognised hacks: lax-ioctls [none]
-    --signal-polltime=<time>  signal poll period (mS) for older kernels [50]
     --lowlat-signals=no|yes   improve thread signal wake-up latency [no]
     --lowlat-syscalls=no|yes  improve thread syscall wake-up latency [no]
     --pointercheck=no|yes     enforce client address space limits [yes]
@@ -48,7 +47,6 @@ usage: valgrind --tool=<toolname> [optio
     --trace-signals=no|yes    show signal handling details? [no]
     --trace-symtab=no|yes     show symbol table details? [no]
     --trace-sched=no|yes      show thread scheduler details? [no]
-    --trace-pthread=none|some|all  show pthread event details? [none]
     --wait-for-gdb=yes|no     pause on startup to wait for gdb attach
 
   debugging options for Valgrind tools that report errors
diff -puN none/tests/pth_blockedsig.c~update-regtest none/tests/pth_blockedsig.c
--- valgrind/none/tests/pth_blockedsig.c~update-regtest	2005-01-12 13:54:43.000000000 -0800
+++ valgrind-jeremy/none/tests/pth_blockedsig.c	2005-01-12 13:54:43.000000000 -0800
@@ -19,8 +19,7 @@ child_main(void *no_args)
 //  for (i = 0; i < 5; ++i)
 //    {
       sleep (1);
-      fprintf (stdout, "thread %ld sending SIGUSR1 to thread %ld\n",
-               pthread_self (), main_thread);
+      fprintf (stdout, "thread CHILD sending SIGUSR1 to thread MAIN\n");
       if (pthread_kill (main_thread, SIGUSR1) != 0)
         fprintf (stderr, "error doing pthread_kill\n"); 
 //    }
diff -puN corecheck/tests/fdleak_cmsg.c~update-regtest corecheck/tests/fdleak_cmsg.c
--- valgrind/corecheck/tests/fdleak_cmsg.c~update-regtest	2005-01-12 13:54:43.000000000 -0800
+++ valgrind-jeremy/corecheck/tests/fdleak_cmsg.c	2005-01-12 13:54:43.000000000 -0800
@@ -6,6 +6,7 @@
 #include <fcntl.h>
 #include <unistd.h>
 #include <stdlib.h>
+#include <errno.h>
 
 char filea[24];
 char fileb[24];
@@ -126,7 +127,10 @@ client ()
       exit(1);
    }
 
+  again:
    if((size = recvmsg(s, &msg, 0)) == -1) {
+      if (errno == EINTR)
+	 goto again;		/* SIGCHLD from server exiting could interrupt */
       perror("recvmsg");
       exit(1);
    }
diff -puN coregrind/linux/syscalls.c~update-regtest coregrind/linux/syscalls.c
--- valgrind/coregrind/linux/syscalls.c~update-regtest	2005-01-12 13:54:43.000000000 -0800
+++ valgrind-jeremy/coregrind/linux/syscalls.c	2005-01-12 13:54:43.000000000 -0800
@@ -52,8 +52,6 @@
 #define arg5	PLATFORM_SYSCALL_ARG5(tst->arch)
 #define arg6	PLATFORM_SYSCALL_ARG6(tst->arch)
 
-#define set_result(val) PLATFORM_SET_SYSCALL_RESULT(tst->arch, (val))
-
 #define PRINT(format, args...)  \
    if (VG_(clo_trace_syscalls))        \
       VG_(printf)(format, ## args)
@@ -90,23 +88,23 @@ PRE(sys_mount, MayBlock)
    PRE_REG_READ5(long, "mount",
                  char *, source, char *, target, char *, type,
                  unsigned long, flags, void *, data);
-   PRE_MEM_RASCIIZ( "mount(source)", arg1);
-   PRE_MEM_RASCIIZ( "mount(target)", arg2);
-   PRE_MEM_RASCIIZ( "mount(type)", arg3);
+   SYS_PRE_MEM_RASCIIZ( "mount(source)", arg1);
+   SYS_PRE_MEM_RASCIIZ( "mount(target)", arg2);
+   SYS_PRE_MEM_RASCIIZ( "mount(type)", arg3);
 }
 
 PRE(sys_oldumount, 0)
 {
    PRINT("sys_oldumount( %p )", arg1);
    PRE_REG_READ1(long, "umount", char *, path);
-   PRE_MEM_RASCIIZ( "umount(path)", arg1);
+   SYS_PRE_MEM_RASCIIZ( "umount(path)", arg1);
 }
 
 PRE(sys_umount, 0)
 {
    PRINT("sys_umount( %p )", arg1);
    PRE_REG_READ2(long, "umount2", char *, path, int, flags);
-   PRE_MEM_RASCIIZ( "umount2(path)", arg1);
+   SYS_PRE_MEM_RASCIIZ( "umount2(path)", arg1);
 }
 
 PRE(sys_llseek, 0)
@@ -116,7 +114,7 @@ PRE(sys_llseek, 0)
                  unsigned int, fd, unsigned long, offset_high,
                  unsigned long, offset_low, vki_loff_t *, result,
                  unsigned int, whence);
-   PRE_MEM_WRITE( "llseek(result)", arg4, sizeof(vki_loff_t));
+   SYS_PRE_MEM_WRITE( "llseek(result)", arg4, sizeof(vki_loff_t));
 }
 
 POST(sys_llseek)
@@ -130,11 +128,11 @@ PRE(sys_adjtimex, 0)
    struct vki_timex *tx = (struct vki_timex *)arg1;
    PRINT("sys_adjtimex ( %p )", arg1);
    PRE_REG_READ1(long, "adjtimex", struct timex *, buf);
-   PRE_MEM_READ( "adjtimex(timex->modes)", arg1, sizeof(tx->modes));
+   SYS_PRE_MEM_READ( "adjtimex(timex->modes)", arg1, sizeof(tx->modes));
 
 #define ADJX(bit,field) 				\
    if (tx->modes & bit)					\
-      PRE_MEM_READ( "adjtimex(timex->"#field")",	\
+      SYS_PRE_MEM_READ( "adjtimex(timex->"#field")",	\
 		    (Addr)&tx->field, sizeof(tx->field))
    ADJX(ADJ_FREQUENCY, freq);
    ADJX(ADJ_MAXERROR, maxerror);
@@ -144,7 +142,7 @@ PRE(sys_adjtimex, 0)
    ADJX(ADJ_TICK, tick);
 #undef ADJX
    
-   PRE_MEM_WRITE( "adjtimex(timex)", arg1, sizeof(struct vki_timex));
+   SYS_PRE_MEM_WRITE( "adjtimex(timex)", arg1, sizeof(struct vki_timex));
 }
 
 POST(sys_adjtimex)
@@ -196,9 +194,9 @@ PRE(sys_getresuid16, 0)
    PRE_REG_READ3(long, "getresuid16",
                  vki_old_uid_t *, ruid, vki_old_uid_t *, euid,
                  vki_old_uid_t *, suid);
-   PRE_MEM_WRITE( "getresuid16(ruid)", arg1, sizeof(vki_old_uid_t) );
-   PRE_MEM_WRITE( "getresuid16(euid)", arg2, sizeof(vki_old_uid_t) );
-   PRE_MEM_WRITE( "getresuid16(suid)", arg3, sizeof(vki_old_uid_t) );
+   SYS_PRE_MEM_WRITE( "getresuid16(ruid)", arg1, sizeof(vki_old_uid_t) );
+   SYS_PRE_MEM_WRITE( "getresuid16(euid)", arg2, sizeof(vki_old_uid_t) );
+   SYS_PRE_MEM_WRITE( "getresuid16(suid)", arg3, sizeof(vki_old_uid_t) );
 }
 
 POST(sys_getresuid16)
@@ -215,9 +213,9 @@ PRE(sys_getresuid, 0)
    PRINT("sys_getresuid ( %p, %p, %p )", arg1,arg2,arg3);
    PRE_REG_READ3(long, "getresuid", 
                  vki_uid_t *, ruid, vki_uid_t *, euid, vki_uid_t *, suid);
-   PRE_MEM_WRITE( "getresuid(ruid)", arg1, sizeof(vki_uid_t) );
-   PRE_MEM_WRITE( "getresuid(euid)", arg2, sizeof(vki_uid_t) );
-   PRE_MEM_WRITE( "getresuid(suid)", arg3, sizeof(vki_uid_t) );
+   SYS_PRE_MEM_WRITE( "getresuid(ruid)", arg1, sizeof(vki_uid_t) );
+   SYS_PRE_MEM_WRITE( "getresuid(euid)", arg2, sizeof(vki_uid_t) );
+   SYS_PRE_MEM_WRITE( "getresuid(suid)", arg3, sizeof(vki_uid_t) );
 }
 
 POST(sys_getresuid)
@@ -249,9 +247,9 @@ PRE(sys_getresgid16, 0)
    PRE_REG_READ3(long, "getresgid16",
                  vki_old_gid_t *, rgid, vki_old_gid_t *, egid,
                  vki_old_gid_t *, sgid);
-   PRE_MEM_WRITE( "getresgid16(rgid)", arg1, sizeof(vki_old_gid_t) );
-   PRE_MEM_WRITE( "getresgid16(egid)", arg2, sizeof(vki_old_gid_t) );
-   PRE_MEM_WRITE( "getresgid16(sgid)", arg3, sizeof(vki_old_gid_t) );
+   SYS_PRE_MEM_WRITE( "getresgid16(rgid)", arg1, sizeof(vki_old_gid_t) );
+   SYS_PRE_MEM_WRITE( "getresgid16(egid)", arg2, sizeof(vki_old_gid_t) );
+   SYS_PRE_MEM_WRITE( "getresgid16(sgid)", arg3, sizeof(vki_old_gid_t) );
 }
 
 POST(sys_getresgid16)
@@ -268,9 +266,9 @@ PRE(sys_getresgid, 0)
    PRINT("sys_getresgid ( %p, %p, %p )", arg1,arg2,arg3);
    PRE_REG_READ3(long, "getresgid", 
                  vki_gid_t *, rgid, vki_gid_t *, egid, vki_gid_t *, sgid);
-   PRE_MEM_WRITE( "getresgid(rgid)", arg1, sizeof(vki_gid_t) );
-   PRE_MEM_WRITE( "getresgid(egid)", arg2, sizeof(vki_gid_t) );
-   PRE_MEM_WRITE( "getresgid(sgid)", arg3, sizeof(vki_gid_t) );
+   SYS_PRE_MEM_WRITE( "getresgid(rgid)", arg1, sizeof(vki_gid_t) );
+   SYS_PRE_MEM_WRITE( "getresgid(egid)", arg2, sizeof(vki_gid_t) );
+   SYS_PRE_MEM_WRITE( "getresgid(sgid)", arg3, sizeof(vki_gid_t) );
 }
 
 POST(sys_getresgid)
@@ -295,7 +293,7 @@ PRE(sys_syslog, MayBlock)
    PRE_REG_READ3(long, "syslog", int, type, char *, bufp, int, len);
    switch (arg1) {
    case 2: case 3: case 4:
-      PRE_MEM_WRITE( "syslog(bufp)", arg2, arg3);
+      SYS_PRE_MEM_WRITE( "syslog(bufp)", arg2, arg3);
       break;
    default: 
       break;
@@ -323,7 +321,7 @@ PRE(sys_sysinfo, 0)
 {
    PRINT("sys_sysinfo ( %p )",arg1);
    PRE_REG_READ1(long, "sysinfo", struct sysinfo *, info);
-   PRE_MEM_WRITE( "sysinfo(info)", arg1, sizeof(struct vki_sysinfo) );
+   SYS_PRE_MEM_WRITE( "sysinfo(info)", arg1, sizeof(struct vki_sysinfo) );
 }
 
 POST(sys_sysinfo)
@@ -339,14 +337,33 @@ PRE(sys_personality, 0)
 
 PRE(sys_sysctl, 0)
 {
+   struct __vki_sysctl_args *args;
+   args = (struct __vki_sysctl_args *)arg1;
    PRINT("sys_sysctl ( %p )", arg1 );
    PRE_REG_READ1(long, "sysctl", struct __sysctl_args *, args);
-   PRE_MEM_WRITE( "sysctl(args)", arg1, sizeof(struct __vki_sysctl_args) );
+   SYS_PRE_MEM_READ( "sysctl(args)", arg1, sizeof(struct __vki_sysctl_args) );
+   if (!VG_(is_addressable)(arg1, sizeof(struct __vki_sysctl_args), VKI_PROT_READ)) {
+      set_result( -VKI_EFAULT );
+      return;
+   }
+
+   SYS_PRE_MEM_READ("sysctl(name)", (Addr)args->name, args->nlen * sizeof(*args->name));
+   if (args->newval != NULL)
+      SYS_PRE_MEM_READ("sysctl(newval)", (Addr)args->newval, args->newlen);
+   if (args->oldlenp != NULL) {
+      SYS_PRE_MEM_READ("sysctl(oldlenp)", (Addr)args->oldlenp, sizeof(*args->oldlenp));
+      SYS_PRE_MEM_WRITE("sysctl(oldval)", (Addr)args->oldval, *args->oldlenp);
+   }
 }
 
 POST(sys_sysctl)
 {
-   POST_MEM_WRITE( arg1, sizeof(struct __vki_sysctl_args) );
+   struct __vki_sysctl_args *args;
+   args = (struct __vki_sysctl_args *)arg1;
+   if (args->oldlenp != NULL) {
+      POST_MEM_WRITE((Addr)args->oldlenp, sizeof(*args->oldlenp));
+      POST_MEM_WRITE((Addr)args->oldval, *args->oldlenp);
+   }
 }
 
 PRE(sys_prctl, MayBlock)
@@ -358,7 +375,7 @@ PRE(sys_prctl, MayBlock)
                  int, option, unsigned long, parg2, unsigned long, parg3,
                  unsigned long, parg4, unsigned long, parg5);
    // XXX: totally wrong... we need to look at the 'option' arg, and do
-   // PRE_MEM_READs/PRE_MEM_WRITEs as necessary...
+   // SYS_PRE_MEM_READs/SYS_PRE_MEM_WRITEs as necessary...
 }
 
 PRE(sys_sendfile, MayBlock)
@@ -368,7 +385,7 @@ PRE(sys_sendfile, MayBlock)
                  int, out_fd, int, in_fd, vki_off_t *, offset,
                  vki_size_t, count);
    if (arg3 != 0)
-      PRE_MEM_WRITE( "sendfile(offset)", arg3, sizeof(vki_off_t) );
+      SYS_PRE_MEM_WRITE( "sendfile(offset)", arg3, sizeof(vki_off_t) );
 }
 
 POST(sys_sendfile)
@@ -383,7 +400,7 @@ PRE(sys_sendfile64, MayBlock)
                  int, out_fd, int, in_fd, vki_loff_t *, offset,
                  vki_size_t, count);
    if (arg3 != 0)
-      PRE_MEM_WRITE( "sendfile64(offset)", arg3, sizeof(vki_loff_t) );
+      SYS_PRE_MEM_WRITE( "sendfile64(offset)", arg3, sizeof(vki_loff_t) );
 }
 
 POST(sys_sendfile64)
@@ -399,11 +416,11 @@ PRE(sys_futex, MayBlock)
    PRE_REG_READ6(long, "futex", 
                  vki_u32 *, futex, int, op, int, val,
                  struct timespec *, utime, vki_u32 *, uaddr2, int, val3);
-   PRE_MEM_READ( "futex(futex)", arg1, sizeof(int) );
+   SYS_PRE_MEM_READ( "futex(futex)", arg1, sizeof(int) );
    if (arg2 == VKI_FUTEX_WAIT && arg4 != 0)
-      PRE_MEM_READ( "futex(timeout)", arg4, sizeof(struct vki_timespec) );
+      SYS_PRE_MEM_READ( "futex(timeout)", arg4, sizeof(struct vki_timespec) );
    if (arg2 == VKI_FUTEX_REQUEUE)
-      PRE_MEM_READ( "futex(futex2)", arg4, sizeof(int) );
+      SYS_PRE_MEM_READ( "futex(futex2)", arg4, sizeof(int) );
 }
 
 POST(sys_futex)
@@ -448,7 +465,7 @@ PRE(sys_epoll_ctl, 0)
          arg1, ( arg2<3 ? epoll_ctl_s[arg2] : "?" ), arg3, arg4);
    PRE_REG_READ4(long, "epoll_ctl",
                  int, epfd, int, op, int, fd, struct epoll_event *, event);
-   PRE_MEM_READ( "epoll_ctl(event)", arg4, sizeof(struct epoll_event) );
+   SYS_PRE_MEM_READ( "epoll_ctl(event)", arg4, sizeof(struct epoll_event) );
 }
 
 PRE(sys_epoll_wait, MayBlock)
@@ -457,7 +474,7 @@ PRE(sys_epoll_wait, MayBlock)
    PRE_REG_READ4(long, "epoll_wait",
                  int, epfd, struct epoll_event *, events,
                  int, maxevents, int, timeout);
-   PRE_MEM_WRITE( "epoll_wait(events)", arg2, sizeof(struct epoll_event)*arg3);
+   SYS_PRE_MEM_WRITE( "epoll_wait(events)", arg2, sizeof(struct epoll_event)*arg3);
 }
 
 POST(sys_epoll_wait)
@@ -477,7 +494,7 @@ PRE(sys_io_setup, Special)
    PRINT("sys_io_setup ( %u, %p )", arg1,arg2);
    PRE_REG_READ2(long, "io_setup",
                  unsigned, nr_events, vki_aio_context_t *, ctxp);
-   PRE_MEM_WRITE( "io_setup(ctxp)", arg2, sizeof(vki_aio_context_t) );
+   SYS_PRE_MEM_WRITE( "io_setup(ctxp)", arg2, sizeof(vki_aio_context_t) );
    
    size = PGROUNDUP(sizeof(struct vki_aio_ring) +
                     arg1*sizeof(struct vki_io_event));
@@ -539,10 +556,10 @@ PRE(sys_io_getevents, MayBlock)
                  struct io_event *, events,
                  struct timespec *, timeout);
    if (arg3 > 0)
-      PRE_MEM_WRITE( "io_getevents(events)",
+      SYS_PRE_MEM_WRITE( "io_getevents(events)",
                      arg4, sizeof(struct vki_io_event)*arg3 );
    if (arg5 != 0)
-      PRE_MEM_READ( "io_getevents(timeout)",
+      SYS_PRE_MEM_READ( "io_getevents(timeout)",
                      arg5, sizeof(struct vki_timespec));
 }
 
@@ -581,18 +598,18 @@ PRE(sys_io_submit, 0)
    PRE_REG_READ3(long, "io_submit",
                  vki_aio_context_t, ctx_id, long, nr,
                  struct iocb **, iocbpp);
-   PRE_MEM_READ( "io_submit(iocbpp)", arg3, arg2*sizeof(struct vki_iocb *) );
+   SYS_PRE_MEM_READ( "io_submit(iocbpp)", arg3, arg2*sizeof(struct vki_iocb *) );
    if (arg3 != 0) {
       for (i = 0; i < arg2; i++) {
          struct vki_iocb *cb = ((struct vki_iocb **)arg3)[i];
-         PRE_MEM_READ( "io_submit(iocb)", (Addr)cb, sizeof(struct vki_iocb) );
+         SYS_PRE_MEM_READ( "io_submit(iocb)", (Addr)cb, sizeof(struct vki_iocb) );
          switch (cb->aio_lio_opcode) {
          case VKI_IOCB_CMD_PREAD:
-            PRE_MEM_WRITE( "io_submit(PREAD)", cb->aio_buf, cb->aio_nbytes );
+            SYS_PRE_MEM_WRITE( "io_submit(PREAD)", cb->aio_buf, cb->aio_nbytes );
             break;
 
          case VKI_IOCB_CMD_PWRITE:
-            PRE_MEM_READ( "io_submit(PWRITE)", cb->aio_buf, cb->aio_nbytes );
+            SYS_PRE_MEM_READ( "io_submit(PWRITE)", cb->aio_buf, cb->aio_nbytes );
             break;
            
          default:
@@ -610,8 +627,8 @@ PRE(sys_io_cancel, 0)
    PRE_REG_READ3(long, "io_cancel",
                  vki_aio_context_t, ctx_id, struct iocb *, iocb,
                  struct io_event *, result);
-   PRE_MEM_READ( "io_cancel(iocb)", arg2, sizeof(struct vki_iocb) );
-   PRE_MEM_WRITE( "io_cancel(result)", arg3, sizeof(struct vki_io_event) );
+   SYS_PRE_MEM_READ( "io_cancel(iocb)", arg2, sizeof(struct vki_iocb) );
+   SYS_PRE_MEM_WRITE( "io_cancel(result)", arg3, sizeof(struct vki_io_event) );
 }
 
 POST(sys_io_cancel)
diff -puN glibc-2.3.supp~update-regtest glibc-2.3.supp
--- valgrind/glibc-2.3.supp~update-regtest	2005-01-12 13:54:43.000000000 -0800
+++ valgrind-jeremy/glibc-2.3.supp	2005-01-12 13:54:43.000000000 -0800
@@ -247,3 +247,74 @@
    Memcheck:Cond
    obj:/lib/ld-2.3.3.so
 }
+##----------------------------------------------------------------------##
+## glibc-2.3.3 on FC2
+## Assumes that sysctl returns \0-terminated strings in is_smp_system
+{
+   Unterminated strstr string in is_smp_system() (NPTL)
+   Memcheck:Cond
+   fun:strstr
+   fun:__pthread_initialize_minimal_internal
+   obj:/lib/tls/libpthread-0.61.so
+   obj:/lib/tls/libpthread-0.61.so
+}
+{
+   Unterminated strstr string in is_smp_system() (LinuxThreads)
+   Memcheck:Cond
+   fun:strstr
+   fun:pthread_initialize
+   obj:/lib/libpthread-0.10.so
+   obj:/lib/libpthread-0.10.so
+}
+
+## Bug in PRE(sys_clone), really.  Some args are not used.
+{
+   LinuxThread clone use (parent_tidptr)
+   Memcheck:Param
+   clone(parent_tidptr)
+   fun:clone
+   fun:pthread_create@@GLIBC_2.1
+}
+{
+   LinuxThread clone use (child_tidptr)
+   Memcheck:Param
+   clone(child_tidptr)
+   fun:clone
+   fun:pthread_create@@GLIBC_2.1
+}
+{
+   LinuxThread clone use (tlsinfo)
+   Memcheck:Param
+   clone(tlsinfo)
+   fun:clone
+   fun:pthread_create@@GLIBC_2.1
+}
+
+## LinuxThreads manager writes messages containing undefined bytes
+{
+   LinuxThreads: write/pthread_onexit_process
+   Memcheck:Param
+   write(buf)
+   fun:pthread_onexit_process
+   fun:exit
+}
+{
+   LinuxThreads: write/pthread_join
+   Memcheck:Param
+   write(buf)
+   fun:pthread_join
+}
+{
+   LinuxThreads: write/pthread_create
+   Memcheck:Param
+   write(buf)
+   fun:pthread_create@@GLIBC_2.1
+}
+{
+   LinuxThreads: write/__pthread_initialize_manager/pthread_create
+   Memcheck:Param
+   write(buf)
+   fun:__pthread_initialize_manager
+   fun:pthread_create@@GLIBC_2.1
+}
+
diff -puN none/tests/yield.c~update-regtest none/tests/yield.c
--- valgrind/none/tests/yield.c~update-regtest	2005-01-12 13:54:43.000000000 -0800
+++ valgrind-jeremy/none/tests/yield.c	2005-01-12 13:54:43.000000000 -0800
@@ -1,3 +1,7 @@
+/* 
+   Check that a thread which yields with pause (rep;nop) makes less
+   progress against a pure spinner.
+ */
 #include <pthread.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -8,25 +12,23 @@ static pthread_cond_t c_go = PTHREAD_CON
 
 static volatile int alive;
 
-static int sch_yield;
+static int spin;
 static int rep_nop;
 
-static void *th1(void *v)
+static void *spinner(void *v)
 {
 	pthread_mutex_lock(&m_go);
 	while(!alive)
 		pthread_cond_wait(&c_go, &m_go);
 	pthread_mutex_unlock(&m_go);
 
-	while(alive) {
-		sch_yield++;
-		sched_yield();
-	}
+	while(alive)
+		spin++;
 
 	return 0;
 }
 
-static void *th2(void *v)
+static void *rep_nopper(void *v)
 {
 	pthread_mutex_lock(&m_go);
 	while(!alive)
@@ -49,8 +51,8 @@ int main()
 {
 	pthread_t a, b;
 
-	pthread_create(&a, NULL, th1, NULL);
-	pthread_create(&b, NULL, th2, NULL);
+	pthread_create(&a, NULL, spinner, NULL);
+	pthread_create(&b, NULL, rep_nopper, NULL);
 
 	/* make sure both threads start at the same time */
 	pthread_mutex_lock(&m_go);
@@ -58,17 +60,25 @@ int main()
 	pthread_cond_broadcast(&c_go);
 	pthread_mutex_unlock(&m_go);
 
-	sleep(1);
+	sleep(2);
 
 	alive = 0;
 	pthread_join(a, NULL);
 	pthread_join(b, NULL);
 
-	if (abs(sch_yield - rep_nop) < 2)
+	if (0)
+		printf("spin=%d rep_nop=%d rep_nop:spin ratio: %g\n", 
+		       spin, rep_nop, (float)rep_nop / spin);
+
+	/* We expect that spinning was faster than rep_nop, but that
+	   rep_nop made at least .1% progress of the spin. (This is
+	   fairly pessimistic, but the non-determinism of this test
+	   makes it hard to be more precise.) */
+	if (spin > rep_nop && ((float)rep_nop / spin) >= .001)
 		printf("PASS\n");
 	else
-		printf("FAIL sch_yield=%d rep_nop=%d\n", 
-		       sch_yield, rep_nop);
+		printf("FAIL spin=%d rep_nop=%d rep_nop:spin ratio: %g\n", 
+		       spin, rep_nop, (float)rep_nop / spin);
 
 	return 0;
 }
diff -puN corecheck/tests/fdleak_cmsg.stderr.exp~update-regtest corecheck/tests/fdleak_cmsg.stderr.exp
--- valgrind/corecheck/tests/fdleak_cmsg.stderr.exp~update-regtest	2005-01-12 13:54:43.000000000 -0800
+++ valgrind-jeremy/corecheck/tests/fdleak_cmsg.stderr.exp	2005-01-12 13:54:43.000000000 -0800
@@ -3,19 +3,19 @@
 FILE DESCRIPTORS: 7 open at exit.
 Open AF_UNIX socket .: /tmp/sock
    at 0x........: accept (in /...libc...)
-   by 0x........: main (fdleak_cmsg.c:170)
+   by 0x........: main (fdleak_cmsg.c:174)
 
 Open AF_UNIX socket .: /tmp/sock
    at 0x........: socket (in /...libc...)
-   by 0x........: main (fdleak_cmsg.c:170)
+   by 0x........: main (fdleak_cmsg.c:174)
 
 Open file descriptor .: /tmp/data2
    at 0x........: open (in /...libc...)
-   by 0x........: main (fdleak_cmsg.c:170)
+   by 0x........: main (fdleak_cmsg.c:174)
 
 Open file descriptor .: /tmp/data1
    at 0x........: open (in /...libc...)
-   by 0x........: main (fdleak_cmsg.c:170)
+   by 0x........: main (fdleak_cmsg.c:174)
 
 Open file descriptor .: .
    <inherited from parent>
@@ -32,15 +32,15 @@ ERROR SUMMARY: 0 errors from 0 contexts 
 FILE DESCRIPTORS: 6 open at exit.
 Open file descriptor .: /tmp/data2
    at 0x........: recvmsg (in /...libc...)
-   by 0x........: main (fdleak_cmsg.c:174)
+   by 0x........: main (fdleak_cmsg.c:178)
 
 Open file descriptor .: /tmp/data1
    at 0x........: recvmsg (in /...libc...)
-   by 0x........: main (fdleak_cmsg.c:174)
+   by 0x........: main (fdleak_cmsg.c:178)
 
 Open AF_UNIX socket .: <unknown>
    at 0x........: socket (in /...libc...)
-   by 0x........: main (fdleak_cmsg.c:174)
+   by 0x........: main (fdleak_cmsg.c:178)
 
 Open file descriptor .: .
    <inherited from parent>
diff -puN coregrind/vg_scheduler.c~update-regtest coregrind/vg_scheduler.c
--- valgrind/coregrind/vg_scheduler.c~update-regtest	2005-01-12 13:54:43.000000000 -0800
+++ valgrind-jeremy/coregrind/vg_scheduler.c	2005-01-12 14:27:49.000000000 -0800
@@ -771,13 +771,9 @@ VgSchedReturnCode VG_(scheduler) ( Threa
 	    break;
 
          case VG_TRC_EBP_JMP_YIELD:
-            /* Explicit yield, because they're expecting to be
-	       spinning. */
-	    //VG_(vg_yield)();
+            /* Explicit yield, because this thread is in a spin-lock
+	       or something.  Let another thread run ASAP. */
 	    VG_(dispatch_ctr) = 0;
-	    //VG_(set_sleeping)(tid, VgTs_Yielding);
-	    //VG_(do_syscall)(__NR_sched_yield);
-	    //VG_(set_running)(tid);
             break;
 
          case VG_TRC_INNER_COUNTERZERO:
diff -puN coregrind/core.h~update-regtest coregrind/core.h
--- valgrind/coregrind/core.h~update-regtest	2005-01-12 13:54:43.000000000 -0800
+++ valgrind-jeremy/coregrind/core.h	2005-01-12 14:27:49.000000000 -0800
@@ -897,6 +897,9 @@ extern Bool VG_(client_signal_OK)(Int si
    before using that signal to kill the process. */
 extern void VG_(set_default_handler)(Int sig);
 
+/* Adjust a client's signal mask to match our internal requirements */
+extern void VG_(sanitize_client_sigmask)(vki_sigset_t *mask);
+
 /* ---------------------------------------------------------------------
    Exports of vg_mylibc.c
    ------------------------------------------------------------------ */
@@ -1574,6 +1577,36 @@ GEN_SYSCALL_WRAPPER(sys_gettid);		// * L
    VG_TRACK( post_mem_write, zzaddr, zzlen)
 
 
+/* These are helper macros, intended to be using in syscall PRE/POST
+   functions, where tst is defined. */
+#define set_result(val) PLATFORM_SET_SYSCALL_RESULT(tst->arch, (val))
+
+#define SYS_PRE_MEM_READ(zzname, zzaddr, zzlen)			\
+   do {								\
+      PRE_MEM_READ(zzname, zzaddr, zzlen);			\
+      if (!VG_(is_addressable)(zzaddr, zzlen, VKI_PROT_READ)) {	\
+	 set_result(-VKI_EFAULT);				\
+	 /* return; */						\
+      }								\
+   } while(0)
+#define SYS_PRE_MEM_RASCIIZ(zzname, zzaddr)			\
+   do {								\
+      PRE_MEM_RASCIIZ(zzname, zzaddr);				\
+      if (!VG_(is_addressable)(zzaddr, 1, VKI_PROT_READ)) {	\
+	 set_result(-VKI_EFAULT);				\
+	 /* return; */						\
+      }								\
+   } while(0)
+#define SYS_PRE_MEM_WRITE(zzname, zzaddr, zzlen)			\
+   do {									\
+      PRE_MEM_WRITE(zzname, zzaddr, zzlen);				\
+      if (!VG_(is_addressable)(zzaddr, zzlen, VKI_PROT_WRITE)) {	\
+	 set_result(-VKI_EFAULT);					\
+	 /* return; */							\
+      }									\
+   } while(0)
+
+
 
 /*--------------------------------------------------------------------*/
 /*--- end                                            vg_syscalls.c ---*/
diff -puN coregrind/vg_signals.c~update-regtest coregrind/vg_signals.c
--- valgrind/coregrind/vg_signals.c~update-regtest	2005-01-12 13:54:43.000000000 -0800
+++ valgrind-jeremy/coregrind/vg_signals.c	2005-01-12 14:27:49.000000000 -0800
@@ -93,7 +93,6 @@ static void vg_sync_signalhandler  ( Int
 static void vg_async_signalhandler ( Int sigNo, vki_siginfo_t *info, struct vki_ucontext * );
 static void sigvgkill_handler	   ( Int sigNo, vki_siginfo_t *info, struct vki_ucontext * );
 static void sigvgchld_handler	   ( Int sigNo, vki_siginfo_t *info, struct vki_ucontext * );
-static void sanitize_client_sigmask(vki_sigset_t *mask);
 
 static const Char *signame(Int sigNo);
 
@@ -504,7 +503,8 @@ Int VG_(do_sys_sigaction) ( Int signo, 
       vg_scss.scss_per_sig[signo].scss_mask     = new_act->sa_mask;
       vg_scss.scss_per_sig[signo].scss_restorer = new_act->sa_restorer;
 
-      sanitize_client_sigmask(&vg_scss.scss_per_sig[signo].scss_mask);
+      VG_(sigdelset)(&vg_scss.scss_per_sig[signo].scss_mask, VKI_SIGKILL);
+      VG_(sigdelset)(&vg_scss.scss_per_sig[signo].scss_mask, VKI_SIGSTOP);
    }
 
    /* All happy bunnies ... */
@@ -564,7 +564,10 @@ void do_sigprocmask_bitops ( Int vki_how
    }
 }
 
-static void sanitize_client_sigmask(vki_sigset_t *mask)
+/* Add and remove signals from mask so that we end up telling the
+   kernel the state we actually want rather than what the client
+   wants. */
+void VG_(sanitize_client_sigmask)(vki_sigset_t *mask)
 {
    VG_(sigdelset)(mask, VKI_SIGKILL);
    VG_(sigdelset)(mask, VKI_SIGSTOP);
@@ -607,8 +610,8 @@ void do_setmask ( ThreadId tid,
    }
    if (newset) {
       do_sigprocmask_bitops (how, &VG_(threads)[tid].sig_mask, newset );
-
-      sanitize_client_sigmask(&VG_(threads)[tid].sig_mask);
+      VG_(sigdelset)(&VG_(threads)[tid].sig_mask, VKI_SIGKILL);
+      VG_(sigdelset)(&VG_(threads)[tid].sig_mask, VKI_SIGSTOP);
    }
 }
 
@@ -680,7 +683,8 @@ void VG_(restore_all_host_signals) ( /* 
 
 Bool VG_(client_signal_OK)(Int sigNo)
 {
-   Bool ret = sigNo >= 1 && sigNo <= VKI_SIGVGRTUSERMAX;
+   /* signal 0 is OK for kill */
+   Bool ret = sigNo >= 0 && sigNo <= VKI_SIGVGRTUSERMAX;
 
    //VG_(printf)("client_signal_OK(%d) -> %d\n", sigNo, ret);
 
@@ -719,8 +723,11 @@ void vg_push_signal_frame ( ThreadId tid
          = (Addr)(tst->altstack.ss_sp) + tst->altstack.ss_size;
       if (VG_(clo_trace_signals))
          VG_(message)(Vg_DebugMsg,
-            "delivering signal %d (%s) to thread %d: on ALT STACK", 
-            sigNo, signame(sigNo), tid );
+		      "delivering signal %d (%s) to thread %d: on ALT STACK (%p-%p; %d bytes)", 
+		      sigNo, signame(sigNo), tid, 
+		      tst->altstack.ss_sp,
+		      tst->altstack.ss_sp + tst->altstack.ss_size,
+		      tst->altstack.ss_size );
 
       /* Signal delivery to tools */
       VG_TRACK( pre_deliver_signal, tid, sigNo, /*alt_stack*/True );
@@ -1445,9 +1452,9 @@ void VG_(deliver_signal) ( ThreadId tid,
       vg_assert(VG_(is_valid_tid)(tid));
 
       /* Before we muck with the thread's state, we need to work out where it is. */
-      if (VG_(is_VCPU_thread)(tid)) {
+      if (VG_(is_VCPU_thread)(tid))
 	 VG_(save_thread_state)(tid);
-      }
+
       vg_push_signal_frame ( tid, info );
 
       if (handler->scss_flags & VKI_SA_ONESHOT) {
@@ -1833,7 +1840,18 @@ static void sigvgkill_handler(int signo,
 /* This handler should never be called */
 static void sigvgchld_handler(int signo, vki_siginfo_t *si, struct vki_ucontext *uc)
 {
-   VG_(core_panic)("SIGVGKILL handler called\n");
+   /* Just ignore it - it seems that LinuxThread signals can get
+      delivered even if they're blocked... */
+   vg_assert(signo == VKI_SIGVGCHLD);
+
+   if (VG_(clo_trace_signals)) {
+      vki_sigset_t mask;
+      VG_(sigprocmask)(0, NULL, &mask);
+      VG_(message)(Vg_DebugMsg, "SIGVGCHLD called in tid %d: mask=%08x%08x (blocked=%d)\n",
+		   VG_(gettid)(), mask.sig[1], mask.sig[0], VG_(sigismember)(&mask, signo));
+   }
+
+   return;
 }
 
 static __attribute((unused))
diff -puN coregrind/vg_syscalls.c~update-regtest coregrind/vg_syscalls.c
--- valgrind/coregrind/vg_syscalls.c~update-regtest	2005-01-12 13:54:43.000000000 -0800
+++ valgrind-jeremy/coregrind/vg_syscalls.c	2005-01-12 13:54:43.000000000 -0800
@@ -837,7 +837,7 @@ static UInt deref_UInt ( ThreadId tid, A
 {
    UInt* a_p = (UInt*)a;
    PRE_MEM_READ( s, (Addr)a_p, sizeof(UInt) );
-   if (a_p == NULL)
+   if (!VG_(is_addressable)((Addr)a_p, sizeof(UInt), VKI_PROT_READ))
       return 0;
    else
       return *a_p;
@@ -848,6 +848,8 @@ static Addr deref_Addr ( ThreadId tid, A
 {
    Addr* a_p = (Addr*)a;
    PRE_MEM_READ( s, (Addr)a_p, sizeof(Addr) );
+   if (!VG_(is_addressable)((Addr)a_p, sizeof(Addr), VKI_PROT_READ))
+      return 0;
    return *a_p;
 }
 
@@ -1028,7 +1030,6 @@ Bool VG_(fd_allowed)(Int fd, const Char 
 #define arg5	PLATFORM_SYSCALL_ARG5(tst->arch)
 #define arg6	PLATFORM_SYSCALL_ARG6(tst->arch)
 
-#define set_result(val) PLATFORM_SET_SYSCALL_RESULT(tst->arch, (val))
 
 #define PRINT(format, args...)  \
    if (VG_(clo_trace_syscalls))        \
@@ -1040,8 +1041,8 @@ Bool VG_(fd_allowed)(Int fd, const Char 
 PRE(sys_exit, Special)
 {
    /* simple; just make this thread exit */
-   PRINT("sys_exit( %d )", arg1);
-   PRE_REG_READ1(void, "sys_exit", int, exitcode);
+   PRINT("exit( %d )", arg1);
+   PRE_REG_READ1(void, "exit", int, exitcode);
 
    tst->exitreason = VgSrc_ExitSyscall;
    tst->os_state.exitcode = arg1;
@@ -1049,7 +1050,7 @@ PRE(sys_exit, Special)
 
 PRE(sys_sched_yield, MayBlock)
 {
-   PRINT("sys_sched_yield()");
+   PRINT("sched_yield()");
    PRE_REG_READ0(long, "sys_sched_yield");
 }
 
@@ -1070,31 +1071,31 @@ PRE(sys_ptrace, 0)
                  long, request, long, pid, long, addr, long, data);
    switch (arg1) {
    case 12:   /* PTRACE_GETREGS */
-      PRE_MEM_WRITE( "ptrace(getregs)", arg4, 
+      SYS_PRE_MEM_WRITE( "ptrace(getregs)", arg4, 
 		     sizeof (struct vki_user_regs_struct));
       break;
    case 14:   /* PTRACE_GETFPREGS */
-      PRE_MEM_WRITE( "ptrace(getfpregs)", arg4, 
+      SYS_PRE_MEM_WRITE( "ptrace(getfpregs)", arg4, 
 		     sizeof (struct vki_user_i387_struct));
       break;
    case 18:   /* PTRACE_GETFPXREGS */
-      PRE_MEM_WRITE( "ptrace(getfpxregs)", arg4, 
+      SYS_PRE_MEM_WRITE( "ptrace(getfpxregs)", arg4, 
                      sizeof(struct vki_user_fxsr_struct) );
       break;
    case 1: case 2: case 3:    /* PTRACE_PEEK{TEXT,DATA,USER} */
-      PRE_MEM_WRITE( "ptrace(peek)", arg4, 
+      SYS_PRE_MEM_WRITE( "ptrace(peek)", arg4, 
 		     sizeof (long));
       break;
    case 13:   /* PTRACE_SETREGS */
-      PRE_MEM_READ( "ptrace(setregs)", arg4, 
+      SYS_PRE_MEM_READ( "ptrace(setregs)", arg4, 
 		     sizeof (struct vki_user_regs_struct));
       break;
    case 15:   /* PTRACE_SETFPREGS */
-      PRE_MEM_READ( "ptrace(setfpregs)", arg4, 
+      SYS_PRE_MEM_READ( "ptrace(setfpregs)", arg4, 
 		     sizeof (struct vki_user_i387_struct));
       break;
    case 19:   /* PTRACE_SETFPXREGS */
-      PRE_MEM_READ( "ptrace(setfpxregs)", arg4, 
+      SYS_PRE_MEM_READ( "ptrace(setfpxregs)", arg4, 
                      sizeof(struct vki_user_fxsr_struct) );
       break;
    default:
@@ -1142,9 +1143,9 @@ PRE(sys_setxattr, MayBlock)
    PRE_REG_READ5(long, "setxattr",
                  char *, path, char *, name,
                  void *, value, vki_size_t, size, int, flags);
-   PRE_MEM_RASCIIZ( "setxattr(path)", arg1 );
-   PRE_MEM_RASCIIZ( "setxattr(name)", arg2 );
-   PRE_MEM_READ( "setxattr(value)", arg3, arg4 );
+   SYS_PRE_MEM_RASCIIZ( "setxattr(path)", arg1 );
+   SYS_PRE_MEM_RASCIIZ( "setxattr(name)", arg2 );
+   SYS_PRE_MEM_READ( "setxattr(value)", arg3, arg4 );
 }
 
 PRE(sys_lsetxattr, MayBlock)
@@ -1154,9 +1155,9 @@ PRE(sys_lsetxattr, MayBlock)
    PRE_REG_READ5(long, "lsetxattr",
                  char *, path, char *, name,
                  void *, value, vki_size_t, size, int, flags);
-   PRE_MEM_RASCIIZ( "lsetxattr(path)", arg1 );
-   PRE_MEM_RASCIIZ( "lsetxattr(name)", arg2 );
-   PRE_MEM_READ( "lsetxattr(value)", arg3, arg4 );
+   SYS_PRE_MEM_RASCIIZ( "lsetxattr(path)", arg1 );
+   SYS_PRE_MEM_RASCIIZ( "lsetxattr(name)", arg2 );
+   SYS_PRE_MEM_READ( "lsetxattr(value)", arg3, arg4 );
 }
 
 PRE(sys_fsetxattr, MayBlock)
@@ -1166,8 +1167,8 @@ PRE(sys_fsetxattr, MayBlock)
    PRE_REG_READ5(long, "fsetxattr",
                  int, fd, char *, name, void *, value,
                  vki_size_t, size, int, flags);
-   PRE_MEM_RASCIIZ( "fsetxattr(name)", arg2 );
-   PRE_MEM_READ( "fsetxattr(value)", arg3, arg4 );
+   SYS_PRE_MEM_RASCIIZ( "fsetxattr(name)", arg2 );
+   SYS_PRE_MEM_READ( "fsetxattr(value)", arg3, arg4 );
 }
 
 PRE(sys_getxattr, MayBlock)
@@ -1175,9 +1176,9 @@ PRE(sys_getxattr, MayBlock)
    PRINT("sys_getxattr ( %p, %p, %p, %llu )", arg1,arg2,arg3, (ULong)arg4);
    PRE_REG_READ4(ssize_t, "getxattr",
                  char *, path, char *, name, void *, value, vki_size_t, size);
-   PRE_MEM_RASCIIZ( "getxattr(path)", arg1 );
-   PRE_MEM_RASCIIZ( "getxattr(name)", arg2 );
-   PRE_MEM_WRITE( "getxattr(value)", arg3, arg4 );
+   SYS_PRE_MEM_RASCIIZ( "getxattr(path)", arg1 );
+   SYS_PRE_MEM_RASCIIZ( "getxattr(name)", arg2 );
+   SYS_PRE_MEM_WRITE( "getxattr(value)", arg3, arg4 );
 }
 
 POST(sys_getxattr)
@@ -1192,9 +1193,9 @@ PRE(sys_lgetxattr, MayBlock)
    PRINT("sys_lgetxattr ( %p, %p, %p, %llu )", arg1,arg2,arg3, (ULong)arg4);
    PRE_REG_READ4(ssize_t, "lgetxattr",
                  char *, path, char *, name, void *, value, vki_size_t, size);
-   PRE_MEM_RASCIIZ( "lgetxattr(path)", arg1 );
-   PRE_MEM_RASCIIZ( "lgetxattr(name)", arg2 );
-   PRE_MEM_WRITE( "lgetxattr(value)", arg3, arg4 );
+   SYS_PRE_MEM_RASCIIZ( "lgetxattr(path)", arg1 );
+   SYS_PRE_MEM_RASCIIZ( "lgetxattr(name)", arg2 );
+   SYS_PRE_MEM_WRITE( "lgetxattr(value)", arg3, arg4 );
 }
 
 POST(sys_lgetxattr)
@@ -1209,8 +1210,8 @@ PRE(sys_fgetxattr, MayBlock)
    PRINT("sys_fgetxattr ( %d, %p, %p, %llu )", arg1, arg2, arg3, (ULong)arg4);
    PRE_REG_READ4(ssize_t, "fgetxattr",
                  int, fd, char *, name, void *, value, vki_size_t, size);
-   PRE_MEM_RASCIIZ( "fgetxattr(name)", arg2 );
-   PRE_MEM_WRITE( "fgetxattr(value)", arg3, arg4 );
+   SYS_PRE_MEM_RASCIIZ( "fgetxattr(name)", arg2 );
+   SYS_PRE_MEM_WRITE( "fgetxattr(value)", arg3, arg4 );
 }
 
 POST(sys_fgetxattr)
@@ -1224,8 +1225,8 @@ PRE(sys_listxattr, MayBlock)
    PRINT("sys_listxattr ( %p, %p, %llu )", arg1, arg2, (ULong)arg3);
    PRE_REG_READ3(ssize_t, "listxattr",
                  char *, path, char *, list, vki_size_t, size);
-   PRE_MEM_RASCIIZ( "listxattr(path)", arg1 );
-   PRE_MEM_WRITE( "listxattr(list)", arg2, arg3 );
+   SYS_PRE_MEM_RASCIIZ( "listxattr(path)", arg1 );
+   SYS_PRE_MEM_WRITE( "listxattr(list)", arg2, arg3 );
 }
 
 POST(sys_listxattr)
@@ -1239,8 +1240,8 @@ PRE(sys_llistxattr, MayBlock)
    PRINT("sys_llistxattr ( %p, %p, %llu )", arg1, arg2, (ULong)arg3);
    PRE_REG_READ3(ssize_t, "llistxattr",
                  char *, path, char *, list, vki_size_t, size);
-   PRE_MEM_RASCIIZ( "llistxattr(path)", arg1 );
-   PRE_MEM_WRITE( "llistxattr(list)", arg2, arg3 );
+   SYS_PRE_MEM_RASCIIZ( "llistxattr(path)", arg1 );
+   SYS_PRE_MEM_WRITE( "llistxattr(list)", arg2, arg3 );
 }
 
 POST(sys_llistxattr)
@@ -1254,7 +1255,7 @@ PRE(sys_flistxattr, MayBlock)
    PRINT("sys_flistxattr ( %d, %p, %llu )", arg1, arg2, (ULong)arg3);
    PRE_REG_READ3(ssize_t, "flistxattr",
                  int, fd, char *, list, vki_size_t, size);
-   PRE_MEM_WRITE( "flistxattr(list)", arg2, arg3 );
+   SYS_PRE_MEM_WRITE( "flistxattr(list)", arg2, arg3 );
 }
 
 POST(sys_flistxattr)
@@ -1267,23 +1268,23 @@ PRE(sys_removexattr, MayBlock)
 {
    PRINT("sys_removexattr ( %p, %p )", arg1, arg2);
    PRE_REG_READ2(long, "removexattr", char *, path, char *, name);
-   PRE_MEM_RASCIIZ( "removexattr(path)", arg1 );
-   PRE_MEM_RASCIIZ( "removexattr(name)", arg2 );
+   SYS_PRE_MEM_RASCIIZ( "removexattr(path)", arg1 );
+   SYS_PRE_MEM_RASCIIZ( "removexattr(name)", arg2 );
 }
 
 PRE(sys_lremovexattr, MayBlock)
 {
    PRINT("sys_lremovexattr ( %p, %p )", arg1, arg2);
    PRE_REG_READ2(long, "lremovexattr", char *, path, char *, name);
-   PRE_MEM_RASCIIZ( "lremovexattr(path)", arg1 );
-   PRE_MEM_RASCIIZ( "lremovexattr(name)", arg2 );
+   SYS_PRE_MEM_RASCIIZ( "lremovexattr(path)", arg1 );
+   SYS_PRE_MEM_RASCIIZ( "lremovexattr(name)", arg2 );
 }
 
 PRE(sys_fremovexattr, MayBlock)
 {
    PRINT("sys_fremovexattr ( %d, %p )", arg1, arg2);
    PRE_REG_READ2(long, "fremovexattr", int, fd, char *, name);
-   PRE_MEM_RASCIIZ( "fremovexattr(name)", arg2 );
+   SYS_PRE_MEM_RASCIIZ( "fremovexattr(name)", arg2 );
 }
 
 PRE(sys_quotactl, 0)
@@ -1292,7 +1293,7 @@ PRE(sys_quotactl, 0)
    PRE_REG_READ4(long, "quotactl",
                  unsigned int, cmd, const char *, special, vki_qid_t, id,
                  void *, addr);
-   PRE_MEM_RASCIIZ( "quotactl(special)", arg2 );
+   SYS_PRE_MEM_RASCIIZ( "quotactl(special)", arg2 );
 }
 
 // XXX: this wrapper is only suitable for 32-bit platforms
@@ -1302,7 +1303,7 @@ PRE(sys_lookup_dcookie, 0)
    PRE_REG_READ4(long, "lookup_dcookie",
                  vki_u32, cookie_low32, vki_u32, cookie_high32,
                  char *, buf, vki_size_t, len);
-   PRE_MEM_WRITE( "lookup_dcookie(buf)", arg3, arg4);
+   SYS_PRE_MEM_WRITE( "lookup_dcookie(buf)", arg3, arg4);
 }
 
 POST(sys_lookup_dcookie)
@@ -1328,7 +1329,7 @@ PRE(sys_msync, MayBlock)
    PRINT("sys_msync ( %p, %llu, %d )", arg1,(ULong)arg2,arg3);
    PRE_REG_READ3(long, "msync",
                  unsigned long, start, vki_size_t, length, int, flags);
-   PRE_MEM_READ( "msync(start)", arg1, arg2 );
+   SYS_PRE_MEM_READ( "msync(start)", arg1, arg2 );
 }
 
 // Nb: getpmsg() and putpmsg() are special additional syscalls used in early
@@ -1353,13 +1354,13 @@ PRE(sys_getpmsg, MayBlock)
    ctrl = (struct vki_pmsg_strbuf *)arg2;
    data = (struct vki_pmsg_strbuf *)arg3;
    if (ctrl && ctrl->maxlen > 0)
-      PRE_MEM_WRITE( "getpmsg(ctrl)", (Addr)ctrl->buf, ctrl->maxlen);
+      SYS_PRE_MEM_WRITE( "getpmsg(ctrl)", (Addr)ctrl->buf, ctrl->maxlen);
    if (data && data->maxlen > 0)
-      PRE_MEM_WRITE( "getpmsg(data)", (Addr)data->buf, data->maxlen);
+      SYS_PRE_MEM_WRITE( "getpmsg(data)", (Addr)data->buf, data->maxlen);
    if (arg4)
-      PRE_MEM_WRITE( "getpmsg(bandp)", (Addr)arg4, sizeof(int));
+      SYS_PRE_MEM_WRITE( "getpmsg(bandp)", (Addr)arg4, sizeof(int));
    if (arg5)
-      PRE_MEM_WRITE( "getpmsg(flagsp)", (Addr)arg5, sizeof(int));
+      SYS_PRE_MEM_WRITE( "getpmsg(flagsp)", (Addr)arg5, sizeof(int));
 }
 
 POST(sys_getpmsg)
@@ -1389,16 +1390,16 @@ PRE(sys_putpmsg, MayBlock)
    ctrl = (struct vki_pmsg_strbuf *)arg2;
    data = (struct vki_pmsg_strbuf *)arg3;
    if (ctrl && ctrl->len > 0)
-      PRE_MEM_READ( "putpmsg(ctrl)", (Addr)ctrl->buf, ctrl->len);
+      SYS_PRE_MEM_READ( "putpmsg(ctrl)", (Addr)ctrl->buf, ctrl->len);
    if (data && data->len > 0)
-      PRE_MEM_READ( "putpmsg(data)", (Addr)data->buf, data->len);
+      SYS_PRE_MEM_READ( "putpmsg(data)", (Addr)data->buf, data->len);
 }
 
 PRE(sys_getitimer, 0)
 {
    PRINT("sys_getitimer ( %d, %p )", arg1, arg2);
    PRE_REG_READ2(long, "getitimer", int, which, struct itimerval *, value);
-   PRE_MEM_WRITE( "getitimer(value)", arg2, sizeof(struct vki_itimerval) );
+   SYS_PRE_MEM_WRITE( "getitimer(value)", arg2, sizeof(struct vki_itimerval) );
 }
 
 POST(sys_getitimer)
@@ -1415,9 +1416,9 @@ PRE(sys_setitimer, 0)
                  int, which,
                  struct itimerval *, value, struct itimerval *, ovalue);
    if (arg2 != (Addr)NULL)
-      PRE_MEM_READ( "setitimer(value)", arg2, sizeof(struct vki_itimerval) );
+      SYS_PRE_MEM_READ( "setitimer(value)", arg2, sizeof(struct vki_itimerval) );
    if (arg3 != (Addr)NULL)
-      PRE_MEM_WRITE( "setitimer(ovalue)", arg3, sizeof(struct vki_itimerval));
+      SYS_PRE_MEM_WRITE( "setitimer(ovalue)", arg3, sizeof(struct vki_itimerval));
 }
 
 POST(sys_setitimer)
@@ -1431,7 +1432,7 @@ PRE(sys_chroot, 0)
 {
    PRINT("sys_chroot ( %p )", arg1);
    PRE_REG_READ1(long, "chroot", const char *, path);
-   PRE_MEM_RASCIIZ( "chroot(path)", arg1 );
+   SYS_PRE_MEM_RASCIIZ( "chroot(path)", arg1 );
 }
 
 PRE(sys_madvise, MayBlock)
@@ -1472,7 +1473,7 @@ PRE(sys_sched_setscheduler, 0)
    PRE_REG_READ3(long, "sched_setscheduler", 
                  vki_pid_t, pid, int, policy, struct sched_param *, p);
    if (arg3 != 0)
-      PRE_MEM_READ( "sched_setscheduler(p)", 
+      SYS_PRE_MEM_READ( "sched_setscheduler(p)", 
 		    arg3, sizeof(struct vki_sched_param));
 }
 
@@ -1538,7 +1539,7 @@ PRE(sys_pwrite64, MayBlock)
    PRE_REG_READ5(ssize_t, "pwrite64",
                  unsigned int, fd, const char *, buf, vki_size_t, count,
                  vki_u32, offset_low32, vki_u32, offset_high32);
-   PRE_MEM_READ( "pwrite64(buf)", arg2, arg3 );
+   SYS_PRE_MEM_READ( "pwrite64(buf)", arg2, arg3 );
 }
 
 PRE(sys_sync, MayBlock)
@@ -1552,7 +1553,7 @@ PRE(sys_fstatfs, 0)
    PRINT("sys_fstatfs ( %d, %p )",arg1,arg2);
    PRE_REG_READ2(long, "fstatfs",
                  unsigned int, fd, struct statfs *, buf);
-   PRE_MEM_WRITE( "fstatfs(buf)", arg2, sizeof(struct vki_statfs) );
+   SYS_PRE_MEM_WRITE( "fstatfs(buf)", arg2, sizeof(struct vki_statfs) );
 }
 
 POST(sys_fstatfs)
@@ -1565,7 +1566,7 @@ PRE(sys_fstatfs64, 0)
    PRINT("sys_fstatfs64 ( %d, %llu, %p )",arg1,(ULong)arg2,arg3);
    PRE_REG_READ3(long, "fstatfs64",
                  unsigned int, fd, vki_size_t, size, struct statfs64 *, buf);
-   PRE_MEM_WRITE( "fstatfs64(buf)", arg3, arg2 );
+   SYS_PRE_MEM_WRITE( "fstatfs64(buf)", arg3, arg2 );
 }
 
 POST(sys_fstatfs64)
@@ -1587,7 +1588,7 @@ PRE(sys_pread64, MayBlock)
    PRE_REG_READ5(ssize_t, "pread64",
                  unsigned int, fd, char *, buf, vki_size_t, count,
                  vki_u32, offset_low32, vki_u32, offset_high32);
-   PRE_MEM_WRITE( "pread64(buf)", arg2, arg3 );
+   SYS_PRE_MEM_WRITE( "pread64(buf)", arg2, arg3 );
 }
 
 POST(sys_pread64)
@@ -1602,7 +1603,7 @@ PRE(sys_mknod, 0)
    PRINT("sys_mknod ( %p, 0x%x, 0x%x )", arg1, arg2, arg3 );
    PRE_REG_READ3(long, "mknod",
                  const char *, pathname, int, mode, unsigned, dev);
-   PRE_MEM_RASCIIZ( "mknod(pathname)", arg1 );
+   SYS_PRE_MEM_RASCIIZ( "mknod(pathname)", arg1 );
 }
 
 PRE(sys_flock, MayBlock)
@@ -1616,8 +1617,8 @@ PRE(sys_init_module, MayBlock)
    PRINT("sys_init_module ( %p, %llu, %p )", arg1, (ULong)arg2, arg3 );
    PRE_REG_READ3(long, "init_module",
                  void *, umod, unsigned long, len, const char *, uargs);
-   PRE_MEM_READ( "init_module(umod)", arg1, arg2 );
-   PRE_MEM_RASCIIZ( "init_module(uargs)", arg3 );
+   SYS_PRE_MEM_READ( "init_module(umod)", arg1, arg2 );
+   SYS_PRE_MEM_RASCIIZ( "init_module(uargs)", arg3 );
 }
 
 PRE(sys_capget, 0)
@@ -1625,9 +1626,9 @@ PRE(sys_capget, 0)
    PRINT("sys_capget ( %p, %p )", arg1, arg2 );
    PRE_REG_READ2(long, "capget", 
                  vki_cap_user_header_t, header, vki_cap_user_data_t, data);
-   PRE_MEM_READ( "capget(header)", arg1, 
+   SYS_PRE_MEM_READ( "capget(header)", arg1, 
                   sizeof(struct __vki_user_cap_header_struct) );
-   PRE_MEM_WRITE( "capget(data)", arg2, 
+   SYS_PRE_MEM_WRITE( "capget(data)", arg2, 
                   sizeof(struct __vki_user_cap_data_struct) );
 }
 
@@ -1643,9 +1644,9 @@ PRE(sys_capset, 0)
    PRE_REG_READ2(long, "capset", 
                  vki_cap_user_header_t, header,
                  const vki_cap_user_data_t, data);
-   PRE_MEM_READ( "capset(header)", 
+   SYS_PRE_MEM_READ( "capset(header)", 
                   arg1, sizeof(struct __vki_user_cap_header_struct) );
-   PRE_MEM_READ( "capset(data)", 
+   SYS_PRE_MEM_READ( "capset(data)", 
                   arg2, sizeof(struct __vki_user_cap_data_struct) );
 }
 
@@ -1668,7 +1669,7 @@ PRE(sys_execve, Special)
    PRINT("sys_execve ( %p(%s), %p, %p )", arg1, arg1, arg2, arg3);
    PRE_REG_READ3(vki_off_t, "execve",
                  char *, filename, char **, argv, char **, envp);
-   PRE_MEM_RASCIIZ( "execve(filename)", arg1 );
+   SYS_PRE_MEM_RASCIIZ( "execve(filename)", arg1 );
    if (arg2 != 0)
       pre_argv_envp( arg2, tid, "execve(argv)", "execve(argv[i])" );
    if (arg3 != 0)
@@ -1744,10 +1745,19 @@ PRE(sys_execve, Special)
          VG_(printf)("env: %s\n", *cpp);
    }
 
-   /* Set our real sigmask to match the client's sigmask so that the
-      exec'd child will get the right mask.  First we need to clear
-      out any pending signals so they they don't get delivered, which
-      would confuse things.
+   /* restore the DATA rlimit for the child */
+   VG_(setrlimit)(VKI_RLIMIT_DATA, &VG_(client_rlimit_data));
+
+   /* 
+      Set the signal state up for exec.
+      
+      We need to set the real signal state to make sure the exec'd
+      process gets SIG_IGN properly.
+
+      Also set our real sigmask to match the client's sigmask so that
+      the exec'd child will get the right mask.  First we need to
+      clear out any pending signals so they they don't get delivered,
+      which would confuse things.
 
       XXX This is a bug - the signals should remain pending, and be
       delivered to the new process after exec.  There's also a
@@ -1759,7 +1769,19 @@ PRE(sys_execve, Special)
       vki_sigset_t allsigs;
       vki_siginfo_t info;
       static const struct vki_timespec zero = { 0, 0 };
-    
+      Int i;
+
+      for(i = 1; i < VG_(max_signal); i++) {
+	 struct vki_sigaction sa;
+	 VG_(do_sys_sigaction)(i, NULL, &sa);
+	 if (sa.ksa_handler == VKI_SIG_IGN)
+	    VG_(sigaction)(i, &sa, NULL);
+	 else {
+	    sa.ksa_handler = VKI_SIG_DFL;
+	    VG_(sigaction)(i, &sa, NULL);
+	 }
+      }
+
       VG_(sigfillset)(&allsigs);
       while(VG_(sigtimedwait)(&allsigs, &info, &zero) > 0)
 	 ;
@@ -1767,9 +1789,6 @@ PRE(sys_execve, Special)
       VG_(sigprocmask)(VKI_SIG_SETMASK, &tst->sig_mask, NULL);
    }
 
-   /* restore the DATA rlimit for the child */
-   VG_(setrlimit)(VKI_RLIMIT_DATA, &VG_(client_rlimit_data));
-
    set_result( VG_(do_syscall)(__NR_execve, arg1, arg2, arg3) );
 
    /* If we got here, then the execve failed.  We've already made too much of a mess
@@ -1784,7 +1803,7 @@ PRE(sys_access, 0)
 {
    PRINT("sys_access ( %p(%s), %d )", arg1,arg1,arg2);
    PRE_REG_READ2(long, "access", const char *, pathname, int, mode);
-   PRE_MEM_RASCIIZ( "access(pathname)", arg1 );
+   SYS_PRE_MEM_RASCIIZ( "access(pathname)", arg1 );
 }
 
 PRE(sys_alarm, 0)
@@ -1839,14 +1858,14 @@ PRE(sys_chdir, 0)
 {
    PRINT("sys_chdir ( %p )", arg1);
    PRE_REG_READ1(long, "chdir", const char *, path);
-   PRE_MEM_RASCIIZ( "chdir(path)", arg1 );
+   SYS_PRE_MEM_RASCIIZ( "chdir(path)", arg1 );
 }
 
 PRE(sys_chmod, 0)
 {
    PRINT("sys_chmod ( %p, %d )", arg1,arg2);
    PRE_REG_READ2(long, "chmod", const char *, path, vki_mode_t, mode);
-   PRE_MEM_RASCIIZ( "chmod(path)", arg1 );
+   SYS_PRE_MEM_RASCIIZ( "chmod(path)", arg1 );
 }
 
 PRE(sys_chown16, 0)
@@ -1855,7 +1874,7 @@ PRE(sys_chown16, 0)
    PRE_REG_READ3(long, "chown16",
                  const char *, path,
                  vki_old_uid_t, owner, vki_old_gid_t, group);
-   PRE_MEM_RASCIIZ( "chown16(path)", arg1 );
+   SYS_PRE_MEM_RASCIIZ( "chown16(path)", arg1 );
 }
 
 PRE(sys_chown, 0)
@@ -1864,7 +1883,7 @@ PRE(sys_chown, 0)
    PRINT("sys_chown ( %p, 0x%x, 0x%x )", arg1,arg2,arg3);
    PRE_REG_READ3(long, "chown",
                  const char *, path, vki_uid_t, owner, vki_gid_t, group);
-   PRE_MEM_RASCIIZ( "chown(path)", arg1 );
+   SYS_PRE_MEM_RASCIIZ( "chown(path)", arg1 );
 }
 
 PRE(sys_lchown, 0)
@@ -1872,7 +1891,7 @@ PRE(sys_lchown, 0)
    PRINT("sys_lchown ( %p, 0x%x, 0x%x )", arg1,arg2,arg3);
    PRE_REG_READ3(long, "lchown",
                  const char *, path, vki_uid_t, owner, vki_gid_t, group);
-   PRE_MEM_RASCIIZ( "lchown(path)", arg1 );
+   SYS_PRE_MEM_RASCIIZ( "lchown(path)", arg1 );
 }
 
 PRE(sys_close, 0)
@@ -2030,7 +2049,7 @@ PRE(sys_newfstat, 0)
 {
    PRINT("sys_newfstat ( %d, %p )", arg1,arg2);
    PRE_REG_READ2(long, "fstat", unsigned int, fd, struct stat *, buf);
-   PRE_MEM_WRITE( "fstat(buf)", arg2, sizeof(struct vki_stat) );
+   SYS_PRE_MEM_WRITE( "fstat(buf)", arg2, sizeof(struct vki_stat) );
 }
 
 POST(sys_newfstat)
@@ -2083,7 +2102,7 @@ PRE(sys_truncate, MayBlock)
    PRINT("sys_truncate ( %p(%s), %d )", arg1,arg1,arg2);
    PRE_REG_READ2(long, "truncate", 
                  const char *, path, unsigned long, length);
-   PRE_MEM_RASCIIZ( "truncate(path)", arg1 );
+   SYS_PRE_MEM_RASCIIZ( "truncate(path)", arg1 );
 }
 
 // XXX: this wrapper is only suitable for 32-bit platforms
@@ -2102,7 +2121,7 @@ PRE(sys_truncate64, MayBlock)
    PRE_REG_READ3(long, "truncate64",
                  const char *, path,
                  vki_u32, length_low32, vki_u32, length_high32);
-   PRE_MEM_RASCIIZ( "truncate64(path)", arg1 );
+   SYS_PRE_MEM_RASCIIZ( "truncate64(path)", arg1 );
 }
 
 
@@ -2112,7 +2131,7 @@ PRE(sys_getdents, MayBlock)
    PRE_REG_READ3(long, "getdents",
                  unsigned int, fd, struct linux_dirent *, dirp,
                  unsigned int, count);
-   PRE_MEM_WRITE( "getdents(dirp)", arg2, arg3 );
+   SYS_PRE_MEM_WRITE( "getdents(dirp)", arg2, arg3 );
 }
 
 POST(sys_getdents)
@@ -2127,7 +2146,7 @@ PRE(sys_getdents64, MayBlock)
    PRE_REG_READ3(long, "getdents64",
                  unsigned int, fd, struct linux_dirent64 *, dirp,
                  unsigned int, count);
-   PRE_MEM_WRITE( "getdents64(dirp)", arg2, arg3 );
+   SYS_PRE_MEM_WRITE( "getdents64(dirp)", arg2, arg3 );
 }
 
 POST(sys_getdents64)
@@ -2141,7 +2160,7 @@ PRE(sys_getgroups16, 0)
    PRINT("sys_getgroups16 ( %d, %p )", arg1, arg2);
    PRE_REG_READ2(long, "getgroups16", int, size, vki_old_gid_t *, list);
    if (arg1 > 0)
-      PRE_MEM_WRITE( "getgroups16(list)", arg2, arg1 * sizeof(vki_old_gid_t) );
+      SYS_PRE_MEM_WRITE( "getgroups16(list)", arg2, arg1 * sizeof(vki_old_gid_t) );
 }
 
 POST(sys_getgroups16)
@@ -2155,7 +2174,7 @@ PRE(sys_getgroups, 0)
    PRINT("sys_getgroups ( %d, %p )", arg1, arg2);
    PRE_REG_READ2(long, "getgroups", int, size, vki_gid_t *, list);
    if (arg1 > 0)
-      PRE_MEM_WRITE( "getgroups(list)", arg2, arg1 * sizeof(vki_gid_t) );
+      SYS_PRE_MEM_WRITE( "getgroups(list)", arg2, arg1 * sizeof(vki_gid_t) );
 }
 
 POST(sys_getgroups)
@@ -2170,7 +2189,7 @@ PRE(sys_getcwd, 0)
    // the glibc one.
    PRINT("sys_getcwd ( %p, %llu )", arg1,(ULong)arg2);
    PRE_REG_READ2(long, "getcwd", char *, buf, unsigned long, size);
-   PRE_MEM_WRITE( "getcwd(buf)", arg1, arg2 );
+   SYS_PRE_MEM_WRITE( "getcwd(buf)", arg1, arg2 );
 }
 
 POST(sys_getcwd)
@@ -2270,7 +2289,7 @@ PRE(sys_old_getrlimit, 0)
    PRINT("sys_old_getrlimit ( %d, %p )", arg1,arg2);
    PRE_REG_READ2(long, "old_getrlimit",
                  unsigned int, resource, struct rlimit *, rlim);
-   PRE_MEM_WRITE( "old_getrlimit(rlim)", arg2, sizeof(struct vki_rlimit) );
+   SYS_PRE_MEM_WRITE( "old_getrlimit(rlim)", arg2, sizeof(struct vki_rlimit) );
 }
 
 POST(sys_old_getrlimit)
@@ -2283,7 +2302,7 @@ PRE(sys_getrlimit, 0)
    PRINT("sys_getrlimit ( %d, %p )", arg1,arg2);
    PRE_REG_READ2(long, "getrlimit",
                  unsigned int, resource, struct rlimit *, rlim);
-   PRE_MEM_WRITE( "getrlimit(rlim)", arg2, sizeof(struct vki_rlimit) );
+   SYS_PRE_MEM_WRITE( "getrlimit(rlim)", arg2, sizeof(struct vki_rlimit) );
 }
 
 POST(sys_getrlimit)
@@ -2296,7 +2315,7 @@ PRE(sys_getrusage, 0)
    /* int getrusage (int who, struct rusage *usage); */
    PRINT("sys_getrusage ( %d, %p )", arg1,arg2);
    PRE_REG_READ2(long, "getrusage", int, who, struct rusage *, usage);
-   PRE_MEM_WRITE( "getrusage(usage)", arg2, sizeof(struct vki_rusage) );
+   SYS_PRE_MEM_WRITE( "getrusage(usage)", arg2, sizeof(struct vki_rusage) );
 }
 
 POST(sys_getrusage)
@@ -2310,9 +2329,9 @@ PRE(sys_gettimeofday, 0)
    PRINT("sys_gettimeofday ( %p, %p )", arg1,arg2);
    PRE_REG_READ2(long, "gettimeofday",
                  struct timeval *, tv, struct timezone *, tz);
-   PRE_MEM_WRITE( "gettimeofday(tv)", arg1, sizeof(struct vki_timeval) );
+   SYS_PRE_MEM_WRITE( "gettimeofday(tv)", arg1, sizeof(struct vki_timeval) );
    if (arg2 != 0)
-      PRE_MEM_WRITE( "gettimeofday(tz)", arg2, sizeof(struct vki_timezone) );
+      SYS_PRE_MEM_WRITE( "gettimeofday(tz)", arg2, sizeof(struct vki_timezone) );
 }
 
 POST(sys_gettimeofday)
@@ -2329,9 +2348,9 @@ PRE(sys_settimeofday, 0)
    PRINT("sys_settimeofday ( %p, %p )", arg1,arg2);
    PRE_REG_READ2(long, "settimeofday",
                  struct timeval *, tv, struct timezone *, tz);
-   PRE_MEM_READ( "settimeofday(tv)", arg1, sizeof(struct vki_timeval) );
+   SYS_PRE_MEM_READ( "settimeofday(tv)", arg1, sizeof(struct vki_timeval) );
    if (arg2 != 0) {
-      PRE_MEM_READ( "settimeofday(tz)", arg2, sizeof(struct vki_timezone) );
+      SYS_PRE_MEM_READ( "settimeofday(tz)", arg2, sizeof(struct vki_timezone) );
       /* maybe should warn if tz->tz_dsttime is non-zero? */
    }
 }
@@ -2360,7 +2379,7 @@ PRE(sys_ipc, 0)
 
    switch (arg1 /* call */) {
    case 1: /* IPCOP_semop */
-      PRE_MEM_READ( "semop(sops)", arg5, arg3 * sizeof(struct vki_sembuf) );
+      SYS_PRE_MEM_READ( "semop(sops)", arg5, arg3 * sizeof(struct vki_sembuf) );
       *flags |= MayBlock;
       break;
    case 2: /* IPCOP_semget */
@@ -2373,7 +2392,7 @@ PRE(sys_ipc, 0)
       case VKI_SEM_INFO:
       {
          Addr buf = deref_Addr( tid, (Addr)&arg->__buf, "semctl(IPC_INFO, arg)" );
-	 PRE_MEM_WRITE( "semctl(IPC_INFO, arg->buf)", buf, 
+	 SYS_PRE_MEM_WRITE( "semctl(IPC_INFO, arg->buf)", buf, 
 			sizeof(struct vki_seminfo) );
 	 break;
       }
@@ -2381,14 +2400,14 @@ PRE(sys_ipc, 0)
       case VKI_SEM_STAT:
       {
          Addr buf = deref_Addr( tid, (Addr)&arg->buf, "semctl(IPC_STAT, arg)" );
-	 PRE_MEM_WRITE( "semctl(IPC_STAT, arg->buf)", buf, 
+	 SYS_PRE_MEM_WRITE( "semctl(IPC_STAT, arg->buf)", buf, 
 			sizeof(struct vki_semid_ds) );
 	 break;
       }
       case VKI_IPC_SET:
       {
          Addr buf = deref_Addr( tid, (Addr)&arg->buf, "semctl(IPC_SET, arg)" );
-	 PRE_MEM_READ( "semctl(IPC_SET, arg->buf)", buf, 
+	 SYS_PRE_MEM_READ( "semctl(IPC_SET, arg->buf)", buf, 
 			sizeof(struct vki_semid_ds) );
 	 break;
       }
@@ -2396,7 +2415,7 @@ PRE(sys_ipc, 0)
       {
          Addr array = deref_Addr( tid, (Addr)&arg->array, "semctl(IPC_GETALL, arg)" );
          UInt nsems = get_sem_count( arg2 );
-	 PRE_MEM_WRITE( "semctl(IPC_GETALL, arg->array)", array, 
+	 SYS_PRE_MEM_WRITE( "semctl(IPC_GETALL, arg->array)", array, 
 			sizeof(short) * nsems );
 	 break;
       }
@@ -2404,13 +2423,13 @@ PRE(sys_ipc, 0)
       {
          Addr array = deref_Addr( tid, (Addr)&arg->array, "semctl(IPC_SETALL, arg)" );
          UInt nsems = get_sem_count( arg2 );
-	 PRE_MEM_READ( "semctl(IPC_SETALL, arg->array)", array, 
+	 SYS_PRE_MEM_READ( "semctl(IPC_SETALL, arg->array)", array, 
 			sizeof(short) * nsems );
 	 break;
       }
       case VKI_SETVAL:
       {
-	 PRE_MEM_READ( "semctl(IPC_SETVAL, arg->array)",
+	 SYS_PRE_MEM_READ( "semctl(IPC_SETVAL, arg->array)",
                         (Addr)&arg->val, sizeof(arg->val) );
 	 break;
       }
@@ -2418,7 +2437,7 @@ PRE(sys_ipc, 0)
       case VKI_SEM_INFO|VKI_IPC_64:
       {
          Addr buf = deref_Addr( tid, (Addr)&arg->__buf, "semctl(IPC_INFO, arg)" );
-	 PRE_MEM_WRITE( "semctl(IPC_INFO, arg->buf)", buf, 
+	 SYS_PRE_MEM_WRITE( "semctl(IPC_INFO, arg->buf)", buf, 
 			sizeof(struct vki_seminfo) );
 	 break;
       }
@@ -2426,14 +2445,14 @@ PRE(sys_ipc, 0)
       case VKI_SEM_STAT|VKI_IPC_64:
       {
          Addr buf = deref_Addr( tid, (Addr)&arg->buf, "semctl(IPC_STAT, arg)" );
-	 PRE_MEM_WRITE( "semctl(IPC_STAT, arg->buf)", buf, 
+	 SYS_PRE_MEM_WRITE( "semctl(IPC_STAT, arg->buf)", buf, 
 			sizeof(struct vki_semid64_ds) );
 	 break;
       }
       case VKI_IPC_SET|VKI_IPC_64:
       {
          Addr buf = deref_Addr( tid, (Addr)&arg->buf, "semctl(IPC_SET, arg)" );
-	 PRE_MEM_READ( "semctl(IPC_SET, arg->buf)", buf, 
+	 SYS_PRE_MEM_READ( "semctl(IPC_SET, arg->buf)", buf, 
 			sizeof(struct vki_semid64_ds) );
 	 break;
       }
@@ -2441,7 +2460,7 @@ PRE(sys_ipc, 0)
       {
          Addr array = deref_Addr( tid, (Addr)&arg->array, "semctl(IPC_GETALL, arg)" );
          UInt nsems = get_sem_count( arg2 );
-	 PRE_MEM_WRITE( "semctl(IPC_GETALL, arg->array)", array, 
+	 SYS_PRE_MEM_WRITE( "semctl(IPC_GETALL, arg->array)", array, 
 			sizeof(short) * nsems );
 	 break;
       }
@@ -2449,13 +2468,13 @@ PRE(sys_ipc, 0)
       {
          Addr array = deref_Addr( tid, (Addr)&arg->array, "semctl(IPC_SETALL, arg)" );
          UInt nsems = get_sem_count( arg2 );
-	 PRE_MEM_READ( "semctl(IPC_SETALL, arg->array)", array, 
+	 SYS_PRE_MEM_READ( "semctl(IPC_SETALL, arg->array)", array, 
 			sizeof(short) * nsems );
 	 break;
       }
       case VKI_SETVAL|VKI_IPC_64:
       {
-	 PRE_MEM_READ( "semctl(IPC_SETVAL, arg->array)",
+	 SYS_PRE_MEM_READ( "semctl(IPC_SETVAL, arg->array)",
                         (Addr)&arg->val, sizeof(arg->val) );
 	 break;
       }
@@ -2465,10 +2484,10 @@ PRE(sys_ipc, 0)
       break;
    }
    case 4: /* IPCOP_semtimedop */
-      PRE_MEM_READ( "semtimedop(sops)", arg5, 
+      SYS_PRE_MEM_READ( "semtimedop(sops)", arg5, 
 		     arg3 * sizeof(struct vki_sembuf) );
       if (arg6 != 0)
-         PRE_MEM_READ( "semtimedop(timeout)", arg6, 
+         SYS_PRE_MEM_READ( "semtimedop(timeout)", arg6, 
                         sizeof(struct vki_timespec) );
       *flags |= MayBlock;
       break;
@@ -2477,9 +2496,9 @@ PRE(sys_ipc, 0)
       struct vki_msgbuf *msgp = (struct vki_msgbuf *)arg5;
       Int msgsz = arg3;
 
-      PRE_MEM_READ( "msgsnd(msgp->mtype)", 
+      SYS_PRE_MEM_READ( "msgsnd(msgp->mtype)", 
 		     (Addr)&msgp->mtype, sizeof(msgp->mtype) );
-      PRE_MEM_READ( "msgsnd(msgp->mtext)", 
+      SYS_PRE_MEM_READ( "msgsnd(msgp->mtext)", 
 		     (Addr)msgp->mtext, msgsz );
 
       if ((arg4 & VKI_IPC_NOWAIT) == 0)
@@ -2495,9 +2514,9 @@ PRE(sys_ipc, 0)
 					  (Addr) (&((struct vki_ipc_kludge *)arg5)->msgp),
 					  "msgrcv(msgp)" );
 
-      PRE_MEM_WRITE( "msgrcv(msgp->mtype)", 
+      SYS_PRE_MEM_WRITE( "msgrcv(msgp->mtype)", 
 		     (Addr)&msgp->mtype, sizeof(msgp->mtype) );
-      PRE_MEM_WRITE( "msgrcv(msgp->mtext)", 
+      SYS_PRE_MEM_WRITE( "msgrcv(msgp->mtext)", 
 		     (Addr)msgp->mtext, msgsz );
 
       if ((arg4 & VKI_IPC_NOWAIT) == 0)
@@ -2511,30 +2530,30 @@ PRE(sys_ipc, 0)
       switch (arg3 /* cmd */) {
       case VKI_IPC_INFO:
       case VKI_MSG_INFO:
-	 PRE_MEM_WRITE( "msgctl(IPC_INFO, buf)", arg5, 
+	 SYS_PRE_MEM_WRITE( "msgctl(IPC_INFO, buf)", arg5, 
 			sizeof(struct vki_msginfo) );
 	 break;
       case VKI_IPC_STAT:
       case VKI_MSG_STAT:
-	 PRE_MEM_WRITE( "msgctl(IPC_STAT, buf)", arg5, 
+	 SYS_PRE_MEM_WRITE( "msgctl(IPC_STAT, buf)", arg5, 
 			sizeof(struct vki_msqid_ds) );
 	 break;
       case VKI_IPC_SET:
-	 PRE_MEM_READ( "msgctl(IPC_SET, buf)", arg5, 
+	 SYS_PRE_MEM_READ( "msgctl(IPC_SET, buf)", arg5, 
 			sizeof(struct vki_msqid_ds) );
 	 break;
       case VKI_IPC_INFO|VKI_IPC_64:
       case VKI_MSG_INFO|VKI_IPC_64:
-	 PRE_MEM_WRITE( "msgctl(IPC_INFO, buf)", arg5, 
+	 SYS_PRE_MEM_WRITE( "msgctl(IPC_INFO, buf)", arg5, 
 			sizeof(struct vki_msginfo) );
 	 break;
       case VKI_IPC_STAT|VKI_IPC_64:
       case VKI_MSG_STAT|VKI_IPC_64:
-	 PRE_MEM_WRITE( "msgctl(IPC_STAT, buf)", arg5, 
+	 SYS_PRE_MEM_WRITE( "msgctl(IPC_STAT, buf)", arg5, 
 			sizeof(struct vki_msqid64_ds) );
 	 break;
       case VKI_IPC_SET|VKI_IPC_64:
-	 PRE_MEM_READ( "msgctl(IPC_SET, buf)", arg5, 
+	 SYS_PRE_MEM_READ( "msgctl(IPC_SET, buf)", arg5, 
 			sizeof(struct vki_msqid64_ds) );
 	 break;
       default:
@@ -2565,37 +2584,37 @@ PRE(sys_ipc, 0)
    {
       switch (arg3 /* cmd */) {
       case VKI_IPC_INFO:
-	 PRE_MEM_WRITE( "shmctl(IPC_INFO, buf)", arg5, 
+	 SYS_PRE_MEM_WRITE( "shmctl(IPC_INFO, buf)", arg5, 
 			sizeof(struct vki_shminfo) );
 	 break;
       case VKI_SHM_INFO:
-	 PRE_MEM_WRITE( "shmctl(SHM_INFO, buf)", arg5, 
+	 SYS_PRE_MEM_WRITE( "shmctl(SHM_INFO, buf)", arg5, 
 			sizeof(struct vki_shm_info) );
 	 break;
       case VKI_IPC_STAT:
       case VKI_SHM_STAT:
-	 PRE_MEM_WRITE( "shmctl(IPC_STAT, buf)", arg5, 
+	 SYS_PRE_MEM_WRITE( "shmctl(IPC_STAT, buf)", arg5, 
 			sizeof(struct vki_shmid_ds) );
 	 break;
       case VKI_IPC_SET:
-	 PRE_MEM_READ( "shmctl(IPC_SET, buf)", arg5, 
+	 SYS_PRE_MEM_READ( "shmctl(IPC_SET, buf)", arg5, 
 			sizeof(struct vki_shmid_ds) );
 	 break;
       case VKI_IPC_INFO|VKI_IPC_64:
-	 PRE_MEM_WRITE( "shmctl(IPC_INFO, buf)", arg5, 
+	 SYS_PRE_MEM_WRITE( "shmctl(IPC_INFO, buf)", arg5, 
 			sizeof(struct vki_shminfo64) );
 	 break;
       case VKI_SHM_INFO|VKI_IPC_64:
-	 PRE_MEM_WRITE( "shmctl(SHM_INFO, buf)", arg5, 
+	 SYS_PRE_MEM_WRITE( "shmctl(SHM_INFO, buf)", arg5, 
 			sizeof(struct vki_shm_info) );
 	 break;
       case VKI_IPC_STAT|VKI_IPC_64:
       case VKI_SHM_STAT|VKI_IPC_64:
-	 PRE_MEM_WRITE( "shmctl(IPC_STAT, buf)", arg5, 
+	 SYS_PRE_MEM_WRITE( "shmctl(IPC_STAT, buf)", arg5, 
 			sizeof(struct vki_shmid64_ds) );
 	 break;
       case VKI_IPC_SET|VKI_IPC_64:
-	 PRE_MEM_READ( "shmctl(IPC_SET, buf)", arg5, 
+	 SYS_PRE_MEM_READ( "shmctl(IPC_SET, buf)", arg5, 
 			sizeof(struct vki_shmid_ds) );
 	 break;
       default:
@@ -2803,18 +2822,18 @@ PRE(sys_ioctl, MayBlock)
    case VKI_TCSETS:
    case VKI_TCSETSW:
    case VKI_TCSETSF:
-      PRE_MEM_READ( "ioctl(TCSET{S,SW,SF})", arg3, sizeof(struct vki_termios) );
+      SYS_PRE_MEM_READ( "ioctl(TCSET{S,SW,SF})", arg3, sizeof(struct vki_termios) );
       break; 
    case VKI_TCGETS:
-      PRE_MEM_WRITE( "ioctl(TCGETS)", arg3, sizeof(struct vki_termios) );
+      SYS_PRE_MEM_WRITE( "ioctl(TCGETS)", arg3, sizeof(struct vki_termios) );
       break;
    case VKI_TCSETA:
    case VKI_TCSETAW:
    case VKI_TCSETAF:
-      PRE_MEM_READ( "ioctl(TCSET{A,AW,AF})", arg3, sizeof(struct vki_termio) );
+      SYS_PRE_MEM_READ( "ioctl(TCSET{A,AW,AF})", arg3, sizeof(struct vki_termio) );
       break;
    case VKI_TCGETA:
-      PRE_MEM_WRITE( "ioctl(TCGETA)", arg3, sizeof(struct vki_termio) );
+      SYS_PRE_MEM_WRITE( "ioctl(TCGETA)", arg3, sizeof(struct vki_termio) );
       break;
    case VKI_TCSBRK:
    case VKI_TCXONC:
@@ -2823,224 +2842,224 @@ PRE(sys_ioctl, MayBlock)
       /* These just take an int by value */
       break;
    case VKI_TIOCGWINSZ:
-      PRE_MEM_WRITE( "ioctl(TIOCGWINSZ)", arg3, sizeof(struct vki_winsize) );
+      SYS_PRE_MEM_WRITE( "ioctl(TIOCGWINSZ)", arg3, sizeof(struct vki_winsize) );
       break;
    case VKI_TIOCSWINSZ:
-      PRE_MEM_READ( "ioctl(TIOCSWINSZ)",  arg3, sizeof(struct vki_winsize) );
+      SYS_PRE_MEM_READ( "ioctl(TIOCSWINSZ)",  arg3, sizeof(struct vki_winsize) );
       break;
    case VKI_TIOCMBIS:
-      PRE_MEM_READ( "ioctl(TIOCMBIS)",    arg3, sizeof(unsigned int) );
+      SYS_PRE_MEM_READ( "ioctl(TIOCMBIS)",    arg3, sizeof(unsigned int) );
       break;
    case VKI_TIOCMBIC:
-      PRE_MEM_READ( "ioctl(TIOCMBIC)",    arg3, sizeof(unsigned int) );
+      SYS_PRE_MEM_READ( "ioctl(TIOCMBIC)",    arg3, sizeof(unsigned int) );
       break;
    case VKI_TIOCMSET:
-      PRE_MEM_READ( "ioctl(TIOCMSET)",    arg3, sizeof(unsigned int) );
+      SYS_PRE_MEM_READ( "ioctl(TIOCMSET)",    arg3, sizeof(unsigned int) );
       break;
    case VKI_TIOCLINUX:
-      PRE_MEM_READ( "ioctl(TIOCLINUX)",   arg3, sizeof(char *) );
+      SYS_PRE_MEM_READ( "ioctl(TIOCLINUX)",   arg3, sizeof(char *) );
       if (*(char *)arg3 == 11) {
-	 PRE_MEM_READ( "ioctl(TIOCLINUX, 11)", arg3, 2 * sizeof(char *) );
+	 SYS_PRE_MEM_READ( "ioctl(TIOCLINUX, 11)", arg3, 2 * sizeof(char *) );
       }
       break;
    case VKI_TIOCGPGRP:
       /* Get process group ID for foreground processing group. */
-      PRE_MEM_WRITE( "ioctl(TIOCGPGRP)", arg3, sizeof(vki_pid_t) );
+      SYS_PRE_MEM_WRITE( "ioctl(TIOCGPGRP)", arg3, sizeof(vki_pid_t) );
       break;
    case VKI_TIOCSPGRP:
       /* Set a process group ID? */
-      PRE_MEM_WRITE( "ioctl(TIOCGPGRP)", arg3, sizeof(vki_pid_t) );
+      SYS_PRE_MEM_WRITE( "ioctl(TIOCGPGRP)", arg3, sizeof(vki_pid_t) );
       break;
    case VKI_TIOCGPTN: /* Get Pty Number (of pty-mux device) */
-      PRE_MEM_WRITE( "ioctl(TIOCGPTN)", arg3, sizeof(int) );
+      SYS_PRE_MEM_WRITE( "ioctl(TIOCGPTN)", arg3, sizeof(int) );
       break;
    case VKI_TIOCSCTTY:
       /* Just takes an int value.  */
       break;
    case VKI_TIOCSPTLCK: /* Lock/unlock Pty */
-      PRE_MEM_READ( "ioctl(TIOCSPTLCK)", arg3, sizeof(int) );
+      SYS_PRE_MEM_READ( "ioctl(TIOCSPTLCK)", arg3, sizeof(int) );
       break;
    case VKI_FIONBIO:
-      PRE_MEM_READ( "ioctl(FIONBIO)",    arg3, sizeof(int) );
+      SYS_PRE_MEM_READ( "ioctl(FIONBIO)",    arg3, sizeof(int) );
       break;
    case VKI_FIOASYNC:
-      PRE_MEM_READ( "ioctl(FIOASYNC)",   arg3, sizeof(int) );
+      SYS_PRE_MEM_READ( "ioctl(FIOASYNC)",   arg3, sizeof(int) );
       break;
    case VKI_FIONREAD:                /* identical to SIOCINQ */
-      PRE_MEM_WRITE( "ioctl(FIONREAD)",  arg3, sizeof(int) );
+      SYS_PRE_MEM_WRITE( "ioctl(FIONREAD)",  arg3, sizeof(int) );
       break;
 
    case VKI_SG_SET_COMMAND_Q:
-      PRE_MEM_READ( "ioctl(SG_SET_COMMAND_Q)", arg3, sizeof(int) );
+      SYS_PRE_MEM_READ( "ioctl(SG_SET_COMMAND_Q)", arg3, sizeof(int) );
       break;
    case VKI_SG_IO:
-      PRE_MEM_WRITE( "ioctl(SG_IO)", arg3, sizeof(vki_sg_io_hdr_t) );
+      SYS_PRE_MEM_WRITE( "ioctl(SG_IO)", arg3, sizeof(vki_sg_io_hdr_t) );
       break;
    case VKI_SG_GET_SCSI_ID:
-      PRE_MEM_WRITE( "ioctl(SG_GET_SCSI_ID)", arg3, sizeof(vki_sg_scsi_id_t) );
+      SYS_PRE_MEM_WRITE( "ioctl(SG_GET_SCSI_ID)", arg3, sizeof(vki_sg_scsi_id_t) );
       break;
    case VKI_SG_SET_RESERVED_SIZE:
-      PRE_MEM_READ( "ioctl(SG_SET_RESERVED_SIZE)", arg3, sizeof(int) );
+      SYS_PRE_MEM_READ( "ioctl(SG_SET_RESERVED_SIZE)", arg3, sizeof(int) );
       break;
    case VKI_SG_SET_TIMEOUT:
-      PRE_MEM_READ( "ioctl(SG_SET_TIMEOUT)", arg3, sizeof(int) );
+      SYS_PRE_MEM_READ( "ioctl(SG_SET_TIMEOUT)", arg3, sizeof(int) );
       break;
    case VKI_SG_GET_RESERVED_SIZE:
-      PRE_MEM_WRITE( "ioctl(SG_GET_RESERVED_SIZE)", arg3, sizeof(int) );
+      SYS_PRE_MEM_WRITE( "ioctl(SG_GET_RESERVED_SIZE)", arg3, sizeof(int) );
       break;
    case VKI_SG_GET_TIMEOUT:
-      PRE_MEM_WRITE( "ioctl(SG_GET_TIMEOUT)", arg3, sizeof(int) );
+      SYS_PRE_MEM_WRITE( "ioctl(SG_GET_TIMEOUT)", arg3, sizeof(int) );
       break;
    case VKI_SG_GET_VERSION_NUM:
-      PRE_MEM_READ(  "ioctl(SG_GET_VERSION_NUM)",  arg3, sizeof(int) );
+      SYS_PRE_MEM_READ(  "ioctl(SG_GET_VERSION_NUM)",  arg3, sizeof(int) );
       break;
    case VKI_SG_EMULATED_HOST: /* 0x2203 */
-      PRE_MEM_WRITE( "ioctl(SG_EMULATED_HOST)",    arg3, sizeof(int) );
+      SYS_PRE_MEM_WRITE( "ioctl(SG_EMULATED_HOST)",    arg3, sizeof(int) );
       break;
    case VKI_SG_GET_SG_TABLESIZE: /* 0x227f */
-      PRE_MEM_WRITE( "ioctl(SG_GET_SG_TABLESIZE)", arg3, sizeof(int) );
+      SYS_PRE_MEM_WRITE( "ioctl(SG_GET_SG_TABLESIZE)", arg3, sizeof(int) );
       break;
 
    case VKI_IIOCGETCPS:
-      PRE_MEM_WRITE( "ioctl(IIOCGETCPS)", arg3,
+      SYS_PRE_MEM_WRITE( "ioctl(IIOCGETCPS)", arg3,
 		     VKI_ISDN_MAX_CHANNELS * 2 * sizeof(unsigned long) );
       break;
    case VKI_IIOCNETGPN:
-      PRE_MEM_READ( "ioctl(IIOCNETGPN)",
+      SYS_PRE_MEM_READ( "ioctl(IIOCNETGPN)",
 		     (Addr)&((vki_isdn_net_ioctl_phone *)arg3)->name,
 		     sizeof(((vki_isdn_net_ioctl_phone *)arg3)->name) );
-      PRE_MEM_WRITE( "ioctl(IIOCNETGPN)", arg3,
+      SYS_PRE_MEM_WRITE( "ioctl(IIOCNETGPN)", arg3,
 		     sizeof(vki_isdn_net_ioctl_phone) );
       break;
 
       /* These all use struct ifreq AFAIK */
    case VKI_SIOCGIFINDEX:        /* get iface index              */
-      PRE_MEM_RASCIIZ( "ioctl(SIOCGIFINDEX)",
+      SYS_PRE_MEM_RASCIIZ( "ioctl(SIOCGIFINDEX)",
                      (Addr)((struct vki_ifreq *)arg3)->vki_ifr_name );
-      PRE_MEM_WRITE( "ioctl(SIOCGIFINDEX)", arg3, sizeof(struct vki_ifreq));
+      SYS_PRE_MEM_WRITE( "ioctl(SIOCGIFINDEX)", arg3, sizeof(struct vki_ifreq));
       break;
    case VKI_SIOCGIFFLAGS:        /* get flags                    */
-      PRE_MEM_RASCIIZ( "ioctl(SIOCGIFFLAGS)",
+      SYS_PRE_MEM_RASCIIZ( "ioctl(SIOCGIFFLAGS)",
                      (Addr)((struct vki_ifreq *)arg3)->vki_ifr_name );
-      PRE_MEM_WRITE( "ioctl(SIOCGIFFLAGS)", arg3, sizeof(struct vki_ifreq));
+      SYS_PRE_MEM_WRITE( "ioctl(SIOCGIFFLAGS)", arg3, sizeof(struct vki_ifreq));
       break;
    case VKI_SIOCGIFHWADDR:       /* Get hardware address         */
-      PRE_MEM_RASCIIZ( "ioctl(SIOCGIFHWADDR)",
+      SYS_PRE_MEM_RASCIIZ( "ioctl(SIOCGIFHWADDR)",
                      (Addr)((struct vki_ifreq *)arg3)->vki_ifr_name );
-      PRE_MEM_WRITE( "ioctl(SIOCGIFHWADDR)", arg3, sizeof(struct vki_ifreq));
+      SYS_PRE_MEM_WRITE( "ioctl(SIOCGIFHWADDR)", arg3, sizeof(struct vki_ifreq));
       break;
    case VKI_SIOCGIFMTU:          /* get MTU size                 */
-      PRE_MEM_RASCIIZ( "ioctl(SIOCGIFMTU)",
+      SYS_PRE_MEM_RASCIIZ( "ioctl(SIOCGIFMTU)",
                      (Addr)((struct vki_ifreq *)arg3)->vki_ifr_name );
-      PRE_MEM_WRITE( "ioctl(SIOCGIFMTU)", arg3, sizeof(struct vki_ifreq));
+      SYS_PRE_MEM_WRITE( "ioctl(SIOCGIFMTU)", arg3, sizeof(struct vki_ifreq));
       break;
    case VKI_SIOCGIFADDR:         /* get PA address               */
-      PRE_MEM_RASCIIZ( "ioctl(SIOCGIFADDR)",
+      SYS_PRE_MEM_RASCIIZ( "ioctl(SIOCGIFADDR)",
                      (Addr)((struct vki_ifreq *)arg3)->vki_ifr_name );
-      PRE_MEM_WRITE( "ioctl(SIOCGIFADDR)", arg3, sizeof(struct vki_ifreq));
+      SYS_PRE_MEM_WRITE( "ioctl(SIOCGIFADDR)", arg3, sizeof(struct vki_ifreq));
       break;
    case VKI_SIOCGIFNETMASK:      /* get network PA mask          */
-      PRE_MEM_RASCIIZ( "ioctl(SIOCGIFNETMASK)",
+      SYS_PRE_MEM_RASCIIZ( "ioctl(SIOCGIFNETMASK)",
                      (Addr)((struct vki_ifreq *)arg3)->vki_ifr_name );
-      PRE_MEM_WRITE( "ioctl(SIOCGIFNETMASK)", arg3, sizeof(struct vki_ifreq));
+      SYS_PRE_MEM_WRITE( "ioctl(SIOCGIFNETMASK)", arg3, sizeof(struct vki_ifreq));
       break;
    case VKI_SIOCGIFMETRIC:       /* get metric                   */
-      PRE_MEM_RASCIIZ( "ioctl(SIOCGIFMETRIC)",
+      SYS_PRE_MEM_RASCIIZ( "ioctl(SIOCGIFMETRIC)",
                      (Addr)((struct vki_ifreq *)arg3)->vki_ifr_name );
-      PRE_MEM_WRITE( "ioctl(SIOCGIFMETRIC)", arg3, sizeof(struct vki_ifreq));
+      SYS_PRE_MEM_WRITE( "ioctl(SIOCGIFMETRIC)", arg3, sizeof(struct vki_ifreq));
       break;
    case VKI_SIOCGIFMAP:          /* Get device parameters        */
-      PRE_MEM_RASCIIZ( "ioctl(SIOCGIFMAP)",
+      SYS_PRE_MEM_RASCIIZ( "ioctl(SIOCGIFMAP)",
                      (Addr)((struct vki_ifreq *)arg3)->vki_ifr_name );
-      PRE_MEM_WRITE( "ioctl(SIOCGIFMAP)", arg3, sizeof(struct vki_ifreq));
+      SYS_PRE_MEM_WRITE( "ioctl(SIOCGIFMAP)", arg3, sizeof(struct vki_ifreq));
       break;
    case VKI_SIOCGIFTXQLEN:       /* Get the tx queue length      */
-      PRE_MEM_RASCIIZ( "ioctl(SIOCGIFTXQLEN)",
+      SYS_PRE_MEM_RASCIIZ( "ioctl(SIOCGIFTXQLEN)",
                      (Addr)((struct vki_ifreq *)arg3)->vki_ifr_name );
-      PRE_MEM_WRITE( "ioctl(SIOCGIFTXQLEN)", arg3, sizeof(struct vki_ifreq));
+      SYS_PRE_MEM_WRITE( "ioctl(SIOCGIFTXQLEN)", arg3, sizeof(struct vki_ifreq));
       break;
    case VKI_SIOCGIFDSTADDR:      /* get remote PA address        */
-      PRE_MEM_RASCIIZ( "ioctl(SIOCGIFDSTADDR)",
+      SYS_PRE_MEM_RASCIIZ( "ioctl(SIOCGIFDSTADDR)",
                      (Addr)((struct vki_ifreq *)arg3)->vki_ifr_name );
-      PRE_MEM_WRITE( "ioctl(SIOCGIFDSTADDR)", arg3, sizeof(struct vki_ifreq));
+      SYS_PRE_MEM_WRITE( "ioctl(SIOCGIFDSTADDR)", arg3, sizeof(struct vki_ifreq));
       break;
    case VKI_SIOCGIFBRDADDR:      /* get broadcast PA address     */
-      PRE_MEM_RASCIIZ( "ioctl(SIOCGIFBRDADDR)",
+      SYS_PRE_MEM_RASCIIZ( "ioctl(SIOCGIFBRDADDR)",
                      (Addr)((struct vki_ifreq *)arg3)->vki_ifr_name );
-      PRE_MEM_WRITE( "ioctl(SIOCGIFBRDADDR)", arg3, sizeof(struct vki_ifreq));
+      SYS_PRE_MEM_WRITE( "ioctl(SIOCGIFBRDADDR)", arg3, sizeof(struct vki_ifreq));
       break;
    case VKI_SIOCGIFNAME:         /* get iface name               */
-      PRE_MEM_READ( "ioctl(SIOCGIFNAME)",
+      SYS_PRE_MEM_READ( "ioctl(SIOCGIFNAME)",
                      (Addr)((struct vki_ifreq *)arg3)->vki_ifr_ifindex,
                      sizeof(((struct vki_ifreq *)arg3)->vki_ifr_ifindex) );
-      PRE_MEM_WRITE( "ioctl(SIOCGIFNAME)", arg3, sizeof(struct vki_ifreq));
+      SYS_PRE_MEM_WRITE( "ioctl(SIOCGIFNAME)", arg3, sizeof(struct vki_ifreq));
       break;
    case VKI_SIOCGMIIPHY:         /* get hardware entry           */
-      PRE_MEM_RASCIIZ( "ioctl(SIOCGIFMIIPHY)",
+      SYS_PRE_MEM_RASCIIZ( "ioctl(SIOCGIFMIIPHY)",
                      (Addr)((struct vki_ifreq *)arg3)->vki_ifr_name );
-      PRE_MEM_WRITE( "ioctl(SIOCGIFMIIPHY)", arg3, sizeof(struct vki_ifreq));
+      SYS_PRE_MEM_WRITE( "ioctl(SIOCGIFMIIPHY)", arg3, sizeof(struct vki_ifreq));
       break;
    case VKI_SIOCGMIIREG:         /* get hardware entry registers */
-      PRE_MEM_RASCIIZ( "ioctl(SIOCGIFMIIREG)",
+      SYS_PRE_MEM_RASCIIZ( "ioctl(SIOCGIFMIIREG)",
                      (Addr)((struct vki_ifreq *)arg3)->vki_ifr_name );
-      PRE_MEM_READ( "ioctl(SIOCGIFMIIREG)",
+      SYS_PRE_MEM_READ( "ioctl(SIOCGIFMIIREG)",
                      (Addr)&((struct vki_mii_ioctl_data *)&((struct vki_ifreq *)arg3)->vki_ifr_data)->phy_id,
                      sizeof(((struct vki_mii_ioctl_data *)&((struct vki_ifreq *)arg3)->vki_ifr_data)->phy_id) );
-      PRE_MEM_READ( "ioctl(SIOCGIFMIIREG)",
+      SYS_PRE_MEM_READ( "ioctl(SIOCGIFMIIREG)",
                      (Addr)&((struct vki_mii_ioctl_data *)&((struct vki_ifreq *)arg3)->vki_ifr_data)->reg_num,
                      sizeof(((struct vki_mii_ioctl_data *)&((struct vki_ifreq *)arg3)->vki_ifr_data)->reg_num) );
-      PRE_MEM_WRITE( "ioctl(SIOCGIFMIIREG)", arg3, 
+      SYS_PRE_MEM_WRITE( "ioctl(SIOCGIFMIIREG)", arg3, 
 		     sizeof(struct vki_ifreq));
       break;
    case VKI_SIOCGIFCONF:         /* get iface list               */
       /* WAS:
-	 PRE_MEM_WRITE( "ioctl(SIOCGIFCONF)", arg3, sizeof(struct ifconf));
+	 SYS_PRE_MEM_WRITE( "ioctl(SIOCGIFCONF)", arg3, sizeof(struct ifconf));
 	 KERNEL_DO_SYSCALL(tid,SYSRES);
 	 if (!VG_(is_kerror)(SYSRES) && SYSRES == 0)
 	 VG_TRACK( post_mem_write,arg3, sizeof(struct ifconf));
       */
-      PRE_MEM_READ( "ioctl(SIOCGIFCONF)", arg3, sizeof(struct vki_ifconf));
+      SYS_PRE_MEM_READ( "ioctl(SIOCGIFCONF)", arg3, sizeof(struct vki_ifconf));
       if ( arg3 ) {
 	 // TODO len must be readable and writable
 	 // buf pointer only needs to be readable
 	 struct vki_ifconf *ifc = (struct vki_ifconf *) arg3;
-	 PRE_MEM_WRITE( "ioctl(SIOCGIFCONF).ifc_buf",
+	 SYS_PRE_MEM_WRITE( "ioctl(SIOCGIFCONF).ifc_buf",
 			(Addr)(ifc->vki_ifc_buf), ifc->ifc_len );
       }
       break;
    case VKI_SIOCGSTAMP:
-      PRE_MEM_WRITE( "ioctl(SIOCGSTAMP)", arg3, sizeof(struct vki_timeval));
+      SYS_PRE_MEM_WRITE( "ioctl(SIOCGSTAMP)", arg3, sizeof(struct vki_timeval));
       break;
       /* SIOCOUTQ is an ioctl that, when called on a socket, returns
 	 the number of bytes currently in that socket's send buffer.
 	 It writes this value as an int to the memory location
 	 indicated by the third argument of ioctl(2). */
    case VKI_SIOCOUTQ:
-      PRE_MEM_WRITE( "ioctl(SIOCOUTQ)", arg3, sizeof(int));
+      SYS_PRE_MEM_WRITE( "ioctl(SIOCOUTQ)", arg3, sizeof(int));
       break;
    case VKI_SIOCGRARP:           /* get RARP table entry         */
    case VKI_SIOCGARP:            /* get ARP table entry          */
-      PRE_MEM_WRITE( "ioctl(SIOCGARP)", arg3, sizeof(struct vki_arpreq));
+      SYS_PRE_MEM_WRITE( "ioctl(SIOCGARP)", arg3, sizeof(struct vki_arpreq));
       break;
                     
    case VKI_SIOCSIFFLAGS:        /* set flags                    */
-      PRE_MEM_RASCIIZ( "ioctl(SIOCSIFFLAGS)",
+      SYS_PRE_MEM_RASCIIZ( "ioctl(SIOCSIFFLAGS)",
                      (Addr)((struct vki_ifreq *)arg3)->vki_ifr_name );
-      PRE_MEM_READ( "ioctl(SIOCSIFFLAGS)",
+      SYS_PRE_MEM_READ( "ioctl(SIOCSIFFLAGS)",
                      (Addr)&((struct vki_ifreq *)arg3)->vki_ifr_flags,
                      sizeof(((struct vki_ifreq *)arg3)->vki_ifr_flags) );
       break;
    case VKI_SIOCSIFMAP:          /* Set device parameters        */
-      PRE_MEM_RASCIIZ( "ioctl(SIOCSIFMAP)",
+      SYS_PRE_MEM_RASCIIZ( "ioctl(SIOCSIFMAP)",
                      (Addr)((struct vki_ifreq *)arg3)->vki_ifr_name );
-      PRE_MEM_READ( "ioctl(SIOCSIFMAP)",
+      SYS_PRE_MEM_READ( "ioctl(SIOCSIFMAP)",
                      (Addr)&((struct vki_ifreq *)arg3)->ifr_map,
                      sizeof(((struct vki_ifreq *)arg3)->ifr_map) );
       break;
    case VKI_SIOCSIFTXQLEN:       /* Set the tx queue length      */
-      PRE_MEM_RASCIIZ( "ioctl(SIOCSIFTXQLEN)",
+      SYS_PRE_MEM_RASCIIZ( "ioctl(SIOCSIFTXQLEN)",
                      (Addr)((struct vki_ifreq *)arg3)->vki_ifr_name );
-      PRE_MEM_READ( "ioctl(SIOCSIFTXQLEN)",
+      SYS_PRE_MEM_READ( "ioctl(SIOCSIFTXQLEN)",
                      (Addr)&((struct vki_ifreq *)arg3)->ifr_qlen,
                      sizeof(((struct vki_ifreq *)arg3)->ifr_qlen) );
       break;
@@ -3048,50 +3067,50 @@ PRE(sys_ioctl, MayBlock)
    case VKI_SIOCSIFDSTADDR:      /* set remote PA address        */
    case VKI_SIOCSIFBRDADDR:      /* set broadcast PA address     */
    case VKI_SIOCSIFNETMASK:      /* set network PA mask          */
-      PRE_MEM_RASCIIZ( "ioctl(SIOCSIF*ADDR)",
+      SYS_PRE_MEM_RASCIIZ( "ioctl(SIOCSIF*ADDR)",
                      (Addr)((struct vki_ifreq *)arg3)->vki_ifr_name );
-      PRE_MEM_READ( "ioctl(SIOCSIF*ADDR)",
+      SYS_PRE_MEM_READ( "ioctl(SIOCSIF*ADDR)",
                      (Addr)&((struct vki_ifreq *)arg3)->ifr_addr,
                      sizeof(((struct vki_ifreq *)arg3)->ifr_addr) );
       break;
    case VKI_SIOCSIFMETRIC:       /* set metric                   */
-      PRE_MEM_RASCIIZ( "ioctl(SIOCSIFMETRIC)",
+      SYS_PRE_MEM_RASCIIZ( "ioctl(SIOCSIFMETRIC)",
                      (Addr)((struct vki_ifreq *)arg3)->vki_ifr_name );
-      PRE_MEM_READ( "ioctl(SIOCSIFMETRIC)",
+      SYS_PRE_MEM_READ( "ioctl(SIOCSIFMETRIC)",
                      (Addr)&((struct vki_ifreq *)arg3)->vki_ifr_metric,
                      sizeof(((struct vki_ifreq *)arg3)->vki_ifr_metric) );
       break;
    case VKI_SIOCSIFMTU:          /* set MTU size                 */
-      PRE_MEM_RASCIIZ( "ioctl(SIOCSIFMTU)",
+      SYS_PRE_MEM_RASCIIZ( "ioctl(SIOCSIFMTU)",
                      (Addr)((struct vki_ifreq *)arg3)->vki_ifr_name );
-      PRE_MEM_READ( "ioctl(SIOCSIFMTU)",
+      SYS_PRE_MEM_READ( "ioctl(SIOCSIFMTU)",
                      (Addr)&((struct vki_ifreq *)arg3)->vki_ifr_mtu,
                      sizeof(((struct vki_ifreq *)arg3)->vki_ifr_mtu) );
       break;
    case VKI_SIOCSIFHWADDR:       /* set hardware address         */
-      PRE_MEM_RASCIIZ( "ioctl(SIOCSIFHWADDR)",
+      SYS_PRE_MEM_RASCIIZ( "ioctl(SIOCSIFHWADDR)",
                      (Addr)((struct vki_ifreq *)arg3)->vki_ifr_name );
-      PRE_MEM_READ( "ioctl(SIOCSIFHWADDR)",
+      SYS_PRE_MEM_READ( "ioctl(SIOCSIFHWADDR)",
                      (Addr)&((struct vki_ifreq *)arg3)->ifr_hwaddr,
                      sizeof(((struct vki_ifreq *)arg3)->ifr_hwaddr) );
       break;
    case VKI_SIOCSMIIREG:         /* set hardware entry registers */
-      PRE_MEM_RASCIIZ( "ioctl(SIOCSMIIREG)",
+      SYS_PRE_MEM_RASCIIZ( "ioctl(SIOCSMIIREG)",
                      (Addr)((struct vki_ifreq *)arg3)->vki_ifr_name );
-      PRE_MEM_READ( "ioctl(SIOCSMIIREG)",
+      SYS_PRE_MEM_READ( "ioctl(SIOCSMIIREG)",
                      (Addr)&((struct vki_mii_ioctl_data *)&((struct vki_ifreq *)arg3)->vki_ifr_data)->phy_id,
                      sizeof(((struct vki_mii_ioctl_data *)&((struct vki_ifreq *)arg3)->vki_ifr_data)->phy_id) );
-      PRE_MEM_READ( "ioctl(SIOCSMIIREG)",
+      SYS_PRE_MEM_READ( "ioctl(SIOCSMIIREG)",
                      (Addr)&((struct vki_mii_ioctl_data *)&((struct vki_ifreq *)arg3)->vki_ifr_data)->reg_num,
                      sizeof(((struct vki_mii_ioctl_data *)&((struct vki_ifreq *)arg3)->vki_ifr_data)->reg_num) );
-      PRE_MEM_READ( "ioctl(SIOCSMIIREG)",
+      SYS_PRE_MEM_READ( "ioctl(SIOCSMIIREG)",
                      (Addr)&((struct vki_mii_ioctl_data *)&((struct vki_ifreq *)arg3)->vki_ifr_data)->val_in,
                      sizeof(((struct vki_mii_ioctl_data *)&((struct vki_ifreq *)arg3)->vki_ifr_data)->val_in) );
       break;
       /* Routing table calls.  */
    case VKI_SIOCADDRT:           /* add routing table entry      */
    case VKI_SIOCDELRT:           /* delete routing table entry   */
-      PRE_MEM_READ( "ioctl(SIOCADDRT/DELRT)", arg3, 
+      SYS_PRE_MEM_READ( "ioctl(SIOCADDRT/DELRT)", arg3, 
 		    sizeof(struct vki_rtentry));
       break;
 
@@ -3101,14 +3120,14 @@ PRE(sys_ioctl, MayBlock)
       /* ARP cache control calls. */
    case VKI_SIOCSARP:            /* set ARP table entry          */
    case VKI_SIOCDARP:            /* delete ARP table entry       */
-      PRE_MEM_READ( "ioctl(SIOCSIFFLAGS)", arg3, sizeof(struct vki_ifreq));
+      SYS_PRE_MEM_READ( "ioctl(SIOCSIFFLAGS)", arg3, sizeof(struct vki_ifreq));
       break;
 
    case VKI_SIOCGPGRP:
-      PRE_MEM_WRITE( "ioctl(SIOCGPGRP)", arg3, sizeof(int) );
+      SYS_PRE_MEM_WRITE( "ioctl(SIOCGPGRP)", arg3, sizeof(int) );
       break;
    case VKI_SIOCSPGRP:
-      PRE_MEM_READ( "ioctl(SIOCSPGRP)", arg3, sizeof(int) );
+      SYS_PRE_MEM_READ( "ioctl(SIOCSPGRP)", arg3, sizeof(int) );
       *flags &= ~MayBlock;
       break;
 
@@ -3131,7 +3150,7 @@ PRE(sys_ioctl, MayBlock)
    case VKI_SOUND_PCM_READ_BITS:
    case (VKI_SOUND_PCM_READ_BITS|0x40000000): /* what the fuck ? */
    case VKI_SOUND_PCM_READ_FILTER:
-      PRE_MEM_WRITE( "ioctl(SNDCTL_XXX|SOUND_XXX (SIOR, int))", 
+      SYS_PRE_MEM_WRITE( "ioctl(SNDCTL_XXX|SOUND_XXX (SIOR, int))", 
 		     arg3, sizeof(int));
       break;
    case VKI_SNDCTL_SEQ_CTRLRATE:
@@ -3149,18 +3168,18 @@ PRE(sys_ioctl, MayBlock)
    case VKI_SNDCTL_TMR_SOURCE:
    case VKI_SNDCTL_MIDI_PRETIME:
    case VKI_SNDCTL_MIDI_MPUMODE:
-      PRE_MEM_READ( "ioctl(SNDCTL_XXX|SOUND_XXX (SIOWR, int))", 
+      SYS_PRE_MEM_READ( "ioctl(SNDCTL_XXX|SOUND_XXX (SIOWR, int))", 
 		     arg3, sizeof(int));
-      PRE_MEM_WRITE( "ioctl(SNDCTL_XXX|SOUND_XXX (SIOWR, int))", 
+      SYS_PRE_MEM_WRITE( "ioctl(SNDCTL_XXX|SOUND_XXX (SIOWR, int))", 
 		     arg3, sizeof(int));
       break;
    case VKI_SNDCTL_DSP_GETOSPACE:
    case VKI_SNDCTL_DSP_GETISPACE:
-      PRE_MEM_WRITE( "ioctl(SNDCTL_XXX|SOUND_XXX (SIOR, audio_buf_info))",
+      SYS_PRE_MEM_WRITE( "ioctl(SNDCTL_XXX|SOUND_XXX (SIOR, audio_buf_info))",
                      arg3, sizeof(vki_audio_buf_info));
       break;
    case VKI_SNDCTL_DSP_SETTRIGGER:
-      PRE_MEM_READ( "ioctl(SNDCTL_XXX|SOUND_XXX (SIOW, int))", 
+      SYS_PRE_MEM_READ( "ioctl(SNDCTL_XXX|SOUND_XXX (SIOW, int))", 
 		     arg3, sizeof(int));
       break;
 
@@ -3182,79 +3201,79 @@ PRE(sys_ioctl, MayBlock)
       break;
    case VKI_RTC_RD_TIME:
    case VKI_RTC_ALM_READ:
-      PRE_MEM_WRITE( "ioctl(RTC_RD_TIME/ALM_READ)", 
+      SYS_PRE_MEM_WRITE( "ioctl(RTC_RD_TIME/ALM_READ)", 
 		     arg3, sizeof(struct vki_rtc_time));
       break;
    case VKI_RTC_ALM_SET:
-      PRE_MEM_READ( "ioctl(RTC_ALM_SET)", arg3, sizeof(struct vki_rtc_time));
+      SYS_PRE_MEM_READ( "ioctl(RTC_ALM_SET)", arg3, sizeof(struct vki_rtc_time));
       break;
    case VKI_RTC_IRQP_READ:
-      PRE_MEM_WRITE( "ioctl(RTC_IRQP_READ)", arg3, sizeof(unsigned long));
+      SYS_PRE_MEM_WRITE( "ioctl(RTC_IRQP_READ)", arg3, sizeof(unsigned long));
       break;
 
    case VKI_BLKGETSIZE:
-      PRE_MEM_WRITE( "ioctl(BLKGETSIZE)", arg3, sizeof(unsigned long));
+      SYS_PRE_MEM_WRITE( "ioctl(BLKGETSIZE)", arg3, sizeof(unsigned long));
       break;
 
       /* Hard disks */
    case VKI_HDIO_GET_IDENTITY: /* 0x030d */
-      PRE_MEM_WRITE( "ioctl(HDIO_GET_IDENTITY)", arg3,
+      SYS_PRE_MEM_WRITE( "ioctl(HDIO_GET_IDENTITY)", arg3,
                      VKI_SIZEOF_STRUCT_HD_DRIVEID );
       break;
 
       /* CD ROM stuff (??)  */
    case VKI_CDROM_GET_MCN:
-      PRE_MEM_READ( "ioctl(CDROM_GET_MCN)", arg3,
+      SYS_PRE_MEM_READ( "ioctl(CDROM_GET_MCN)", arg3,
                     sizeof(struct vki_cdrom_mcn) );
       break;
    case VKI_CDROM_SEND_PACKET:
-      PRE_MEM_READ( "ioctl(CDROM_SEND_PACKET)", arg3,
+      SYS_PRE_MEM_READ( "ioctl(CDROM_SEND_PACKET)", arg3,
                     sizeof(struct vki_cdrom_generic_command));
       break;
    case VKI_CDROMSUBCHNL:
-      PRE_MEM_READ( "ioctl(CDROMSUBCHNL (cdsc_format, char))",
+      SYS_PRE_MEM_READ( "ioctl(CDROMSUBCHNL (cdsc_format, char))",
 		    (Addr) &(((struct vki_cdrom_subchnl*) arg3)->cdsc_format),
 		    sizeof(((struct vki_cdrom_subchnl*) arg3)->cdsc_format));
-      PRE_MEM_WRITE( "ioctl(CDROMSUBCHNL)", arg3, 
+      SYS_PRE_MEM_WRITE( "ioctl(CDROMSUBCHNL)", arg3, 
 		     sizeof(struct vki_cdrom_subchnl));
       break;
    case VKI_CDROMREADMODE2:
-      PRE_MEM_READ( "ioctl(CDROMREADMODE2)", arg3, VKI_CD_FRAMESIZE_RAW0 );
+      SYS_PRE_MEM_READ( "ioctl(CDROMREADMODE2)", arg3, VKI_CD_FRAMESIZE_RAW0 );
       break;
    case VKI_CDROMREADTOCHDR:
-      PRE_MEM_WRITE( "ioctl(CDROMREADTOCHDR)", arg3, 
+      SYS_PRE_MEM_WRITE( "ioctl(CDROMREADTOCHDR)", arg3, 
 		     sizeof(struct vki_cdrom_tochdr));
       break;
    case VKI_CDROMREADTOCENTRY:
-      PRE_MEM_READ( "ioctl(CDROMREADTOCENTRY (cdte_format, char))",
+      SYS_PRE_MEM_READ( "ioctl(CDROMREADTOCENTRY (cdte_format, char))",
 		    (Addr) &(((struct vki_cdrom_tocentry*) arg3)->cdte_format),
 		    sizeof(((struct vki_cdrom_tocentry*) arg3)->cdte_format));
-      PRE_MEM_READ( "ioctl(CDROMREADTOCENTRY (cdte_track, char))",
+      SYS_PRE_MEM_READ( "ioctl(CDROMREADTOCENTRY (cdte_track, char))",
 		    (Addr) &(((struct vki_cdrom_tocentry*) arg3)->cdte_track), 
 		    sizeof(((struct vki_cdrom_tocentry*) arg3)->cdte_track));
-      PRE_MEM_WRITE( "ioctl(CDROMREADTOCENTRY)", arg3, 
+      SYS_PRE_MEM_WRITE( "ioctl(CDROMREADTOCENTRY)", arg3, 
 		     sizeof(struct vki_cdrom_tocentry));
       break;
    case VKI_CDROMMULTISESSION: /* 0x5310 */
-      PRE_MEM_WRITE( "ioctl(CDROMMULTISESSION)", arg3,
+      SYS_PRE_MEM_WRITE( "ioctl(CDROMMULTISESSION)", arg3,
 		     sizeof(struct vki_cdrom_multisession));
       break;
    case VKI_CDROMVOLREAD: /* 0x5313 */
-      PRE_MEM_WRITE( "ioctl(CDROMVOLREAD)", arg3,
+      SYS_PRE_MEM_WRITE( "ioctl(CDROMVOLREAD)", arg3,
 		     sizeof(struct vki_cdrom_volctrl));
       break;
    case VKI_CDROMREADAUDIO: /* 0x530e */
-      PRE_MEM_READ( "ioctl(CDROMREADAUDIO)", arg3,
+      SYS_PRE_MEM_READ( "ioctl(CDROMREADAUDIO)", arg3,
 		     sizeof (struct vki_cdrom_read_audio));
       if ( arg3 ) {
          /* ToDo: don't do any of the following if the structure is invalid */
          struct vki_cdrom_read_audio *cra = (struct vki_cdrom_read_audio *) arg3;
-	 PRE_MEM_WRITE( "ioctl(CDROMREADAUDIO).buf",
+	 SYS_PRE_MEM_WRITE( "ioctl(CDROMREADAUDIO).buf",
 	                (Addr)(cra->buf), cra->nframes * VKI_CD_FRAMESIZE_RAW);
       }
       break;      
    case VKI_CDROMPLAYMSF:
-      PRE_MEM_READ( "ioctl(CDROMPLAYMSF)", arg3, sizeof(struct vki_cdrom_msf));
+      SYS_PRE_MEM_READ( "ioctl(CDROMPLAYMSF)", arg3, sizeof(struct vki_cdrom_msf));
       break;
       /* The following two are probably bogus (should check args
 	 for readability).  JRS 20021117 */
@@ -3263,18 +3282,18 @@ PRE(sys_ioctl, MayBlock)
       break;
 
    case VKI_FIGETBSZ:
-      PRE_MEM_WRITE( "ioctl(FIGETBSZ)", arg3, sizeof(unsigned long));
+      SYS_PRE_MEM_WRITE( "ioctl(FIGETBSZ)", arg3, sizeof(unsigned long));
       break;
    case VKI_FIBMAP:
-      PRE_MEM_READ( "ioctl(FIBMAP)", arg3, sizeof(unsigned long));
+      SYS_PRE_MEM_READ( "ioctl(FIBMAP)", arg3, sizeof(unsigned long));
       break;
 
    case VKI_FBIOGET_VSCREENINFO: /* 0x4600 */
-      PRE_MEM_WRITE( "ioctl(FBIOGET_VSCREENINFO)", arg3,
+      SYS_PRE_MEM_WRITE( "ioctl(FBIOGET_VSCREENINFO)", arg3,
                      sizeof(struct vki_fb_var_screeninfo));
       break;
    case VKI_FBIOGET_FSCREENINFO: /* 0x4602 */
-      PRE_MEM_WRITE( "ioctl(FBIOGET_FSCREENINFO)", arg3,
+      SYS_PRE_MEM_WRITE( "ioctl(FBIOGET_FSCREENINFO)", arg3,
                      sizeof(struct vki_fb_fix_screeninfo));
       break;
 
@@ -3284,85 +3303,85 @@ PRE(sys_ioctl, MayBlock)
    case VKI_PPRELEASE:
       break;
    case VKI_PPSETMODE:
-      PRE_MEM_READ( "ioctl(PPSETMODE)",   arg3, sizeof(int) );
+      SYS_PRE_MEM_READ( "ioctl(PPSETMODE)",   arg3, sizeof(int) );
       break;
    case VKI_PPGETMODE:
-      PRE_MEM_WRITE( "ioctl(PPGETMODE)",  arg3, sizeof(int) );
+      SYS_PRE_MEM_WRITE( "ioctl(PPGETMODE)",  arg3, sizeof(int) );
       break;
    case VKI_PPSETPHASE:
-      PRE_MEM_READ(  "ioctl(PPSETPHASE)", arg3, sizeof(int) );
+      SYS_PRE_MEM_READ(  "ioctl(PPSETPHASE)", arg3, sizeof(int) );
       break;
    case VKI_PPGETPHASE:
-      PRE_MEM_WRITE( "ioctl(PPGETPHASE)", arg3, sizeof(int) );
+      SYS_PRE_MEM_WRITE( "ioctl(PPGETPHASE)", arg3, sizeof(int) );
       break;
    case VKI_PPGETMODES:
-      PRE_MEM_WRITE( "ioctl(PPGETMODES)", arg3, sizeof(unsigned int) );
+      SYS_PRE_MEM_WRITE( "ioctl(PPGETMODES)", arg3, sizeof(unsigned int) );
       break;
    case VKI_PPSETFLAGS:
-      PRE_MEM_READ(  "ioctl(PPSETFLAGS)", arg3, sizeof(int) );
+      SYS_PRE_MEM_READ(  "ioctl(PPSETFLAGS)", arg3, sizeof(int) );
       break;
    case VKI_PPGETFLAGS:
-      PRE_MEM_WRITE( "ioctl(PPGETFLAGS)", arg3, sizeof(int) );
+      SYS_PRE_MEM_WRITE( "ioctl(PPGETFLAGS)", arg3, sizeof(int) );
       break;
    case VKI_PPRSTATUS:
-      PRE_MEM_WRITE( "ioctl(PPRSTATUS)",  arg3, sizeof(unsigned char) );
+      SYS_PRE_MEM_WRITE( "ioctl(PPRSTATUS)",  arg3, sizeof(unsigned char) );
       break;
    case VKI_PPRDATA:
-      PRE_MEM_WRITE( "ioctl(PPRDATA)",    arg3, sizeof(unsigned char) );
+      SYS_PRE_MEM_WRITE( "ioctl(PPRDATA)",    arg3, sizeof(unsigned char) );
       break;
    case VKI_PPRCONTROL:
-      PRE_MEM_WRITE( "ioctl(PPRCONTROL)", arg3, sizeof(unsigned char) );
+      SYS_PRE_MEM_WRITE( "ioctl(PPRCONTROL)", arg3, sizeof(unsigned char) );
       break;
    case VKI_PPWDATA:
-      PRE_MEM_READ(  "ioctl(PPWDATA)",    arg3, sizeof(unsigned char) );
+      SYS_PRE_MEM_READ(  "ioctl(PPWDATA)",    arg3, sizeof(unsigned char) );
       break;
    case VKI_PPWCONTROL:
-      PRE_MEM_READ(  "ioctl(PPWCONTROL)", arg3, sizeof(unsigned char) );
+      SYS_PRE_MEM_READ(  "ioctl(PPWCONTROL)", arg3, sizeof(unsigned char) );
       break;
    case VKI_PPFCONTROL:
-      PRE_MEM_READ(  "ioctl(PPFCONTROL)", arg3, 2 * sizeof(unsigned char) );
+      SYS_PRE_MEM_READ(  "ioctl(PPFCONTROL)", arg3, 2 * sizeof(unsigned char) );
       break;
    case VKI_PPDATADIR:
-      PRE_MEM_READ(  "ioctl(PPDATADIR)",  arg3, sizeof(int) );
+      SYS_PRE_MEM_READ(  "ioctl(PPDATADIR)",  arg3, sizeof(int) );
       break;
    case VKI_PPNEGOT:
-      PRE_MEM_READ(  "ioctl(PPNEGOT)",    arg3, sizeof(int) );
+      SYS_PRE_MEM_READ(  "ioctl(PPNEGOT)",    arg3, sizeof(int) );
       break;
    case VKI_PPWCTLONIRQ:
-      PRE_MEM_READ(  "ioctl(PPWCTLONIRQ)",arg3, sizeof(unsigned char) );
+      SYS_PRE_MEM_READ(  "ioctl(PPWCTLONIRQ)",arg3, sizeof(unsigned char) );
       break;
    case VKI_PPCLRIRQ:
-      PRE_MEM_WRITE( "ioctl(PPCLRIRQ)",   arg3, sizeof(int) );
+      SYS_PRE_MEM_WRITE( "ioctl(PPCLRIRQ)",   arg3, sizeof(int) );
       break;
    case VKI_PPSETTIME:
-      PRE_MEM_READ(  "ioctl(PPSETTIME)",  arg3, sizeof(struct vki_timeval) );
+      SYS_PRE_MEM_READ(  "ioctl(PPSETTIME)",  arg3, sizeof(struct vki_timeval) );
       break;
    case VKI_PPGETTIME:
-      PRE_MEM_WRITE( "ioctl(PPGETTIME)",  arg3, sizeof(struct vki_timeval) );
+      SYS_PRE_MEM_WRITE( "ioctl(PPGETTIME)",  arg3, sizeof(struct vki_timeval) );
       break;
 
    case VKI_GIO_FONT:
-      PRE_MEM_WRITE( "ioctl(GIO_FONT)", arg3, 32 * 256 );
+      SYS_PRE_MEM_WRITE( "ioctl(GIO_FONT)", arg3, 32 * 256 );
       break;
    case VKI_PIO_FONT:
-      PRE_MEM_READ( "ioctl(PIO_FONT)", arg3, 32 * 256 );
+      SYS_PRE_MEM_READ( "ioctl(PIO_FONT)", arg3, 32 * 256 );
       break;
 
    case VKI_GIO_FONTX:
-      PRE_MEM_READ( "ioctl(GIO_FONTX)", arg3, sizeof(struct vki_consolefontdesc) );
+      SYS_PRE_MEM_READ( "ioctl(GIO_FONTX)", arg3, sizeof(struct vki_consolefontdesc) );
       if ( arg3 ) {
          /* ToDo: don't do any of the following if the structure is invalid */
          struct vki_consolefontdesc *cfd = (struct vki_consolefontdesc *)arg3;
-         PRE_MEM_WRITE( "ioctl(GIO_FONTX).chardata", (Addr)cfd->chardata,
+         SYS_PRE_MEM_WRITE( "ioctl(GIO_FONTX).chardata", (Addr)cfd->chardata,
                         32 * cfd->charcount );
       }
       break;
    case VKI_PIO_FONTX:
-      PRE_MEM_READ( "ioctl(PIO_FONTX)", arg3, sizeof(struct vki_consolefontdesc) );
+      SYS_PRE_MEM_READ( "ioctl(PIO_FONTX)", arg3, sizeof(struct vki_consolefontdesc) );
       if ( arg3 ) {
          /* ToDo: don't do any of the following if the structure is invalid */
          struct vki_consolefontdesc *cfd = (struct vki_consolefontdesc *)arg3;
-         PRE_MEM_READ( "ioctl(PIO_FONTX).chardata", (Addr)cfd->chardata,
+         SYS_PRE_MEM_READ( "ioctl(PIO_FONTX).chardata", (Addr)cfd->chardata,
                        32 * cfd->charcount );
       }
       break;
@@ -3371,10 +3390,10 @@ PRE(sys_ioctl, MayBlock)
       break;
 
    case VKI_GIO_CMAP:
-      PRE_MEM_WRITE( "ioctl(GIO_CMAP)", arg3, 16 * 3 );
+      SYS_PRE_MEM_WRITE( "ioctl(GIO_CMAP)", arg3, 16 * 3 );
       break;
    case VKI_PIO_CMAP:
-      PRE_MEM_READ( "ioctl(PIO_CMAP)", arg3, 16 * 3 );
+      SYS_PRE_MEM_READ( "ioctl(PIO_CMAP)", arg3, 16 * 3 );
       break;
 
    case VKI_KIOCSOUND:
@@ -3382,13 +3401,13 @@ PRE(sys_ioctl, MayBlock)
       break;
 
    case VKI_KDGETLED:
-      PRE_MEM_WRITE( "ioctl(KDGETLED)", arg3, sizeof(char) );
+      SYS_PRE_MEM_WRITE( "ioctl(KDGETLED)", arg3, sizeof(char) );
       break;
    case VKI_KDSETLED:
       break;
 
    case VKI_KDGKBTYPE:
-      PRE_MEM_WRITE( "ioctl(KDGKBTYPE)", arg3, sizeof(char) );
+      SYS_PRE_MEM_WRITE( "ioctl(KDGKBTYPE)", arg3, sizeof(char) );
       break;
 
    case VKI_KDADDIO:
@@ -3400,7 +3419,7 @@ PRE(sys_ioctl, MayBlock)
    case VKI_KDSETMODE:
       break;
    case VKI_KDGETMODE:
-      PRE_MEM_WRITE( "ioctl(KDGETMODE)", arg3, sizeof(int) );
+      SYS_PRE_MEM_WRITE( "ioctl(KDGETMODE)", arg3, sizeof(int) );
       break;
 
    case VKI_KDMAPDISP:
@@ -3408,97 +3427,97 @@ PRE(sys_ioctl, MayBlock)
       break;
 
    case VKI_GIO_SCRNMAP:
-      PRE_MEM_WRITE( "ioctl(GIO_SCRNMAP)", arg3, VKI_E_TABSZ );
+      SYS_PRE_MEM_WRITE( "ioctl(GIO_SCRNMAP)", arg3, VKI_E_TABSZ );
       break;
    case VKI_PIO_SCRNMAP:
-      PRE_MEM_READ( "ioctl(PIO_SCRNMAP)", arg3, VKI_E_TABSZ  );
+      SYS_PRE_MEM_READ( "ioctl(PIO_SCRNMAP)", arg3, VKI_E_TABSZ  );
       break;
    case VKI_GIO_UNISCRNMAP:
-      PRE_MEM_WRITE( "ioctl(GIO_UNISCRNMAP)", arg3,
+      SYS_PRE_MEM_WRITE( "ioctl(GIO_UNISCRNMAP)", arg3,
                      VKI_E_TABSZ * sizeof(unsigned short) );
       break;
    case VKI_PIO_UNISCRNMAP:
-      PRE_MEM_READ( "ioctl(PIO_UNISCRNMAP)", arg3,
+      SYS_PRE_MEM_READ( "ioctl(PIO_UNISCRNMAP)", arg3,
                     VKI_E_TABSZ * sizeof(unsigned short) );
       break;
 
    case VKI_KDGKBMODE:
-      PRE_MEM_WRITE( "ioctl(KDGKBMODE)", arg3, sizeof(int) );
+      SYS_PRE_MEM_WRITE( "ioctl(KDGKBMODE)", arg3, sizeof(int) );
       break;
    case VKI_KDSKBMODE:
       break;
       
    case VKI_KDGKBMETA:
-      PRE_MEM_WRITE( "ioctl(KDGKBMETA)", arg3, sizeof(int) );
+      SYS_PRE_MEM_WRITE( "ioctl(KDGKBMETA)", arg3, sizeof(int) );
       break;
    case VKI_KDSKBMETA:
       break;
       
    case VKI_KDGKBLED:
-      PRE_MEM_WRITE( "ioctl(KDGKBLED)", arg3, sizeof(char) );
+      SYS_PRE_MEM_WRITE( "ioctl(KDGKBLED)", arg3, sizeof(char) );
       break;
    case VKI_KDSKBLED:
       break;
       
    case VKI_KDGKBENT:
-      PRE_MEM_READ( "ioctl(KDGKBENT).kb_table",
+      SYS_PRE_MEM_READ( "ioctl(KDGKBENT).kb_table",
                     (Addr)&((struct vki_kbentry *)arg3)->kb_table,
                     sizeof(((struct vki_kbentry *)arg3)->kb_table) );
-      PRE_MEM_READ( "ioctl(KDGKBENT).kb_index",
+      SYS_PRE_MEM_READ( "ioctl(KDGKBENT).kb_index",
                     (Addr)&((struct vki_kbentry *)arg3)->kb_index,
                     sizeof(((struct vki_kbentry *)arg3)->kb_index) );
-      PRE_MEM_WRITE( "ioctl(KDGKBENT).kb_value",
+      SYS_PRE_MEM_WRITE( "ioctl(KDGKBENT).kb_value",
 		     (Addr)&((struct vki_kbentry *)arg3)->kb_value,
 		     sizeof(((struct vki_kbentry *)arg3)->kb_value) );
       break;
    case VKI_KDSKBENT:
-      PRE_MEM_READ( "ioctl(KDSKBENT).kb_table",
+      SYS_PRE_MEM_READ( "ioctl(KDSKBENT).kb_table",
                     (Addr)&((struct vki_kbentry *)arg3)->kb_table,
                     sizeof(((struct vki_kbentry *)arg3)->kb_table) );
-      PRE_MEM_READ( "ioctl(KDSKBENT).kb_index",
+      SYS_PRE_MEM_READ( "ioctl(KDSKBENT).kb_index",
                     (Addr)&((struct vki_kbentry *)arg3)->kb_index,
                     sizeof(((struct vki_kbentry *)arg3)->kb_index) );
-      PRE_MEM_READ( "ioctl(KDSKBENT).kb_value",
+      SYS_PRE_MEM_READ( "ioctl(KDSKBENT).kb_value",
                     (Addr)&((struct vki_kbentry *)arg3)->kb_value,
                     sizeof(((struct vki_kbentry *)arg3)->kb_value) );
       break;
       
    case VKI_KDGKBSENT:
-      PRE_MEM_READ( "ioctl(KDGKBSENT).kb_func",
+      SYS_PRE_MEM_READ( "ioctl(KDGKBSENT).kb_func",
                     (Addr)&((struct vki_kbsentry *)arg3)->kb_func,
                     sizeof(((struct vki_kbsentry *)arg3)->kb_func) );
-      PRE_MEM_WRITE( "ioctl(KDGKSENT).kb_string",
+      SYS_PRE_MEM_WRITE( "ioctl(KDGKSENT).kb_string",
 		     (Addr)((struct vki_kbsentry *)arg3)->kb_string,
 		     sizeof(((struct vki_kbsentry *)arg3)->kb_string) );
       break;
    case VKI_KDSKBSENT:
-      PRE_MEM_READ( "ioctl(KDSKBSENT).kb_func",
+      SYS_PRE_MEM_READ( "ioctl(KDSKBSENT).kb_func",
                     (Addr)&((struct vki_kbsentry *)arg3)->kb_func,
                     sizeof(((struct vki_kbsentry *)arg3)->kb_func) );
-      PRE_MEM_RASCIIZ( "ioctl(KDSKBSENT).kb_string",
+      SYS_PRE_MEM_RASCIIZ( "ioctl(KDSKBSENT).kb_string",
                        (Addr)((struct vki_kbsentry *)arg3)->kb_string );
       break;
       
    case VKI_KDGKBDIACR:
-      PRE_MEM_WRITE( "ioctl(KDGKBDIACR)", arg3, sizeof(struct vki_kbdiacrs) );
+      SYS_PRE_MEM_WRITE( "ioctl(KDGKBDIACR)", arg3, sizeof(struct vki_kbdiacrs) );
       break;
    case VKI_KDSKBDIACR:
-      PRE_MEM_READ( "ioctl(KDSKBDIACR)", arg3, sizeof(struct vki_kbdiacrs) );
+      SYS_PRE_MEM_READ( "ioctl(KDSKBDIACR)", arg3, sizeof(struct vki_kbdiacrs) );
       break;
       
    case VKI_KDGETKEYCODE:
-      PRE_MEM_READ( "ioctl(KDGETKEYCODE).scancode",
+      SYS_PRE_MEM_READ( "ioctl(KDGETKEYCODE).scancode",
                     (Addr)&((struct vki_kbkeycode *)arg3)->scancode,
                     sizeof(((struct vki_kbkeycode *)arg3)->scancode) );
-      PRE_MEM_WRITE( "ioctl(KDGETKEYCODE).keycode",
+      SYS_PRE_MEM_WRITE( "ioctl(KDGETKEYCODE).keycode",
 		     (Addr)((struct vki_kbkeycode *)arg3)->keycode,
 		     sizeof(((struct vki_kbkeycode *)arg3)->keycode) );
       break;
    case VKI_KDSETKEYCODE:
-      PRE_MEM_READ( "ioctl(KDSETKEYCODE).scancode",
+      SYS_PRE_MEM_READ( "ioctl(KDSETKEYCODE).scancode",
                     (Addr)&((struct vki_kbkeycode *)arg3)->scancode,
                     sizeof(((struct vki_kbkeycode *)arg3)->scancode) );
-      PRE_MEM_READ( "ioctl(KDSETKEYCODE).keycode",
+      SYS_PRE_MEM_READ( "ioctl(KDSETKEYCODE).keycode",
                     (Addr)((struct vki_kbkeycode *)arg3)->keycode,
                     sizeof(((struct vki_kbkeycode *)arg3)->keycode) );
       break;
@@ -3507,7 +3526,7 @@ PRE(sys_ioctl, MayBlock)
       break;
 
    case VKI_KDKBDREP:
-      PRE_MEM_READ( "ioctl(KBKBDREP)", arg3, sizeof(struct vki_kbd_repeat) );
+      SYS_PRE_MEM_READ( "ioctl(KBKBDREP)", arg3, sizeof(struct vki_kbd_repeat) );
       break;
       
       /* We don't have any specific information on it, so
@@ -3547,9 +3566,9 @@ PRE(sys_ioctl, MayBlock)
 	 }
       } else {
 	 if ((dir & _VKI_IOC_WRITE) && size > 0)
-	    PRE_MEM_READ( "ioctl(generic)", arg3, size);
+	    SYS_PRE_MEM_READ( "ioctl(generic)", arg3, size);
 	 if ((dir & _VKI_IOC_READ) && size > 0)
-	    PRE_MEM_WRITE( "ioctl(generic)", arg3, size);
+	    SYS_PRE_MEM_WRITE( "ioctl(generic)", arg3, size);
       }
       break;
    }
@@ -3708,7 +3727,7 @@ POST(sys_ioctl)
       break;
    case VKI_SIOCGIFCONF:         /* get iface list               */
       /* WAS:
-	 PRE_MEM_WRITE("ioctl(SIOCGIFCONF)", arg3, sizeof(struct ifconf));
+	 SYS_PRE_MEM_WRITE("ioctl(SIOCGIFCONF)", arg3, sizeof(struct ifconf));
 	 KERNEL_DO_SYSCALL(tid,SYSRES);
 	 if (!VG_(is_kerror)(SYSRES) && SYSRES == 0)
 	 VG_TRACK( post_mem_write,arg3, sizeof(struct ifconf));
@@ -4124,8 +4143,8 @@ PRE(sys_link, MayBlock)
 {
    PRINT("sys_link ( %p, %p)", arg1, arg2);
    PRE_REG_READ2(long, "link", const char *, oldpath, const char *, newpath);
-   PRE_MEM_RASCIIZ( "link(oldpath)", arg1);
-   PRE_MEM_RASCIIZ( "link(newpath)", arg2);
+   SYS_PRE_MEM_RASCIIZ( "link(oldpath)", arg1);
+   SYS_PRE_MEM_RASCIIZ( "link(newpath)", arg2);
 }
 
 PRE(sys_lseek, 0)
@@ -4139,8 +4158,8 @@ PRE(sys_newlstat, 0)
 {
    PRINT("sys_newlstat ( %p(%s), %p )", arg1,arg1,arg2);
    PRE_REG_READ2(long, "lstat", char *, file_name, struct stat *, buf);
-   PRE_MEM_RASCIIZ( "lstat(file_name)", arg1 );
-   PRE_MEM_WRITE( "lstat(buf)", arg2, sizeof(struct vki_stat) );
+   SYS_PRE_MEM_RASCIIZ( "lstat(file_name)", arg1 );
+   SYS_PRE_MEM_WRITE( "lstat(buf)", arg2, sizeof(struct vki_stat) );
 }
 
 POST(sys_newlstat)
@@ -4154,8 +4173,8 @@ PRE(sys_lstat64, 0)
 {
    PRINT("sys_lstat64 ( %p(%s), %p )",arg1,arg1,arg2);
    PRE_REG_READ2(long, "lstat64", char *, file_name, struct stat64 *, buf);
-   PRE_MEM_RASCIIZ( "lstat64(file_name)", arg1 );
-   PRE_MEM_WRITE( "lstat64(buf)", arg2, sizeof(struct vki_stat64) );
+   SYS_PRE_MEM_RASCIIZ( "lstat64(file_name)", arg1 );
+   SYS_PRE_MEM_WRITE( "lstat64(buf)", arg2, sizeof(struct vki_stat64) );
 }
 
 POST(sys_lstat64)
@@ -4169,7 +4188,7 @@ PRE(sys_mkdir, MayBlock)
 {
    PRINT("sys_mkdir ( %p, %d )", arg1,arg2);
    PRE_REG_READ2(long, "mkdir", const char *, pathname, int, mode);
-   PRE_MEM_RASCIIZ( "mkdir(pathname)", arg1 );
+   SYS_PRE_MEM_RASCIIZ( "mkdir(pathname)", arg1 );
 }
 
 PRE(old_mmap, Special)
@@ -4294,7 +4313,7 @@ PRE(sys_mincore, 0)
    PRE_REG_READ3(long, "mincore",
                  unsigned long, start, vki_size_t, length,
                  unsigned char *, vec);
-   PRE_MEM_WRITE( "mincore(vec)", arg3, PGROUNDUP(arg2) );
+   SYS_PRE_MEM_WRITE( "mincore(vec)", arg3, PGROUNDUP(arg2) );
 }
 
 POST(sys_mincore)
@@ -4307,9 +4326,9 @@ PRE(sys_nanosleep, MayBlock|PostOnFail)
    PRINT("sys_nanosleep ( %p, %p )", arg1,arg2);
    PRE_REG_READ2(long, "nanosleep", 
                  struct timespec *, req, struct timespec *, rem);
-   PRE_MEM_READ( "nanosleep(req)", arg1, sizeof(struct vki_timespec) );
+   SYS_PRE_MEM_READ( "nanosleep(req)", arg1, sizeof(struct vki_timespec) );
    if (arg2 != 0)
-      PRE_MEM_WRITE( "nanosleep(rem)", arg2, sizeof(struct vki_timespec) );
+      SYS_PRE_MEM_WRITE( "nanosleep(rem)", arg2, sizeof(struct vki_timespec) );
 }
 
 POST(sys_nanosleep)
@@ -4322,16 +4341,23 @@ PRE(sys_open, MayBlock)
 {
    if (arg2 & VKI_O_CREAT) {
       // 3-arg version
-      PRINT("sys_open ( %p(%s), %d, %d )",arg1,arg1,arg2,arg3);
+      PRINT("sys_open ( %p(%s), %d, %d )",arg1,
+	    VG_(is_addressable)(arg1, 1, VKI_PROT_READ) ? arg1 : (Addr)"??",
+	    arg2,arg3);
       PRE_REG_READ3(long, "open",
                     const char *, filename, int, flags, int, mode);
    } else {
       // 2-arg version
-      PRINT("sys_open ( %p(%s), %d )",arg1,arg1,arg2);
+      PRINT("sys_open ( %p(%s), %d )",arg1,
+	    VG_(is_addressable)(arg1, 1, VKI_PROT_READ) ? arg1 : (Addr)"??",
+	    arg2);
       PRE_REG_READ2(long, "open",
                     const char *, filename, int, flags);
    }
-   PRE_MEM_RASCIIZ( "open(filename)", arg1 );
+   SYS_PRE_MEM_RASCIIZ( "open(filename)", arg1 );
+
+   if (VG_(is_kerror)(SYSRES))
+      return;
 
    if (VG_(strcmp)((Char *)arg1, "/proc/self/exe") == 0) {
       Char name[20];
@@ -4362,7 +4388,7 @@ PRE(sys_read, MayBlock)
    if (!VG_(fd_allowed)(arg1, "read", tid, False))
       set_result( -VKI_EBADF );
    else
-      PRE_MEM_WRITE( "read(buf)", arg2, arg3 );
+      SYS_PRE_MEM_WRITE( "read(buf)", arg2, arg3 );
 }
 
 POST(sys_read)
@@ -4378,14 +4404,14 @@ PRE(sys_write, MayBlock)
    if (!VG_(fd_allowed)(arg1, "write", tid, False))
       set_result( -VKI_EBADF );
    else
-      PRE_MEM_READ( "write(buf)", arg2, arg3 );
+      SYS_PRE_MEM_READ( "write(buf)", arg2, arg3 );
 }
 
 PRE(sys_creat, MayBlock)
 {
    PRINT("sys_creat ( %p(%s), %d )", arg1,arg1,arg2);
    PRE_REG_READ2(long, "creat", const char *, pathname, int, mode);
-   PRE_MEM_RASCIIZ( "creat(pathname)", arg1 );
+   SYS_PRE_MEM_RASCIIZ( "creat(pathname)", arg1 );
 }
 
 POST(sys_creat)
@@ -4404,7 +4430,7 @@ PRE(sys_pipe, 0)
 {
    PRINT("sys_pipe ( %p )", arg1);
    PRE_REG_READ1(int, "pipe", unsigned long *, filedes);
-   PRE_MEM_WRITE( "pipe(filedes)", arg1, 2*sizeof(long) );
+   SYS_PRE_MEM_WRITE( "pipe(filedes)", arg1, 2*sizeof(long) );
 }
 
 POST(sys_pipe)
@@ -4446,9 +4472,9 @@ PRE(sys_poll, MayBlock)
       // 'fd' and 'events' field are inputs;  'revents' is output.
       // XXX: this is x86 specific -- the pollfd struct varies across
       // different architectures.
-      PRE_MEM_READ( "poll(ufds)",
+      SYS_PRE_MEM_READ( "poll(ufds)",
                     (Addr)(&ufds[i]), sizeof(int) + sizeof(short) );
-      PRE_MEM_WRITE( "poll(ufds)", (Addr)(&ufds[i].revents), sizeof(short) );
+      SYS_PRE_MEM_WRITE( "poll(ufds)", (Addr)(&ufds[i].revents), sizeof(short) );
    }  
 }
 
@@ -4469,8 +4495,8 @@ PRE(sys_readlink, Special)
    PRINT("sys_readlink ( %p, %p, %llu )", arg1,arg2,(ULong)arg3);
    PRE_REG_READ3(long, "readlink",
                  const char *, path, char *, buf, int, bufsiz);
-   PRE_MEM_RASCIIZ( "readlink(path)", arg1 );
-   PRE_MEM_WRITE( "readlink(buf)", arg2,arg3 );
+   SYS_PRE_MEM_RASCIIZ( "readlink(path)", arg1 );
+   SYS_PRE_MEM_WRITE( "readlink(buf)", arg2,arg3 );
 
    /*
     * Handle the case where readlink is looking at /proc/self/exe or
@@ -4505,13 +4531,17 @@ PRE(sys_readv, MayBlock)
    if (!VG_(fd_allowed)(arg1, "readv", tid, False)) {
       set_result( -VKI_EBADF );
    } else {
-      PRE_MEM_READ( "readv(vector)", arg2, arg3 * sizeof(struct vki_iovec) );
+      SYS_PRE_MEM_READ( "readv(vector)", arg2, arg3 * sizeof(struct vki_iovec) );
 
+      if ((Int)arg3 < 0) {
+	 set_result( -VKI_EINVAL );
+	 return;
+      }
       if (arg2 != 0) {
          /* ToDo: don't do any of the following if the vector is invalid */
          vec = (struct vki_iovec *)arg2;
          for (i = 0; i < (Int)arg3; i++)
-            PRE_MEM_WRITE( "readv(vector[...])",
+            SYS_PRE_MEM_WRITE( "readv(vector[...])",
                            (Addr)vec[i].iov_base, vec[i].iov_len );
       }
    }
@@ -4539,15 +4569,15 @@ PRE(sys_rename, 0)
 {
    PRINT("sys_rename ( %p, %p )", arg1, arg2 );
    PRE_REG_READ2(long, "rename", const char *, oldpath, const char *, newpath);
-   PRE_MEM_RASCIIZ( "rename(oldpath)", arg1 );
-   PRE_MEM_RASCIIZ( "rename(newpath)", arg2 );
+   SYS_PRE_MEM_RASCIIZ( "rename(oldpath)", arg1 );
+   SYS_PRE_MEM_RASCIIZ( "rename(newpath)", arg2 );
 }
 
 PRE(sys_rmdir, MayBlock)
 {
    PRINT("sys_rmdir ( %p )", arg1);
    PRE_REG_READ1(long, "rmdir", const char *, pathname);
-   PRE_MEM_RASCIIZ( "rmdir(pathname)", arg1 );
+   SYS_PRE_MEM_RASCIIZ( "rmdir(pathname)", arg1 );
 }
 
 PRE(sys_sched_setparam, 0)
@@ -4555,7 +4585,7 @@ PRE(sys_sched_setparam, 0)
    PRINT("sched_setparam ( %d, %p )", arg1, arg2 );
    PRE_REG_READ2(long, "sched_setparam", 
                  vki_pid_t, pid, struct sched_param *, p);
-   PRE_MEM_READ( "sched_setparam(p)", arg2, sizeof(struct vki_sched_param) );
+   SYS_PRE_MEM_READ( "sched_setparam(p)", arg2, sizeof(struct vki_sched_param) );
 }
 
 POST(sys_sched_setparam)
@@ -4568,7 +4598,7 @@ PRE(sys_sched_getparam, 0)
    PRINT("sched_getparam ( %d, %p )", arg1, arg2 );
    PRE_REG_READ2(long, "sched_getparam", 
                  vki_pid_t, pid, struct sched_param *, p);
-   PRE_MEM_WRITE( "sched_getparam(p)", arg2, sizeof(struct vki_sched_param) );
+   SYS_PRE_MEM_WRITE( "sched_getparam(p)", arg2, sizeof(struct vki_sched_param) );
 }
 
 POST(sys_sched_getparam)
@@ -4584,16 +4614,16 @@ PRE(sys_select, MayBlock)
                  vki_fd_set *, exceptfds, struct timeval *, timeout);
    // XXX: this possibly understates how much memory is read.
    if (arg2 != 0)
-      PRE_MEM_READ( "select(readfds)",   
+      SYS_PRE_MEM_READ( "select(readfds)",   
 		     arg2, arg1/8 /* __FD_SETSIZE/8 */ );
    if (arg3 != 0)
-      PRE_MEM_READ( "select(writefds)",  
+      SYS_PRE_MEM_READ( "select(writefds)",  
 		     arg3, arg1/8 /* __FD_SETSIZE/8 */ );
    if (arg4 != 0)
-      PRE_MEM_READ( "select(exceptfds)", 
+      SYS_PRE_MEM_READ( "select(exceptfds)", 
 		     arg4, arg1/8 /* __FD_SETSIZE/8 */ );
    if (arg5 != 0)
-      PRE_MEM_READ( "select(timeout)", arg5, sizeof(struct vki_timeval) );
+      SYS_PRE_MEM_READ( "select(timeout)", arg5, sizeof(struct vki_timeval) );
 }
 
 PRE(sys_setgid16, 0)
@@ -4619,7 +4649,7 @@ PRE(sys_setgroups16, 0)
    PRINT("sys_setgroups16 ( %llu, %p )", (ULong)arg1, arg2);
    PRE_REG_READ2(long, "setgroups16", int, size, vki_old_gid_t *, list);
    if (arg1 > 0)
-      PRE_MEM_READ( "setgroups16(list)", arg2, arg1 * sizeof(vki_old_gid_t) );
+      SYS_PRE_MEM_READ( "setgroups16(list)", arg2, arg1 * sizeof(vki_old_gid_t) );
 }
 
 PRE(sys_setgroups, 0)
@@ -4627,7 +4657,7 @@ PRE(sys_setgroups, 0)
    PRINT("setgroups ( %llu, %p )", (ULong)arg1, arg2);
    PRE_REG_READ2(long, "setgroups", int, size, vki_gid_t *, list);
    if (arg1 > 0)
-      PRE_MEM_READ( "setgroups(list)", arg2, arg1 * sizeof(vki_gid_t) );
+      SYS_PRE_MEM_READ( "setgroups(list)", arg2, arg1 * sizeof(vki_gid_t) );
 }
 
 PRE(sys_setpgid, 0)
@@ -4659,7 +4689,7 @@ PRE(sys_setrlimit, 0)
    PRINT("sys_setrlimit ( %d, %p )", arg1,arg2);
    PRE_REG_READ2(long, "setrlimit",
                  unsigned int, resource, struct rlimit *, rlim);
-   PRE_MEM_READ( "setrlimit(rlim)", arg2, sizeof(struct vki_rlimit) );
+   SYS_PRE_MEM_READ( "setrlimit(rlim)", arg2, sizeof(struct vki_rlimit) );
 
    if (arg1 == VKI_RLIMIT_NOFILE) {
       if (((struct vki_rlimit *)arg2)->rlim_cur > VG_(fd_hard_limit) ||
@@ -4715,32 +4745,32 @@ PRE(sys_socketcall, MayBlock)
 
    case VKI_SYS_SOCKETPAIR:
       /* int socketpair(int d, int type, int protocol, int sv[2]); */
-      PRE_MEM_READ( "socketcall.socketpair(args)", arg2, 4*sizeof(Addr) );
-      PRE_MEM_WRITE( "socketcall.socketpair(sv)", 
+      SYS_PRE_MEM_READ( "socketcall.socketpair(args)", arg2, 4*sizeof(Addr) );
+      SYS_PRE_MEM_WRITE( "socketcall.socketpair(sv)", 
 		     ((UWord*)arg2)[3], 2*sizeof(int) );
       break;
 
    case VKI_SYS_SOCKET:
       /* int socket(int domain, int type, int protocol); */
-      PRE_MEM_READ( "socketcall.socket(args)", arg2, 3*sizeof(Addr) );
+      SYS_PRE_MEM_READ( "socketcall.socket(args)", arg2, 3*sizeof(Addr) );
       break;
 
    case VKI_SYS_BIND:
       /* int bind(int sockfd, struct sockaddr *my_addr, 
 	 int addrlen); */
-      PRE_MEM_READ( "socketcall.bind(args)", arg2, 3*sizeof(Addr) );
+      SYS_PRE_MEM_READ( "socketcall.bind(args)", arg2, 3*sizeof(Addr) );
       pre_mem_read_sockaddr( tid, "socketcall.bind(my_addr.%s)",
 			     (struct vki_sockaddr *) (((UWord*)arg2)[1]), ((UWord*)arg2)[2]);
       break;
                
    case VKI_SYS_LISTEN:
       /* int listen(int s, int backlog); */
-      PRE_MEM_READ( "socketcall.listen(args)", arg2, 2*sizeof(Addr) );
+      SYS_PRE_MEM_READ( "socketcall.listen(args)", arg2, 2*sizeof(Addr) );
       break;
 
    case VKI_SYS_ACCEPT: {
       /* int accept(int s, struct sockaddr *addr, int *addrlen); */
-      PRE_MEM_READ( "socketcall.accept(args)", arg2, 3*sizeof(Addr) );
+      SYS_PRE_MEM_READ( "socketcall.accept(args)", arg2, 3*sizeof(Addr) );
       {
 	 Addr addr_p     = ((UWord*)arg2)[1];
 	 Addr addrlen_p  = ((UWord*)arg2)[2];
@@ -4756,8 +4786,8 @@ PRE(sys_socketcall, MayBlock)
       /* int sendto(int s, const void *msg, int len, 
 	 unsigned int flags, 
 	 const struct sockaddr *to, int tolen); */
-      PRE_MEM_READ( "socketcall.sendto(args)", arg2, 6*sizeof(Addr) );
-      PRE_MEM_READ( "socketcall.sendto(msg)",
+      SYS_PRE_MEM_READ( "socketcall.sendto(args)", arg2, 6*sizeof(Addr) );
+      SYS_PRE_MEM_READ( "socketcall.sendto(msg)",
 		     ((UWord*)arg2)[1], /* msg */
 		     ((UWord*)arg2)[2]  /* len */ );
       pre_mem_read_sockaddr( tid, "socketcall.sendto(to.%s)",
@@ -4766,8 +4796,8 @@ PRE(sys_socketcall, MayBlock)
 
    case VKI_SYS_SEND:
       /* int send(int s, const void *msg, size_t len, int flags); */
-      PRE_MEM_READ( "socketcall.send(args)", arg2, 4*sizeof(Addr) );
-      PRE_MEM_READ( "socketcall.send(msg)",
+      SYS_PRE_MEM_READ( "socketcall.send(args)", arg2, 4*sizeof(Addr) );
+      SYS_PRE_MEM_READ( "socketcall.send(msg)",
 		     ((UWord*)arg2)[1], /* msg */
 		     ((UWord*)arg2)[2]  /* len */ );
       break;
@@ -4775,14 +4805,14 @@ PRE(sys_socketcall, MayBlock)
    case VKI_SYS_RECVFROM:
       /* int recvfrom(int s, void *buf, int len, unsigned int flags,
 	 struct sockaddr *from, int *fromlen); */
-      PRE_MEM_READ( "socketcall.recvfrom(args)", arg2, 6*sizeof(Addr) );
+      SYS_PRE_MEM_READ( "socketcall.recvfrom(args)", arg2, 6*sizeof(Addr) );
       {
 	 Addr buf_p      = ((UWord*)arg2)[1];
 	 Int  len        = ((UWord*)arg2)[2];
 	 Addr from_p     = ((UWord*)arg2)[4];
 	 Addr fromlen_p  = ((UWord*)arg2)[5];
 
-	 PRE_MEM_WRITE( "socketcall.recvfrom(buf)", buf_p, len );
+	 SYS_PRE_MEM_WRITE( "socketcall.recvfrom(buf)", buf_p, len );
 	 if (from_p != (Addr)NULL) 
 	    buf_and_len_pre_check ( tid, from_p, fromlen_p, 
 				    "socketcall.recvfrom(from)",
@@ -4797,8 +4827,8 @@ PRE(sys_socketcall, MayBlock)
 	 (see connect(2)) and is identical to recvfrom with a  NULL
 	 from parameter.
       */
-      PRE_MEM_READ( "socketcall.recv(args)", arg2, 4*sizeof(Addr) );
-      PRE_MEM_WRITE( "socketcall.recv(buf)", 
+      SYS_PRE_MEM_READ( "socketcall.recv(args)", arg2, 4*sizeof(Addr) );
+      SYS_PRE_MEM_WRITE( "socketcall.recv(buf)", 
 		     ((UWord*)arg2)[1], /* buf */
 		     ((UWord*)arg2)[2]  /* len */ );
       break;
@@ -4806,8 +4836,8 @@ PRE(sys_socketcall, MayBlock)
    case VKI_SYS_CONNECT:
       /* int connect(int sockfd, 
 	 struct sockaddr *serv_addr, int addrlen ); */
-      PRE_MEM_READ( "socketcall.connect(args)", arg2, 3*sizeof(Addr) );
-      PRE_MEM_READ( "socketcall.connect(serv_addr.sa_family)",
+      SYS_PRE_MEM_READ( "socketcall.connect(args)", arg2, 3*sizeof(Addr) );
+      SYS_PRE_MEM_READ( "socketcall.connect(serv_addr.sa_family)",
 		     ((UWord*)arg2)[1], /* serv_addr */
 		     sizeof(vki_sa_family_t));
       pre_mem_read_sockaddr( tid,
@@ -4818,8 +4848,8 @@ PRE(sys_socketcall, MayBlock)
    case VKI_SYS_SETSOCKOPT:
       /* int setsockopt(int s, int level, int optname, 
 	 const void *optval, int optlen); */
-      PRE_MEM_READ( "socketcall.setsockopt(args)", arg2, 5*sizeof(Addr) );
-      PRE_MEM_READ( "socketcall.setsockopt(optval)",
+      SYS_PRE_MEM_READ( "socketcall.setsockopt(args)", arg2, 5*sizeof(Addr) );
+      SYS_PRE_MEM_READ( "socketcall.setsockopt(optval)",
 		     ((UWord*)arg2)[3], /* optval */
 		     ((UWord*)arg2)[4]  /* optlen */ );
       break;
@@ -4827,7 +4857,7 @@ PRE(sys_socketcall, MayBlock)
    case VKI_SYS_GETSOCKOPT:
       /* int setsockopt(int s, int level, int optname, 
 	 void *optval, socklen_t *optlen); */
-      PRE_MEM_READ( "socketcall.getsockopt(args)", arg2, 5*sizeof(Addr) );
+      SYS_PRE_MEM_READ( "socketcall.getsockopt(args)", arg2, 5*sizeof(Addr) );
       {
 	 Addr optval_p  = ((UWord*)arg2)[3];
 	 Addr optlen_p  = ((UWord*)arg2)[4];
@@ -4841,7 +4871,7 @@ PRE(sys_socketcall, MayBlock)
 
    case VKI_SYS_GETSOCKNAME:
       /* int getsockname(int s, struct sockaddr* name, int* namelen) */
-      PRE_MEM_READ( "socketcall.getsockname(args)", arg2, 3*sizeof(Addr) );
+      SYS_PRE_MEM_READ( "socketcall.getsockname(args)", arg2, 3*sizeof(Addr) );
       {
 	 Addr name_p     = ((UWord*)arg2)[1];
 	 Addr namelen_p  = ((UWord*)arg2)[2];
@@ -4855,7 +4885,7 @@ PRE(sys_socketcall, MayBlock)
 
    case VKI_SYS_GETPEERNAME:
       /* int getpeername(int s, struct sockaddr* name, int* namelen) */
-      PRE_MEM_READ( "socketcall.getpeername(args)", arg2, 3*sizeof(Addr) );
+      SYS_PRE_MEM_READ( "socketcall.getpeername(args)", arg2, 3*sizeof(Addr) );
       {
 	 Addr name_p     = ((UWord*)arg2)[1];
 	 Addr namelen_p  = ((UWord*)arg2)[2];
@@ -4869,7 +4899,7 @@ PRE(sys_socketcall, MayBlock)
 
    case VKI_SYS_SHUTDOWN:
       /* int shutdown(int s, int how); */
-      PRE_MEM_READ( "socketcall.shutdown(args)", arg2, 2*sizeof(Addr) );
+      SYS_PRE_MEM_READ( "socketcall.shutdown(args)", arg2, 2*sizeof(Addr) );
       break;
 
    case VKI_SYS_SENDMSG: {
@@ -4877,7 +4907,7 @@ PRE(sys_socketcall, MayBlock)
 
       /* this causes warnings, and I don't get why. glibc bug?
        * (after all it's glibc providing the arguments array)
-       PRE_MEM_READ( "socketcall.sendmsg(args)", arg2, 3*sizeof(Addr) );
+       SYS_PRE_MEM_READ( "socketcall.sendmsg(args)", arg2, 3*sizeof(Addr) );
       */
 
       struct vki_msghdr *msg = (struct vki_msghdr *)((UWord*)arg2)[ 1 ];
@@ -4891,7 +4921,7 @@ PRE(sys_socketcall, MayBlock)
 
       /* this causes warnings, and I don't get why. glibc bug?
        * (after all it's glibc providing the arguments array)
-       PRE_MEM_READ("socketcall.recvmsg(args)", arg2, 3*sizeof(Addr) );
+       SYS_PRE_MEM_READ("socketcall.recvmsg(args)", arg2, 3*sizeof(Addr) );
       */
 
       struct vki_msghdr *msg = (struct vki_msghdr *)((UWord*)arg2)[ 1 ];
@@ -5058,8 +5088,8 @@ PRE(sys_newstat, 0)
 {
    PRINT("sys_newstat ( %p(%s), %p )", arg1,arg1,arg2);
    PRE_REG_READ2(long, "stat", char *, file_name, struct stat *, buf);
-   PRE_MEM_RASCIIZ( "stat(file_name)", arg1 );
-   PRE_MEM_WRITE( "stat(buf)", arg2, sizeof(struct vki_stat) );
+   SYS_PRE_MEM_RASCIIZ( "stat(file_name)", arg1 );
+   SYS_PRE_MEM_WRITE( "stat(buf)", arg2, sizeof(struct vki_stat) );
 }
 
 POST(sys_newstat)
@@ -5071,8 +5101,8 @@ PRE(sys_statfs, 0)
 {
    PRINT("sys_statfs ( %p, %p )",arg1,arg2);
    PRE_REG_READ2(long, "statfs", const char *, path, struct statfs *, buf);
-   PRE_MEM_RASCIIZ( "statfs(path)", arg1 );
-   PRE_MEM_WRITE( "statfs(buf)", arg2, sizeof(struct vki_statfs) );
+   SYS_PRE_MEM_RASCIIZ( "statfs(path)", arg1 );
+   SYS_PRE_MEM_WRITE( "statfs(buf)", arg2, sizeof(struct vki_statfs) );
 }
 
 POST(sys_statfs)
@@ -5085,8 +5115,8 @@ PRE(sys_statfs64, 0)
    PRINT("sys_statfs64 ( %p, %llu, %p )",arg1,(ULong)arg2,arg3);
    PRE_REG_READ3(long, "statfs64",
                  const char *, path, vki_size_t, size, struct statfs64 *, buf);
-   PRE_MEM_RASCIIZ( "statfs64(path)", arg1 );
-   PRE_MEM_WRITE( "statfs64(buf)", arg3, arg2 );
+   SYS_PRE_MEM_RASCIIZ( "statfs64(path)", arg1 );
+   SYS_PRE_MEM_WRITE( "statfs64(buf)", arg3, arg2 );
 }
 
 POST(sys_statfs64)
@@ -5098,16 +5128,16 @@ PRE(sys_symlink, MayBlock)
 {
    PRINT("sys_symlink ( %p, %p )",arg1,arg2);
    PRE_REG_READ2(long, "symlink", const char *, oldpath, const char *, newpath);
-   PRE_MEM_RASCIIZ( "symlink(oldpath)", arg1 );
-   PRE_MEM_RASCIIZ( "symlink(newpath)", arg2 );
+   SYS_PRE_MEM_RASCIIZ( "symlink(oldpath)", arg1 );
+   SYS_PRE_MEM_RASCIIZ( "symlink(newpath)", arg2 );
 }
 
 PRE(sys_stat64, 0)
 {
    PRINT("sys_stat64 ( %p, %p )",arg1,arg2);
    PRE_REG_READ2(long, "stat64", char *, file_name, struct stat64 *, buf);
-   PRE_MEM_RASCIIZ( "stat64(file_name)", arg1 );
-   PRE_MEM_WRITE( "stat64(buf)", arg2, sizeof(struct vki_stat64) );
+   SYS_PRE_MEM_RASCIIZ( "stat64(file_name)", arg1 );
+   SYS_PRE_MEM_WRITE( "stat64(buf)", arg2, sizeof(struct vki_stat64) );
 }
 
 POST(sys_stat64)
@@ -5119,7 +5149,7 @@ PRE(sys_fstat64, 0)
 {
    PRINT("sys_fstat64 ( %d, %p )",arg1,arg2);
    PRE_REG_READ2(long, "fstat64", unsigned long, fd, struct stat64 *, buf);
-   PRE_MEM_WRITE( "fstat64(buf)", arg2, sizeof(struct vki_stat64) );
+   SYS_PRE_MEM_WRITE( "fstat64(buf)", arg2, sizeof(struct vki_stat64) );
 }
 
 POST(sys_fstat64)
@@ -5133,7 +5163,7 @@ PRE(sys_time, 0)
    PRINT("sys_time ( %p )",arg1);
    PRE_REG_READ1(long, "time", int *, t);
    if (arg1 != 0) {
-      PRE_MEM_WRITE( "time(t)", arg1, sizeof(vki_time_t) );
+      SYS_PRE_MEM_WRITE( "time(t)", arg1, sizeof(vki_time_t) );
    }
 }
 
@@ -5148,7 +5178,7 @@ PRE(sys_times, 0)
 {
    PRINT("sys_times ( %p )", arg1);
    PRE_REG_READ1(long, "times", struct tms *, buf);
-   PRE_MEM_WRITE( "times(buf)", arg1, sizeof(struct vki_tms) );
+   SYS_PRE_MEM_WRITE( "times(buf)", arg1, sizeof(struct vki_tms) );
 }
 
 POST(sys_times)
@@ -5168,14 +5198,14 @@ PRE(sys_unlink, MayBlock)
 {
    PRINT("sys_unlink ( %p(%s) )", arg1,arg1);
    PRE_REG_READ1(long, "unlink", const char *, pathname);
-   PRE_MEM_RASCIIZ( "unlink(pathname)", arg1 );
+   SYS_PRE_MEM_RASCIIZ( "unlink(pathname)", arg1 );
 }
 
 PRE(sys_newuname, 0)
 {
    PRINT("sys_newuname ( %p )", arg1);
    PRE_REG_READ1(long, "uname", struct new_utsname *, buf);
-   PRE_MEM_WRITE( "uname(buf)", arg1, sizeof(struct vki_new_utsname) );
+   SYS_PRE_MEM_WRITE( "uname(buf)", arg1, sizeof(struct vki_new_utsname) );
 }
 
 POST(sys_newuname)
@@ -5189,9 +5219,9 @@ PRE(sys_utime, MayBlock)
 {
    PRINT("sys_utime ( %p, %p )", arg1,arg2);
    PRE_REG_READ2(long, "utime", char *, filename, struct utimbuf *, buf);
-   PRE_MEM_RASCIIZ( "utime(filename)", arg1 );
+   SYS_PRE_MEM_RASCIIZ( "utime(filename)", arg1 );
    if (arg2 != 0)
-      PRE_MEM_READ( "utime(buf)", arg2, sizeof(struct vki_utimbuf) );
+      SYS_PRE_MEM_READ( "utime(buf)", arg2, sizeof(struct vki_utimbuf) );
 }
 
 PRE(sys_waitpid, MayBlock)
@@ -5201,7 +5231,7 @@ PRE(sys_waitpid, MayBlock)
                  vki_pid_t, pid, unsigned int *, status, int, options);
 
    if (arg2 != (Addr)NULL)
-      PRE_MEM_WRITE( "waitpid(status)", arg2, sizeof(int) );
+      SYS_PRE_MEM_WRITE( "waitpid(status)", arg2, sizeof(int) );
 }
 
 POST(sys_waitpid)
@@ -5218,9 +5248,9 @@ PRE(sys_wait4, MayBlock)
                  vki_pid_t, pid, unsigned int *, status, int, options,
                  struct rusage *, rusage);
    if (arg2 != (Addr)NULL)
-      PRE_MEM_WRITE( "wait4(status)", arg2, sizeof(int) );
+      SYS_PRE_MEM_WRITE( "wait4(status)", arg2, sizeof(int) );
    if (arg4 != (Addr)NULL)
-      PRE_MEM_WRITE( "wait4(rusage)", arg4, sizeof(struct vki_rusage) );
+      SYS_PRE_MEM_WRITE( "wait4(rusage)", arg4, sizeof(struct vki_rusage) );
 }
 
 POST(sys_wait4)
@@ -5242,13 +5272,17 @@ PRE(sys_writev, MayBlock)
    if (!VG_(fd_allowed)(arg1, "writev", tid, False)) {
       set_result( -VKI_EBADF );
    } else {
-      PRE_MEM_READ( "writev(vector)", 
+      SYS_PRE_MEM_READ( "writev(vector)", 
 		     arg2, arg3 * sizeof(struct vki_iovec) );
+      if ((Int)arg3 < 0) {
+	 set_result( -VKI_EINVAL );
+	 return;
+      }
       if (arg2 != 0) {
          /* ToDo: don't do any of the following if the vector is invalid */
          vec = (struct vki_iovec *)arg2;
          for (i = 0; i < (Int)arg3; i++)
-            PRE_MEM_READ( "writev(vector[...])",
+            SYS_PRE_MEM_READ( "writev(vector[...])",
                            (Addr)vec[i].iov_base, vec[i].iov_len );
       }
    }
@@ -5258,9 +5292,9 @@ PRE(sys_utimes, 0)
 {
    PRINT("sys_utimes ( %p, %p )", arg1,arg2);
    PRE_REG_READ2(long, "utimes", char *, filename, struct timeval *, tvp);
-   PRE_MEM_RASCIIZ( "utimes(filename)", arg1 );
+   SYS_PRE_MEM_RASCIIZ( "utimes(filename)", arg1 );
    if (arg2 != 0)
-      PRE_MEM_READ( "utimes(tvp)", arg2, sizeof(struct vki_timeval) );
+      SYS_PRE_MEM_READ( "utimes(tvp)", arg2, sizeof(struct vki_timeval) );
 }
 
 PRE(sys_sched_setaffinity, 0)
@@ -5268,7 +5302,7 @@ PRE(sys_sched_setaffinity, 0)
    PRINT("sched_setaffinity ( %d, %d, %p )", arg1, arg2, arg3);
    PRE_REG_READ3(long, "sched_setaffinity", 
                  vki_pid_t, pid, unsigned int, len, unsigned long *, mask);
-   PRE_MEM_READ( "sched_setaffinity(mask)", arg3, arg2);
+   SYS_PRE_MEM_READ( "sched_setaffinity(mask)", arg3, arg2);
 }
 
 PRE(sys_sched_getaffinity, 0)
@@ -5276,7 +5310,7 @@ PRE(sys_sched_getaffinity, 0)
    PRINT("sched_getaffinity ( %d, %d, %p )", arg1, arg2, arg3);
    PRE_REG_READ3(long, "sched_getaffinity", 
                  vki_pid_t, pid, unsigned int, len, unsigned long *, mask);
-   PRE_MEM_WRITE( "sched_getaffinity(mask)", arg3, arg2);
+   SYS_PRE_MEM_WRITE( "sched_getaffinity(mask)", arg3, arg2);
 }
 
 POST(sys_sched_getaffinity)
@@ -5288,7 +5322,7 @@ PRE(sys_acct, 0)
 {
    PRINT("sys_acct ( %p )", arg1);
    PRE_REG_READ1(long, "acct", const char *, filename);
-   PRE_MEM_RASCIIZ( "acct(filename)", arg1 );
+   SYS_PRE_MEM_RASCIIZ( "acct(filename)", arg1 );
 }
 
 PRE(sys_pause, MayBlock)
@@ -5327,7 +5361,7 @@ PRE(sys_rt_sigsuspend, MayBlock)
    PRINT("sys_rt_sigsuspend ( %p, %d )", arg1,arg2 );
    PRE_REG_READ2(int, "rt_sigsuspend", vki_sigset_t *, mask, vki_size_t, size)
    if (arg1 != (Addr)NULL) {
-      PRE_MEM_READ( "rt_sigsuspend(mask)", arg1, sizeof(vki_sigset_t) );
+      SYS_PRE_MEM_READ( "rt_sigsuspend(mask)", arg1, sizeof(vki_sigset_t) );
    }
 }
 
@@ -5339,11 +5373,12 @@ PRE(sys_rt_sigtimedwait, MayBlock)
                  const vki_sigset_t *, set, vki_siginfo_t *, info,
                  const struct timespec *, timeout, vki_size_t, sigsetsize);
    if (arg1 != 0) 
-      PRE_MEM_READ(  "rt_sigtimedwait(set)",  arg1, sizeof(vki_sigset_t));
+      SYS_PRE_MEM_READ(  "rt_sigtimedwait(set)",  arg1, sizeof(vki_sigset_t));
    if (arg2 != 0)
-      PRE_MEM_WRITE( "rt_sigtimedwait(info)", arg2, sizeof(vki_siginfo_t) );
-   PRE_MEM_READ( "rt_sigtimedwait(timeout)",
-                 arg3, sizeof(struct vki_timespec) );
+      SYS_PRE_MEM_WRITE( "rt_sigtimedwait(info)", arg2, sizeof(vki_siginfo_t) );
+   if (arg3 != 0)
+      SYS_PRE_MEM_READ( "rt_sigtimedwait(timeout)",
+		     arg3, sizeof(struct vki_timespec) );
 }
 
 POST(sys_rt_sigtimedwait)
@@ -5358,7 +5393,7 @@ PRE(sys_rt_sigqueueinfo, 0)
    PRE_REG_READ3(long, "rt_sigqueueinfo", 
                  int, pid, int, sig, vki_siginfo_t *, uinfo);
    if (arg2 != 0)
-      PRE_MEM_READ( "rt_sigqueueinfo(uinfo)", arg3, sizeof(vki_siginfo_t) );
+      SYS_PRE_MEM_READ( "rt_sigqueueinfo(uinfo)", arg3, sizeof(vki_siginfo_t) );
 }
 
 POST(sys_rt_sigqueueinfo)
@@ -5374,10 +5409,10 @@ PRE(sys_sigaltstack, Special)
    PRE_REG_READ2(int, "sigaltstack",
                  const vki_stack_t *, ss, vki_stack_t *, oss);
    if (arg1 != 0) {
-      PRE_MEM_READ( "sigaltstack(ss)", arg1, sizeof(vki_stack_t) );
+      SYS_PRE_MEM_READ( "sigaltstack(ss)", arg1, sizeof(vki_stack_t) );
    }
    if (arg2 != 0) {
-      PRE_MEM_WRITE( "sigaltstack(oss)", arg2, sizeof(vki_stack_t) );
+      SYS_PRE_MEM_WRITE( "sigaltstack(oss)", arg2, sizeof(vki_stack_t) );
    }
 
    VG_(do_sys_sigaltstack) (tid);
@@ -5402,10 +5437,20 @@ PRE(sys_sigaction, Special)
 
    newp = oldp = NULL;
 
+   if (arg2 != 0)
+      SYS_PRE_MEM_READ( "sigaction(act)", arg2, sizeof(struct vki_old_sigaction));
+
+   if (arg3 != 0) {
+      SYS_PRE_MEM_WRITE( "sigaction(oldact)", arg3, sizeof(struct vki_old_sigaction));
+      oldp = &old;
+   }
+
+   if (VG_(is_kerror)(SYSRES))
+      return;
+
    if (arg2 != 0) {
       struct vki_old_sigaction *oldnew = (struct vki_old_sigaction *)arg2;
 
-      PRE_MEM_READ( "sigaction(act)", arg2, sizeof(struct vki_old_sigaction));
       new.ksa_handler = oldnew->ksa_handler;
       new.sa_flags = oldnew->sa_flags;
       new.sa_restorer = oldnew->sa_restorer;
@@ -5414,11 +5459,6 @@ PRE(sys_sigaction, Special)
       newp = &new;
    }
 
-   if (arg3 != 0) {
-      PRE_MEM_WRITE( "sigaction(oldact)", arg3, sizeof(struct vki_old_sigaction));
-      oldp = &old;
-   }
-
    set_result(VG_(do_sys_sigaction)(arg1, newp, oldp));
 
    if (arg3 != 0 && SYSRES == 0) {
@@ -5446,9 +5486,9 @@ PRE(sys_rt_sigaction, Special)
                  struct sigaction *, oldact, vki_size_t, sigsetsize);
 
    if (arg2 != 0)
-      PRE_MEM_READ( "rt_sigaction(act)", arg2, sizeof(struct vki_sigaction));
+      SYS_PRE_MEM_READ( "rt_sigaction(act)", arg2, sizeof(struct vki_sigaction));
    if (arg3 != 0)
-      PRE_MEM_WRITE( "rt_sigaction(oldact)", arg3, sizeof(struct vki_sigaction));
+      SYS_PRE_MEM_WRITE( "rt_sigaction(oldact)", arg3, sizeof(struct vki_sigaction));
 
    set_result(VG_(do_sys_sigaction)(arg1, (const struct vki_sigaction *)arg2,
 				    (struct vki_sigaction *)arg3));
@@ -5466,9 +5506,9 @@ PRE(sys_sigprocmask, Special)
    PRE_REG_READ3(long, "sigprocmask", 
                  int, how, vki_old_sigset_t *, set, vki_old_sigset_t *, oldset);
    if (arg2 != 0)
-      PRE_MEM_READ( "sigprocmask(set)", arg2, sizeof(vki_old_sigset_t));
+      SYS_PRE_MEM_READ( "sigprocmask(set)", arg2, sizeof(vki_old_sigset_t));
    if (arg3 != 0)
-      PRE_MEM_WRITE( "sigprocmask(oldset)", arg3, sizeof(vki_old_sigset_t));
+      SYS_PRE_MEM_WRITE( "sigprocmask(oldset)", arg3, sizeof(vki_old_sigset_t));
 
    {
       // Nb: We must convert the smaller vki_old_sigset_t params into bigger
@@ -5504,9 +5544,9 @@ PRE(sys_rt_sigprocmask, Special)
                  int, how, vki_sigset_t *, set, vki_sigset_t *, oldset,
                  vki_size_t, sigsetsize);
    if (arg2 != 0)
-      PRE_MEM_READ( "rt_sigprocmask(set)", arg2, sizeof(vki_sigset_t));
+      SYS_PRE_MEM_READ( "rt_sigprocmask(set)", arg2, sizeof(vki_sigset_t));
    if (arg3 != 0)
-      PRE_MEM_WRITE( "rt_sigprocmask(oldset)", arg3, sizeof(vki_sigset_t));
+      SYS_PRE_MEM_WRITE( "rt_sigprocmask(oldset)", arg3, sizeof(vki_sigset_t));
 
    // Like the kernel, we fail if the sigsetsize is not exactly what we expect.
    if (sizeof(vki_sigset_t) != arg4)
@@ -5528,7 +5568,7 @@ PRE(sys_sigpending, 0)
 {
    PRINT( "sys_sigpending ( %p )", arg1 );
    PRE_REG_READ1(long, "sigpending", vki_old_sigset_t *, set);
-   PRE_MEM_WRITE( "sigpending(set)", arg1, sizeof(vki_old_sigset_t));
+   SYS_PRE_MEM_WRITE( "sigpending(set)", arg1, sizeof(vki_old_sigset_t));
 }
 
 POST(sys_sigpending)
@@ -5541,7 +5581,7 @@ PRE(sys_rt_sigpending, 0)
    PRINT( "sys_rt_sigpending ( %p )", arg1 );
    PRE_REG_READ2(long, "rt_sigpending", 
                  vki_sigset_t *, set, vki_size_t, sigsetsize);
-   PRE_MEM_WRITE( "rt_sigpending(set)", arg1, sizeof(vki_sigset_t));
+   SYS_PRE_MEM_WRITE( "rt_sigpending(set)", arg1, sizeof(vki_sigset_t));
 }
 
 POST(sys_rt_sigpending)
@@ -5556,12 +5596,12 @@ PRE(sys_mq_open, 0)
    PRE_REG_READ4(long, "mq_open",
                  const char *, name, int, oflag, vki_mode_t, mode,
                  struct mq_attr *, attr);
-   PRE_MEM_RASCIIZ( "mq_open(name)", arg1 );
+   SYS_PRE_MEM_RASCIIZ( "mq_open(name)", arg1 );
    if ((arg2 & VKI_O_CREAT) != 0 && arg4 != 0) {
       const struct vki_mq_attr *attr = (struct vki_mq_attr *)arg4;
-      PRE_MEM_READ( "mq_open(attr->mq_maxmsg)",
+      SYS_PRE_MEM_READ( "mq_open(attr->mq_maxmsg)",
                      (Addr)&attr->mq_maxmsg, sizeof(attr->mq_maxmsg) );
-      PRE_MEM_READ( "mq_open(attr->mq_msgsize)",
+      SYS_PRE_MEM_READ( "mq_open(attr->mq_msgsize)",
                      (Addr)&attr->mq_msgsize, sizeof(attr->mq_msgsize) );
    }
 }
@@ -5581,7 +5621,7 @@ PRE(sys_mq_unlink, 0)
 {
    PRINT("sys_mq_unlink ( %p(%s) )", arg1,arg1);
    PRE_REG_READ1(long, "mq_unlink", const char *, name);
-   PRE_MEM_RASCIIZ( "mq_unlink(name)", arg1 );
+   SYS_PRE_MEM_RASCIIZ( "mq_unlink(name)", arg1 );
 }
 
 PRE(sys_mq_timedsend, MayBlock)
@@ -5594,9 +5634,9 @@ PRE(sys_mq_timedsend, MayBlock)
    if (!VG_(fd_allowed)(arg1, "mq_timedsend", tid, False)) {
       set_result( -VKI_EBADF );
    } else {
-      PRE_MEM_READ( "mq_timedsend(msg_ptr)", arg2, arg3 );
+      SYS_PRE_MEM_READ( "mq_timedsend(msg_ptr)", arg2, arg3 );
       if (arg5 != 0)
-         PRE_MEM_READ( "mq_timedsend(abs_timeout)", arg5,
+         SYS_PRE_MEM_READ( "mq_timedsend(abs_timeout)", arg5,
                         sizeof(struct vki_timespec) );
    }
 }
@@ -5612,12 +5652,12 @@ PRE(sys_mq_timedreceive, MayBlock)
    if (!VG_(fd_allowed)(arg1, "mq_timedreceive", tid, False)) {
       set_result( -VKI_EBADF );
    } else {
-      PRE_MEM_WRITE( "mq_timedreceive(msg_ptr)", arg2, arg3 );
+      SYS_PRE_MEM_WRITE( "mq_timedreceive(msg_ptr)", arg2, arg3 );
       if (arg4 != 0)
-         PRE_MEM_WRITE( "mq_timedreceive(msg_prio)",
+         SYS_PRE_MEM_WRITE( "mq_timedreceive(msg_prio)",
                         arg4, sizeof(unsigned int) );
       if (arg5 != 0)
-         PRE_MEM_READ( "mq_timedreceive(abs_timeout)",
+         SYS_PRE_MEM_READ( "mq_timedreceive(abs_timeout)",
                         arg5, sizeof(struct vki_timespec) );
    }
 }
@@ -5637,7 +5677,7 @@ PRE(sys_mq_notify, 0)
    if (!VG_(fd_allowed)(arg1, "mq_notify", tid, False))
       set_result( -VKI_EBADF );
    else if (arg2 != 0)
-      PRE_MEM_READ( "mq_notify(notification)",
+      SYS_PRE_MEM_READ( "mq_notify(notification)",
                     arg2, sizeof(struct vki_sigevent) );
 }
 
@@ -5652,11 +5692,11 @@ PRE(sys_mq_getsetattr, 0)
    } else {
       if (arg2 != 0) {
          const struct vki_mq_attr *attr = (struct vki_mq_attr *)arg2;
-         PRE_MEM_READ( "mq_getsetattr(mqstat->mq_flags)",
+         SYS_PRE_MEM_READ( "mq_getsetattr(mqstat->mq_flags)",
                         (Addr)&attr->mq_flags, sizeof(attr->mq_flags) );
       }
       if (arg3 != 0)
-         PRE_MEM_WRITE( "mq_getsetattr(omqstat)", arg3,
+         SYS_PRE_MEM_WRITE( "mq_getsetattr(omqstat)", arg3,
                         sizeof(struct vki_mq_attr) );
    }   
 }
@@ -5674,8 +5714,8 @@ PRE(sys_timer_create, 0)
                  vki_clockid_t, clockid, struct sigevent *, evp,
                  vki_timer_t *, timerid);
    if (arg2 != 0)
-      PRE_MEM_READ( "timer_create(evp)", arg2, sizeof(struct vki_sigevent) );
-   PRE_MEM_WRITE( "timer_create(timerid)", arg3, sizeof(vki_timer_t) );
+      SYS_PRE_MEM_READ( "timer_create(evp)", arg2, sizeof(struct vki_sigevent) );
+   SYS_PRE_MEM_WRITE( "timer_create(timerid)", arg3, sizeof(vki_timer_t) );
 }
 
 POST(sys_timer_create)
@@ -5690,10 +5730,10 @@ PRE(sys_timer_settime, 0)
                  vki_timer_t, timerid, int, flags,
                  const struct itimerspec *, value,
                  struct itimerspec *, ovalue);
-   PRE_MEM_READ( "timer_settime(value)", arg3,
+   SYS_PRE_MEM_READ( "timer_settime(value)", arg3,
                   sizeof(struct vki_itimerspec) );
    if (arg4 != 0)
-       PRE_MEM_WRITE( "timer_settime(ovalue)", arg4,
+       SYS_PRE_MEM_WRITE( "timer_settime(ovalue)", arg4,
                       sizeof(struct vki_itimerspec) );
 }
 
@@ -5708,7 +5748,7 @@ PRE(sys_timer_gettime, 0)
    PRINT("sys_timer_gettime( %lld, %p )", (ULong)arg1,arg2);
    PRE_REG_READ2(long, "timer_gettime", 
                  vki_timer_t, timerid, struct itimerspec *, value);
-   PRE_MEM_WRITE( "timer_gettime(value)", arg2,
+   SYS_PRE_MEM_WRITE( "timer_gettime(value)", arg2,
                   sizeof(struct vki_itimerspec));
 }
 
@@ -5734,7 +5774,7 @@ PRE(sys_clock_settime, 0)
    PRINT("sys_clock_settime( %d, %p )", arg1,arg2);
    PRE_REG_READ2(long, "clock_settime", 
                  vki_clockid_t, clk_id, const struct timespec *, tp);
-   PRE_MEM_READ( "clock_settime(tp)", arg2, sizeof(struct vki_timespec) );
+   SYS_PRE_MEM_READ( "clock_settime(tp)", arg2, sizeof(struct vki_timespec) );
 }
 
 PRE(sys_clock_gettime, 0)
@@ -5742,7 +5782,7 @@ PRE(sys_clock_gettime, 0)
    PRINT("sys_clock_gettime( %d, %p )" , arg1,arg2);
    PRE_REG_READ2(long, "clock_gettime", 
                  vki_clockid_t, clk_id, struct timespec *, tp);
-   PRE_MEM_WRITE( "clock_gettime(tp)", arg2, sizeof(struct vki_timespec) );
+   SYS_PRE_MEM_WRITE( "clock_gettime(tp)", arg2, sizeof(struct vki_timespec) );
 }
 
 POST(sys_clock_gettime)
@@ -5754,8 +5794,8 @@ PRE(sys_clock_getres, 0)
 {
    PRINT("sys_clock_getres( %d, %p )" , arg1,arg2);
    PRE_REG_READ2(long, "clock_getres", 
-                 vki_clockid_t, clk_id, struct timespec *, res);
-   PRE_MEM_WRITE( "clock_getres(res)", arg2, sizeof(struct vki_timespec) );
+                 vki_clockid_t, clk_id, struct timespec *, cres);
+   SYS_PRE_MEM_WRITE( "clock_getres(cres)", arg2, sizeof(struct vki_timespec) );
 }
 
 POST(sys_clock_getres)
@@ -5871,11 +5911,15 @@ void VG_(client_syscall) ( ThreadId tid 
 	 /* "before" did the syscall, so don't do anything else. */
          PRINT(" ==> %lld (0x%llx)\n", (Long)(Word)SYSRES, (ULong)SYSRES);
       } else if (mayBlock) {
+	 vki_sigset_t mask;
 	 /* Syscall may block, so run it asynchronously */
          PRINT(" --> ...\n");
 
+	 mask = tst->sig_mask;
+	 VG_(sanitize_client_sigmask)(&mask);
+
 	 VG_(set_sleeping)(tid, VgTs_WaitSys);
-	 VGA_(client_syscall)(syscallno, &tst->arch, &tst->sig_mask,
+	 VGA_(client_syscall)(syscallno, &tst->arch, &mask,
 			      &VG_(blocked_mask), 
 			      _VKI_NSIG_WORDS * sizeof(UWord));
 	 /* VGA_(client_syscall) may not return if the syscall was
diff -puN none/tests/exec-sigmask.c~update-regtest none/tests/exec-sigmask.c
--- valgrind/none/tests/exec-sigmask.c~update-regtest	2005-01-12 13:54:43.000000000 -0800
+++ valgrind-jeremy/none/tests/exec-sigmask.c	2005-01-12 13:54:43.000000000 -0800
@@ -3,24 +3,65 @@
 #include <errno.h>
 #include <string.h>
 #include <stdio.h>
+#include <sys/wait.h>
+#include <sys/types.h>
+#include <stdlib.h>
 
-int main(int argc, char **argv)
+static void do_exec(const char *path, const char *arg, const sigset_t *mask)
 {
-	if (argc == 1) {
-		sigset_t all;
+	pid_t pid;
+	int status;
 
+	pid = fork();
+	if (pid == -1) {
+		perror("fork");
+		exit(1);
+	}
+	if (pid == 0) {
+		sigprocmask(SIG_SETMASK, mask, NULL);
+		execl(path, path, arg, NULL);
+			
+		fprintf(stderr, "FAILED: execl failed with %s\n",
+			strerror(errno));
+	} else {
+		int ret;
+		do 
+			ret = waitpid(pid, &status, 0);
+		while(ret == -1 && errno == EINTR);
+		if (ret != pid) {
+			perror("waitpid");
+			exit(1);
+		}
+		if (status != 0) {
+			fprintf(stderr, "child exec failed\n");
+			exit(1);
+		}
+	}
+}
 
-		sigfillset(&all);
-		sigprocmask(SIG_SETMASK, &all, NULL);
+int main(int argc, char **argv)
+{
+	if (argc == 1) {
+		sigset_t mask;
 
-		execl(argv[0], argv[0], "test", NULL);
+		sigfillset(&mask);
+		do_exec(argv[0], "full", &mask);
 
-		fprintf(stderr, "FAILED: execl failed with %s\n",
-			strerror(errno));
-		return 1;
+		sigemptyset(&mask);
+		do_exec(argv[0], "empty", &mask);
 	} else {
 		sigset_t mask;
 		int i;
+		int empty;
+
+		if (strcmp(argv[1], "full") == 0)
+			empty = 0;
+		else if (strcmp(argv[1], "empty") == 0)
+			empty = 1;
+		else {
+			fprintf(stderr, "empty or full?\n");
+			exit(1);
+		}
 
 		sigprocmask(SIG_SETMASK, NULL, &mask);
 
@@ -28,8 +69,13 @@ int main(int argc, char **argv)
 			if (i == SIGKILL || i == SIGSTOP)
 				continue;
 
-			if (!sigismember(&mask, i))
-				printf("signal %d missing from mask\n", i);
+			if (empty) {
+				if (sigismember(&mask, i))
+					printf("empty: signal %d added to mask\n", i);
+			} else {
+				if (!sigismember(&mask, i))
+					printf("full: signal %d missing from mask\n", i);
+			}
 		}
 	}
 
diff -puN none/tests/exec-sigmask.stdout.exp~update-regtest none/tests/exec-sigmask.stdout.exp
--- valgrind/none/tests/exec-sigmask.stdout.exp~update-regtest	2005-01-12 13:54:43.000000000 -0800
+++ valgrind-jeremy/none/tests/exec-sigmask.stdout.exp	2005-01-12 13:54:43.000000000 -0800
@@ -0,0 +1 @@
+full: signal 32 missing from mask
diff -puN none/tests/exec-sigmask.stderr.exp~update-regtest none/tests/exec-sigmask.stderr.exp
--- valgrind/none/tests/exec-sigmask.stderr.exp~update-regtest	2005-01-12 13:54:43.000000000 -0800
+++ valgrind-jeremy/none/tests/exec-sigmask.stderr.exp	2005-01-12 13:54:43.000000000 -0800
@@ -1 +1,2 @@
 
+
diff -puN coregrind/vg_memory.c~update-regtest coregrind/vg_memory.c
--- valgrind/coregrind/vg_memory.c~update-regtest	2005-01-12 13:54:43.000000000 -0800
+++ valgrind-jeremy/coregrind/vg_memory.c	2005-01-12 13:54:43.000000000 -0800
@@ -81,7 +81,8 @@ Bool VG_(seg_overlaps)(const Segment *s,
    Addr se = s->addr+s->len;
    Addr pe = p+len;
 
-   vg_assert(pe >= p);
+   if (pe < p)
+      return False;		/* wrapped */
 
    return (p < se && pe > s->addr);
 }
@@ -694,43 +695,35 @@ void VG_(unknown_SP_update)(Addr new_SP)
    }
 }
 
-static jmp_buf segv_jmpbuf;
-
-static void segv_handler(Int seg)
-{
-   __builtin_longjmp(segv_jmpbuf, 1);
-   VG_(core_panic)("longjmp failed");
-}
-
 /* 
-   Test if a piece of memory is addressable by setting up a temporary
-   SIGSEGV handler, then try to touch the memory.  No signal = good,
-   signal = bad.
+   Test if a piece of memory is addressable with at least the "prot"
+   protection permissions by examining the underlying segments.
  */
-Bool VG_(is_addressable)(Addr p, SizeT size)
+Bool VG_(is_addressable)(Addr p, SizeT size, UInt prot)
 {
-   volatile Char * volatile cp = (volatile Char *)p;
-   volatile Bool ret;
-   struct vki_sigaction sa, origsa;
-   vki_sigset_t mask;
-
-   sa.ksa_handler = segv_handler;
-   sa.sa_flags = 0;
-   VG_(sigfillset)(&sa.sa_mask);
-   VG_(sigaction)(VKI_SIGSEGV, &sa, &origsa);
-   VG_(sigprocmask)(VKI_SIG_SETMASK, NULL, &mask);
-
-   if (__builtin_setjmp(&segv_jmpbuf) == 0) {
-      while(size--)
-	 *cp++;
-      ret = True;
-    } else
-      ret = False;
+   Segment *seg;
 
-   VG_(sigaction)(VKI_SIGSEGV, &origsa, NULL);
-   VG_(sigprocmask)(VKI_SIG_SETMASK, &mask, NULL);
+   if ((p + size) < p)
+      return False;
 
-   return ret;
+   for(seg = VG_(find_segment)(p); 
+       size > 0 &&
+       seg &&
+       VG_(seg_overlaps)(seg, p, size) &&
+       (seg->prot & prot) == prot; 
+       seg = VG_(next_segment)(seg)) {
+      Addr end = p + size;
+      Addr segend = seg->addr + seg->len;
+
+      if (end <= segend)
+	 size = 0;
+      else {
+	 size -= segend - p;
+	 p = segend;
+      }
+   }
+
+   return size == 0;
 }
 
 /*--------------------------------------------------------------------*/
diff -puN coregrind/vg_translate.c~update-regtest coregrind/vg_translate.c
--- valgrind/coregrind/vg_translate.c~update-regtest	2005-01-12 13:54:43.000000000 -0800
+++ valgrind-jeremy/coregrind/vg_translate.c	2005-01-12 13:54:43.000000000 -0800
@@ -2476,7 +2476,7 @@ Bool VG_(translate) ( ThreadId tid, Addr
        !VG_(seg_contains)(seg, orig_addr, 1) || 
        (seg->prot & (VKI_PROT_READ|VKI_PROT_EXEC)) == 0) {
       /* Code address is bad - deliver a signal instead */
-      vg_assert(!VG_(is_addressable)(orig_addr, 1));
+      vg_assert(!VG_(is_addressable)(orig_addr, 1, VKI_PROT_EXEC));
 
       if (seg != NULL && VG_(seg_contains)(seg, orig_addr, 1)) {
 	 vg_assert((seg->prot & VKI_PROT_EXEC) == 0);
diff -puN include/tool.h.base~update-regtest include/tool.h.base
--- valgrind/include/tool.h.base~update-regtest	2005-01-12 13:54:43.000000000 -0800
+++ valgrind-jeremy/include/tool.h.base	2005-01-12 13:54:43.000000000 -0800
@@ -507,7 +507,7 @@ extern Addr VG_(get_shadow_size)(void);
 
 extern void *VG_(shadow_alloc)(UInt size);
 
-extern Bool VG_(is_addressable)(Addr p, SizeT sz);
+extern Bool VG_(is_addressable)(Addr p, SizeT sz, UInt prot);
 
 extern Addr VG_(client_alloc)(Addr base, SizeT len, UInt prot, UInt flags);
 extern void VG_(client_free)(Addr addr);
diff -puN memcheck/tests/scalar.c~update-regtest memcheck/tests/scalar.c
--- valgrind/memcheck/tests/scalar.c~update-regtest	2005-01-12 13:54:43.000000000 -0800
+++ valgrind-jeremy/memcheck/tests/scalar.c	2005-01-12 13:54:43.000000000 -0800
@@ -1007,7 +1007,7 @@ int main(void)
 
    // __NR_flistxattr 234
    GO(__NR_flistxattr, "3s 1m");
-   SY(__NR_flistxattr, x0-1, x0, x0+1); FAILx(EBADF);
+   SY(__NR_flistxattr, x0-1, x0, x0+1); FAILx(EFAULT); /* kernel returns EBADF, but both seem correct */
 
    // __NR_removexattr 235
    GO(__NR_removexattr, "2s 2m");
diff -puN coregrind/x86-linux/syscalls.c~update-regtest coregrind/x86-linux/syscalls.c
--- valgrind/coregrind/x86-linux/syscalls.c~update-regtest	2005-01-12 13:54:43.000000000 -0800
+++ valgrind-jeremy/coregrind/x86-linux/syscalls.c	2005-01-12 14:27:49.000000000 -0800
@@ -337,7 +337,6 @@ static Int do_clone(ThreadId ptid, 
 #define arg5	PLATFORM_SYSCALL_ARG5(tst->arch)
 #define arg6	PLATFORM_SYSCALL_ARG6(tst->arch)
 
-#define set_result(val) PLATFORM_SET_SYSCALL_RESULT(tst->arch, (val))
 
 #define PRINT(format, args...)  \
    if (VG_(clo_trace_syscalls))        \
@@ -352,7 +351,7 @@ PRE(old_select, MayBlock)
       };
    */
    PRE_REG_READ1(long, "old_select", struct sel_arg_struct *, args);
-   PRE_MEM_READ( "old_select(args)", arg1, 5*sizeof(UWord) );
+   SYS_PRE_MEM_READ( "old_select(args)", arg1, 5*sizeof(UWord) );
 
    {
       UInt* arg_struct = (UInt*)arg1;
@@ -366,13 +365,13 @@ PRE(old_select, MayBlock)
 
       PRINT("old_select ( %d, %p, %p, %p, %p )", a1,a2,a3,a4,a5);
       if (a2 != (Addr)NULL)
-	 PRE_MEM_READ( "old_select(readfds)",   a2, a1/8 /* __FD_SETSIZE/8 */ );
+	 SYS_PRE_MEM_READ( "old_select(readfds)",   a2, a1/8 /* __FD_SETSIZE/8 */ );
       if (a3 != (Addr)NULL)
-	 PRE_MEM_READ( "old_select(writefds)",  a3, a1/8 /* __FD_SETSIZE/8 */ );
+	 SYS_PRE_MEM_READ( "old_select(writefds)",  a3, a1/8 /* __FD_SETSIZE/8 */ );
       if (a4 != (Addr)NULL)
-	 PRE_MEM_READ( "old_select(exceptfds)", a4, a1/8 /* __FD_SETSIZE/8 */ );
+	 SYS_PRE_MEM_READ( "old_select(exceptfds)", a4, a1/8 /* __FD_SETSIZE/8 */ );
       if (a5 != (Addr)NULL)
-	 PRE_MEM_READ( "old_select(timeout)", a5, sizeof(struct vki_timeval) );
+	 SYS_PRE_MEM_READ( "old_select(timeout)", a5, sizeof(struct vki_timeval) );
    }
 }
 
@@ -388,17 +387,32 @@ PRE(sys_clone, Special)
 		 vki_modify_ldt_t *, tlsinfo,
 		 int *, child_tidptr);
 
-   if (arg1 & VKI_CLONE_PARENT_SETTID)
-      PRE_MEM_WRITE("clone(parent_tidptr)", arg3, sizeof(Int));
-   if (arg1 & (VKI_CLONE_CHILD_SETTID | VKI_CLONE_CHILD_CLEARTID))
-      PRE_MEM_WRITE("clone(child_tidptr)", arg5, sizeof(Int));
-   if (arg1 & VKI_CLONE_SETTLS)
-      PRE_MEM_READ("clone(tls_user_desc)", arg4, sizeof(vki_modify_ldt_t));
+   if (arg1 & VKI_CLONE_PARENT_SETTID) {
+      SYS_PRE_MEM_WRITE("clone(parent_tidptr)", arg3, sizeof(Int));
+      if (!VG_(is_addressable)(arg3, sizeof(Int), VKI_PROT_WRITE)) {
+	 set_result( -VKI_EFAULT );
+	 return;
+      }
+   }
+   if (arg1 & (VKI_CLONE_CHILD_SETTID | VKI_CLONE_CHILD_CLEARTID)) {
+      SYS_PRE_MEM_WRITE("clone(child_tidptr)", arg5, sizeof(Int));
+      if (!VG_(is_addressable)(arg5, sizeof(Int), VKI_PROT_WRITE)) {
+	 set_result( -VKI_EFAULT );
+	 return;
+      }
+   }
+   if (arg1 & VKI_CLONE_SETTLS) {
+      SYS_PRE_MEM_READ("clone(tls_user_desc)", arg4, sizeof(vki_modify_ldt_t));
+      if (!VG_(is_addressable)(arg4, sizeof(vki_modify_ldt_t), VKI_PROT_READ)) {
+	 set_result( -VKI_EFAULT );
+	 return;
+      }
+   }
 
    /* Only look at the flags we really care about */
    cloneflags = arg1 & (VKI_CLONE_VM | VKI_CLONE_FS | VKI_CLONE_FILES | VKI_CLONE_VFORK);
    
-   if ((arg1 & VKI_CSIGNAL) && !VG_(client_signal_OK)(arg1 & VKI_CSIGNAL)) {
+   if (!VG_(client_signal_OK)(arg1 & VKI_CSIGNAL)) {
       set_result( -VKI_EINVAL );
       return;
    }
@@ -450,11 +464,11 @@ PRE(sys_modify_ldt, Special)
    
    if (arg1 == 0) {
       /* read the LDT into ptr */
-      PRE_MEM_WRITE( "modify_ldt(ptr)", arg2, arg3 );
+      SYS_PRE_MEM_WRITE( "modify_ldt(ptr)", arg2, arg3 );
    }
    if (arg1 == 1 || arg1 == 0x11) {
       /* write the LDT with the entry pointed at by ptr */
-      PRE_MEM_READ( "modify_ldt(ptr)", arg2, sizeof(vki_modify_ldt_t) );
+      SYS_PRE_MEM_READ( "modify_ldt(ptr)", arg2, sizeof(vki_modify_ldt_t) );
    }
    /* "do" the syscall ourselves; the kernel never sees it */
    res = VG_(sys_modify_ldt)( tid, arg1, (void*)arg2, arg3 );
@@ -468,7 +482,7 @@ PRE(sys_set_thread_area, Special)
 {
    PRINT("sys_set_thread_area ( %p )", arg1);
    PRE_REG_READ1(int, "set_thread_area", struct user_desc *, u_info)
-   PRE_MEM_READ( "set_thread_area(u_info)", arg1, sizeof(vki_modify_ldt_t) );
+   SYS_PRE_MEM_READ( "set_thread_area(u_info)", arg1, sizeof(vki_modify_ldt_t) );
 
    /* "do" the syscall ourselves; the kernel never sees it */
    set_result( VG_(sys_set_thread_area)( tid, (void *)arg1 ) );
@@ -478,7 +492,7 @@ PRE(sys_get_thread_area, Special)
 {
    PRINT("sys_get_thread_area ( %p )", arg1);
    PRE_REG_READ1(int, "get_thread_area", struct user_desc *, u_info)
-   PRE_MEM_WRITE( "get_thread_area(u_info)", arg1, sizeof(vki_modify_ldt_t) );
+   SYS_PRE_MEM_WRITE( "get_thread_area(u_info)", arg1, sizeof(vki_modify_ldt_t) );
 
    /* "do" the syscall ourselves; the kernel never sees it */
    set_result( VG_(sys_get_thread_area)( tid, (void *)arg1 ) );
diff -puN coregrind/x86/signal.c~update-regtest coregrind/x86/signal.c
--- valgrind/coregrind/x86/signal.c~update-regtest	2005-01-12 13:54:43.000000000 -0800
+++ valgrind-jeremy/coregrind/x86/signal.c	2005-01-12 14:27:49.000000000 -0800
@@ -342,49 +342,6 @@ static void synth_ucontext(ThreadId tid,
    SET_THREAD_REG(zztid, zzval, ARCH_STACK_PTR, R_STACK_PTR, \
                   post_reg_write_deliver_signal)
 
-static Bool seg_ok(Segment *seg, VgSigFrame *frame)
-{
-   if (!VG_(seg_overlaps)(seg, (Addr)frame, sizeof(*frame)))
-      return False;
-
-   if ((seg->prot & (VKI_PROT_READ|VKI_PROT_WRITE)) != (VKI_PROT_READ|VKI_PROT_WRITE))
-      return False;
-
-   return True;
-}
-
-/* Make sure that there are segments covering all of frame, and
-   they're read/write.  */
-static Bool compat_segments(Segment *seg, VgSigFrame *frame)
-{
-   Segment *next;
-   Addr a = (Addr)frame;
-   UInt remains = sizeof(*frame);
-
-   while(remains && seg) {
-      Addr end = seg->addr + seg->len;
-
-      next = VG_(next_segment)(seg);
-
-      if (!seg_ok(seg, frame))
-	 return False;
-
-      if ((end - a) > remains)
-	 remains = 0;
-      else {
-	 remains -= end - a;
-	 a = end;
-      }
-
-      if (next->addr != end)
-	 next = NULL;
-
-      seg = next;
-   }
-
-   return remains == 0;
-}
-
 void VGA_(push_signal_frame)(ThreadId tid, Addr esp_top_of_frame,
                              const vki_siginfo_t *siginfo,
                              void *handler, UInt flags,
@@ -407,7 +364,8 @@ void VGA_(push_signal_frame)(ThreadId ti
 		     frame, stackseg->addr, stackseg->addr+stackseg->len);
    }
 
-   if (stackseg == NULL || !compat_segments(stackseg, frame)) {
+   if (stackseg == NULL ||
+       !VG_(is_addressable)((Addr)frame, sizeof(*frame), VKI_PROT_READ|VKI_PROT_WRITE)) {
       VG_(message)(Vg_UserMsg,
 		   "Can't extend stack to %p during signal delivery for thread %d:",
 		   frame, tid);
diff -puN memcheck/tests/scalar.stderr.exp~update-regtest memcheck/tests/scalar.stderr.exp
--- valgrind/memcheck/tests/scalar.stderr.exp~update-regtest	2005-01-12 13:54:43.000000000 -0800
+++ valgrind-jeremy/memcheck/tests/scalar.stderr.exp	2005-01-12 13:54:43.000000000 -0800
@@ -1555,10 +1555,21 @@ Syscall param clone(parent_tidptr) conta
    by 0x........: __libc_start_main (...libc...)
    by 0x........: ...
 
+Syscall param clone(tlsinfo) contains uninitialised byte(s)
+   at 0x........: syscall (in /...libc...)
+   by 0x........: __libc_start_main (...libc...)
+   by 0x........: ...
+
 Syscall param clone(child_tidptr) contains uninitialised byte(s)
    at 0x........: syscall (in /...libc...)
    by 0x........: __libc_start_main (...libc...)
    by 0x........: ...
+
+Syscall param clone(parent_tidptr) points to unaddressable byte(s)
+   at 0x........: syscall (in /...libc...)
+   by 0x........: __libc_start_main (...libc...)
+   by 0x........: ...
+ Address 0x........ is not stack'd, malloc'd or (recently) free'd
 -----------------------------------------------------
 121:  __NR_setdomainname n/a
 -----------------------------------------------------
@@ -4569,7 +4580,7 @@ Read the file README_MISSING_SYSCALL_OR_
   1:           __NR_exit 1s 0m
 -----------------------------------------------------
 
-Syscall param exit(error_code) contains uninitialised byte(s)
+Syscall param exit(exitcode) contains uninitialised byte(s)
    at 0x........: syscall (in /...libc...)
    by 0x........: __libc_start_main (...libc...)
    by 0x........: ...
diff -puN memcheck/tests/zeropage.stderr.exp~update-regtest memcheck/tests/zeropage.stderr.exp
--- valgrind/memcheck/tests/zeropage.stderr.exp~update-regtest	2005-01-12 13:54:43.000000000 -0800
+++ valgrind-jeremy/memcheck/tests/zeropage.stderr.exp	2005-01-12 13:54:43.000000000 -0800
@@ -1,3 +0,0 @@
-Warning: client syscall mmap2 tried to modify addresses 0x........-0x........
-Warning: client syscall mmap2 tried to modify addresses 0x........-0x........
-Warning: client syscall mmap2 tried to modify addresses 0x........-0x........
diff -puN /dev/null memcheck/tests/zeropage.stdout.exp
--- /dev/null	2004-02-23 13:02:56.000000000 -0800
+++ valgrind-jeremy/memcheck/tests/zeropage.stdout.exp	2005-01-12 13:54:43.000000000 -0800
@@ -0,0 +1,3 @@
+succeeded?!
+succeeded?!
+succeeded?!
diff -puN coregrind/vg_symtab2.c~update-regtest coregrind/vg_symtab2.c
--- valgrind/coregrind/vg_symtab2.c~update-regtest	2005-01-12 13:54:43.000000000 -0800
+++ valgrind-jeremy/coregrind/vg_symtab2.c	2005-01-12 13:54:43.000000000 -0800
@@ -1096,6 +1096,7 @@ Addr open_debug_file( Char* name, UInt c
    Int fd;
    struct vki_stat stat_buf;
    Addr addr;
+   UInt calccrc;
 
    if ((fd = VG_(open)(name, VKI_O_RDONLY, 0)) < 0)
       return 0;
@@ -1105,6 +1106,9 @@ Addr open_debug_file( Char* name, UInt c
       return 0;
    }
 
+   if (VG_(clo_verbosity) > 1)
+      VG_(message)(Vg_UserMsg, "Reading debug info from %s...", name);
+
    *size = stat_buf.st_size;
    
    if ((addr = (Addr)VG_(mmap)(NULL, *size, VKI_PROT_READ,
@@ -1117,9 +1121,12 @@ Addr open_debug_file( Char* name, UInt c
 
    VG_(close)(fd);
    
-   if (calc_gnu_debuglink_crc32(0, (UChar*)addr, *size) != crc) {
+   calccrc = calc_gnu_debuglink_crc32(0, (UChar*)addr, *size);
+   if (calccrc != crc) {
       int res = VG_(munmap)((void*)addr, *size);
       vg_assert(0 == res);
+      if (VG_(clo_verbosity) > 1)
+	 VG_(message)(Vg_UserMsg, "... CRC mismatch (computed %08x wanted %08x)", calccrc, crc);
       return 0;
    }
    
@@ -1433,7 +1440,7 @@ Bool vg_read_lib_symbols ( SegInfo* si )
 
       /* Did we find a debuglink section? */
       if (debuglink != NULL) {
-         UInt crc_offset = (VG_(strlen)(debuglink) + 4) & ~3;
+         UInt crc_offset = ROUNDUP(VG_(strlen)(debuglink)+1, 4);
          UInt crc;
 
          vg_assert(crc_offset + sizeof(UInt) <= debuglink_sz);

_