diff --git a/addrcheck/ac_main.c b/addrcheck/ac_main.c
index 12ae62a..22d8169 100644
--- a/addrcheck/ac_main.c
+++ b/addrcheck/ac_main.c
@@ -630,6 +630,12 @@
    }
 }
 
+static
+void ac_post_mem_write(CorePart part, ThreadId tid, Addr a, SizeT len)
+{
+   ac_make_accessible(a, len);
+}
+
 
 /*------------------------------------------------------------*/
 /*--- Functions called directly from generated code.       ---*/
diff --git a/coregrind/core.h b/coregrind/core.h
index 8fac3b1..9d7302d 100644
--- a/coregrind/core.h
+++ b/coregrind/core.h
@@ -913,26 +913,26 @@
 // Write a value to a client's thread register, and shadow (if necessary).
 // Note that there are some further similar macros in the arch- and
 // platform-specific parts;  these ones are the totally generic ones.
-#define SET_THREAD_REG( zztid, zzval, zzGETREG, zzREG, zzevent, zzargs... ) \
-   do { zzGETREG(VG_(threads)[zztid].arch) = (zzval);         \
-        VG_TRACK( zzevent, zztid, zzREG, ##zzargs );          \
+#define SET_THREAD_REG( zztid, zzval, zzGETREG, zzevent, zzargs... ) \
+   do { zzGETREG(VG_(threads)[zztid].arch) = (zzval); \
+        VG_TRACK( zzevent, ##zzargs ); \
    } while (0)
 
 #define SET_CLREQ_RETVAL(zztid, zzval) \
-   SET_THREAD_REG(zztid, zzval, ARCH_CLREQ_RET, R_CLREQ_RET, \
-                  post_reg_write_clientreq_return)
+   SET_THREAD_REG(zztid, zzval, CLREQ_RET, post_reg_write, \
+                  Vg_CoreClientReq, zztid, O_CLREQ_RET, sizeof(UWord))
 
 #define SET_CLCALL_RETVAL(zztid, zzval, f) \
-   SET_THREAD_REG(zztid, zzval, ARCH_CLREQ_RET, R_CLREQ_RET, \
-                  post_reg_write_clientcall_return, f)
+   SET_THREAD_REG(zztid, zzval, CLREQ_RET, post_reg_write_clientcall_return, \
+                  zztid, O_CLREQ_RET, sizeof(UWord), f)
 
 #define SET_PTHREQ_ESP(zztid, zzval) \
-   SET_THREAD_REG(zztid, zzval, ARCH_STACK_PTR, R_STACK_PTR, \
-                  post_reg_write_pthread_return)
+   SET_THREAD_REG(zztid, zzval, STACK_PTR, post_reg_write, \
+                  Vg_CorePThread, zztid, O_STACK_PTR, sizeof(Addr))
 
 #define SET_PTHREQ_RETVAL(zztid, zzval) \
-   SET_THREAD_REG(zztid, zzval, ARCH_PTHREQ_RET, R_PTHREQ_RET, \
-                  post_reg_write_pthread_return)
+   SET_THREAD_REG(zztid, zzval, PTHREQ_RET, post_reg_write, \
+                  Vg_CorePThread, zztid, O_PTHREQ_RET, sizeof(UWord))
 
 
 /* ---------------------------------------------------------------------
@@ -1630,10 +1630,10 @@
 
 #define PRRSN \
       TL_(pre_reg_read)(Vg_CoreSysCall, tid, "(syscallno)", \
-                        R_SYSCALL_NUM, sizeof(UWord));
+                        O_SYSCALL_NUM, sizeof(UWord));
 #define PRRAn(n,s,t,a) \
       TL_(pre_reg_read)(Vg_CoreSysCall, tid, s"("#a")", \
-                        R_SYSCALL_ARG##n, sizeof(t));
+                        O_SYSCALL_ARG##n, sizeof(t));
 #define PRE_REG_READ0(tr, s) \
    if (VG_(defined_pre_reg_read)()) { \
       PRRSN; \
@@ -1682,7 +1682,7 @@
    VG_TRACK( pre_mem_write, Vg_CoreSysCall, tid, zzname, zzaddr, zzlen)
 
 #define POST_MEM_WRITE(zzaddr, zzlen) \
-   VG_TRACK( post_mem_write, zzaddr, zzlen)
+   VG_TRACK( post_mem_write, Vg_CoreSysCall, tid, zzaddr, zzlen)
 
 /* ---------------------------------------------------------------------
    Exports of vg_transtab.c
@@ -1754,6 +1754,23 @@
 // Architecture-specific things defined in eg. x86/*.c
 // ---------------------------------------------------------------------
 
+// Accessors for the ThreadArchState
+#define INSTR_PTR(regs)    ((regs).vex.ARCH_INSTR_PTR)
+#define STACK_PTR(regs)    ((regs).vex.ARCH_STACK_PTR)
+#define FRAME_PTR(regs)    ((regs).vex.ARCH_FRAME_PTR)
+
+#define CLREQ_ARGS(regs)   ((regs).vex.ARCH_CLREQ_ARGS)
+#define PTHREQ_RET(regs)   ((regs).vex.ARCH_PTHREQ_RET)
+#define CLREQ_RET(regs)    ((regs).vex.ARCH_CLREQ_RET)
+
+// Offsets for the shadow state
+#define O_STACK_PTR        (offsetof(VexGuestArchState, ARCH_STACK_PTR))
+#define O_FRAME_PTR        (offsetof(VexGuestArchState, ARCH_FRAME_PTR))
+
+#define O_CLREQ_RET        (offsetof(VexGuestArchState, ARCH_CLREQ_RET))
+#define O_PTHREQ_RET       (offsetof(VexGuestArchState, ARCH_PTHREQ_RET))
+
+
 // Setting up the initial thread (1) state
 extern void 
        VGA_(init_thread1state) ( Addr client_eip, 
@@ -1769,7 +1786,7 @@
 extern void VGA_(thread_initial_stack)  ( ThreadId tid, UWord arg, Addr ret );
 
 // Symtab stuff
-extern UInt* VGA_(reg_addr_from_tst) ( Int reg, ThreadArchState* );
+extern UInt* VGA_(reg_addr_from_tst) ( Int regno, ThreadArchState* );
 
 // Pointercheck
 extern Bool VGA_(setup_pointercheck) ( void );
@@ -1818,6 +1835,26 @@
 // Platform-specific things defined in eg. x86/*.c
 // ---------------------------------------------------------------------
 
+// Accessors for the ThreadArchState
+#define SYSCALL_NUM(regs)  ((regs).vex.PLATFORM_SYSCALL_NUM)
+#define SYSCALL_ARG1(regs) ((regs).vex.PLATFORM_SYSCALL_ARG1)
+#define SYSCALL_ARG2(regs) ((regs).vex.PLATFORM_SYSCALL_ARG2)
+#define SYSCALL_ARG3(regs) ((regs).vex.PLATFORM_SYSCALL_ARG3)
+#define SYSCALL_ARG4(regs) ((regs).vex.PLATFORM_SYSCALL_ARG4)
+#define SYSCALL_ARG5(regs) ((regs).vex.PLATFORM_SYSCALL_ARG5)
+#define SYSCALL_ARG6(regs) ((regs).vex.PLATFORM_SYSCALL_ARG6)
+#define SYSCALL_RET(regs)  ((regs).vex.PLATFORM_SYSCALL_RET)
+
+// Offsets for the shadow state
+#define O_SYSCALL_NUM   (offsetof(VexGuestArchState, PLATFORM_SYSCALL_ARG6))
+#define O_SYSCALL_ARG1  (offsetof(VexGuestArchState, PLATFORM_SYSCALL_ARG1))
+#define O_SYSCALL_ARG2  (offsetof(VexGuestArchState, PLATFORM_SYSCALL_ARG2))
+#define O_SYSCALL_ARG3  (offsetof(VexGuestArchState, PLATFORM_SYSCALL_ARG3))
+#define O_SYSCALL_ARG4  (offsetof(VexGuestArchState, PLATFORM_SYSCALL_ARG4))
+#define O_SYSCALL_ARG5  (offsetof(VexGuestArchState, PLATFORM_SYSCALL_ARG5))
+#define O_SYSCALL_ARG6  (offsetof(VexGuestArchState, PLATFORM_SYSCALL_ARG6))
+#define O_SYSCALL_RET   (offsetof(VexGuestArchState, PLATFORM_SYSCALL_RET))
+
 struct SyscallTableEntry {
    UInt  *flags_ptr;
    void        (*before)(ThreadId tid, ThreadState *tst);
diff --git a/coregrind/linux/syscalls.c b/coregrind/linux/syscalls.c
index 2832e4f..e731c82 100644
--- a/coregrind/linux/syscalls.c
+++ b/coregrind/linux/syscalls.c
@@ -43,14 +43,14 @@
 #define POST(x) \
    void VGA_(linux_##x##_after) (ThreadId tid, ThreadState *tst)
 
-#define SYSNO	PLATFORM_SYSCALL_NUM(tst->arch)    // in PRE(x)
-#define res	PLATFORM_SYSCALL_RET(tst->arch)	   // in POST(x)
-#define arg1	PLATFORM_SYSCALL_ARG1(tst->arch)
-#define arg2	PLATFORM_SYSCALL_ARG2(tst->arch)
-#define arg3	PLATFORM_SYSCALL_ARG3(tst->arch)
-#define arg4	PLATFORM_SYSCALL_ARG4(tst->arch)
-#define arg5	PLATFORM_SYSCALL_ARG5(tst->arch)
-#define arg6	PLATFORM_SYSCALL_ARG6(tst->arch)
+#define SYSNO   SYSCALL_NUM(tst->arch)    // in PRE(x)
+#define res     SYSCALL_RET(tst->arch)    // in POST(x)
+#define arg1    SYSCALL_ARG1(tst->arch)
+#define arg2    SYSCALL_ARG2(tst->arch)
+#define arg3    SYSCALL_ARG3(tst->arch)
+#define arg4    SYSCALL_ARG4(tst->arch)
+#define arg5    SYSCALL_ARG5(tst->arch)
+#define arg6    SYSCALL_ARG6(tst->arch)
 
 #define set_result(val) PLATFORM_SET_SYSCALL_RESULT(tst->arch, (val))
 
@@ -127,7 +127,7 @@
 
 POST(sys_adjtimex)
 {
-   VG_TRACK(post_mem_write, arg1, sizeof(struct vki_timex));
+   POST_MEM_WRITE( arg1, sizeof(struct vki_timex) );
 }
 
 PRE(sys_setfsuid16, 0)
diff --git a/coregrind/toolfuncs.def b/coregrind/toolfuncs.def
index 1fa39ef..cf60f1c 100644
--- a/coregrind/toolfuncs.def
+++ b/coregrind/toolfuncs.def
@@ -204,33 +204,21 @@
 void,	ban_mem_stack,	Addr a, SizeT len
 
 ## These ones occur around syscalls, signal handling, etc
-void,	pre_mem_read,	CorePart part, ThreadId tid, Char* s, Addr a, SizeT size
-void,	pre_mem_read_asciiz,	CorePart part, ThreadId tid, Char* s, Addr a
-void,	pre_mem_write,	CorePart part, ThreadId tid, Char* s, Addr a, SizeT size
-## Not implemented yet -- have to add in lots of places, which is a
-## pain.  Won't bother unless/until there's a need.
-## void (*post_mem_read)  ( ThreadState* tst, Char* s, Addr a, SizeT size );
-void,	post_mem_write,	Addr a, SizeT size
+void,	pre_mem_read,	    CorePart part, ThreadId tid, Char* s, Addr a, SizeT size
+void,	pre_mem_read_asciiz,CorePart part, ThreadId tid, Char* s, Addr a
+void,	pre_mem_write,	    CorePart part, ThreadId tid, Char* s, Addr a, SizeT size
+void,	post_mem_write,	    CorePart part, ThreadId tid, Addr a, SizeT size
 
 
-## Register events -- if `shadow_regs' need is set, all should probably be
-## used.  Use VG_(set_thread_shadow_archreg)() to set the shadow of the
-## changed register.
-
-void,	pre_reg_read,	CorePart part, ThreadId tid, Char* s, UInt reg, SizeT size
-
-## Use VG_(set_shadow_archreg)() to set the eight general purpose regs,
-## and use VG_(set_shadow_eflags)() to set eflags.
-void,	post_regs_write_init,	void
-
-## Use VG_(set_thread_shadow_archreg)() to set the shadow regs for these
+## Register events -- if `shadow_regs' need is set, these should probably be
+## used.  Use VG_(set_shadow_state_area)() to set the shadow regs for these
 ## events.
-void,	post_reg_write_syscall_return,	ThreadId tid, UInt reg
-void,	post_reg_write_deliver_signal,	ThreadId tid, UInt reg
-void,	post_reg_write_pthread_return,	ThreadId tid, UInt reg
-void,	post_reg_write_clientreq_return,	ThreadId tid, UInt reg
+
+void,	pre_reg_read,	CorePart part, ThreadId tid, Char* s, OffT guest_state_offset, SizeT size
+void,	post_reg_write,	CorePart part, ThreadId tid, OffT guest_state_offset, SizeT size
+
 ## This one is called for malloc() et al if they are replaced by a tool.
-void,	post_reg_write_clientcall_return,	ThreadId tid, UInt reg, Addr f
+void,	post_reg_write_clientcall_return,	ThreadId tid, OffT guest_state_offset, SizeT size, Addr f
 
 
 ## Scheduler events (not exhaustive)
diff --git a/coregrind/vg_execontext.c b/coregrind/vg_execontext.c
index 371d26e..8f53fc4 100644
--- a/coregrind/vg_execontext.c
+++ b/coregrind/vg_execontext.c
@@ -306,9 +306,9 @@
                      Addr* stack_highest_word)
 {
    ThreadState* tst = & VG_(threads)[ tid ];
-   *ip                 = ARCH_INSTR_PTR(tst->arch);
-   *fp                 = ARCH_FRAME_PTR(tst->arch);
-   *sp                 = ARCH_STACK_PTR(tst->arch);
+   *ip                 = INSTR_PTR(tst->arch);
+   *fp                 = FRAME_PTR(tst->arch);
+   *sp                 = STACK_PTR(tst->arch);
    *stack_highest_word = tst->stack_highest_word;
 
    /* Nasty little hack to deal with sysinfo syscalls - if libc is
@@ -355,7 +355,7 @@
 
 Addr VG_(get_EIP) ( ThreadId tid )
 {
-   return ARCH_INSTR_PTR(VG_(threads)[ tid ].arch);
+   return INSTR_PTR(VG_(threads)[ tid ].arch);
 }
 
 /*--------------------------------------------------------------------*/
diff --git a/coregrind/vg_main.c b/coregrind/vg_main.c
index 091391b..114ad1e 100644
--- a/coregrind/vg_main.c
+++ b/coregrind/vg_main.c
@@ -326,7 +326,7 @@
 /* Get the simulated stack pointer */
 Addr VG_(get_stack_pointer) ( ThreadId tid )
 {
-   return ARCH_STACK_PTR( VG_(threads)[tid].arch );
+   return STACK_PTR( VG_(threads)[tid].arch );
 }
 
 /* Initialize the PID and PGRP of scheduler LWP; this is also called
diff --git a/coregrind/vg_needs.c b/coregrind/vg_needs.c
index 4ac6354..c62c5b5 100644
--- a/coregrind/vg_needs.c
+++ b/coregrind/vg_needs.c
@@ -102,10 +102,7 @@
       VG_(tool_panic)("`die_mem_stack' should be defined\n");
    }
 
-   if ( (VG_(defined_post_reg_write_syscall_return)()    ||
-         VG_(defined_post_reg_write_deliver_signal)()    ||
-         VG_(defined_post_reg_write_pthread_return)()    ||
-         VG_(defined_post_reg_write_clientreq_return)()  ||
+   if ( (VG_(defined_post_reg_write)()    ||
          VG_(defined_post_reg_write_clientcall_return)()) &&
        ! VG_(needs).shadow_regs) 
    {
diff --git a/coregrind/vg_proxylwp.c b/coregrind/vg_proxylwp.c
index dde25f7..ae3d1f3 100644
--- a/coregrind/vg_proxylwp.c
+++ b/coregrind/vg_proxylwp.c
@@ -307,7 +307,7 @@
 	 anywhere else, except that we can make some assertions about
 	 the proxy and machine state here. */
       vg_assert(px->state == PXS_RunSyscall);
-      vg_assert(PLATFORM_SYSCALL_RET(px->tst->arch) == -VKI_ERESTARTSYS);
+      vg_assert(SYSCALL_RET(px->tst->arch) == -VKI_ERESTARTSYS);
    } else if (vga_sys_after <= ip && ip <= vga_sys_done) {
       /* We're after the syscall.  Either it was interrupted by the
 	 signal, or the syscall completed normally.  In either case
@@ -316,7 +316,7 @@
       vg_assert(px->state == PXS_RunSyscall ||
 		px->state == PXS_SysDone);
       px->state = PXS_SysDone;
-      PLATFORM_SYSCALL_RET(px->tst->arch) = sysnum;
+      SYSCALL_RET(px->tst->arch) = sysnum;
    }
    px_printf("  signalled in state %s\n", pxs_name(px->state));
 
@@ -433,7 +433,7 @@
 	       */
 	       reply.u.syscallno = tst->syscallno;
 
-	       PLATFORM_SYSCALL_RET(tst->arch) = -VKI_ERESTARTSYS;
+	       SYSCALL_RET(tst->arch) = -VKI_ERESTARTSYS;
 	       px->state = PXS_IntReply;
 	       break;
 
@@ -603,14 +603,14 @@
 	       */
 	       px_printf("RunSyscall in SigACK: rejecting syscall %d with ERESTARTSYS\n",
 			 reply.u.syscallno);
-	       PLATFORM_SYSCALL_RET(tst->arch) = -VKI_ERESTARTSYS;
+	       SYSCALL_RET(tst->arch) = -VKI_ERESTARTSYS;
 	    } else {
 	       Int syscallno = tst->syscallno;
 	       
 	       px->state = PXS_RunSyscall;
 	       /* If we're interrupted before we get to the syscall
 		  itself, we want the syscall restarted. */
-	       PLATFORM_SYSCALL_RET(tst->arch) = -VKI_ERESTARTSYS;
+	       SYSCALL_RET(tst->arch) = -VKI_ERESTARTSYS;
 
 	       /* set our process group ID to match parent */
 	       if (VG_(getpgrp)() != VG_(main_pgrp))
@@ -1022,8 +1022,8 @@
 	    if (VG_(clo_trace_syscalls))
 	       VG_(printf)("sys_wait_results: got PX_RunSyscall for SYSCALL[%d,%d](%3d) --> %lld (%llx)\n",
 			   VG_(getpid)(), res.tid, tst->syscallno,
-                            (Long)(Word)PLATFORM_SYSCALL_RET(tst->arch),
-                           (ULong)PLATFORM_SYSCALL_RET(tst->arch));
+                            (Long)(Word)SYSCALL_RET(tst->arch),
+                           (ULong)SYSCALL_RET(tst->arch));
 
 	    if (tst->status != VgTs_WaitSys)
 	       VG_(printf)("tid %d in status %d\n",
@@ -1201,8 +1201,8 @@
 
    req.request = PX_RunSyscall;
 
-   tst->syscallno = PLATFORM_SYSCALL_NUM(tst->arch);
-   PLATFORM_SYSCALL_RET(tst->arch) = -VKI_ERESTARTSYS;
+   tst->syscallno = SYSCALL_NUM(tst->arch);
+   SYSCALL_RET(tst->arch) = -VKI_ERESTARTSYS;
 
    res = VG_(write)(proxy->topx, &req, sizeof(req));
 
diff --git a/coregrind/vg_scheduler.c b/coregrind/vg_scheduler.c
index 4179360..ffb09d7 100644
--- a/coregrind/vg_scheduler.c
+++ b/coregrind/vg_scheduler.c
@@ -148,7 +148,7 @@
    for (tid = 1; tid < VG_N_THREADS; tid++) {
       if (VG_(threads)[tid].status == VgTs_Empty) continue;
       if (tid == tid_to_skip) continue;
-      if ( p ( ARCH_STACK_PTR(VG_(threads)[tid].arch),
+      if ( p ( STACK_PTR(VG_(threads)[tid].arch),
                VG_(threads)[tid].stack_highest_word, d ) )
          return tid;
    }
@@ -180,9 +180,9 @@
                   VG_(threads)[i].associated_mx,
                   VG_(threads)[i].associated_cv );
       VG_(pp_ExeContext)( 
-         VG_(get_ExeContext2)( ARCH_INSTR_PTR(VG_(threads)[i].arch),
-                               ARCH_FRAME_PTR(VG_(threads)[i].arch),
-                               ARCH_STACK_PTR(VG_(threads)[i].arch),
+         VG_(get_ExeContext2)( INSTR_PTR(VG_(threads)[i].arch),
+                               FRAME_PTR(VG_(threads)[i].arch),
+                               STACK_PTR(VG_(threads)[i].arch),
                                VG_(threads)[i].stack_highest_word)
       );
    }
@@ -443,12 +443,12 @@
       return;
 
    if (VG_(threads)[tid].status == VgTs_Sleeping
-       && PLATFORM_SYSCALL_NUM(VG_(threads)[tid].arch) == __NR_nanosleep) {
+       && SYSCALL_NUM(VG_(threads)[tid].arch) == __NR_nanosleep) {
       /* We interrupted a nanosleep().  The right thing to do is to
          write the unused time to nanosleep's second param, but that's
          too much effort ... we just say that 1 nanosecond was not
          used, and return EINTR. */
-      rem = (struct vki_timespec*)PLATFORM_SYSCALL_ARG2(VG_(threads)[tid].arch);
+      rem = (struct vki_timespec*)SYSCALL_ARG2(VG_(threads)[tid].arch);
       if (rem != NULL) {
          rem->tv_sec = 0;
          rem->tv_nsec = 1;
@@ -502,7 +502,7 @@
    vg_assert(VG_(is_valid_tid)(tid));
    vg_assert(VG_(threads)[tid].status == VgTs_Runnable);
 
-   syscall_no = PLATFORM_SYSCALL_NUM(VG_(threads)[tid].arch);
+   syscall_no = SYSCALL_NUM(VG_(threads)[tid].arch);
 
    /* Special-case nanosleep because we can.  But should we?
 
@@ -512,7 +512,7 @@
    if (0 && syscall_no == __NR_nanosleep) {
       UInt t_now, t_awaken;
       struct vki_timespec* req;
-      req = (struct vki_timespec*)PLATFORM_SYSCALL_ARG1(VG_(threads)[tid].arch);
+      req = (struct vki_timespec*)SYSCALL_ARG1(VG_(threads)[tid].arch);
 
       if (req->tv_sec < 0 || req->tv_nsec < 0 || req->tv_nsec >= 1000000000) {
 	 SET_SYSCALL_RETVAL(tid, -VKI_EINVAL);
@@ -821,18 +821,18 @@
          if (VG_(bbs_done) > 31700000 + 0) {
             dispatch_ctr_SAVED = VG_(dispatch_ctr) = 2;
             VG_(translate)(&VG_(threads)[tid], 
-                           ARCH_INSTR_PTR(VG_(threads)[tid].arch),
+                           INSTR_PTR(VG_(threads)[tid].arch),
                            /*debugging*/True);
          }
-         vg_assert(ARCH_INSTR_PTR(VG_(threads)[tid].arch) != 0);
+         vg_assert(INSTR_PTR(VG_(threads)[tid].arch) != 0);
 #        endif
 
          trc = run_thread_for_a_while ( tid );
 
 #        if 0
-         if (0 == ARCH_INSTR_PTR(VG_(threads)[tid].arch)) {
+         if (0 == INSTR_PTR(VG_(threads)[tid].arch)) {
             VG_(printf)("tid = %d,  dc = %llu\n", tid, VG_(bbs_done));
-            vg_assert(0 != ARCH_INSTR_PTR(VG_(threads)[tid].arch));
+            vg_assert(0 != INSTR_PTR(VG_(threads)[tid].arch));
          }
 #        endif
 
@@ -840,7 +840,7 @@
             thread. */
 
          if (trc == VG_TRC_INNER_FASTMISS) {
-            Addr ip = ARCH_INSTR_PTR(VG_(threads)[tid].arch);
+            Addr ip = INSTR_PTR(VG_(threads)[tid].arch);
 
             vg_assert(VG_(dispatch_ctr) > 1);
 
@@ -868,7 +868,7 @@
          }
 
          if (trc == VG_TRC_EBP_JMP_CLIENTREQ) {
-            UWord* args = (UWord*)(ARCH_CLREQ_ARGS(VG_(threads)[tid].arch));
+            UWord* args = (UWord*)(CLREQ_ARGS(VG_(threads)[tid].arch));
             UWord reqno = args[0];
             /* VG_(printf)("request 0x%x\n", reqno); */
 
@@ -899,7 +899,7 @@
                to exit. */
 #           if 0
             { UInt* esp; Int i;
-              esp=(UInt*)ARCH_STACK_PTR(VG_(threads)[tid].arch);
+              esp=(UInt*)STACK_PTR(VG_(threads)[tid].arch);
               VG_(printf)("\nBEFORE\n");
               for (i = 10; i >= -10; i--)
                  VG_(printf)("%2d  %p  =  0x%x\n", i, &esp[i], esp[i]);
@@ -917,24 +917,24 @@
                __libc_freeres does some invalid frees which crash
                the unprotected malloc/free system. */
 
-            if (PLATFORM_SYSCALL_NUM(VG_(threads)[tid].arch) == __NR_exit
-                || PLATFORM_SYSCALL_NUM(VG_(threads)[tid].arch) == __NR_exit_group
+            if (SYSCALL_NUM(VG_(threads)[tid].arch) == __NR_exit
+                || SYSCALL_NUM(VG_(threads)[tid].arch) == __NR_exit_group
                ) {
 
                /* Remember the supplied argument. */
-               *exitcode = PLATFORM_SYSCALL_ARG1(VG_(threads)[tid].arch);
+               *exitcode = SYSCALL_ARG1(VG_(threads)[tid].arch);
 
                // Inform tool about regs read by syscall
                VG_TRACK( pre_reg_read, Vg_CoreSysCall, tid, "(syscallno)",
-                         R_SYSCALL_NUM, sizeof(UWord) );
+                         O_SYSCALL_NUM, sizeof(UWord) );
 
-               if (PLATFORM_SYSCALL_NUM(VG_(threads)[tid].arch) == __NR_exit)
+               if (SYSCALL_NUM(VG_(threads)[tid].arch) == __NR_exit)
                   VG_TRACK( pre_reg_read, Vg_CoreSysCall, tid,
-                            "exit(error_code)", R_SYSCALL_ARG1, sizeof(int) );
+                            "exit(error_code)", O_SYSCALL_ARG1, sizeof(int) );
 
-               if (PLATFORM_SYSCALL_NUM(VG_(threads)[tid].arch) == __NR_exit_group)
+               if (SYSCALL_NUM(VG_(threads)[tid].arch) == __NR_exit_group)
                   VG_TRACK( pre_reg_read, Vg_CoreSysCall, tid,
-                            "exit_group(error_code)", R_SYSCALL_ARG1,
+                            "exit_group(error_code)", O_SYSCALL_ARG1,
                             sizeof(int) );
 
                /* Only run __libc_freeres if the tool says it's ok and
@@ -950,7 +950,7 @@
                         "Caught __NR_exit; running __libc_freeres()");
                   }
                   VG_(nuke_all_threads_except) ( tid );
-                  ARCH_INSTR_PTR(VG_(threads)[tid].arch) = 
+                  INSTR_PTR(VG_(threads)[tid].arch) = 
                      __libc_freeres_wrapper;
                   vg_assert(VG_(threads)[tid].status == VgTs_Runnable);
                   goto stage1; /* party on, dudes (but not for much longer :) */
@@ -968,13 +968,13 @@
             }
 
             /* We've dealt with __NR_exit at this point. */
-            vg_assert(PLATFORM_SYSCALL_NUM(VG_(threads)[tid].arch) != __NR_exit && 
-                      PLATFORM_SYSCALL_NUM(VG_(threads)[tid].arch) != __NR_exit_group);
+            vg_assert(SYSCALL_NUM(VG_(threads)[tid].arch) != __NR_exit && 
+                      SYSCALL_NUM(VG_(threads)[tid].arch) != __NR_exit_group);
 
             /* Trap syscalls to __NR_sched_yield and just have this
                thread yield instead.  Not essential, just an
                optimisation. */
-	    if (PLATFORM_SYSCALL_NUM(VG_(threads)[tid].arch) == __NR_sched_yield) {
+	    if (SYSCALL_NUM(VG_(threads)[tid].arch) == __NR_sched_yield) {
                SET_SYSCALL_RETVAL(tid, 0); /* syscall returns with success */
                goto stage1; /* find a new thread to run */
 	    }
@@ -983,7 +983,7 @@
 
 #           if 0
             { UInt* esp; Int i;
-              esp=(UInt*)ARCH_STACK_PTR(VG_(threads)[tid].arch);
+              esp=(UInt*)STACK_PTR(VG_(threads)[tid].arch);
               VG_(printf)("AFTER\n");
               for (i = 10; i >= -10; i--)
                  VG_(printf)("%2d  %p  =  0x%x\n", i, &esp[i], esp[i]);
@@ -1166,7 +1166,7 @@
    VGA_(set_arg_and_bogus_ret)(tid, (UWord)PTHREAD_CANCELED, 0xBEADDEEF);
 
    /* .cancel_pend will hold &thread_exit_wrapper */
-   ARCH_INSTR_PTR(VG_(threads)[tid].arch) = (UWord)VG_(threads)[tid].cancel_pend;
+   INSTR_PTR(VG_(threads)[tid].arch) = (UWord)VG_(threads)[tid].cancel_pend;
 
    VG_(proxy_abort_syscall)(tid);
 
@@ -1304,7 +1304,8 @@
          *thread_return = VG_(threads)[jee].joinee_retval;
          /* Not really right, since it makes the thread's return value
             appear to be defined even if it isn't. */
-         VG_TRACK( post_mem_write, (Addr)thread_return, sizeof(void*) );
+         VG_TRACK( post_mem_write, Vg_CorePThread, jnr,
+                   (Addr)thread_return, sizeof(void*) );
       }
 
       /* Joinee is discarded */
@@ -1413,7 +1414,8 @@
    VG_TRACK( pre_mem_write, Vg_CorePThread, tid,
                             "cleanup pop", (Addr)cu, sizeof(CleanupEntry) );
    *cu = VG_(threads)[tid].custack[sp];
-   VG_TRACK( post_mem_write, (Addr)cu, sizeof(CleanupEntry) );
+   VG_TRACK( post_mem_write, Vg_CorePThread, tid,
+                                           (Addr)cu, sizeof(CleanupEntry) );
    VG_(threads)[tid].custack_used = sp;
    SET_PTHREQ_RETVAL(tid, 0);
 }
@@ -1802,14 +1804,14 @@
    VG_TRACK ( die_mem_stack, VG_(threads)[tid].stack_base, 
                              VG_(threads)[tid].stack_size
                              - VG_AR_CLIENT_STACKBASE_REDZONE_SZB);
-   VG_TRACK ( ban_mem_stack, ARCH_STACK_PTR(VG_(threads)[tid].arch), 
+   VG_TRACK ( ban_mem_stack, STACK_PTR(VG_(threads)[tid].arch), 
                              VG_AR_CLIENT_STACKBASE_REDZONE_SZB );
    
    VGA_(thread_initial_stack)(tid, (UWord)arg,
                               (Addr)&do__apply_in_new_thread_bogusRA);
 
    /* this is where we start */
-   ARCH_INSTR_PTR(VG_(threads)[tid].arch) = (UWord)fn;
+   INSTR_PTR(VG_(threads)[tid].arch) = (UWord)fn;
 
    if (VG_(clo_trace_sched)) {
       VG_(sprintf)(msg_buf, "new thread, created by %d", parent_tid );
@@ -2482,7 +2484,8 @@
    VG_TRACK( pre_mem_write, Vg_CorePThread, tid, "pthread_key_create: key",
                             (Addr)key, sizeof(pthread_key_t));
    *key = i;
-   VG_TRACK( post_mem_write, (Addr)key, sizeof(pthread_key_t) );
+   VG_TRACK( post_mem_write, Vg_CorePThread, tid,
+                            (Addr)key, sizeof(pthread_key_t) );
 
    SET_PTHREQ_RETVAL(tid, 0);
 }
@@ -2598,7 +2601,8 @@
       cu->data.function.arg = VG_(threads)[tid].specifics_ptr[key];
    }
 
-   VG_TRACK( post_mem_write, (Addr)cu, sizeof(CleanupEntry) );
+   VG_TRACK( post_mem_write, Vg_CorePThread, tid, 
+                             (Addr)cu, sizeof(CleanupEntry) );
    SET_PTHREQ_RETVAL(tid, 0);
 }
 
@@ -2639,7 +2643,8 @@
    VG_(do_pthread_sigmask_SCSS_upd) ( tid, vki_how, newmask, oldmask );
 
    if (oldmask)
-      VG_TRACK( post_mem_write, (Addr)oldmask, sizeof(vki_sigset_t) );
+      VG_TRACK( post_mem_write, Vg_CorePThread, tid,
+                                (Addr)oldmask, sizeof(vki_sigset_t) );
 
    /* Success. */
    SET_PTHREQ_RETVAL(tid, 0);
@@ -2780,7 +2785,8 @@
    *fh = vg_fhstack[n];
    SET_PTHREQ_RETVAL(tid, 0);
 
-   VG_TRACK( post_mem_write, (Addr)fh, sizeof(ForkHandlerEntry) );
+   VG_TRACK( post_mem_write, Vg_CorePThread, tid,
+                             (Addr)fh, sizeof(ForkHandlerEntry) );
 }
 
 
@@ -2812,17 +2818,52 @@
 }
 
 /* ---------------------------------------------------------------------
-   Specifying shadow register values
+   Shadow register manipulations
    ------------------------------------------------------------------ */
 
-void VG_(set_return_from_syscall_shadow) ( ThreadId tid, UInt ret_shadow )
+void VG_(set_shadow_regs_area) ( ThreadId tid, OffT offset, SizeT size, 
+                                 const UChar* area )
 {
-   VGA_(set_thread_shadow_archreg)(tid, R_SYSCALL_RET, ret_shadow);
+   ThreadState* tst;
+
+   vg_assert(VG_(is_valid_tid)(tid));
+   tst = & VG_(threads)[tid];
+
+   // Bounds check
+   vg_assert(0 <= offset && offset < sizeof(VexGuestArchState));
+   vg_assert(offset + size <= sizeof(VexGuestArchState));
+
+   VG_(memcpy)( (void*)(((Addr)(&tst->arch.vex_shadow)) + offset), area, size);
+}
+
+void VG_(get_shadow_regs_area) ( ThreadId tid, OffT offset, SizeT size, 
+                                 UChar* area )
+{
+   ThreadState* tst;
+
+   vg_assert(VG_(is_valid_tid)(tid));
+   tst = & VG_(threads)[tid];
+
+   // Bounds check
+   vg_assert(0 <= offset && offset < sizeof(VexGuestArchState));
+   vg_assert(offset + size <= sizeof(VexGuestArchState));
+
+   VG_(memcpy)( area, (void*)(((Addr)&(tst->arch.vex_shadow)) + offset), size);
+}
+
+
+void VG_(set_return_from_syscall_shadow) ( ThreadId tid, UWord ret_shadow )
+{
+   VG_(set_shadow_regs_area)(tid, O_SYSCALL_RET, sizeof(UWord),
+                             (UChar*)&ret_shadow);
 }
 
 UInt VG_(get_exit_status_shadow) ( ThreadId tid )
 {
-   return VGA_(get_thread_shadow_archreg)(tid, R_SYSCALL_ARG1);
+   UInt ret;
+   VG_(get_shadow_regs_area)(tid, O_SYSCALL_ARG1, sizeof(UInt),
+                             (UChar*)&ret);
+   return ret;
 }
 
 void VG_(intercept_libc_freeres_wrapper)(Addr addr)
@@ -3273,7 +3314,7 @@
       if (VG_(threads)[i].status != VgTs_Empty) {
          Int
          stack_used = (Addr)VG_(threads)[i].stack_highest_word 
-                      - (Addr)ARCH_STACK_PTR(VG_(threads)[i].arch);
+                      - (Addr)STACK_PTR(VG_(threads)[i].arch);
          Int
          stack_avail = VG_(threads)[i].stack_size
                        - VG_AR_CLIENT_STACKBASE_REDZONE_SZB
diff --git a/coregrind/vg_signals.c b/coregrind/vg_signals.c
index 046ce2d..044e3b0 100644
--- a/coregrind/vg_signals.c
+++ b/coregrind/vg_signals.c
@@ -481,9 +481,9 @@
    Addr         m_SP;
 
    vg_assert(VG_(is_valid_tid)(tid));
-   ss    = (vki_stack_t*)PLATFORM_SYSCALL_ARG1(VG_(threads)[tid].arch);
-   oss   = (vki_stack_t*)PLATFORM_SYSCALL_ARG2(VG_(threads)[tid].arch);
-   m_SP  = ARCH_STACK_PTR(VG_(threads)[tid].arch);
+   ss    = (vki_stack_t*)SYSCALL_ARG1(VG_(threads)[tid].arch);
+   oss   = (vki_stack_t*)SYSCALL_ARG2(VG_(threads)[tid].arch);
+   m_SP  = STACK_PTR(VG_(threads)[tid].arch);
 
    if (VG_(clo_trace_signals))
       VG_(message)(Vg_DebugExtraMsg, 
@@ -498,7 +498,7 @@
    }
 
    if (ss != NULL) {
-      if (on_sig_stack(tid, ARCH_STACK_PTR(VG_(threads)[tid].arch))) {
+      if (on_sig_stack(tid, STACK_PTR(VG_(threads)[tid].arch))) {
          SET_SYSCALL_RETVAL(tid, -VKI_EPERM);
          return;
       }
@@ -534,9 +534,9 @@
    vg_assert(is_correct_sigmask());
 
    vg_assert(VG_(is_valid_tid)(tid));
-   signo   =                        PLATFORM_SYSCALL_ARG1(VG_(threads)[tid].arch);
-   new_act = (struct vki_sigaction*)PLATFORM_SYSCALL_ARG2(VG_(threads)[tid].arch);
-   old_act = (struct vki_sigaction*)PLATFORM_SYSCALL_ARG3(VG_(threads)[tid].arch);
+   signo   =                        SYSCALL_ARG1(VG_(threads)[tid].arch);
+   new_act = (struct vki_sigaction*)SYSCALL_ARG2(VG_(threads)[tid].arch);
+   old_act = (struct vki_sigaction*)SYSCALL_ARG3(VG_(threads)[tid].arch);
 
    if (VG_(clo_trace_signals))
       VG_(message)(Vg_DebugExtraMsg, 
@@ -839,7 +839,7 @@
        && /* there is a defined and enabled alt stack, which we're not
              already using.  Logic from get_sigframe in
              arch/i386/kernel/signal.c. */
-          sas_ss_flags(tid, ARCH_STACK_PTR(tst->arch)) == 0
+          sas_ss_flags(tid, STACK_PTR(tst->arch)) == 0
       ) {
       esp_top_of_frame 
          = (Addr)(tst->altstack.ss_sp) + tst->altstack.ss_size;
@@ -852,7 +852,7 @@
       VG_TRACK( pre_deliver_signal, tid, sigNo, /*alt_stack*/True );
       
    } else {
-      esp_top_of_frame = ARCH_STACK_PTR(tst->arch);
+      esp_top_of_frame = STACK_PTR(tst->arch);
 
       /* Signal delivery to tools */
       VG_TRACK( pre_deliver_signal, tid, sigNo, /*alt_stack*/False );
@@ -1503,8 +1503,8 @@
 
       if (tst->status == VgTs_WaitSys) {
 	 /* blocked in a syscall; we assume it should be interrupted */
-	 if (PLATFORM_SYSCALL_RET(tst->arch) == -VKI_ERESTARTSYS)
-	    PLATFORM_SYSCALL_RET(tst->arch) = -VKI_EINTR;
+	 if (SYSCALL_RET(tst->arch) == -VKI_ERESTARTSYS)
+	    SYSCALL_RET(tst->arch) = -VKI_EINTR;
       }
 
       VG_(proxy_sigack)(tid, &tst->sig_mask);
@@ -1729,7 +1729,7 @@
    if (info->si_signo == VKI_SIGSEGV) {
       ThreadId tid = VG_(get_current_tid)();
       Addr fault = (Addr)info->_sifields._sigfault._addr;
-      Addr esp   =  ARCH_STACK_PTR(VG_(threads)[tid].arch);
+      Addr esp   =  STACK_PTR(VG_(threads)[tid].arch);
       Segment *seg;
 
       seg = VG_(find_segment)(fault);
diff --git a/coregrind/vg_syscalls.c b/coregrind/vg_syscalls.c
index 9d02ccc..88cdd13 100644
--- a/coregrind/vg_syscalls.c
+++ b/coregrind/vg_syscalls.c
@@ -858,8 +858,7 @@
    if (VG_(defined_pre_mem_write)()) {
       UInt buflen_in = deref_UInt( tid, buflen_p, buflen_s);
       if (buflen_in > 0) {
-         TL_(pre_mem_write) ( Vg_CoreSysCall,
-			      tid, buf_s, buf_p, buflen_in );
+         TL_(pre_mem_write) ( Vg_CoreSysCall, tid, buf_s, buf_p, buflen_in );
       }
    }
 }
@@ -871,7 +870,7 @@
    if (!VG_(is_kerror)(res) && VG_(defined_post_mem_write)()) {
       UInt buflen_out = deref_UInt( tid, buflen_p, s);
       if (buflen_out > 0 && buf_p != (Addr)NULL) {
-         TL_(post_mem_write) ( buf_p, buflen_out );
+         TL_(post_mem_write) ( Vg_CoreSysCall, tid, buf_p, buflen_out );
       }
    }
 }
@@ -1023,14 +1022,14 @@
 #define POST(x) \
    void VGA_(gen_##x##_after) (ThreadId tid, ThreadState *tst)
 
-#define SYSNO	PLATFORM_SYSCALL_NUM(tst->arch)    // in PRE(x)
-#define res	PLATFORM_SYSCALL_RET(tst->arch)	   // in POST(x)
-#define arg1	PLATFORM_SYSCALL_ARG1(tst->arch)
-#define arg2	PLATFORM_SYSCALL_ARG2(tst->arch)
-#define arg3	PLATFORM_SYSCALL_ARG3(tst->arch)
-#define arg4	PLATFORM_SYSCALL_ARG4(tst->arch)
-#define arg5	PLATFORM_SYSCALL_ARG5(tst->arch)
-#define arg6	PLATFORM_SYSCALL_ARG6(tst->arch)
+#define SYSNO   SYSCALL_NUM(tst->arch)    // in PRE(x)
+#define res     SYSCALL_RET(tst->arch)    // in POST(x)
+#define arg1    SYSCALL_ARG1(tst->arch)
+#define arg2    SYSCALL_ARG2(tst->arch)
+#define arg3    SYSCALL_ARG3(tst->arch)
+#define arg4    SYSCALL_ARG4(tst->arch)
+#define arg5    SYSCALL_ARG5(tst->arch)
+#define arg6    SYSCALL_ARG6(tst->arch)
 
 #define set_result(val) PLATFORM_SET_SYSCALL_RESULT(tst->arch, (val))
 
@@ -1415,7 +1414,7 @@
 POST(sys_getitimer)
 {
    if (arg2 != (Addr)NULL) {
-      VG_TRACK( post_mem_write,arg2, sizeof(struct vki_itimerval));
+      POST_MEM_WRITE(arg2, sizeof(struct vki_itimerval));
    }
 }
 
@@ -1434,7 +1433,7 @@
 POST(sys_setitimer)
 {
    if (arg3 != (Addr)NULL) {
-      VG_TRACK( post_mem_write,arg3, sizeof(struct vki_itimerval));
+      POST_MEM_WRITE(arg3, sizeof(struct vki_itimerval));
    }
 }
 
@@ -2275,7 +2274,7 @@
    PRE_REG_READ0(long, "getppid");
 }
 
-static void common_post_getrlimit(UWord a1, UWord a2)
+static void common_post_getrlimit(ThreadId tid, UWord a1, UWord a2)
 {
    POST_MEM_WRITE( a2, sizeof(struct vki_rlimit) );
 
@@ -2305,7 +2304,7 @@
 
 POST(sys_old_getrlimit)
 {
-   common_post_getrlimit(arg1, arg2);
+   common_post_getrlimit(tid, arg1, arg2);
 }
 
 PRE(sys_getrlimit, 0)
@@ -2318,7 +2317,7 @@
 
 POST(sys_getrlimit)
 {
-   common_post_getrlimit(arg1, arg2);
+   common_post_getrlimit(tid, arg1, arg2);
 }
 
 PRE(sys_getrusage, 0)
@@ -2332,7 +2331,7 @@
 POST(sys_getrusage)
 {
    if (res == 0)
-      VG_TRACK( post_mem_write, arg2, sizeof(struct vki_rusage) );
+      POST_MEM_WRITE( arg2, sizeof(struct vki_rusage) );
 }
 
 PRE(sys_gettimeofday, 0)
@@ -3027,7 +3026,7 @@
 	 PRE_MEM_WRITE( "ioctl(SIOCGIFCONF)", arg3, sizeof(struct ifconf));
 	 KERNEL_DO_SYSCALL(tid,res);
 	 if (!VG_(is_kerror)(res) && res == 0)
-	 VG_TRACK( post_mem_write,arg3, sizeof(struct ifconf));
+	 POST_MEM_WRITE(arg3, sizeof(struct ifconf));
       */
       PRE_MEM_READ( "ioctl(SIOCGIFCONF)", arg3, sizeof(struct vki_ifconf));
       if ( arg3 ) {
@@ -3645,28 +3644,28 @@
    case VKI_SG_SET_COMMAND_Q:
       break;
    case VKI_SG_IO:
-      VG_TRACK( post_mem_write,arg3, sizeof(vki_sg_io_hdr_t));
+      POST_MEM_WRITE(arg3, sizeof(vki_sg_io_hdr_t));
       break;
    case VKI_SG_GET_SCSI_ID:
-      VG_TRACK( post_mem_write,arg3, sizeof(vki_sg_scsi_id_t));
+      POST_MEM_WRITE(arg3, sizeof(vki_sg_scsi_id_t));
       break;
    case VKI_SG_SET_RESERVED_SIZE:
       break;
    case VKI_SG_SET_TIMEOUT:
       break;
    case VKI_SG_GET_RESERVED_SIZE:
-      VG_TRACK( post_mem_write,arg3, sizeof(int));
+      POST_MEM_WRITE(arg3, sizeof(int));
       break;
    case VKI_SG_GET_TIMEOUT:
-      VG_TRACK( post_mem_write,arg3, sizeof(int));
+      POST_MEM_WRITE(arg3, sizeof(int));
       break;
    case VKI_SG_GET_VERSION_NUM:
       break;
    case VKI_SG_EMULATED_HOST:
-      VG_TRACK( post_mem_write,arg3, sizeof(int));
+      POST_MEM_WRITE(arg3, sizeof(int));
       break;
    case VKI_SG_GET_SG_TABLESIZE:
-      VG_TRACK( post_mem_write,arg3, sizeof(int));
+      POST_MEM_WRITE(arg3, sizeof(int));
       break;      
 
    case VKI_IIOCGETCPS:
@@ -3678,61 +3677,57 @@
 
       /* These all use struct ifreq AFAIK */
    case VKI_SIOCGIFINDEX:        /* get iface index              */
-      VG_TRACK( post_mem_write,
-                (Addr)&((struct vki_ifreq *)arg3)->vki_ifr_ifindex,
-                sizeof(((struct vki_ifreq *)arg3)->vki_ifr_ifindex) );
+      POST_MEM_WRITE( (Addr)&((struct vki_ifreq *)arg3)->vki_ifr_ifindex,
+                      sizeof(((struct vki_ifreq *)arg3)->vki_ifr_ifindex) );
       break;
    case VKI_SIOCGIFFLAGS:        /* get flags                    */
-      VG_TRACK( post_mem_write,
-                (Addr)&((struct vki_ifreq *)arg3)->vki_ifr_flags,
-                sizeof(((struct vki_ifreq *)arg3)->vki_ifr_flags) );
+      POST_MEM_WRITE( (Addr)&((struct vki_ifreq *)arg3)->vki_ifr_flags,
+                      sizeof(((struct vki_ifreq *)arg3)->vki_ifr_flags) );
       break;
    case VKI_SIOCGIFHWADDR:       /* Get hardware address         */
-      VG_TRACK( post_mem_write,
-                (Addr)&((struct vki_ifreq *)arg3)->ifr_hwaddr,
-                sizeof(((struct vki_ifreq *)arg3)->ifr_hwaddr) );
+      POST_MEM_WRITE( (Addr)&((struct vki_ifreq *)arg3)->ifr_hwaddr,
+                      sizeof(((struct vki_ifreq *)arg3)->ifr_hwaddr) );
       break;
    case VKI_SIOCGIFMTU:          /* get MTU size                 */
-      VG_TRACK( post_mem_write,
-                (Addr)&((struct vki_ifreq *)arg3)->vki_ifr_mtu,
-                sizeof(((struct vki_ifreq *)arg3)->vki_ifr_mtu) );
+      POST_MEM_WRITE( (Addr)&((struct vki_ifreq *)arg3)->vki_ifr_mtu,
+                      sizeof(((struct vki_ifreq *)arg3)->vki_ifr_mtu) );
       break;
    case VKI_SIOCGIFADDR:         /* get PA address               */
    case VKI_SIOCGIFDSTADDR:      /* get remote PA address        */
    case VKI_SIOCGIFBRDADDR:      /* get broadcast PA address     */
    case VKI_SIOCGIFNETMASK:      /* get network PA mask          */
-      VG_TRACK( post_mem_write,
+      POST_MEM_WRITE(
                 (Addr)&((struct vki_ifreq *)arg3)->ifr_addr,
                 sizeof(((struct vki_ifreq *)arg3)->ifr_addr) );
       break;
    case VKI_SIOCGIFMETRIC:       /* get metric                   */
-      VG_TRACK( post_mem_write,
+      POST_MEM_WRITE(
                 (Addr)&((struct vki_ifreq *)arg3)->vki_ifr_metric,
                 sizeof(((struct vki_ifreq *)arg3)->vki_ifr_metric) );
       break;
    case VKI_SIOCGIFMAP:          /* Get device parameters        */
-      VG_TRACK( post_mem_write,
+      POST_MEM_WRITE(
                 (Addr)&((struct vki_ifreq *)arg3)->ifr_map,
                 sizeof(((struct vki_ifreq *)arg3)->ifr_map) );
       break;
      break;
    case VKI_SIOCGIFTXQLEN:       /* Get the tx queue length      */
-      VG_TRACK( post_mem_write,
+      POST_MEM_WRITE(
                 (Addr)&((struct vki_ifreq *)arg3)->ifr_qlen,
                 sizeof(((struct vki_ifreq *)arg3)->ifr_qlen) );
       break;
    case VKI_SIOCGIFNAME:         /* get iface name               */
-      VG_TRACK( post_mem_write,
+      POST_MEM_WRITE(
                 (Addr)&((struct vki_ifreq *)arg3)->vki_ifr_name,
                 sizeof(((struct vki_ifreq *)arg3)->vki_ifr_name) );
       break;
    case VKI_SIOCGMIIPHY:         /* get hardware entry           */
-      VG_TRACK( post_mem_write,
+      POST_MEM_WRITE(
                 (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) );
       break;
    case VKI_SIOCGMIIREG:         /* get hardware entry registers */
-      VG_TRACK( post_mem_write,
+      POST_MEM_WRITE(
                 (Addr)&((struct vki_mii_ioctl_data *)&((struct vki_ifreq *)arg3)->vki_ifr_data)->val_out,
                 sizeof(((struct vki_mii_ioctl_data *)&((struct vki_ifreq *)arg3)->vki_ifr_data)->val_out) );
       break;
@@ -3741,7 +3736,7 @@
 	 PRE_MEM_WRITE("ioctl(SIOCGIFCONF)", arg3, sizeof(struct ifconf));
 	 KERNEL_DO_SYSCALL(tid,res);
 	 if (!VG_(is_kerror)(res) && res == 0)
-	 VG_TRACK( post_mem_write,arg3, sizeof(struct ifconf));
+	 POST_MEM_WRITE(arg3, sizeof(struct ifconf));
       */
       if (res == 0 && arg3 ) {
 	 struct vki_ifconf *ifc = (struct vki_ifconf *) arg3;
@@ -3750,18 +3745,18 @@
       }
       break;
    case VKI_SIOCGSTAMP:
-      VG_TRACK( post_mem_write,arg3, sizeof(struct vki_timeval));
+      POST_MEM_WRITE( 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:
-      VG_TRACK( post_mem_write,arg3, sizeof(int));
+      POST_MEM_WRITE(arg3, sizeof(int));
       break;
    case VKI_SIOCGRARP:           /* get RARP table entry         */
    case VKI_SIOCGARP:            /* get ARP table entry          */
-      VG_TRACK( post_mem_write,arg3, sizeof(struct vki_arpreq));
+      POST_MEM_WRITE(arg3, sizeof(struct vki_arpreq));
       break;
                     
    case VKI_SIOCSIFFLAGS:        /* set flags                    */
@@ -3790,7 +3785,7 @@
       break;
 
    case VKI_SIOCGPGRP:
-      VG_TRACK( post_mem_write,arg3, sizeof(int));
+      POST_MEM_WRITE(arg3, sizeof(int));
       break;
    case VKI_SIOCSPGRP:
       break;
@@ -3814,7 +3809,7 @@
    case VKI_SOUND_PCM_READ_BITS:
    case (VKI_SOUND_PCM_READ_BITS|0x40000000): /* what the fuck ? */
    case VKI_SOUND_PCM_READ_FILTER:
-      VG_TRACK( post_mem_write,arg3, sizeof(int));
+      POST_MEM_WRITE(arg3, sizeof(int));
       break;
    case VKI_SNDCTL_SEQ_CTRLRATE:
    case VKI_SNDCTL_DSP_SPEED:
@@ -3834,7 +3829,7 @@
       break;
    case VKI_SNDCTL_DSP_GETOSPACE:
    case VKI_SNDCTL_DSP_GETISPACE:
-      VG_TRACK( post_mem_write,arg3, sizeof(vki_audio_buf_info));
+      POST_MEM_WRITE(arg3, sizeof(vki_audio_buf_info));
       break;
    case VKI_SNDCTL_DSP_SETTRIGGER:
       break;
@@ -3857,38 +3852,38 @@
       break;
    case VKI_RTC_RD_TIME:
    case VKI_RTC_ALM_READ:
-      VG_TRACK( post_mem_write,arg3, sizeof(struct vki_rtc_time));
+      POST_MEM_WRITE(arg3, sizeof(struct vki_rtc_time));
       break;
    case VKI_RTC_ALM_SET:
       break;
    case VKI_RTC_IRQP_READ:
-      VG_TRACK( post_mem_write,arg3, sizeof(unsigned long));
+      POST_MEM_WRITE(arg3, sizeof(unsigned long));
       break;
 
    case VKI_BLKGETSIZE:
-      VG_TRACK( post_mem_write,arg3, sizeof(unsigned long));
+      POST_MEM_WRITE(arg3, sizeof(unsigned long));
       break;
 
       /* Hard disks */
    case VKI_HDIO_GET_IDENTITY: /* 0x030d */
-      VG_TRACK( post_mem_write,arg3, VKI_SIZEOF_STRUCT_HD_DRIVEID );
+      POST_MEM_WRITE(arg3, VKI_SIZEOF_STRUCT_HD_DRIVEID );
       break;
 
       /* CD ROM stuff (??)  */
    case VKI_CDROMSUBCHNL:
-      VG_TRACK( post_mem_write,arg3, sizeof(struct vki_cdrom_subchnl));
+      POST_MEM_WRITE(arg3, sizeof(struct vki_cdrom_subchnl));
       break;
    case VKI_CDROMREADTOCHDR:
-      VG_TRACK( post_mem_write,arg3, sizeof(struct vki_cdrom_tochdr));
+      POST_MEM_WRITE(arg3, sizeof(struct vki_cdrom_tochdr));
       break;
    case VKI_CDROMREADTOCENTRY:
-      VG_TRACK( post_mem_write,arg3, sizeof(struct vki_cdrom_tochdr));
+      POST_MEM_WRITE(arg3, sizeof(struct vki_cdrom_tochdr));
       break;
    case VKI_CDROMMULTISESSION:
-      VG_TRACK( post_mem_write,arg3, sizeof(struct vki_cdrom_multisession));
+      POST_MEM_WRITE(arg3, sizeof(struct vki_cdrom_multisession));
       break;
    case VKI_CDROMVOLREAD:
-      VG_TRACK( post_mem_write,arg3, sizeof(struct vki_cdrom_volctrl));
+      POST_MEM_WRITE(arg3, sizeof(struct vki_cdrom_volctrl));
       break;
    case VKI_CDROMREADAUDIO:
    {
@@ -3906,17 +3901,17 @@
       break;
 
    case VKI_FIGETBSZ:
-      VG_TRACK( post_mem_write,arg3, sizeof(unsigned long));
+      POST_MEM_WRITE(arg3, sizeof(unsigned long));
       break;
    case VKI_FIBMAP:
-      VG_TRACK( post_mem_write,arg3, sizeof(unsigned long));
+      POST_MEM_WRITE(arg3, sizeof(unsigned long));
       break;
 
    case VKI_FBIOGET_VSCREENINFO: //0x4600
-      VG_TRACK( post_mem_write,arg3, sizeof(struct vki_fb_var_screeninfo));
+      POST_MEM_WRITE(arg3, sizeof(struct vki_fb_var_screeninfo));
       break;
    case VKI_FBIOGET_FSCREENINFO: //0x4602
-      VG_TRACK( post_mem_write,arg3, sizeof(struct vki_fb_fix_screeninfo));
+      POST_MEM_WRITE(arg3, sizeof(struct vki_fb_fix_screeninfo));
       break;
 
    case VKI_PPCLAIM:
@@ -4090,7 +4085,7 @@
       if (size > 0 && (dir & _VKI_IOC_READ)
 	  && res == 0
 	  && arg3 != (Addr)NULL)
-	 VG_TRACK( post_mem_write,arg3, size);
+	 POST_MEM_WRITE(arg3, size);
       break;
    }
    }
@@ -5282,7 +5277,7 @@
 
 POST(sys_sched_getaffinity)
 {
-   VG_TRACK(post_mem_write, arg3, arg2);
+   POST_MEM_WRITE(arg3, arg2);
 }
 
 PRE(sys_acct, 0)
diff --git a/coregrind/x86-linux/core_platform.h b/coregrind/x86-linux/core_platform.h
index 7810905..01ac0cd 100644
--- a/coregrind/x86-linux/core_platform.h
+++ b/coregrind/x86-linux/core_platform.h
@@ -36,36 +36,27 @@
 //#include "platform_arch.h"        // platform-specific tool stuff
 
 /* ---------------------------------------------------------------------
-   Interesting registers
+   Dealing with registers
    ------------------------------------------------------------------ */
 
 // Accessors for the ThreadArchState
-#define PLATFORM_SYSCALL_NUM(regs)     ((regs).vex.guest_EAX)
-#define PLATFORM_SYSCALL_RET(regs)     ((regs).vex.guest_EAX)
-#define PLATFORM_SYSCALL_ARG1(regs)    ((regs).vex.guest_EBX)
-#define PLATFORM_SYSCALL_ARG2(regs)    ((regs).vex.guest_ECX)
-#define PLATFORM_SYSCALL_ARG3(regs)    ((regs).vex.guest_EDX)
-#define PLATFORM_SYSCALL_ARG4(regs)    ((regs).vex.guest_ESI)
-#define PLATFORM_SYSCALL_ARG5(regs)    ((regs).vex.guest_EDI)
-#define PLATFORM_SYSCALL_ARG6(regs)    ((regs).vex.guest_EBP)
+#define PLATFORM_SYSCALL_NUM     guest_EAX
+#define PLATFORM_SYSCALL_ARG1    guest_EBX
+#define PLATFORM_SYSCALL_ARG2    guest_ECX
+#define PLATFORM_SYSCALL_ARG3    guest_EDX
+#define PLATFORM_SYSCALL_ARG4    guest_ESI
+#define PLATFORM_SYSCALL_ARG5    guest_EDI
+#define PLATFORM_SYSCALL_ARG6    guest_EBP
+#define PLATFORM_SYSCALL_RET     guest_EAX
 
+// Setting a syscall result
 #define PLATFORM_SET_SYSCALL_RESULT(regs, val)     \
    ((regs).vex.guest_EAX = (val))
 
-// Interesting register numbers
-#define R_SYSCALL_NUM                  R_EAX
-#define R_SYSCALL_ARG1                 R_EBX
-#define R_SYSCALL_ARG2                 R_ECX
-#define R_SYSCALL_ARG3                 R_EDX
-#define R_SYSCALL_ARG4                 R_ESI
-#define R_SYSCALL_ARG5                 R_EDI
-#define R_SYSCALL_ARG6                 R_EBP
-#define R_SYSCALL_RET                  R_EAX
-
 // Setting thread regs and shadow regs from within the core
 #define SET_SYSCALL_RETVAL(zztid, zzval) \
-   SET_THREAD_REG(zztid, zzval, PLATFORM_SYSCALL_RET, R_SYSCALL_RET, \
-                  post_reg_write_syscall_return)
+   SET_THREAD_REG(zztid, zzval, SYSCALL_RET, post_reg_write, \
+                  Vg_CoreSysCall, zztid, O_SYSCALL_RET, sizeof(UWord))
 
 /* ---------------------------------------------------------------------
    Exports of vg_ldt.c
@@ -115,7 +106,7 @@
 }
 
 #define PLATFORM_GET_MMAP_ARGS(tst, a1, a2, a3, a4, a5, a6) do {\
-   UInt *arg_block = (UInt*)PLATFORM_SYSCALL_ARG1(tst->arch);   \
+   UInt *arg_block = (UInt*)SYSCALL_ARG1(tst->arch);            \
    PRE_MEM_READ( "old_mmap(args)", arg1, 6*sizeof(UWord) );     \
    a1 = arg_block[0];                                           \
    a2 = arg_block[1];                                           \
diff --git a/coregrind/x86-linux/ldt.c b/coregrind/x86-linux/ldt.c
index 86173d1..a85b480 100644
--- a/coregrind/x86-linux/ldt.c
+++ b/coregrind/x86-linux/ldt.c
@@ -450,7 +450,7 @@
              "set_thread_area(info->entry)",
              (Addr) & info->entry_number, sizeof(unsigned int) );
    info->entry_number = idx + VKI_GDT_ENTRY_TLS_MIN;
-   VG_TRACK( post_mem_write,
+   VG_TRACK( post_mem_write, Vg_CoreSysCall, tid,
              (Addr) & info->entry_number, sizeof(unsigned int) );
 
    return 0;
diff --git a/coregrind/x86-linux/syscalls.c b/coregrind/x86-linux/syscalls.c
index 70d5758..97aede5 100644
--- a/coregrind/x86-linux/syscalls.c
+++ b/coregrind/x86-linux/syscalls.c
@@ -181,14 +181,14 @@
 #define POST(x) \
    static void x86_linux_##x##_after (ThreadId tid, ThreadState *tst)
 
-#define SYSNO	PLATFORM_SYSCALL_NUM(tst->arch)    // in PRE(x)
-#define res	PLATFORM_SYSCALL_RET(tst->arch)	   // in POST(x)
-#define arg1	PLATFORM_SYSCALL_ARG1(tst->arch)
-#define arg2	PLATFORM_SYSCALL_ARG2(tst->arch)
-#define arg3	PLATFORM_SYSCALL_ARG3(tst->arch)
-#define arg4	PLATFORM_SYSCALL_ARG4(tst->arch)
-#define arg5	PLATFORM_SYSCALL_ARG5(tst->arch)
-#define arg6	PLATFORM_SYSCALL_ARG6(tst->arch)
+#define SYSNO   SYSCALL_NUM(tst->arch)    // in PRE(x)
+#define res     SYSCALL_RET(tst->arch)    // in POST(x)
+#define arg1    SYSCALL_ARG1(tst->arch)
+#define arg2    SYSCALL_ARG2(tst->arch)
+#define arg3    SYSCALL_ARG3(tst->arch)
+#define arg4    SYSCALL_ARG4(tst->arch)
+#define arg5    SYSCALL_ARG5(tst->arch)
+#define arg6    SYSCALL_ARG6(tst->arch)
 
 #define set_result(val) PLATFORM_SET_SYSCALL_RESULT(tst->arch, (val))
 
diff --git a/coregrind/x86/core_arch.h b/coregrind/x86/core_arch.h
index 0d8747a..1b8f702 100644
--- a/coregrind/x86/core_arch.h
+++ b/coregrind/x86/core_arch.h
@@ -41,21 +41,18 @@
    Interesting registers
    ------------------------------------------------------------------ */
 
-// Accessors for the ThreadArchState
-#define ARCH_INSTR_PTR(regs)           ((regs).vex.guest_EIP)
-#define ARCH_STACK_PTR(regs)           ((regs).vex.guest_ESP)
-#define ARCH_FRAME_PTR(regs)           ((regs).vex.guest_EBP)
+// Vex field names
+#define ARCH_INSTR_PTR        guest_EIP
+#define ARCH_STACK_PTR        guest_ESP
+#define ARCH_FRAME_PTR        guest_EBP
 
-#define ARCH_CLREQ_ARGS(regs)          ((regs).vex.guest_EAX)
-#define ARCH_PTHREQ_RET(regs)          ((regs).vex.guest_EDX)
-#define ARCH_CLREQ_RET(regs)           ((regs).vex.guest_EDX)
+#define ARCH_CLREQ_ARGS       guest_EAX
+#define ARCH_CLREQ_RET        guest_EDX
+#define ARCH_PTHREQ_RET       guest_EDX
 
-// Accessors for the baseBlock
-#define R_STACK_PTR                    R_ESP
-#define R_FRAME_PTR                    R_EBP
-
-#define R_CLREQ_RET                    R_EDX
-#define R_PTHREQ_RET                   R_EDX
+// Register numbers, for vg_symtab2.c
+#define R_STACK_PTR           4
+#define R_FRAME_PTR           5
 
 // Stack frame layout and linkage
 #define FIRST_STACK_FRAME(ebp)         (ebp)
@@ -155,6 +152,7 @@
    } 
    ThreadArchState;
 
+typedef VexGuestX86State VexGuestArchState;
 
 /* ---------------------------------------------------------------------
    libpthread stuff
diff --git a/coregrind/x86/signal.c b/coregrind/x86/signal.c
index 59cf02b..3eed1c1 100644
--- a/coregrind/x86/signal.c
+++ b/coregrind/x86/signal.c
@@ -147,8 +147,8 @@
 }
 
 #define SET_SIGNAL_ESP(zztid, zzval) \
-   SET_THREAD_REG(zztid, zzval, ARCH_STACK_PTR, R_STACK_PTR, \
-                  post_reg_write_deliver_signal)
+   SET_THREAD_REG(zztid, zzval, STACK_PTR, post_reg_write, \
+                  Vg_CoreSignal, zztid, O_STACK_PTR, sizeof(Addr))
 
 void VGA_(push_signal_frame)(ThreadId tid, Addr esp_top_of_frame,
                              const vki_siginfo_t *siginfo,
@@ -181,7 +181,8 @@
    frame->retaddr    = (UInt)VG_(client_trampoline_code)+VG_(tramp_sigreturn_offset);
    frame->sigNo      = sigNo;
    frame->sigNo_private = sigNo;
-   VG_TRACK( post_mem_write, (Addr)frame, offsetof(VgSigFrame, handlerArgs) );
+   VG_TRACK( post_mem_write, Vg_CoreSignal, tid,
+             (Addr)frame, offsetof(VgSigFrame, handlerArgs) );
 
    if (flags & VKI_SA_SIGINFO) {
       /* if the client asked for a siginfo delivery, then build the stack that way */
@@ -189,17 +190,20 @@
 		(Addr)&frame->handlerArgs, sizeof(frame->handlerArgs.sigInfo) );
       frame->handlerArgs.sigInfo.psigInfo   = (Addr)&frame->sigInfo;
       frame->handlerArgs.sigInfo.puContext = (Addr)&frame->uContext;
-      VG_TRACK( post_mem_write, (Addr)&frame->handlerArgs, sizeof(frame->handlerArgs.sigInfo) );
+      VG_TRACK( post_mem_write, Vg_CoreSignal, tid,
+                (Addr)&frame->handlerArgs, sizeof(frame->handlerArgs.sigInfo) );
 
       VG_TRACK( pre_mem_write, Vg_CoreSignal, tid, "signal handler frame (siginfo)", 
 		(Addr)&frame->sigInfo, sizeof(frame->sigInfo) );
       VG_(memcpy)(&frame->sigInfo, siginfo, sizeof(vki_siginfo_t));
-      VG_TRACK( post_mem_write, (Addr)&frame->sigInfo, sizeof(frame->sigInfo) );
+      VG_TRACK( post_mem_write, Vg_CoreSignal, tid, 
+                (Addr)&frame->sigInfo, sizeof(frame->sigInfo) );
 
       VG_TRACK( pre_mem_write, Vg_CoreSignal, tid, "signal handler frame (siginfo)", 
 		(Addr)&frame->uContext, sizeof(frame->uContext) );
       synth_ucontext(tid, siginfo, mask, &frame->uContext);
-      VG_TRACK( post_mem_write, (Addr)&frame->uContext, sizeof(frame->uContext) );
+      VG_TRACK( post_mem_write, Vg_CoreSignal, tid, 
+                (Addr)&frame->uContext, sizeof(frame->uContext) );
    } else {
       struct vki_ucontext uc;
 
@@ -211,8 +215,8 @@
 		(Addr)&frame->handlerArgs, sizeof(frame->handlerArgs.sigContext) );
       VG_(memcpy)(&frame->handlerArgs.sigContext, &uc.uc_mcontext, 
 		  sizeof(struct vki_sigcontext));
-      VG_TRACK( post_mem_write, (Addr)&frame->handlerArgs, 
-		sizeof(frame->handlerArgs.sigContext) );
+      VG_TRACK( post_mem_write, Vg_CoreSignal, tid,
+                (Addr)&frame->handlerArgs, sizeof(frame->handlerArgs.sigContext) );
       
       frame->handlerArgs.sigContext.oldmask = tst->sig_mask.sig[0];
    }
diff --git a/coregrind/x86/state.c b/coregrind/x86/state.c
index 3f710a9..5e97522 100644
--- a/coregrind/x86/state.c
+++ b/coregrind/x86/state.c
@@ -79,7 +79,8 @@
    VGOFF_(m_eip) = offsetof(VexGuestX86State,guest_EIP)/4;
 
    if (VG_(needs).shadow_regs) {
-      VG_TRACK( post_regs_write_init );
+      VG_TRACK( post_reg_write, Vg_CoreStartup, /*tid*/1, /*offset*/0,
+                sizeof(VexGuestArchState));
    }
 
    /* I assume that if we have SSE2 we also have SSE */
@@ -97,57 +98,6 @@
 
 
 /*------------------------------------------------------------*/
-/*--- Register access stuff                                ---*/
-/*------------------------------------------------------------*/
-
-void VGA_(set_thread_shadow_archreg) ( ThreadId tid, UInt archreg, UInt val )
-{
-   ThreadState* tst;
-
-   vg_assert(VG_(is_valid_tid)(tid));
-   tst = & VG_(threads)[tid];
-   if (0)
-   VG_(printf)("set_thread_shadow_archreg(%d, %d, 0x%x)\n",
-               tid, archreg, val);
-   switch (archreg) {
-      case R_EAX: tst->arch.vex_shadow.guest_EAX = val; break;
-      case R_ECX: tst->arch.vex_shadow.guest_ECX = val; break;
-      case R_EDX: tst->arch.vex_shadow.guest_EDX = val; break;
-      case R_EBX: tst->arch.vex_shadow.guest_EBX = val; break;
-      case R_ESP: tst->arch.vex_shadow.guest_ESP = val; break;
-      case R_EBP: tst->arch.vex_shadow.guest_EBP = val; break;
-      case R_ESI: tst->arch.vex_shadow.guest_ESI = val; break;
-      case R_EDI: tst->arch.vex_shadow.guest_EDI = val; break;
-      default:    VG_(core_panic)( "set_thread_shadow_archreg");
-   }
-}
-
-UInt VGA_(get_thread_shadow_archreg) ( ThreadId tid, UInt archreg )
-{
-   ThreadState* tst;
-
-   vg_assert(VG_(is_valid_tid)(tid));
-   tst = & VG_(threads)[tid];
-
-   if (0)
-   VG_(printf)("get_thread_shadow_archreg(%d, %d)\n",
-               tid, archreg);
-
-   switch (archreg) {
-      case R_EAX: return tst->arch.vex_shadow.guest_EAX;
-      case R_ECX: return tst->arch.vex_shadow.guest_ECX;
-      case R_EDX: return tst->arch.vex_shadow.guest_EDX;
-      case R_EBX: return tst->arch.vex_shadow.guest_EBX;
-      case R_ESP: return tst->arch.vex_shadow.guest_ESP;
-      case R_EBP: return tst->arch.vex_shadow.guest_EBP;
-      case R_ESI: return tst->arch.vex_shadow.guest_ESI;
-      case R_EDI: return tst->arch.vex_shadow.guest_EDI;
-      default:    VG_(core_panic)( "get_thread_shadow_archreg");
-   }
-}
-
-
-/*------------------------------------------------------------*/
 /*--- Thread stuff                                         ---*/
 /*------------------------------------------------------------*/
 
@@ -187,8 +137,8 @@
    /* Push the arg, and mark it as readable. */
    SET_PTHREQ_ESP(tid, VG_(threads)[tid].arch.vex.guest_ESP - sizeof(UWord));
    * (UInt*)(VG_(threads)[tid].arch.vex.guest_ESP) = arg;
-   VG_TRACK( post_mem_write, VG_(threads)[tid].arch.vex.guest_ESP, 
-                             sizeof(void*) );
+   VG_TRACK( post_mem_write, Vg_CoreSignal, tid, 
+             VG_(threads)[tid].arch.vex.guest_ESP, sizeof(void*) );
 
    /* Don't mark the pushed return address as readable; any attempt to read
       this is an internal valgrind bug since thread_exit_wrapper() should not
@@ -199,7 +149,7 @@
 
 void VGA_(thread_initial_stack)(ThreadId tid, UWord arg, Addr ret)
 {
-   Addr esp = (Addr)ARCH_STACK_PTR(VG_(threads)[tid].arch);
+   Addr esp = (Addr)STACK_PTR(VG_(threads)[tid].arch);
 
    /* push two args */
    esp -= 2 * sizeof(UWord);
@@ -213,7 +163,7 @@
    *(UWord*)(esp+sizeof(UWord)) = arg;
    *(UWord*)(esp)               = ret;
 
-   VG_TRACK ( post_mem_write, esp, 2 * sizeof(UWord) );
+   VG_TRACK ( post_mem_write, Vg_CoreSignal, tid, esp, 2 * sizeof(UWord) );
 }
 
 
@@ -221,6 +171,16 @@
 /*--- Symtab stuff                                         ---*/
 /*------------------------------------------------------------*/
 
+/* This is the Intel register encoding -- integer regs. */
+#define R_EAX 0
+#define R_ECX 1
+#define R_EDX 2
+#define R_EBX 3
+#define R_ESP 4
+#define R_EBP 5
+#define R_ESI 6
+#define R_EDI 7
+
 UInt *VGA_(reg_addr_from_tst)(Int regno, ThreadArchState *arch)
 {
    switch (regno) {
diff --git a/include/tool.h.base b/include/tool.h.base
index 31b278e..b59eb7e 100644
--- a/include/tool.h.base
+++ b/include/tool.h.base
@@ -566,28 +566,13 @@
 /* ------------------------------------------------------------------ */
 /* Accessing archregs and their shadows */
 
-extern UInt VGA_(get_archreg)            ( UInt archreg );
-extern UInt VGA_(get_thread_archreg)     ( ThreadId tid, UInt archreg );
+// For get/set, 'area' is where the asked-for shadow state will be copied
+// into/from.
 
-extern UInt VGA_(get_shadow_archreg)     ( UInt archreg );
-extern void VGA_(set_shadow_archreg)     ( UInt archreg, UInt val );
-
-extern UInt VGA_(get_thread_shadow_archreg) ( ThreadId tid, UInt archreg );
-extern void VGA_(set_thread_shadow_archreg) ( ThreadId tid, UInt archreg,
-                                              UInt val );
-
-/* ToDo: FIX */
-/* This is the Intel register encoding -- integer regs. */
-#define R_EAX 0
-#define R_ECX 1
-#define R_EDX 2
-#define R_EBX 3
-#define R_ESP 4
-#define R_EBP 5
-#define R_ESI 6
-#define R_EDI 7
-
-
+extern void VG_(get_shadow_regs_area) ( ThreadId tid, OffT guest_state_offset,
+                                        SizeT size, UChar* area );
+extern void VG_(set_shadow_regs_area) ( ThreadId tid, OffT guest_state_offset,
+                                        SizeT size, const UChar* area );
 
 /*====================================================================*/
 /*=== Execution contexts                                           ===*/
@@ -957,7 +942,7 @@
    syscall.  Call it from TL_(post_syscall)() (not TL_(pre_syscall)()!) to
    override the default shadow register value. */
 extern void VG_(set_return_from_syscall_shadow) ( ThreadId tid,
-                                                  UInt ret_shadow );
+                                                  UWord ret_shadow );
 
 /* This can be called from TL_(fini)() to find the shadow of the argument
    to exit(), ie. the shadow of the program's return value. */
@@ -1101,7 +1086,8 @@
 /* Part of the core from which this call was made.  Useful for determining
    what kind of error message should be emitted. */
 typedef
-   enum { Vg_CorePThread, Vg_CoreSignal, Vg_CoreSysCall, Vg_CoreTranslate }
+   enum { Vg_CoreStartup, Vg_CorePThread, Vg_CoreSignal, Vg_CoreSysCall,
+          Vg_CoreTranslate, Vg_CoreClientReq }
    CorePart;
 
 /* Useful to use in VG_(get_Xreg_usage)() */
diff --git a/memcheck/mc_main.c b/memcheck/mc_main.c
index 94667c8..776814a 100644
--- a/memcheck/mc_main.c
+++ b/memcheck/mc_main.c
@@ -740,35 +740,36 @@
    else         mc_make_noaccess(a, len);
 }
 
+static
+void mc_post_mem_write(CorePart part, ThreadId tid, Addr a, SizeT len)
+{
+   mc_make_readable(a, len);
+}
 
 /*------------------------------------------------------------*/
 /*--- Register event handlers                              ---*/
 /*------------------------------------------------------------*/
 
-static void mc_post_regs_write_init ( void )
+// When a reg is written, mark the corresponding shadow reg bytes as valid.
+static void mc_post_reg_write(CorePart part, ThreadId tid, OffT offset,
+                              SizeT size)
 {
-#if 0
-   UInt i;
-   for (i = FIRST_ARCH_REG; i <= LAST_ARCH_REG; i++)
-      VG_(set_shadow_archreg)( i, VGM_WORD_VALID );
-   VG_(set_shadow_eflags)( VGM_EFLAGS_VALID );
-#endif
+   UChar area[size];
+   VG_(memset)(area, VGM_BYTE_VALID, size);
+   VG_(set_shadow_regs_area)( tid, offset, size, area );
 }
 
-static void mc_post_reg_write(ThreadId tid, UInt reg)
+static void mc_post_reg_write_clientcall(ThreadId tid, OffT offset, SizeT size,
+                                         Addr f)
 {
-   VGA_(set_thread_shadow_archreg)( tid, reg, VGM_WORD_VALID );
+   mc_post_reg_write(/*dummy*/0, tid, offset, size);
 }
 
-static void mc_post_reg_write_clientcall(ThreadId tid, UInt reg, Addr f )
-{
-   VGA_(set_thread_shadow_archreg)( tid, reg, VGM_WORD_VALID );
-}
-
-static void mc_pre_reg_read(CorePart part, ThreadId tid, Char* s, UInt reg,
+static void mc_pre_reg_read(CorePart part, ThreadId tid, Char* s, OffT offset,
                             SizeT size)
 {
    UWord mask;
+   UWord sh_reg_contents;
    
    // XXX: the only one at the moment
    tl_assert(Vg_CoreSysCall == part);
@@ -780,7 +781,8 @@
    default: VG_(tool_panic)("Unhandled size in mc_pre_reg_read");
    }
 
-   if (VGM_WORD_VALID != (mask & VGA_(get_thread_shadow_archreg)( tid, reg )) )
+   VG_(get_shadow_regs_area)( tid, offset, size, (UChar*)&sh_reg_contents );
+   if ( VGM_WORD_VALID != (mask & sh_reg_contents) )
       MAC_(record_param_error) ( tid, 0, /*isReg*/True, /*isUnaddr*/False, s );
 }
 
@@ -1950,15 +1952,11 @@
    VG_(init_pre_mem_read)         ( & mc_check_is_readable );
    VG_(init_pre_mem_read_asciiz)  ( & mc_check_is_readable_asciiz );
    VG_(init_pre_mem_write)        ( & mc_check_is_writable );
-   VG_(init_post_mem_write)       ( & mc_make_readable );
+   VG_(init_post_mem_write)       ( & mc_post_mem_write );
 
    VG_(init_pre_reg_read)         ( & mc_pre_reg_read );
 
-   VG_(init_post_regs_write_init)             ( & mc_post_regs_write_init );
-   VG_(init_post_reg_write_syscall_return)    ( & mc_post_reg_write );
-   VG_(init_post_reg_write_deliver_signal)    ( & mc_post_reg_write );
-   VG_(init_post_reg_write_pthread_return)    ( & mc_post_reg_write );
-   VG_(init_post_reg_write_clientreq_return)  ( & mc_post_reg_write );
+   VG_(init_post_reg_write)                   ( & mc_post_reg_write );
    VG_(init_post_reg_write_clientcall_return) ( & mc_post_reg_write_clientcall );
 
    VGP_(register_profile_event) ( VgpSetMem,   "set-mem-perms" );