---
 i386-linux-tdep.c |    3 
 linux-record.c    | 1387 +++++++++++++++++++++++++++++-------------------------
 linux-record.h    |    4 
 3 files changed, 774 insertions(+), 620 deletions(-)

--- a/i386-linux-tdep.c
+++ b/i386-linux-tdep.c
@@ -479,6 +479,7 @@ i386_linux_init_abi (struct gdbarch_info
   /* Initialize the i386_linux_record_tdep.  */
   /* These values are the size of the type that will be used in a system
      call.  They are obtained from Linux Kernel source.  */
+  i386_linux_record_tdep.size_pointer = 4;
   i386_linux_record_tdep.size__old_kernel_stat = 32;
   i386_linux_record_tdep.size_tms = 16;
   i386_linux_record_tdep.size_loff_t = 8;
@@ -544,6 +545,8 @@ i386_linux_init_abi (struct gdbarch_info
   i386_linux_record_tdep.size_serial_struct = 60;
   i386_linux_record_tdep.size_serial_icounter_struct = 80;
   i386_linux_record_tdep.size_hayes_esp_config = 12;
+  i386_linux_record_tdep.size_size_t = 4;
+  i386_linux_record_tdep.size_iovec = 8;
 
   /* These values are the second argument of system call "sys_ioctl".
      They are obtained from Linux Kernel source.  */
--- a/linux-record.c
+++ b/linux-record.c
@@ -19,6 +19,7 @@
 
 #include "defs.h"
 #include "target.h"
+#include "gdbtypes.h"
 #include "regcache.h"
 #include "record.h"
 #include "linux-record.h"
@@ -92,11 +93,14 @@
 
    Return -1 if something wrong.  */
 
+#define OUTPUT_REG(val, num)      phex_nz ((val), \
+    TYPE_LENGTH (gdbarch_register_type (get_regcache_arch (regcache), (num))))
+
 int
 record_linux_system_call (int num, struct regcache *regcache,
 			  struct linux_record_tdep *tdep)
 {
-  uint32_t tmpu32;
+  ULONGEST tmpulongest;
 
   switch (num)
     {
@@ -126,10 +130,10 @@ record_linux_system_call (int num, struc
       /* sys_read */
     case 3:
       {
-	uint32_t addr, count;
-	regcache_raw_read (regcache, tdep->arg2, (gdb_byte *) & addr);
-	regcache_raw_read (regcache, tdep->arg3, (gdb_byte *) & count);
-	if (record_arch_list_add_mem (addr, count))
+	ULONGEST addr, count;
+	regcache_raw_read_unsigned (regcache, tdep->arg2, &addr);
+	regcache_raw_read_unsigned (regcache, tdep->arg3, &count);
+	if (record_arch_list_add_mem ((CORE_ADDR)addr, (int)count))
 	  return -1;
       }
       break;
@@ -170,8 +174,9 @@ record_linux_system_call (int num, struc
     case 28:
       /* sys_lstat */
     case 84:
-      regcache_raw_read (regcache, tdep->arg2, (gdb_byte *) & tmpu32);
-      if (record_arch_list_add_mem (tmpu32, tdep->size__old_kernel_stat))
+      regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
+      if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+                                    tdep->size__old_kernel_stat))
 	return -1;
       break;
 
@@ -193,14 +198,14 @@ record_linux_system_call (int num, struc
 
       /* sys_ptrace */
     case 26:
-      regcache_raw_read (regcache, tdep->arg1, (gdb_byte *) & tmpu32);
-      if (tmpu32 == RECORD_PTRACE_PEEKTEXT
-	  || tmpu32 == RECORD_PTRACE_PEEKDATA
-	  || tmpu32 == RECORD_PTRACE_PEEKUSR)
+      regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
+      if (tmpulongest == RECORD_PTRACE_PEEKTEXT
+	  || tmpulongest == RECORD_PTRACE_PEEKDATA
+	  || tmpulongest == RECORD_PTRACE_PEEKUSR)
 	{
-	  regcache_raw_read (regcache, tdep->arg4,
-			     (gdb_byte *) & tmpu32);
-	  if (record_arch_list_add_mem (tmpu32, 4))
+	  regcache_raw_read_unsigned (regcache, tdep->arg4,
+			              &tmpulongest);
+	  if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest, 4))
 	    return -1;
 	}
       break;
@@ -239,8 +244,8 @@ record_linux_system_call (int num, struc
 
       /* sys_times */
     case 43:
-      regcache_raw_read (regcache, tdep->arg1, (gdb_byte *) & tmpu32);
-      if (record_arch_list_add_mem (tmpu32, tdep->size_tms))
+      regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
+      if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest, tdep->size_tms))
 	return -1;
       break;
 
@@ -269,123 +274,145 @@ record_linux_system_call (int num, struc
       /* sys_ioctl */
     case 54:
       /* XXX Need to add a lot of support of other ioctl requests.  */
-      regcache_raw_read (regcache, tdep->arg2, (gdb_byte *) & tmpu32);
-      if (tmpu32 == tdep->ioctl_FIOCLEX || tmpu32 == tdep->ioctl_FIONCLEX
-	  || tmpu32 == tdep->ioctl_FIONBIO || tmpu32 == tdep->ioctl_FIOASYNC
-	  || tmpu32 == tdep->ioctl_TCSETS || tmpu32 == tdep->ioctl_TCSETSW
-	  || tmpu32 == tdep->ioctl_TCSETSF || tmpu32 == tdep->ioctl_TCSETA
-	  || tmpu32 == tdep->ioctl_TCSETAW || tmpu32 == tdep->ioctl_TCSETAF
-	  || tmpu32 == tdep->ioctl_TCSBRK || tmpu32 == tdep->ioctl_TCXONC
-	  || tmpu32 == tdep->ioctl_TCFLSH || tmpu32 == tdep->ioctl_TIOCEXCL
-	  || tmpu32 == tdep->ioctl_TIOCNXCL
-	  || tmpu32 == tdep->ioctl_TIOCSCTTY
-	  || tmpu32 == tdep->ioctl_TIOCSPGRP || tmpu32 == tdep->ioctl_TIOCSTI
-	  || tmpu32 == tdep->ioctl_TIOCSWINSZ
-	  || tmpu32 == tdep->ioctl_TIOCMBIS || tmpu32 == tdep->ioctl_TIOCMBIC
-	  || tmpu32 == tdep->ioctl_TIOCMSET
-	  || tmpu32 == tdep->ioctl_TIOCSSOFTCAR
-	  || tmpu32 == tdep->ioctl_TIOCCONS
-	  || tmpu32 == tdep->ioctl_TIOCSSERIAL
-	  || tmpu32 == tdep->ioctl_TIOCPKT || tmpu32 == tdep->ioctl_TIOCNOTTY
-	  || tmpu32 == tdep->ioctl_TIOCSETD || tmpu32 == tdep->ioctl_TCSBRKP
-	  || tmpu32 == tdep->ioctl_TIOCTTYGSTRUCT
-	  || tmpu32 == tdep->ioctl_TIOCSBRK || tmpu32 == tdep->ioctl_TIOCCBRK
-	  || tmpu32 == tdep->ioctl_TCSETS2 || tmpu32 == tdep->ioctl_TCSETSW2
-	  || tmpu32 == tdep->ioctl_TCSETSF2
-	  || tmpu32 == tdep->ioctl_TIOCSPTLCK
-	  || tmpu32 == tdep->ioctl_TIOCSERCONFIG
-	  || tmpu32 == tdep->ioctl_TIOCSERGWILD
-	  || tmpu32 == tdep->ioctl_TIOCSERSWILD
-	  || tmpu32 == tdep->ioctl_TIOCSLCKTRMIOS
-	  || tmpu32 == tdep->ioctl_TIOCSERGETMULTI
-	  || tmpu32 == tdep->ioctl_TIOCSERSETMULTI
-	  || tmpu32 == tdep->ioctl_TIOCMIWAIT
-	  || tmpu32 == tdep->ioctl_TIOCSHAYESESP)
+      regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
+      if (tmpulongest == tdep->ioctl_FIOCLEX
+          || tmpulongest == tdep->ioctl_FIONCLEX
+	  || tmpulongest == tdep->ioctl_FIONBIO
+          || tmpulongest == tdep->ioctl_FIOASYNC
+	  || tmpulongest == tdep->ioctl_TCSETS
+          || tmpulongest == tdep->ioctl_TCSETSW
+	  || tmpulongest == tdep->ioctl_TCSETSF
+          || tmpulongest == tdep->ioctl_TCSETA
+	  || tmpulongest == tdep->ioctl_TCSETAW
+          || tmpulongest == tdep->ioctl_TCSETAF
+	  || tmpulongest == tdep->ioctl_TCSBRK
+          || tmpulongest == tdep->ioctl_TCXONC
+	  || tmpulongest == tdep->ioctl_TCFLSH
+          || tmpulongest == tdep->ioctl_TIOCEXCL
+	  || tmpulongest == tdep->ioctl_TIOCNXCL
+	  || tmpulongest == tdep->ioctl_TIOCSCTTY
+	  || tmpulongest == tdep->ioctl_TIOCSPGRP
+          || tmpulongest == tdep->ioctl_TIOCSTI
+	  || tmpulongest == tdep->ioctl_TIOCSWINSZ
+	  || tmpulongest == tdep->ioctl_TIOCMBIS
+          || tmpulongest == tdep->ioctl_TIOCMBIC
+	  || tmpulongest == tdep->ioctl_TIOCMSET
+	  || tmpulongest == tdep->ioctl_TIOCSSOFTCAR
+	  || tmpulongest == tdep->ioctl_TIOCCONS
+	  || tmpulongest == tdep->ioctl_TIOCSSERIAL
+	  || tmpulongest == tdep->ioctl_TIOCPKT
+          || tmpulongest == tdep->ioctl_TIOCNOTTY
+	  || tmpulongest == tdep->ioctl_TIOCSETD
+          || tmpulongest == tdep->ioctl_TCSBRKP
+	  || tmpulongest == tdep->ioctl_TIOCTTYGSTRUCT
+	  || tmpulongest == tdep->ioctl_TIOCSBRK
+          || tmpulongest == tdep->ioctl_TIOCCBRK
+	  || tmpulongest == tdep->ioctl_TCSETS2
+          || tmpulongest == tdep->ioctl_TCSETSW2
+	  || tmpulongest == tdep->ioctl_TCSETSF2
+	  || tmpulongest == tdep->ioctl_TIOCSPTLCK
+	  || tmpulongest == tdep->ioctl_TIOCSERCONFIG
+	  || tmpulongest == tdep->ioctl_TIOCSERGWILD
+	  || tmpulongest == tdep->ioctl_TIOCSERSWILD
+	  || tmpulongest == tdep->ioctl_TIOCSLCKTRMIOS
+	  || tmpulongest == tdep->ioctl_TIOCSERGETMULTI
+	  || tmpulongest == tdep->ioctl_TIOCSERSETMULTI
+	  || tmpulongest == tdep->ioctl_TIOCMIWAIT
+	  || tmpulongest == tdep->ioctl_TIOCSHAYESESP)
 	{
 	  /* Nothing to do.  */
 	}
-      else if (tmpu32 == tdep->ioctl_TCGETS || tmpu32 == tdep->ioctl_TCGETA
-	       || tmpu32 == tdep->ioctl_TIOCGLCKTRMIOS)
+      else if (tmpulongest == tdep->ioctl_TCGETS
+               || tmpulongest == tdep->ioctl_TCGETA
+	       || tmpulongest == tdep->ioctl_TIOCGLCKTRMIOS)
 	{
-	  regcache_raw_read (regcache, tdep->arg3,
-			     (gdb_byte *) & tmpu32);
-	  if (record_arch_list_add_mem (tmpu32, tdep->size_termios))
+	  regcache_raw_read_unsigned (regcache, tdep->arg3,
+			              &tmpulongest);
+	  if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+                                        tdep->size_termios))
 	    return -1;
 	}
-      else if (tmpu32 == tdep->ioctl_TIOCGPGRP
-	       || tmpu32 == tdep->ioctl_TIOCGSID)
+      else if (tmpulongest == tdep->ioctl_TIOCGPGRP
+	       || tmpulongest == tdep->ioctl_TIOCGSID)
 	{
-	  regcache_raw_read (regcache, tdep->arg3,
-			     (gdb_byte *) & tmpu32);
-	  if (record_arch_list_add_mem (tmpu32, tdep->size_pid_t))
+	  regcache_raw_read_unsigned (regcache, tdep->arg3,
+			              &tmpulongest);
+	  if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+                                        tdep->size_pid_t))
 	    return -1;
 	}
-      else if (tmpu32 == tdep->ioctl_TIOCOUTQ
-	       || tmpu32 == tdep->ioctl_TIOCMGET
-	       || tmpu32 == tdep->ioctl_TIOCGSOFTCAR
-	       || tmpu32 == tdep->ioctl_FIONREAD
-	       || tmpu32 == tdep->ioctl_TIOCINQ
-	       || tmpu32 == tdep->ioctl_TIOCGETD
-	       || tmpu32 == tdep->ioctl_TIOCGPTN
-	       || tmpu32 == tdep->ioctl_TIOCSERGETLSR)
+      else if (tmpulongest == tdep->ioctl_TIOCOUTQ
+	       || tmpulongest == tdep->ioctl_TIOCMGET
+	       || tmpulongest == tdep->ioctl_TIOCGSOFTCAR
+	       || tmpulongest == tdep->ioctl_FIONREAD
+	       || tmpulongest == tdep->ioctl_TIOCINQ
+	       || tmpulongest == tdep->ioctl_TIOCGETD
+	       || tmpulongest == tdep->ioctl_TIOCGPTN
+	       || tmpulongest == tdep->ioctl_TIOCSERGETLSR)
 	{
-	  regcache_raw_read (regcache, tdep->arg3,
-			     (gdb_byte *) & tmpu32);
-	  if (record_arch_list_add_mem (tmpu32, tdep->size_int))
+	  regcache_raw_read_unsigned (regcache, tdep->arg3,
+			              &tmpulongest);
+	  if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+                                        tdep->size_int))
 	    return -1;
 	}
-      else if (tmpu32 == tdep->ioctl_TIOCGWINSZ)
+      else if (tmpulongest == tdep->ioctl_TIOCGWINSZ)
 	{
-	  regcache_raw_read (regcache, tdep->arg3,
-			     (gdb_byte *) & tmpu32);
-	  if (record_arch_list_add_mem (tmpu32, tdep->size_winsize))
+	  regcache_raw_read_unsigned (regcache, tdep->arg3,
+			              &tmpulongest);
+	  if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+                                        tdep->size_winsize))
 	    return -1;
 	}
-      else if (tmpu32 == tdep->ioctl_TIOCLINUX)
+      else if (tmpulongest == tdep->ioctl_TIOCLINUX)
 	{
-	  regcache_raw_read (regcache, tdep->arg3,
-			     (gdb_byte *) & tmpu32);
+	  regcache_raw_read_unsigned (regcache, tdep->arg3,
+			              &tmpulongest);
           /* This syscall affect a char size memory.  */
-	  if (record_arch_list_add_mem (tmpu32, 1))
+	  if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest, 1))
 	    return -1;
 	}
-      else if (tmpu32 == tdep->ioctl_TIOCGSERIAL)
+      else if (tmpulongest == tdep->ioctl_TIOCGSERIAL)
 	{
-	  regcache_raw_read (regcache, tdep->arg3,
-			     (gdb_byte *) & tmpu32);
-	  if (record_arch_list_add_mem (tmpu32, tdep->size_serial_struct))
+	  regcache_raw_read_unsigned (regcache, tdep->arg3,
+			              &tmpulongest);
+	  if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+                                        tdep->size_serial_struct))
 	    return -1;
 	}
-      else if (tmpu32 == tdep->ioctl_TCGETS2)
+      else if (tmpulongest == tdep->ioctl_TCGETS2)
 	{
-	  regcache_raw_read (regcache, tdep->arg3,
-			     (gdb_byte *) & tmpu32);
-	  if (record_arch_list_add_mem (tmpu32, tdep->size_termios2))
+	  regcache_raw_read_unsigned (regcache, tdep->arg3,
+			              &tmpulongest);
+	  if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+                                        tdep->size_termios2))
 	    return -1;
 	}
-      else if (tmpu32 == tdep->ioctl_FIOQSIZE)
+      else if (tmpulongest == tdep->ioctl_FIOQSIZE)
 	{
-	  regcache_raw_read (regcache, tdep->arg3,
-			     (gdb_byte *) & tmpu32);
-	  if (record_arch_list_add_mem (tmpu32, tdep->size_loff_t))
+	  regcache_raw_read_unsigned (regcache, tdep->arg3,
+			              &tmpulongest);
+	  if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+                                        tdep->size_loff_t))
 	    return -1;
 	}
-      else if (tmpu32 == tdep->ioctl_TIOCGICOUNT)
+      else if (tmpulongest == tdep->ioctl_TIOCGICOUNT)
 	{
-	  regcache_raw_read (regcache, tdep->arg3,
-			     (gdb_byte *) & tmpu32);
-	  if (record_arch_list_add_mem
-	      (tmpu32, tdep->size_serial_icounter_struct))
+	  regcache_raw_read_unsigned (regcache, tdep->arg3,
+			              &tmpulongest);
+	  if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+                                        tdep->size_serial_icounter_struct))
 	    return -1;
 	}
-      else if (tmpu32 == tdep->ioctl_TIOCGHAYESESP)
+      else if (tmpulongest == tdep->ioctl_TIOCGHAYESESP)
 	{
-	  regcache_raw_read (regcache, tdep->arg3,
-			     (gdb_byte *) & tmpu32);
-	  if (record_arch_list_add_mem (tmpu32, tdep->size_hayes_esp_config))
+	  regcache_raw_read_unsigned (regcache, tdep->arg3,
+			              &tmpulongest);
+          if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+                                        tdep->size_hayes_esp_config))
 	    return -1;
 	}
-      else if (tmpu32 == tdep->ioctl_TIOCSERGSTRUCT)
+      else if (tmpulongest == tdep->ioctl_TIOCSERGSTRUCT)
 	{
 	  printf_unfiltered (_("Process record and replay target doesn't "
 			       "support ioctl request TIOCSERGSTRUCT\n"));
@@ -393,9 +420,9 @@ record_linux_system_call (int num, struc
 	}
       else
 	{
-	  printf_unfiltered (_("Process record and replay target doesn't "
-			       "support ioctl request 0x%s.\n"),
-			     phex_nz (tmpu32, 4));
+          printf_unfiltered (_("Process record and replay target doesn't "
+                               "support ioctl request 0x%s.\n"),
+                             OUTPUT_REG (tmpulongest, tdep->arg2));
 	  return 1;
 	}
       break;
@@ -403,13 +430,14 @@ record_linux_system_call (int num, struc
       /* sys_fcntl */
     case 55:
       /* XXX */
-      regcache_raw_read (regcache, tdep->arg2, (gdb_byte *) & tmpu32);
+      regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
     sys_fcntl:
-      if (tmpu32 == tdep->fcntl_F_GETLK)
+      if (tmpulongest == tdep->fcntl_F_GETLK)
 	{
-	  regcache_raw_read (regcache, tdep->arg3,
-			     (gdb_byte *) & tmpu32);
-	  if (record_arch_list_add_mem (tmpu32, tdep->size_flock))
+	  regcache_raw_read_unsigned (regcache, tdep->arg3,
+			              &tmpulongest);
+          if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+                                        tdep->size_flock))
 	    return -1;
 	}
       break;
@@ -424,8 +452,9 @@ record_linux_system_call (int num, struc
 
       /* sys_olduname */
     case 59:
-      regcache_raw_read (regcache, tdep->arg1, (gdb_byte *) & tmpu32);
-      if (record_arch_list_add_mem (tmpu32, tdep->size_oldold_utsname))
+      regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
+      if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+                                    tdep->size_oldold_utsname))
 	return -1;
       break;
 
@@ -437,8 +466,9 @@ record_linux_system_call (int num, struc
 
       /* sys_ustat */
     case 62:
-      regcache_raw_read (regcache, tdep->arg2, (gdb_byte *) & tmpu32);
-      if (record_arch_list_add_mem (tmpu32, tdep->size_ustat))
+      regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
+      if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+                                    tdep->size_ustat))
 	return -1;
       break;
 
@@ -454,8 +484,9 @@ record_linux_system_call (int num, struc
 
       /* sys_sigaction */
     case 67:
-      regcache_raw_read (regcache, tdep->arg3, (gdb_byte *) & tmpu32);
-      if (record_arch_list_add_mem (tmpu32, tdep->size_old_sigaction))
+      regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
+      if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+                                    tdep->size_old_sigaction))
 	return -1;
       break;
 
@@ -473,8 +504,9 @@ record_linux_system_call (int num, struc
 
       /* sys_sigpending */
     case 73:
-      regcache_raw_read (regcache, tdep->arg1, (gdb_byte *) & tmpu32);
-      if (record_arch_list_add_mem (tmpu32, tdep->size_old_sigset_t))
+      regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
+      if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+                                    tdep->size_old_sigset_t))
 	return -1;
       break;
 
@@ -486,25 +518,29 @@ record_linux_system_call (int num, struc
 
       /* sys_old_getrlimit */
     case 76:
-      regcache_raw_read (regcache, tdep->arg2, (gdb_byte *) & tmpu32);
-      if (record_arch_list_add_mem (tmpu32, tdep->size_rlimit))
+      regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
+      if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+                                    tdep->size_rlimit))
 	return -1;
       break;
 
       /* sys_getrusage */
     case 77:
-      regcache_raw_read (regcache, tdep->arg2, (gdb_byte *) & tmpu32);
-      if (record_arch_list_add_mem (tmpu32, tdep->size_rusage))
+      regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
+      if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+                                    tdep->size_rusage))
 	return -1;
       break;
 
       /* sys_gettimeofday */
     case 78:
-      regcache_raw_read (regcache, tdep->arg1, (gdb_byte *) & tmpu32);
-      if (record_arch_list_add_mem (tmpu32, tdep->size_timeval))
+      regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
+      if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+                                    tdep->size_timeval))
 	return -1;
-      regcache_raw_read (regcache, tdep->arg2, (gdb_byte *) & tmpu32);
-      if (record_arch_list_add_mem (tmpu32, tdep->size_timezone))
+      regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
+      if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+                                    tdep->size_timezone))
 	return -1;
       break;
 
@@ -514,15 +550,17 @@ record_linux_system_call (int num, struc
 
       /* sys_getgroups16 */
     case 80:
-      regcache_raw_read (regcache, tdep->arg2, (gdb_byte *) & tmpu32);
-      if (record_arch_list_add_mem (tmpu32, tdep->size_old_gid_t))
+      regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
+      if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+                                    tdep->size_old_gid_t))
 	return -1;
       break;
 
       /* sys_setgroups16 */
     case 81:
-      regcache_raw_read (regcache, tdep->arg2, (gdb_byte *) & tmpu32);
-      if (record_arch_list_add_mem (tmpu32, tdep->size_old_gid_t))
+      regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
+      if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+                                    tdep->size_old_gid_t))
 	return -1;
       break;
 
@@ -538,17 +576,18 @@ record_linux_system_call (int num, struc
 	  CORE_ADDR tvp;
 	} sel;
 
-	regcache_raw_read (regcache, tdep->arg1,
-			   (gdb_byte *) & tmpu32);
-	if (tmpu32)
+	regcache_raw_read_unsigned (regcache, tdep->arg1,
+			            &tmpulongest);
+	if (tmpulongest)
 	  {
-	    if (target_read_memory (tmpu32, (gdb_byte *) & sel, sizeof (sel)))
+	    if (target_read_memory (tmpulongest, (gdb_byte *)&sel,
+                                    sizeof(sel)))
 	      {
 		if (record_debug)
 		  fprintf_unfiltered (gdb_stdlog,
 				      "Process record: error reading memory "
 				      "at addr = 0x%s len = %lu.\n",
-				      paddr_nz (tmpu32),
+				      OUTPUT_REG (tmpulongest, tdep->arg1),
 				      (unsigned long)sizeof (sel));
 		return -1;
 	      }
@@ -571,11 +610,11 @@ record_linux_system_call (int num, struc
       /* sys_readlink */
     case 85:
       {
-	uint32_t len;
-	regcache_raw_read (regcache, tdep->arg2,
-			   (gdb_byte *) & tmpu32);
-	regcache_raw_read (regcache, tdep->arg3, (gdb_byte *) & len);
-	if (record_arch_list_add_mem (tmpu32, len))
+	ULONGEST len;
+	regcache_raw_read_unsigned (regcache, tdep->arg2,
+			            &tmpulongest);
+	regcache_raw_read_unsigned (regcache, tdep->arg3, &len);
+        if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest, (int)len))
 	  return -1;
       }
       break;
@@ -603,8 +642,9 @@ record_linux_system_call (int num, struc
 
       /* old_readdir */
     case 89:
-      regcache_raw_read (regcache, tdep->arg2, (gdb_byte *) & tmpu32);
-      if (record_arch_list_add_mem (tmpu32, tdep->size_dirent))
+      regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
+      if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+                                    tdep->size_dirent))
 	return -1;
       break;
 
@@ -616,18 +656,18 @@ record_linux_system_call (int num, struc
     case 91:
       {
 	int q;
-	uint32_t len;
+	ULONGEST len;
 
-	regcache_raw_read (regcache, tdep->arg1,
-			   (gdb_byte *) & tmpu32);
-	regcache_raw_read (regcache, tdep->arg2, (gdb_byte *) & len);
+	regcache_raw_read_unsigned (regcache, tdep->arg1,
+			            &tmpulongest);
+	regcache_raw_read_unsigned (regcache, tdep->arg2, &len);
 	target_terminal_ours ();
 	q =
 	  yquery (_("The next instruction is syscall munmap.  "
 		    "It will free the memory addr = 0x%s len = %u.  "
 		    "It will make record target get error.  "
 		    "Do you want to stop the program?"),
-		  paddr_nz (tmpu32), (int)len);
+		  OUTPUT_REG (tmpulongest, tdep->arg1), (int)len);
 	target_terminal_inferior ();
 	if (q)
 	  return 1;
@@ -654,8 +694,9 @@ record_linux_system_call (int num, struc
     case 99:
       /* sys_fstatfs */
     case 100:
-      regcache_raw_read (regcache, tdep->arg2, (gdb_byte *) & tmpu32);
-      if (record_arch_list_add_mem (tmpu32, tdep->size_statfs))
+      regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
+      if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+                                    tdep->size_statfs))
 	return -1;
       break;
 
@@ -665,8 +706,8 @@ record_linux_system_call (int num, struc
 
       /* sys_socketcall */
     case 102:
-      regcache_raw_read (regcache, tdep->arg1, (gdb_byte *) & tmpu32);
-      switch (tmpu32)
+      regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
+      switch (tmpulongest)
 	{
 	case RECORD_SYS_SOCKET:
 	case RECORD_SYS_BIND:
@@ -677,24 +718,31 @@ record_linux_system_call (int num, struc
 	case RECORD_SYS_GETSOCKNAME:
 	case RECORD_SYS_GETPEERNAME:
 	  {
-	    uint32_t a[3];
-	    regcache_raw_read (regcache, tdep->arg2,
-			       (gdb_byte *) & tmpu32);
-	    if (tmpu32)
+	    gdb_byte *a = alloca (tdep->size_ulong * 2);
+	    regcache_raw_read_unsigned (regcache, tdep->arg2,
+			                &tmpulongest);
+	    if (tmpulongest)
 	      {
-		if (target_read_memory (tmpu32, (gdb_byte *) a, sizeof (a)))
+                tmpulongest += tdep->size_ulong;
+		if (target_read_memory ((CORE_ADDR)tmpulongest, a,
+                                        tdep->size_ulong * 2))
 		  {
 		    if (record_debug)
 		      fprintf_unfiltered (gdb_stdlog,
 					  "Process record: error reading "
-					  "memory at addr = 0x%s len = %lu.\n",
-					  paddr_nz (tmpu32),
-					  (unsigned long)sizeof (a));
+					  "memory at addr = 0x%s len = %d.\n",
+					  OUTPUT_REG (tmpulongest, tdep->arg2),
+					  tdep->size_ulong * 2);
 		    return -1;
 		  }
-		if (record_arch_list_add_mem (a[1], tdep->size_sockaddr))
+		if (record_arch_list_add_mem ((CORE_ADDR)extract_unsigned_integer
+                                                           (a, tdep->size_ulong),
+                                              tdep->size_sockaddr))
 		  return -1;
-		if (record_arch_list_add_mem (a[2], tdep->size_int))
+                a += tdep->size_ulong;
+		if (record_arch_list_add_mem ((CORE_ADDR)extract_unsigned_integer
+                                                           (a, tdep->size_ulong),
+                                              tdep->size_int))
 		  return -1;
 	      }
 	  }
@@ -702,22 +750,26 @@ record_linux_system_call (int num, struc
 
 	case RECORD_SYS_SOCKETPAIR:
 	  {
-	    uint32_t a[4];
-	    regcache_raw_read (regcache, tdep->arg2,
-			       (gdb_byte *) & tmpu32);
-	    if (tmpu32)
+	    gdb_byte *a = alloca (tdep->size_ulong);
+	    regcache_raw_read_unsigned (regcache, tdep->arg2,
+			                &tmpulongest);
+	    if (tmpulongest)
 	      {
-		if (target_read_memory (tmpu32, (gdb_byte *) a, sizeof (a)))
+                tmpulongest += tdep->size_ulong * 3;
+		if (target_read_memory ((CORE_ADDR)tmpulongest, a,
+                                        tdep->size_ulong))
 		  {
 		    if (record_debug)
 		      fprintf_unfiltered (gdb_stdlog,
 					  "Process record: error reading "
-					  "memory at addr = 0x%s len = %lu.\n",
-					  paddr_nz (tmpu32),
-				          (unsigned long)sizeof (a));
+					  "memory at addr = 0x%s len = %d.\n",
+					  OUTPUT_REG (tmpulongest, tdep->arg2),
+				          tdep->size_ulong);
 		    return -1;
 		  }
-		if (record_arch_list_add_mem (a[3], tdep->size_int))
+		if (record_arch_list_add_mem ((CORE_ADDR)extract_unsigned_integer
+                                                           (a, tdep->size_ulong),
+                                              tdep->size_int))
 		  return -1;
 	      }
 	  }
@@ -727,36 +779,44 @@ record_linux_system_call (int num, struc
 	  break;
 	case RECORD_SYS_RECV:
 	  {
-	    uint32_t a[3];
-	    regcache_raw_read (regcache, tdep->arg2,
-			       (gdb_byte *) & tmpu32);
-	    if (tmpu32)
+	    gdb_byte *a = alloca (tdep->size_ulong * 2);
+	    regcache_raw_read_unsigned (regcache, tdep->arg2,
+			                &tmpulongest);
+	    if (tmpulongest)
 	      {
-		if (target_read_memory (tmpu32, (gdb_byte *) a, sizeof (a)))
+                tmpulongest += tdep->size_ulong * 2;
+		if (target_read_memory ((CORE_ADDR)tmpulongest, a,
+                                        tdep->size_ulong))
 		  {
 		    if (record_debug)
 		      fprintf_unfiltered (gdb_stdlog,
 					  "Process record: error reading "
-					  "memory at addr = 0x%s len = %lu.\n",
-					  paddr_nz (tmpu32),
-					  (unsigned long)sizeof (a));
+					  "memory at addr = 0x%s len = %d.\n",
+					  OUTPUT_REG (tmpulongest, tdep->arg2),
+					  tdep->size_ulong);
 		    return -1;
 		  }
-		if (a[2])
+                tmpulongest = extract_unsigned_integer (a, tdep->size_ulong);
+		if (tmpulongest)
 		  {
-		    if (target_read_memory
-			(a[2], (gdb_byte *) & (a[2]), sizeof (a[2])))
+		    if (target_read_memory ((CORE_ADDR)tmpulongest,
+                                            a, tdep->size_ulong * 2))
 		      {
 			if (record_debug)
 			  fprintf_unfiltered (gdb_stdlog,
 					      "Process record: error reading "
 					      "memory at addr = 0x%s "
-					      "len = %lu.\n",
-					      paddr_nz (a[2]),
-					      (unsigned long)sizeof (a[2]));
+					      "len = %d.\n",
+					      phex_nz (tmpulongest,
+                                                       tdep->size_ulong),
+					      tdep->size_ulong * 2);
 			return -1;
 		      }
-		    if (record_arch_list_add_mem (a[1], a[2]))
+		    if (record_arch_list_add_mem ((CORE_ADDR)extract_unsigned_integer
+                                                               (a, tdep->size_ulong),
+                                                  (int)extract_unsigned_integer
+                                                               (a + tdep->size_ulong,
+                                                                tdep->size_ulong)))
 		      return -1;
 		  }
 	      }
@@ -764,40 +824,56 @@ record_linux_system_call (int num, struc
 	  break;
 	case RECORD_SYS_RECVFROM:
 	  {
-	    uint32_t a[6];
-	    regcache_raw_read (regcache, tdep->arg2,
-			       (gdb_byte *) & tmpu32);
-	    if (tmpu32)
+            gdb_byte *a = alloca (tdep->size_ulong * 5);
+	    regcache_raw_read_unsigned (regcache, tdep->arg2,
+			                &tmpulongest);
+	    if (tmpulongest)
 	      {
-		if (target_read_memory (tmpu32, (gdb_byte *) a, sizeof (a)))
+                tmpulongest += tdep->size_ulong;
+		if (target_read_memory ((CORE_ADDR)tmpulongest, a,
+                    tdep->size_ulong * 5))
 		  {
 		    if (record_debug)
 		      fprintf_unfiltered (gdb_stdlog,
 					  "Process record: error reading "
-					  "memory at addr = 0x%s len = %lu.\n",
-					  paddr_nz (tmpu32),
-					  (unsigned long)sizeof (a));
+					  "memory at addr = 0x%s len = %d.\n",
+					  OUTPUT_REG (tmpulongest, tdep->arg2),
+					  tdep->size_ulong * 5);
 		    return -1;
 		  }
-		if (a[2])
+                tmpulongest = extract_unsigned_integer (a + tdep->size_ulong,
+                                                  tdep->size_ulong);
+		if (tmpulongest)
 		  {
-		    if (target_read_memory
-			(a[2], (gdb_byte *) & (a[2]), sizeof (a[2])))
+		    if (target_read_memory ((CORE_ADDR)tmpulongest,
+                                            a + tdep->size_ulong,
+                                            tdep->size_ulong))
 		      {
 			if (record_debug)
 			  fprintf_unfiltered (gdb_stdlog,
 					      "Process record: error reading "
 					      "memory at addr = 0x%s "
-					      "len = %lu.\n",
-					      paddr_nz (a[2]),
-					      (unsigned long)sizeof (a[2]));
+					      "len = %d.\n",
+					      phex_nz (tmpulongest,
+                                                       tdep->size_ulong),
+					      tdep->size_ulong);
 			return -1;
 		      }
-		    if (record_arch_list_add_mem (a[1], a[2]))
+		    if (record_arch_list_add_mem ((CORE_ADDR)extract_unsigned_integer
+                                                               (a, tdep->size_ulong),
+                                                  (int)extract_unsigned_integer
+                                                               (a + tdep->size_ulong,
+                                                                tdep->size_ulong)))
 		      return -1;
-		    if (record_arch_list_add_mem (a[4], tdep->size_sockaddr))
+                    a += tdep->size_ulong * 3;
+		    if (record_arch_list_add_mem ((CORE_ADDR)extract_unsigned_integer
+                                                               (a, tdep->size_ulong),
+                                                  tdep->size_sockaddr))
 		      return -1;
-		    if (record_arch_list_add_mem (a[5], tdep->size_int))
+                    a += tdep->size_ulong;
+		    if (record_arch_list_add_mem ((CORE_ADDR)extract_unsigned_integer
+                                                               (a, tdep->size_ulong),
+                                                  tdep->size_int))
 		      return -1;
 		  }
 	      }
@@ -808,40 +884,50 @@ record_linux_system_call (int num, struc
 	  break;
 	case RECORD_SYS_GETSOCKOPT:
 	  {
-	    uint32_t a[5];
-	    uint32_t av;
+            gdb_byte *a = alloca (tdep->size_ulong * 2);
+            gdb_byte *av = alloca (tdep->size_ulong);
 
-	    regcache_raw_read (regcache, tdep->arg2,
-			       (gdb_byte *) & tmpu32);
-	    if (tmpu32)
+	    regcache_raw_read_unsigned (regcache, tdep->arg2,
+			                &tmpulongest);
+	    if (tmpulongest)
 	      {
-		if (target_read_memory (tmpu32, (gdb_byte *) a, sizeof (a)))
+                tmpulongest += tdep->size_ulong * 3;
+		if (target_read_memory ((CORE_ADDR)tmpulongest, a, tdep->size_ulong * 2))
 		  {
 		    if (record_debug)
 		      fprintf_unfiltered (gdb_stdlog,
 					  "Process record: error reading "
-					  "memory at addr = 0x%s len = %lu.\n",
-					  paddr_nz (tmpu32),
-					  (unsigned long)sizeof (a));
+					  "memory at addr = 0x%s len = %d.\n",
+					  OUTPUT_REG (tmpulongest, tdep->arg2),
+					  tdep->size_ulong * 2);
 		    return -1;
 		  }
-		if (a[4])
+                tmpulongest = extract_unsigned_integer (a + tdep->size_ulong,
+                                                  tdep->size_ulong);
+		if (tmpulongest)
 		  {
-		    if (target_read_memory
-			(a[4], (gdb_byte *) & av, sizeof (av)))
+		    if (target_read_memory ((CORE_ADDR)tmpulongest, av,
+                                            tdep->size_ulong))
 		      {
 			if (record_debug)
 			  fprintf_unfiltered (gdb_stdlog,
 					      "Process record: error reading "
 					      "memory at addr = 0x%s "
-					      "len = %lu.\n",
-					      paddr_nz (a[4]),
-					      (unsigned long)sizeof (av));
+					      "len = %d.\n",
+					      phex_nz (tmpulongest,
+                                                       tdep->size_ulong),
+					      tdep->size_ulong);
 			return -1;
 		      }
-		    if (record_arch_list_add_mem (a[3], av))
+		    if (record_arch_list_add_mem ((CORE_ADDR)extract_unsigned_integer
+                                                               (a, tdep->size_ulong),
+                                                  (int)extract_unsigned_integer
+                                                               (av, tdep->size_ulong)))
 		      return -1;
-		    if (record_arch_list_add_mem (a[4], tdep->size_int))
+                    a += tdep->size_ulong;
+		    if (record_arch_list_add_mem ((CORE_ADDR)extract_unsigned_integer
+                                                               (a, tdep->size_ulong),
+                                                  tdep->size_int))
 		      return -1;
 		  }
 	      }
@@ -851,84 +937,96 @@ record_linux_system_call (int num, struc
 	  break;
 	case RECORD_SYS_RECVMSG:
 	  {
-	    uint32_t a[2], i;
-	    struct record_msghdr
-	    {
-	      uint32_t msg_name;
-	      uint32_t msg_namelen;
-	      uint32_t msg_iov;
-	      uint32_t msg_iovlen;
-	      uint32_t msg_control;
-	      uint32_t msg_controllen;
-	      uint32_t msg_flags;
-	    } rec;
-	    struct record_iovec
-	    {
-	      uint32_t iov_base;
-	      uint32_t iov_len;
-	    } iov;
+            gdb_byte *a = alloca (tdep->size_ulong);
 
-	    regcache_raw_read (regcache, tdep->arg2,
-			       (gdb_byte *) & tmpu32);
-	    if (tmpu32)
+	    regcache_raw_read_unsigned (regcache, tdep->arg2,
+			                &tmpulongest);
+	    if (tmpulongest)
 	      {
-		if (target_read_memory (tmpu32, (gdb_byte *) a, sizeof (a)))
+                tmpulongest += tdep->size_ulong;
+		if (target_read_memory ((CORE_ADDR)tmpulongest, a,
+                    tdep->size_ulong))
 		  {
 		    if (record_debug)
 		      fprintf_unfiltered (gdb_stdlog,
 					  "Process record: error reading "
-					  "memory at addr = 0x%s len = %lu.\n",
-					  paddr_nz (tmpu32),
-					  (unsigned long)sizeof (a));
+					  "memory at addr = 0x%s len = %d.\n",
+					  OUTPUT_REG (tmpulongest, tdep->arg2),
+					  tdep->size_ulong);
 		    return -1;
 		  }
-		if (record_arch_list_add_mem (a[1], tdep->size_msghdr))
-		  return -1;
-		if (a[1])
+                tmpulongest = extract_unsigned_integer (a, tdep->size_ulong);
+		if (tmpulongest)
 		  {
-		    if (target_read_memory
-			(a[1], (gdb_byte *) & rec, sizeof (rec)))
+		    if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+                                                  tdep->size_msghdr))
+		      return -1;
+                    a = alloca (tdep->size_msghdr);
+		    if (target_read_memory ((CORE_ADDR)tmpulongest, a,
+                                            tdep->size_msghdr))
 		      {
 			if (record_debug)
 			  fprintf_unfiltered (gdb_stdlog,
 					      "Process record: error reading "
 					      "memory at addr = 0x%s "
-					      "len = %lu.\n",
-					      paddr_nz (a[1]),
-					      (unsigned long)sizeof (rec));
+					      "len = %d.\n",
+					      phex_nz (tmpulongest,
+                                                       tdep->size_ulong),
+					      tdep->size_msghdr);
 			return -1;
 		      }
-		    if (record_arch_list_add_mem
-			(rec.msg_name, rec.msg_namelen))
-		      return -1;
-		    if (record_arch_list_add_mem
-			(rec.msg_control, rec.msg_controllen))
+                    /* msg_name msg_namelen */
+		    tmpulongest = extract_unsigned_integer (a, tdep->size_pointer);
+                    a += tdep->size_pointer;
+                    if (record_arch_list_add_mem
+                          ((CORE_ADDR)tmpulongest,
+                           (int)extract_unsigned_integer (a, tdep->size_int)))
 		      return -1;
-		    if (rec.msg_iov)
+                    a += tdep->size_int;
+		    /* msg_iov msg_iovlen */
+		    tmpulongest = extract_unsigned_integer (a, tdep->size_pointer);
+                    a += tdep->size_pointer;
+                    if (tmpulongest)
 		      {
-			for (i = 0; i < rec.msg_iovlen; i++)
+                        ULONGEST i;
+                        ULONGEST len = extract_unsigned_integer
+                                         (a, tdep->size_size_t);
+                        gdb_byte *iov = alloca (tdep->size_iovec);
+
+			for (i = 0; i < len; i++)
 			  {
-			    if (target_read_memory
-				(rec.msg_iov, (gdb_byte *) & iov,
-				 sizeof (iov)))
+			    if (target_read_memory ((CORE_ADDR)tmpulongest,
+                                                    iov, tdep->size_iovec))
 			      {
 				if (record_debug)
 				  fprintf_unfiltered (gdb_stdlog,
 						      "Process record: error "
 						      "reading memory at "
 						      "addr = 0x%s "
-						      "len = %lu.\n",
-						      paddr_nz (rec.
-								msg_iov),
-						      (unsigned long)sizeof (iov));
+						      "len = %d.\n",
+						      phex_nz (tmpulongest,
+								tdep->size_pointer),
+						      tdep->size_iovec);
 				return -1;
 			      }
-			    if (record_arch_list_add_mem
-				(iov.iov_base, iov.iov_len))
+		            if (record_arch_list_add_mem
+                                  ((CORE_ADDR)extract_unsigned_integer
+                                                (iov, tdep->size_pointer),
+                                   (int)extract_unsigned_integer
+                                          (iov + tdep->size_pointer,
+                                           tdep->size_size_t)))
 			      return -1;
-			    rec.msg_iov += sizeof (struct record_iovec);
+			    tmpulongest += tdep->size_iovec;
 			  }
 		      }
+                    a += tdep->size_size_t;
+                    /* msg_control msg_controllen */
+                    tmpulongest = extract_unsigned_integer (a, tdep->size_pointer);
+                    a += tdep->size_pointer;
+		    if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+                                                  (int)extract_unsigned_integer
+                                                         (a, tdep->size_size_t)))
+		      return -1;
 		  }
 	      }
 	  }
@@ -936,7 +1034,7 @@ record_linux_system_call (int num, struc
 	default:
 	  printf_unfiltered (_("Process record and replay target "
 			       "doesn't support socketcall call 0x%s\n"),
-			     phex_nz (tmpu32, 4));
+			     OUTPUT_REG (tmpulongest, tdep->arg1));
 	  return -1;
 	  break;
 	}
@@ -948,15 +1046,17 @@ record_linux_system_call (int num, struc
 
       /* sys_setitimer */
     case 104:
-      regcache_raw_read (regcache, tdep->arg3, (gdb_byte *) & tmpu32);
-      if (record_arch_list_add_mem (tmpu32, tdep->size_itimerval))
+      regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
+      if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+                                    tdep->size_itimerval))
 	return -1;
       break;
 
       /* sys_getitimer */
     case 105:
-      regcache_raw_read (regcache, tdep->arg2, (gdb_byte *) & tmpu32);
-      if (record_arch_list_add_mem (tmpu32, tdep->size_itimerval))
+      regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
+      if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+                                    tdep->size_itimerval))
 	return -1;
       break;
 
@@ -966,15 +1066,16 @@ record_linux_system_call (int num, struc
     case 107:
       /* sys_newfstat */
     case 108:
-      regcache_raw_read (regcache, tdep->arg2, (gdb_byte *) & tmpu32);
-      if (record_arch_list_add_mem (tmpu32, tdep->size_stat))
+      regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
+      if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest, tdep->size_stat))
 	return -1;
       break;
 
       /* sys_uname */
     case 109:
-      regcache_raw_read (regcache, tdep->arg1, (gdb_byte *) & tmpu32);
-      if (record_arch_list_add_mem (tmpu32, tdep->size_old_utsname))
+      regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
+      if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+                                    tdep->size_old_utsname))
 	return -1;
       break;
 
@@ -990,11 +1091,13 @@ record_linux_system_call (int num, struc
 
       /* sys_wait4 */
     case 114:
-      regcache_raw_read (regcache, tdep->arg2, (gdb_byte *) & tmpu32);
-      if (record_arch_list_add_mem (tmpu32, tdep->size_int))
+      regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
+      if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+                                    tdep->size_int))
 	return -1;
-      regcache_raw_read (regcache, tdep->arg4, (gdb_byte *) & tmpu32);
-      if (record_arch_list_add_mem (tmpu32, tdep->size_rusage))
+      regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
+      if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+                                    tdep->size_rusage))
 	return -1;
       break;
 
@@ -1004,44 +1107,47 @@ record_linux_system_call (int num, struc
 
       /* sys_sysinfo */
     case 116:
-      regcache_raw_read (regcache, tdep->arg1, (gdb_byte *) & tmpu32);
-      if (record_arch_list_add_mem (tmpu32, tdep->size_sysinfo))
+      regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
+      if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+                                    tdep->size_sysinfo))
 	return -1;
       break;
 
       /* sys_ipc */
     case 117:
-      regcache_raw_read (regcache, tdep->arg1, (gdb_byte *) & tmpu32);
-      switch (tmpu32)
+      regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
+      switch (tmpulongest)
 	{
 	case RECORD_MSGRCV:
 	  {
-	    int32_t second;
-	    uint32_t ptr;
-	    regcache_raw_read (regcache, tdep->arg3,
-			       (gdb_byte *) & second);
-	    regcache_raw_read (regcache, tdep->arg5,
-			       (gdb_byte *) & ptr);
-	    if (record_arch_list_add_mem (ptr, second + tdep->size_long))
+	    ULONGEST second;
+	    ULONGEST ptr;
+	    regcache_raw_read_unsigned (regcache, tdep->arg3, &second);
+	    regcache_raw_read_unsigned (regcache, tdep->arg5, &ptr);
+	    if (record_arch_list_add_mem ((CORE_ADDR)ptr,
+                                          (int)second + tdep->size_long))
 	      return -1;
 	  }
 	  break;
 	case RECORD_MSGCTL:
-	  regcache_raw_read (regcache, tdep->arg5,
-			     (gdb_byte *) & tmpu32);
-	  if (record_arch_list_add_mem (tmpu32, tdep->size_msqid_ds))
+	  regcache_raw_read_unsigned (regcache, tdep->arg5,
+			              &tmpulongest);
+          if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+                                        tdep->size_msqid_ds))
 	    return -1;
 	  break;
 	case RECORD_SHMAT:
-	  regcache_raw_read (regcache, tdep->arg4,
-			     (gdb_byte *) & tmpu32);
-	  if (record_arch_list_add_mem (tmpu32, tdep->size_ulong))
+	  regcache_raw_read_unsigned (regcache, tdep->arg4,
+			              &tmpulongest);
+          if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+                                        tdep->size_ulong))
 	    return -1;
 	  break;
 	case RECORD_SHMCTL:
-	  regcache_raw_read (regcache, tdep->arg5,
-			     (gdb_byte *) & tmpu32);
-	  if (record_arch_list_add_mem (tmpu32, tdep->size_shmid_ds))
+	  regcache_raw_read_unsigned (regcache, tdep->arg5,
+			              &tmpulongest);
+          if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+                                        tdep->size_shmid_ds))
 	    return -1;
 	  break;
 	}
@@ -1059,29 +1165,29 @@ record_linux_system_call (int num, struc
 
       /* sys_newuname */
     case 122:
-      regcache_raw_read (regcache, tdep->arg1, (gdb_byte *) & tmpu32);
-      if (record_arch_list_add_mem (tmpu32, tdep->size_new_utsname))
+      regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
+      if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+                                    tdep->size_new_utsname))
 	return -1;
       break;
 
       /* sys_modify_ldt */
     case 123:
-      regcache_raw_read (regcache, tdep->arg1, (gdb_byte *) & tmpu32);
-      if (tmpu32 == 0 || tmpu32 == 2)
+      regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
+      if (tmpulongest == 0 || tmpulongest == 2)
 	{
-	  uint32_t ptr, bytecount;
-	  regcache_raw_read (regcache, tdep->arg2, (gdb_byte *) & ptr);
-	  regcache_raw_read (regcache, tdep->arg3,
-			     (gdb_byte *) & bytecount);
-	  if (record_arch_list_add_mem (ptr, bytecount))
+	  ULONGEST ptr, bytecount;
+	  regcache_raw_read_unsigned (regcache, tdep->arg2, &ptr);
+	  regcache_raw_read_unsigned (regcache, tdep->arg3, &bytecount);
+	  if (record_arch_list_add_mem ((CORE_ADDR)ptr, (int)bytecount))
 	    return -1;
 	}
       break;
 
       /* sys_adjtimex */
     case 124:
-      regcache_raw_read (regcache, tdep->arg1, (gdb_byte *) & tmpu32);
-      if (record_arch_list_add_mem (tmpu32, tdep->size_timex))
+      regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
+      if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest, tdep->size_timex))
 	return -1;
       break;
 
@@ -1091,8 +1197,9 @@ record_linux_system_call (int num, struc
 
       /* sys_sigprocmask */
     case 126:
-      regcache_raw_read (regcache, tdep->arg3, (gdb_byte *) & tmpu32);
-      if (record_arch_list_add_mem (tmpu32, tdep->size_old_sigset_t))
+      regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
+      if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+                                    tdep->size_old_sigset_t))
 	return -1;
       break;
 
@@ -1108,32 +1215,35 @@ record_linux_system_call (int num, struc
 
       /* sys_quotactl */
     case 131:
-      regcache_raw_read (regcache, tdep->arg1, (gdb_byte *) & tmpu32);
-      switch (tmpu32)
+      regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
+      switch (tmpulongest)
 	{
 	case RECORD_Q_GETFMT:
-	  regcache_raw_read (regcache, tdep->arg4,
-			     (gdb_byte *) & tmpu32);
-	  if (record_arch_list_add_mem (tmpu32, 4))
+	  regcache_raw_read_unsigned (regcache, tdep->arg4,
+			              &tmpulongest);
+          if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest, 4))
 	    return -1;
 	  break;
 	case RECORD_Q_GETINFO:
-	  regcache_raw_read (regcache, tdep->arg4,
-			     (gdb_byte *) & tmpu32);
-	  if (record_arch_list_add_mem (tmpu32, tdep->size_mem_dqinfo))
+	  regcache_raw_read_unsigned (regcache, tdep->arg4,
+			              &tmpulongest);
+          if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+                                        tdep->size_mem_dqinfo))
 	    return -1;
 	  break;
 	case RECORD_Q_GETQUOTA:
-	  regcache_raw_read (regcache, tdep->arg4,
-			     (gdb_byte *) & tmpu32);
-	  if (record_arch_list_add_mem (tmpu32, tdep->size_if_dqblk))
+	  regcache_raw_read_unsigned (regcache, tdep->arg4,
+			              &tmpulongest);
+          if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+                                        tdep->size_if_dqblk))
 	    return -1;
 	  break;
 	case RECORD_Q_XGETQSTAT:
 	case RECORD_Q_XGETQUOTA:
-	  regcache_raw_read (regcache, tdep->arg4,
-			     (gdb_byte *) & tmpu32);
-	  if (record_arch_list_add_mem (tmpu32, tdep->size_fs_quota_stat))
+	  regcache_raw_read_unsigned (regcache, tdep->arg4,
+			              &tmpulongest);
+          if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+                                        tdep->size_fs_quota_stat))
 	    return -1;
 	  break;
 	}
@@ -1149,13 +1259,13 @@ record_linux_system_call (int num, struc
 
       /* sys_sysfs */
     case 135:
-      regcache_raw_read (regcache, tdep->arg1, (gdb_byte *) & tmpu32);
-      if (tmpu32 == 2)
+      regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
+      if (tmpulongest == 2)
 	{
-	  regcache_raw_read (regcache, tdep->arg3,
-			     (gdb_byte *) & tmpu32);
+	  regcache_raw_read_unsigned (regcache, tdep->arg3,
+			              &tmpulongest);
 	  /*XXX the size of memory is not very clear.  */
-	  if (record_arch_list_add_mem (tmpu32, 10))
+          if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest, 10))
 	    return -1;
 	}
       break;
@@ -1172,36 +1282,42 @@ record_linux_system_call (int num, struc
 
       /* sys_llseek */
     case 140:
-      regcache_raw_read (regcache, tdep->arg4, (gdb_byte *) & tmpu32);
-      if (record_arch_list_add_mem (tmpu32, tdep->size_loff_t))
+      regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
+      if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+                                    tdep->size_loff_t))
 	return -1;
       break;
 
       /* sys_getdents */
     case 141:
       {
-	uint32_t count;
-	regcache_raw_read (regcache, tdep->arg2,
-			   (gdb_byte *) & tmpu32);
-	regcache_raw_read (regcache, tdep->arg3, (gdb_byte *) & count);
-	if (record_arch_list_add_mem (tmpu32, tdep->size_dirent * count))
+	ULONGEST count;
+	regcache_raw_read_unsigned (regcache, tdep->arg2,
+			            &tmpulongest);
+	regcache_raw_read_unsigned (regcache, tdep->arg3, &count);
+        if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+                                      tdep->size_dirent * count))
 	  return -1;
       }
       break;
 
       /* sys_select */
     case 142:
-      regcache_raw_read (regcache, tdep->arg2, (gdb_byte *) & tmpu32);
-      if (record_arch_list_add_mem (tmpu32, tdep->size_fd_set))
+      regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
+      if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+                                    tdep->size_fd_set))
 	return -1;
-      regcache_raw_read (regcache, tdep->arg3, (gdb_byte *) & tmpu32);
-      if (record_arch_list_add_mem (tmpu32, tdep->size_fd_set))
+      regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
+      if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+                                    tdep->size_fd_set))
 	return -1;
-      regcache_raw_read (regcache, tdep->arg4, (gdb_byte *) & tmpu32);
-      if (record_arch_list_add_mem (tmpu32, tdep->size_fd_set))
+      regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
+      if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+                                    tdep->size_fd_set))
 	return -1;
-      regcache_raw_read (regcache, tdep->arg5, (gdb_byte *) & tmpu32);
-      if (record_arch_list_add_mem (tmpu32, tdep->size_timeval))
+      regcache_raw_read_unsigned (regcache, tdep->arg5, &tmpulongest);
+      if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+                                    tdep->size_timeval))
 	return -1;
       break;
 
@@ -1214,34 +1330,34 @@ record_linux_system_call (int num, struc
       /* sys_readv */
     case 145:
       {
-	uint32_t vec;
-	uint32_t vlen;
-	struct record_iovec
-	{
-	  uint32_t iov_base;
-	  uint32_t iov_len;
-	} iov;
-	regcache_raw_read (regcache, tdep->arg2, (gdb_byte *) & vec);
+	ULONGEST vec, vlen;
+
+	regcache_raw_read_unsigned (regcache, tdep->arg2, &vec);
 	if (vec)
 	  {
-	    regcache_raw_read (regcache, tdep->arg3,
-			       (gdb_byte *) & vlen);
-	    for (tmpu32 = 0; tmpu32 < vlen; tmpu32++)
+            gdb_byte *iov = alloca (tdep->size_iovec);
+
+	    regcache_raw_read_unsigned (regcache, tdep->arg3, &vlen);
+	    for (tmpulongest = 0; tmpulongest < vlen; tmpulongest++)
 	      {
-		if (target_read_memory
-		    (vec, (gdb_byte *) & iov, sizeof (struct record_iovec)))
+		if (target_read_memory ((CORE_ADDR)vec, iov,
+                                        tdep->size_iovec))
 		  {
 		    if (record_debug)
 		      fprintf_unfiltered (gdb_stdlog,
 					  "Process record: error reading "
-					  "memory at addr = 0x%s len = %lu.\n",
-					  paddr_nz (vec),
-					  (unsigned long)sizeof (struct record_iovec));
+					  "memory at addr = 0x%s len = %d.\n",
+					  OUTPUT_REG (vec, tdep->arg2),
+					  tdep->size_iovec);
 		    return -1;
 		  }
-		if (record_arch_list_add_mem (iov.iov_base, iov.iov_len))
+		if (record_arch_list_add_mem
+                      ((CORE_ADDR)extract_unsigned_integer
+                                    (iov, tdep->size_pointer),
+                       (int)extract_unsigned_integer
+                              (iov + tdep->size_pointer, tdep->size_size_t)))
 		  return -1;
-		vec += sizeof (struct record_iovec);
+		vec += tdep->size_iovec;
 	      }
 	  }
       }
@@ -1269,8 +1385,8 @@ record_linux_system_call (int num, struc
 
       /* sys_sched_getparam */
     case 155:
-      regcache_raw_read (regcache, tdep->arg2, (gdb_byte *) & tmpu32);
-      if (record_arch_list_add_mem (tmpu32, tdep->size_int))
+      regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
+      if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest, tdep->size_int))
 	return -1;
       break;
 
@@ -1290,8 +1406,9 @@ record_linux_system_call (int num, struc
     case 161:
       /* sys_nanosleep */
     case 162:
-      regcache_raw_read (regcache, tdep->arg2, (gdb_byte *) & tmpu32);
-      if (record_arch_list_add_mem (tmpu32, tdep->size_timespec))
+      regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
+      if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+                                    tdep->size_timespec))
 	return -1;
       break;
 
@@ -1303,14 +1420,16 @@ record_linux_system_call (int num, struc
 
       /* sys_getresuid16 */
     case 165:
-      regcache_raw_read (regcache, tdep->arg1, (gdb_byte *) & tmpu32);
-      if (record_arch_list_add_mem (tmpu32, tdep->size_old_uid_t))
+      regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
+      if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+                                    tdep->size_old_uid_t))
 	return -1;
-      regcache_raw_read (regcache, tdep->arg2, (gdb_byte *) & tmpu32);
-      if (record_arch_list_add_mem (tmpu32, tdep->size_old_uid_t))
+      regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
+      if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+                                    tdep->size_old_uid_t))
 	return -1;
-      regcache_raw_read (regcache, tdep->arg3, (gdb_byte *) & tmpu32);
-      if (record_arch_list_add_mem (tmpu32, tdep->size_old_uid_t))
+      regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
+      if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest, tdep->size_old_uid_t))
 	return -1;
       break;
 
@@ -1322,30 +1441,30 @@ record_linux_system_call (int num, struc
 
       /* sys_poll */
     case 168:
-      regcache_raw_read (regcache, tdep->arg1, (gdb_byte *) & tmpu32);
-      if (tmpu32)
+      regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
+      if (tmpulongest)
 	{
-	  uint32_t nfds;
-	  regcache_raw_read (regcache, tdep->arg2,
-			     (gdb_byte *) & nfds);
-	  if (record_arch_list_add_mem (tmpu32, tdep->size_pollfd * nfds))
+	  ULONGEST nfds;
+	  regcache_raw_read_unsigned (regcache, tdep->arg2, &nfds);
+          if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+                                        tdep->size_pollfd * nfds))
 	    return -1;
 	}
       break;
 
       /* sys_nfsservctl */
     case 169:
-      regcache_raw_read (regcache, tdep->arg1, (gdb_byte *) & tmpu32);
-      if (tmpu32 == 7 || tmpu32 == 8)
+      regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
+      if (tmpulongest == 7 || tmpulongest == 8)
 	{
-	  uint32_t rsize;
-	  if (tmpu32 == 7)
+	  int rsize;
+	  if (tmpulongest == 7)
 	    rsize = tdep->size_NFS_FHSIZE;
 	  else
 	    rsize = tdep->size_knfsd_fh;
-	  regcache_raw_read (regcache, tdep->arg3,
-			     (gdb_byte *) & tmpu32);
-	  if (record_arch_list_add_mem (tmpu32, rsize))
+	  regcache_raw_read_unsigned (regcache, tdep->arg3,
+			              &tmpulongest);
+          if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest, rsize))
 	    return -1;
 	}
       break;
@@ -1356,32 +1475,34 @@ record_linux_system_call (int num, struc
 
       /* sys_getresgid16 */
     case 171:
-      regcache_raw_read (regcache, tdep->arg1, (gdb_byte *) & tmpu32);
-      if (record_arch_list_add_mem (tmpu32, tdep->size_old_gid_t))
+      regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
+      if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,tdep->size_old_gid_t))
 	return -1;
-      regcache_raw_read (regcache, tdep->arg2, (gdb_byte *) & tmpu32);
-      if (record_arch_list_add_mem (tmpu32, tdep->size_old_gid_t))
+      regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
+      if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest, tdep->size_old_gid_t))
 	return -1;
-      regcache_raw_read (regcache, tdep->arg3, (gdb_byte *) & tmpu32);
-      if (record_arch_list_add_mem (tmpu32, tdep->size_old_gid_t))
+      regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
+      if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest, tdep->size_old_gid_t))
 	return -1;
       break;
 
       /* sys_prctl */
     case 172:
-      regcache_raw_read (regcache, tdep->arg1, (gdb_byte *) & tmpu32);
-      switch (tmpu32)
+      regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
+      switch (tmpulongest)
 	{
 	case 2:
-	  regcache_raw_read (regcache, tdep->arg2,
-			     (gdb_byte *) & tmpu32);
-	  if (record_arch_list_add_mem (tmpu32, tdep->size_int))
+	  regcache_raw_read_unsigned (regcache, tdep->arg2,
+			              &tmpulongest);
+	  if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+	                                tdep->size_int))
 	    return -1;
 	  break;
 	case 16:
-	  regcache_raw_read (regcache, tdep->arg2,
-			     (gdb_byte *) & tmpu32);
-	  if (record_arch_list_add_mem (tmpu32, tdep->size_TASK_COMM_LEN))
+	  regcache_raw_read_unsigned (regcache, tdep->arg2,
+			              &tmpulongest);
+	  if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+	                                tdep->size_TASK_COMM_LEN))
 	    return -1;
 	  break;
 	}
@@ -1393,35 +1514,38 @@ record_linux_system_call (int num, struc
 
       /* sys_rt_sigaction */
     case 174:
-      regcache_raw_read (regcache, tdep->arg3, (gdb_byte *) & tmpu32);
-      if (record_arch_list_add_mem (tmpu32, tdep->size_sigaction))
+      regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
+      if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+	                            tdep->size_sigaction))
 	return -1;
       break;
 
       /* sys_rt_sigprocmask */
     case 175:
-      regcache_raw_read (regcache, tdep->arg3, (gdb_byte *) & tmpu32);
-      if (record_arch_list_add_mem (tmpu32, tdep->size_sigset_t))
+      regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
+      if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+	                            tdep->size_sigset_t))
 	return -1;
       break;
 
       /* sys_rt_sigpending */
     case 176:
-      regcache_raw_read (regcache, tdep->arg1, (gdb_byte *) & tmpu32);
-      if (tmpu32)
+      regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
+      if (tmpulongest)
 	{
-	  uint32_t sigsetsize;
-	  regcache_raw_read (regcache, tdep->arg2,
-			     (gdb_byte *) & sigsetsize);
-	  if (record_arch_list_add_mem (tmpu32, sigsetsize))
+	  ULONGEST sigsetsize;
+	  regcache_raw_read_unsigned (regcache, tdep->arg2,&sigsetsize);
+	  if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+                                        (int)sigsetsize))
 	    return -1;
 	}
       break;
 
       /* sys_rt_sigtimedwait */
     case 177:
-      regcache_raw_read (regcache, tdep->arg2, (gdb_byte *) & tmpu32);
-      if (record_arch_list_add_mem (tmpu32, tdep->size_siginfo_t))
+      regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
+      if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+	                            tdep->size_siginfo_t))
 	return -1;
       break;
 
@@ -1433,13 +1557,12 @@ record_linux_system_call (int num, struc
 
       /* sys_pread64 */
     case 180:
-      regcache_raw_read (regcache, tdep->arg2, (gdb_byte *) & tmpu32);
-      if (tmpu32)
+      regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
+      if (tmpulongest)
 	{
-	  uint32_t count;
-	  regcache_raw_read (regcache, tdep->arg3,
-			     (gdb_byte *) & count);
-	  if (record_arch_list_add_mem (tmpu32, count))
+	  ULONGEST count;
+	  regcache_raw_read_unsigned (regcache, tdep->arg3,&count);
+	  if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest, (int)count))
 	    return -1;
 	}
       break;
@@ -1452,21 +1575,21 @@ record_linux_system_call (int num, struc
 
       /* sys_getcwd */
     case 183:
-      regcache_raw_read (regcache, tdep->arg1, (gdb_byte *) & tmpu32);
-      if (tmpu32)
+      regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
+      if (tmpulongest)
 	{
-	  uint32_t size;
-	  regcache_raw_read (regcache, tdep->arg2,
-			     (gdb_byte *) & size);
-	  if (record_arch_list_add_mem (tmpu32, size))
+	  ULONGEST size;
+	  regcache_raw_read_unsigned (regcache, tdep->arg2, &size);
+	  if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest, (int)size))
 	    return -1;
 	}
       break;
 
       /* sys_capget */
     case 184:
-      regcache_raw_read (regcache, tdep->arg2, (gdb_byte *) & tmpu32);
-      if (record_arch_list_add_mem (tmpu32, tdep->size_cap_user_data_t))
+      regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
+      if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+	                            tdep->size_cap_user_data_t))
 	return -1;
       break;
 
@@ -1476,15 +1599,16 @@ record_linux_system_call (int num, struc
 
       /* sys_sigaltstack */
     case 186:
-      regcache_raw_read (regcache, tdep->arg2, (gdb_byte *) & tmpu32);
-      if (record_arch_list_add_mem (tmpu32, tdep->size_stack_t))
+      regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
+      if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+	                            tdep->size_stack_t))
 	return -1;
       break;
 
       /* sys_sendfile */
     case 187:
-      regcache_raw_read (regcache, tdep->arg3, (gdb_byte *) & tmpu32);
-      if (record_arch_list_add_mem (tmpu32, tdep->size_off_t))
+      regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
+      if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest, tdep->size_off_t))
 	return -1;
       break;
 
@@ -1498,8 +1622,9 @@ record_linux_system_call (int num, struc
 
       /* sys_getrlimit */
     case 191:
-      regcache_raw_read (regcache, tdep->arg2, (gdb_byte *) & tmpu32);
-      if (record_arch_list_add_mem (tmpu32, tdep->size_rlimit))
+      regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
+      if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+	                            tdep->size_rlimit))
 	return -1;
       break;
 
@@ -1519,8 +1644,9 @@ record_linux_system_call (int num, struc
     case 196:
       /* sys_fstat64 */
     case 197:
-      regcache_raw_read (regcache, tdep->arg2, (gdb_byte *) & tmpu32);
-      if (record_arch_list_add_mem (tmpu32, tdep->size_stat64))
+      regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
+      if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+	                            tdep->size_stat64))
 	return -1;
       break;
 
@@ -1542,14 +1668,14 @@ record_linux_system_call (int num, struc
 
       /* sys_getgroups */
     case 205:
-      regcache_raw_read (regcache, tdep->arg2, (gdb_byte *) & tmpu32);
-      if (tmpu32)
+      regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
+      if (tmpulongest)
 	{
-	  int gidsetsize;
-	  regcache_raw_read (regcache, tdep->arg1,
-			     (gdb_byte *) & gidsetsize);
-	  if (record_arch_list_add_mem
-	      (tmpu32, tdep->size_gid_t * gidsetsize))
+	  ULONGEST gidsetsize;
+	  regcache_raw_read_unsigned (regcache, tdep->arg1,
+			              &gidsetsize);
+	  if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+	                                tdep->size_gid_t * (int)gidsetsize))
 	    return -1;
 	}
       break;
@@ -1564,14 +1690,14 @@ record_linux_system_call (int num, struc
 
       /* sys_getresuid */
     case 209:
-      regcache_raw_read (regcache, tdep->arg1, (gdb_byte *) & tmpu32);
-      if (record_arch_list_add_mem (tmpu32, tdep->size_uid_t))
+      regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
+      if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest, tdep->size_uid_t))
 	return -1;
-      regcache_raw_read (regcache, tdep->arg2, (gdb_byte *) & tmpu32);
-      if (record_arch_list_add_mem (tmpu32, tdep->size_uid_t))
+      regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
+      if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest, tdep->size_uid_t))
 	return -1;
-      regcache_raw_read (regcache, tdep->arg3, (gdb_byte *) & tmpu32);
-      if (record_arch_list_add_mem (tmpu32, tdep->size_uid_t))
+      regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
+      if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest, tdep->size_uid_t))
 	return -1;
       break;
 
@@ -1581,14 +1707,14 @@ record_linux_system_call (int num, struc
 
       /* sys_getresgid */
     case 211:
-      regcache_raw_read (regcache, tdep->arg1, (gdb_byte *) & tmpu32);
-      if (record_arch_list_add_mem (tmpu32, tdep->size_gid_t))
+      regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
+      if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest, tdep->size_gid_t))
 	return -1;
-      regcache_raw_read (regcache, tdep->arg2, (gdb_byte *) & tmpu32);
-      if (record_arch_list_add_mem (tmpu32, tdep->size_gid_t))
+      regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
+      if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest, tdep->size_gid_t))
 	return -1;
-      regcache_raw_read (regcache, tdep->arg3, (gdb_byte *) & tmpu32);
-      if (record_arch_list_add_mem (tmpu32, tdep->size_gid_t))
+      regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
+      if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest, tdep->size_gid_t))
 	return -1;
       break;
 
@@ -1608,8 +1734,9 @@ record_linux_system_call (int num, struc
 
       /* sys_mincore */
     case 218:
-      regcache_raw_read (regcache, tdep->arg3, (gdb_byte *) & tmpu32);
-      if (record_arch_list_add_mem (tmpu32, tdep->size_PAGE_SIZE))
+      regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
+      if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+	                            tdep->size_PAGE_SIZE))
 	return -1;
       break;
 
@@ -1620,27 +1747,29 @@ record_linux_system_call (int num, struc
       /* sys_getdents64 */
     case 220:
       {
-	uint32_t count;
-	regcache_raw_read (regcache, tdep->arg2,
-			   (gdb_byte *) & tmpu32);
-	regcache_raw_read (regcache, tdep->arg3, (gdb_byte *) & count);
-	if (record_arch_list_add_mem (tmpu32, tdep->size_dirent64 * count))
+	ULONGEST count;
+	regcache_raw_read_unsigned (regcache, tdep->arg2,
+			            &tmpulongest);
+	regcache_raw_read_unsigned (regcache, tdep->arg3, &count);
+	if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+	                              tdep->size_dirent64 * count))
 	  return -1;
       }
       break;
 
       /* sys_fcntl64 */
     case 221:
-      regcache_raw_read (regcache, tdep->arg2, (gdb_byte *) & tmpu32);
-      if (tmpu32 == tdep->fcntl_F_GETLK64)
+      regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
+      if (tmpulongest == tdep->fcntl_F_GETLK64)
         {
-	  regcache_raw_read (regcache, tdep->arg3,
-			     (gdb_byte *) & tmpu32);
-	  if (record_arch_list_add_mem (tmpu32, tdep->size_flock64))
+	  regcache_raw_read_unsigned (regcache, tdep->arg3,
+			              &tmpulongest);
+	  if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+	                                tdep->size_flock64))
 	    return -1;
 	}
-      else if (tmpu32 != tdep->fcntl_F_SETLK64
-	       && tmpu32 != tdep->fcntl_F_SETLKW64)
+      else if (tmpulongest != tdep->fcntl_F_SETLK64
+	       && tmpulongest != tdep->fcntl_F_SETLKW64)
         {
 	  goto sys_fcntl;
 	}
@@ -1668,13 +1797,12 @@ record_linux_system_call (int num, struc
     case 230:
       /* sys_fgetxattr */
     case 231:
-      regcache_raw_read (regcache, tdep->arg3, (gdb_byte *) & tmpu32);
-      if (tmpu32)
+      regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
+      if (tmpulongest)
 	{
-	  uint32_t size;
-	  regcache_raw_read (regcache, tdep->arg4,
-			     (gdb_byte *) & size);
-	  if (record_arch_list_add_mem (tmpu32, size))
+	  ULONGEST size;
+	  regcache_raw_read_unsigned (regcache, tdep->arg4, &size);
+	  if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest, (int)size))
 	    return -1;
 	}
       break;
@@ -1685,13 +1813,12 @@ record_linux_system_call (int num, struc
     case 233:
       /* sys_flistxattr */
     case 234:
-      regcache_raw_read (regcache, tdep->arg2, (gdb_byte *) & tmpu32);
-      if (tmpu32)
+      regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
+      if (tmpulongest)
 	{
-	  uint32_t size;
-	  regcache_raw_read (regcache, tdep->arg3,
-			     (gdb_byte *) & size);
-	  if (record_arch_list_add_mem (tmpu32, size))
+	  ULONGEST size;
+	  regcache_raw_read_unsigned (regcache, tdep->arg3, &size);
+	  if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest, (int)size))
 	    return -1;
 	}
       break;
@@ -1708,8 +1835,9 @@ record_linux_system_call (int num, struc
 
       /* sys_sendfile64 */
     case 239:
-      regcache_raw_read (regcache, tdep->arg3, (gdb_byte *) & tmpu32);
-      if (record_arch_list_add_mem (tmpu32, tdep->size_loff_t))
+      regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
+      if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+	                            tdep->size_loff_t))
 	return -1;
       break;
 
@@ -1721,34 +1849,35 @@ record_linux_system_call (int num, struc
 
       /* sys_sched_getaffinity */
     case 242:
-      regcache_raw_read (regcache, tdep->arg3, (gdb_byte *) & tmpu32);
-      if (tmpu32)
+      regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
+      if (tmpulongest)
 	{
-	  uint32_t len;
-	  regcache_raw_read (regcache, tdep->arg2, (gdb_byte *) & len);
-	  if (record_arch_list_add_mem (tmpu32, len))
+	  ULONGEST len;
+	  regcache_raw_read_unsigned (regcache, tdep->arg2, &len);
+	  if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest, (int)len))
 	    return -1;
 	}
       break;
 
       /* sys_set_thread_area */
     case 243:
-      regcache_raw_read (regcache, tdep->arg1, (gdb_byte *) & tmpu32);
-      if (record_arch_list_add_mem (tmpu32, tdep->size_int))
+      regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
+      if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest, tdep->size_int))
 	return -1;
       break;
 
       /* sys_get_thread_area */
     case 244:
-      regcache_raw_read (regcache, tdep->arg1, (gdb_byte *) & tmpu32);
-      if (record_arch_list_add_mem (tmpu32, tdep->size_user_desc))
+      regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
+      if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+	                            tdep->size_user_desc))
 	return -1;
       break;
 
       /* sys_io_setup */
     case 245:
-      regcache_raw_read (regcache, tdep->arg2, (gdb_byte *) & tmpu32);
-      if (record_arch_list_add_mem (tmpu32, tdep->size_long))
+      regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
+      if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest, tdep->size_long))
 	return -1;
       break;
 
@@ -1758,48 +1887,55 @@ record_linux_system_call (int num, struc
 
       /* sys_io_getevents */
     case 247:
-      regcache_raw_read (regcache, tdep->arg4, (gdb_byte *) & tmpu32);
-      if (tmpu32)
+      regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
+      if (tmpulongest)
 	{
-	  int32_t nr;
-	  regcache_raw_read (regcache, tdep->arg3, (gdb_byte *) & nr);
-	  if (record_arch_list_add_mem (tmpu32, nr * tdep->size_io_event))
+	  ULONGEST nr;
+	  regcache_raw_read_unsigned (regcache, tdep->arg3, &nr);
+	  if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+	                                nr * tdep->size_io_event))
 	    return -1;
 	}
       break;
 
       /* sys_io_submit */
     case 248:
-      regcache_raw_read (regcache, tdep->arg3, (gdb_byte *) & tmpu32);
-      if (tmpu32)
+      regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
+      if (tmpulongest)
 	{
-	  int32_t i, nr;
-	  uint32_t *iocbp;
-	  regcache_raw_read (regcache, tdep->arg2, (gdb_byte *) & nr);
-	  iocbp = (uint32_t *) alloca (nr * tdep->size_int);
-	  if (target_read_memory
-	      (tmpu32, (gdb_byte *) iocbp, nr * tdep->size_int))
+          ULONGEST nr, i;
+          gdb_byte *iocbp;
+
+	  regcache_raw_read_unsigned (regcache, tdep->arg2, &nr);
+          iocbp = alloca (nr * tdep->size_pointer);
+	  if (target_read_memory ((CORE_ADDR)tmpulongest, iocbp,
+                                  nr * tdep->size_pointer))
 	    {
 	      if (record_debug)
 		fprintf_unfiltered (gdb_stdlog,
 				    "Process record: error reading memory "
 				    "at addr = 0x%s len = %u.\n",
-				    paddr_nz (tmpu32),
-				    (int)(nr * tdep->size_int));
+				    OUTPUT_REG (tmpulongest, tdep->arg2),
+				    (int)(nr * tdep->size_pointer));
 	      return -1;
 	    }
 	  for (i = 0; i < nr; i++)
 	    {
-	      if (record_arch_list_add_mem (iocbp[i], tdep->size_iocb))
+	      if (record_arch_list_add_mem ((CORE_ADDR)extract_unsigned_integer
+                                                         (iocbp,
+                                                          tdep->size_pointer),
+                                            tdep->size_iocb))
 		return -1;
+              iocbp += tdep->size_pointer;
 	    }
 	}
       break;
 
       /* sys_io_cancel */
     case 249:
-      regcache_raw_read (regcache, tdep->arg3, (gdb_byte *) & tmpu32);
-      if (record_arch_list_add_mem (tmpu32, tdep->size_io_event))
+      regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
+      if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+	                            tdep->size_io_event))
 	return -1;
       break;
 
@@ -1826,12 +1962,12 @@ record_linux_system_call (int num, struc
 
       /* sys_lookup_dcookie */
     case 253:
-      regcache_raw_read (regcache, tdep->arg2, (gdb_byte *) & tmpu32);
-      if (tmpu32)
+      regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
+      if (tmpulongest)
 	{
-	  uint32_t len;
-	  regcache_raw_read (regcache, tdep->arg3, (gdb_byte *) & len);
-	  if (record_arch_list_add_mem (tmpu32, len))
+	  ULONGEST len;
+	  regcache_raw_read_unsigned (regcache, tdep->arg3, &len);
+	  if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest, (int)len))
 	    return -1;
 	}
       break;
@@ -1844,14 +1980,13 @@ record_linux_system_call (int num, struc
 
       /* sys_epoll_wait */
     case 256:
-      regcache_raw_read (regcache, tdep->arg2, (gdb_byte *) & tmpu32);
-      if (tmpu32)
+      regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
+      if (tmpulongest)
 	{
-	  int32_t maxevents;
-	  regcache_raw_read (regcache, tdep->arg3,
-			     (gdb_byte *) & maxevents);
-	  if (record_arch_list_add_mem
-	      (tmpu32, maxevents * tdep->size_epoll_event))
+	  ULONGEST maxevents;
+	  regcache_raw_read_unsigned (regcache, tdep->arg3, &maxevents);
+	  if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+	                                maxevents * tdep->size_epoll_event))
 	    return -1;
 	}
       break;
@@ -1864,22 +1999,24 @@ record_linux_system_call (int num, struc
 
       /* sys_timer_create */
     case 259:
-      regcache_raw_read (regcache, tdep->arg3, (gdb_byte *) & tmpu32);
-      if (record_arch_list_add_mem (tmpu32, tdep->size_int))
+      regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
+      if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest, tdep->size_int))
 	return -1;
       break;
 
       /* sys_timer_settime */
     case 260:
-      regcache_raw_read (regcache, tdep->arg4, (gdb_byte *) & tmpu32);
-      if (record_arch_list_add_mem (tmpu32, tdep->size_itimerspec))
+      regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
+      if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+	                            tdep->size_itimerspec))
 	return -1;
       break;
 
       /* sys_timer_gettime */
     case 261:
-      regcache_raw_read (regcache, tdep->arg2, (gdb_byte *) & tmpu32);
-      if (record_arch_list_add_mem (tmpu32, tdep->size_itimerspec))
+      regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
+      if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+	                            tdep->size_itimerspec))
 	return -1;
       break;
 
@@ -1893,22 +2030,25 @@ record_linux_system_call (int num, struc
 
       /* sys_clock_gettime */
     case 265:
-      regcache_raw_read (regcache, tdep->arg2, (gdb_byte *) & tmpu32);
-      if (record_arch_list_add_mem (tmpu32, tdep->size_timespec))
+      regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
+      if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+	                            tdep->size_timespec))
 	return -1;
       break;
 
       /* sys_clock_getres */
     case 266:
-      regcache_raw_read (regcache, tdep->arg2, (gdb_byte *) & tmpu32);
-      if (record_arch_list_add_mem (tmpu32, tdep->size_timespec))
+      regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
+      if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+	                            tdep->size_timespec))
 	return -1;
       break;
 
       /* sys_clock_nanosleep */
     case 267:
-      regcache_raw_read (regcache, tdep->arg4, (gdb_byte *) & tmpu32);
-      if (record_arch_list_add_mem (tmpu32, tdep->size_timespec))
+      regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
+      if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+	                            tdep->size_timespec))
 	return -1;
       break;
 
@@ -1916,8 +2056,9 @@ record_linux_system_call (int num, struc
     case 268:
       /* sys_fstatfs64 */
     case 269:
-      regcache_raw_read (regcache, tdep->arg3, (gdb_byte *) & tmpu32);
-      if (record_arch_list_add_mem (tmpu32, tdep->size_statfs64))
+      regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
+      if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+	                            tdep->size_statfs64))
 	return -1;
       break;
 
@@ -1935,16 +2076,16 @@ record_linux_system_call (int num, struc
 
       /* sys_get_mempolicy */
     case 275:
-      regcache_raw_read (regcache, tdep->arg1, (gdb_byte *) & tmpu32);
-      if (record_arch_list_add_mem (tmpu32, tdep->size_int))
+      regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
+      if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest, tdep->size_int))
 	return -1;
-      regcache_raw_read (regcache, tdep->arg2, (gdb_byte *) & tmpu32);
-      if (tmpu32)
+      regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
+      if (tmpulongest)
 	{
-	  uint32_t maxnode;
-	  regcache_raw_read (regcache, tdep->arg3,
-			     (gdb_byte *) & maxnode);
-	  if (record_arch_list_add_mem (tmpu32, maxnode * tdep->size_long))
+	  ULONGEST maxnode;
+	  regcache_raw_read_unsigned (regcache, tdep->arg3, &maxnode);
+	  if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+	                                maxnode * tdep->size_long))
 	    return -1;
 	}
       break;
@@ -1961,17 +2102,16 @@ record_linux_system_call (int num, struc
 
       /* sys_mq_timedreceive */
     case 280:
-      regcache_raw_read (regcache, tdep->arg2, (gdb_byte *) & tmpu32);
-      if (tmpu32)
+      regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
+      if (tmpulongest)
 	{
-	  uint32_t msg_len;
-	  regcache_raw_read (regcache, tdep->arg3,
-			     (gdb_byte *) & msg_len);
-	  if (record_arch_list_add_mem (tmpu32, msg_len))
+	  ULONGEST msg_len;
+	  regcache_raw_read_unsigned (regcache, tdep->arg3, &msg_len);
+	  if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest, (int)msg_len))
 	    return -1;
 	}
-      regcache_raw_read (regcache, tdep->arg4, (gdb_byte *) & tmpu32);
-      if (record_arch_list_add_mem (tmpu32, tdep->size_int))
+      regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
+      if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest, tdep->size_int))
 	return -1;
       break;
 
@@ -1981,8 +2121,9 @@ record_linux_system_call (int num, struc
 
       /* sys_mq_getsetattr */
     case 282:
-      regcache_raw_read (regcache, tdep->arg3, (gdb_byte *) & tmpu32);
-      if (record_arch_list_add_mem (tmpu32, tdep->size_mq_attr))
+      regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
+      if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+	                            tdep->size_mq_attr))
 	return -1;
       break;
 
@@ -1992,11 +2133,13 @@ record_linux_system_call (int num, struc
 
       /* sys_waitid */
     case 284:
-      regcache_raw_read (regcache, tdep->arg3, (gdb_byte *) & tmpu32);
-      if (record_arch_list_add_mem (tmpu32, tdep->size_siginfo))
+      regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
+      if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+	                            tdep->size_siginfo))
 	return -1;
-      regcache_raw_read (regcache, tdep->arg5, (gdb_byte *) & tmpu32);
-      if (record_arch_list_add_mem (tmpu32, tdep->size_rusage))
+      regcache_raw_read_unsigned (regcache, tdep->arg5, &tmpulongest);
+      if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+	                            tdep->size_rusage))
 	return -1;
       break;
 
@@ -2010,17 +2153,17 @@ record_linux_system_call (int num, struc
 
       /* sys_keyctl */
     case 288:
-      regcache_raw_read (regcache, tdep->arg1, (gdb_byte *) & tmpu32);
-      if (tmpu32 == 6 || tmpu32 == 11)
+      regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
+      if (tmpulongest == 6 || tmpulongest == 11)
 	{
-	  regcache_raw_read (regcache, tdep->arg3,
-			     (gdb_byte *) & tmpu32);
-	  if (tmpu32)
+	  regcache_raw_read_unsigned (regcache, tdep->arg3,
+			              &tmpulongest);
+	  if (tmpulongest)
 	    {
-	      uint32_t buflen;
-	      regcache_raw_read (regcache, tdep->arg4,
-				 (gdb_byte *) & buflen);
-	      if (record_arch_list_add_mem (tmpu32, buflen))
+	      ULONGEST buflen;
+	      regcache_raw_read_unsigned (regcache, tdep->arg4, &buflen);
+	      if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+                                            (int)buflen))
 		return -1;
 	    }
 	}
@@ -2052,8 +2195,9 @@ record_linux_system_call (int num, struc
 
       /* sys_fstatat64 */
     case 300:
-      regcache_raw_read (regcache, tdep->arg3, (gdb_byte *) & tmpu32);
-      if (record_arch_list_add_mem (tmpu32, tdep->size_stat64))
+      regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
+      if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+	                            tdep->size_stat64))
 	return -1;
       break;
 
@@ -2069,13 +2213,12 @@ record_linux_system_call (int num, struc
 
       /* sys_readlinkat */
     case 305:
-      regcache_raw_read (regcache, tdep->arg3, (gdb_byte *) & tmpu32);
-      if (tmpu32)
+      regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
+      if (tmpulongest)
 	{
-	  int32_t bufsiz;
-	  regcache_raw_read (regcache, tdep->arg4,
-			     (gdb_byte *) & bufsiz);
-	  if (record_arch_list_add_mem (tmpu32, bufsiz))
+	  ULONGEST bufsiz;
+	  regcache_raw_read_unsigned (regcache, tdep->arg4, &bufsiz);
+	  if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest, (int)bufsiz))
 	    return -1;
 	}
       break;
@@ -2088,33 +2231,38 @@ record_linux_system_call (int num, struc
 
       /* sys_pselect6 */
     case 308:
-      regcache_raw_read (regcache, tdep->arg2, (gdb_byte *) & tmpu32);
-      if (record_arch_list_add_mem (tmpu32, tdep->size_fd_set))
+      regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
+      if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+                                    tdep->size_fd_set))
 	return -1;
-      regcache_raw_read (regcache, tdep->arg3, (gdb_byte *) & tmpu32);
-      if (record_arch_list_add_mem (tmpu32, tdep->size_fd_set))
+      regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
+      if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+                                    tdep->size_fd_set))
 	return -1;
-      regcache_raw_read (regcache, tdep->arg4, (gdb_byte *) & tmpu32);
-      if (record_arch_list_add_mem (tmpu32, tdep->size_fd_set))
+      regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
+      if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+                                    tdep->size_fd_set))
 	return -1;
-      regcache_raw_read (regcache, tdep->arg5, (gdb_byte *) & tmpu32);
-      if (record_arch_list_add_mem (tmpu32, tdep->size_timespec))
+      regcache_raw_read_unsigned (regcache, tdep->arg5, &tmpulongest);
+      if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+                                    tdep->size_timespec))
 	return -1;
       break;
 
       /* sys_ppoll */
     case 309:
-      regcache_raw_read (regcache, tdep->arg1, (gdb_byte *) & tmpu32);
-      if (tmpu32)
+      regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
+      if (tmpulongest)
 	{
-	  uint32_t nfds;
-	  regcache_raw_read (regcache, tdep->arg2,
-			     (gdb_byte *) & nfds);
-	  if (record_arch_list_add_mem (tmpu32, tdep->size_pollfd * nfds))
+	  ULONGEST nfds;
+	  regcache_raw_read_unsigned (regcache, tdep->arg2, &nfds);
+	  if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+                                        tdep->size_pollfd * nfds))
 	    return -1;
 	}
-      regcache_raw_read (regcache, tdep->arg3, (gdb_byte *) & tmpu32);
-      if (record_arch_list_add_mem (tmpu32, tdep->size_timespec))
+      regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
+      if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+                                    tdep->size_timespec))
 	return -1;
       break;
 
@@ -2126,21 +2274,23 @@ record_linux_system_call (int num, struc
 
       /* sys_get_robust_list */
     case 312:
-      regcache_raw_read (regcache, tdep->arg2, (gdb_byte *) & tmpu32);
-      if (record_arch_list_add_mem (tmpu32, tdep->size_int))
+      regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
+      if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest, tdep->size_int))
 	return -1;
-      regcache_raw_read (regcache, tdep->arg3, (gdb_byte *) & tmpu32);
-      if (record_arch_list_add_mem (tmpu32, tdep->size_int))
+      regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
+      if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest, tdep->size_int))
 	return -1;
       break;
 
       /* sys_splice */
     case 313:
-      regcache_raw_read (regcache, tdep->arg2, (gdb_byte *) & tmpu32);
-      if (record_arch_list_add_mem (tmpu32, tdep->size_loff_t))
+      regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
+      if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+                                    tdep->size_loff_t))
 	return -1;
-      regcache_raw_read (regcache, tdep->arg4, (gdb_byte *) & tmpu32);
-      if (record_arch_list_add_mem (tmpu32, tdep->size_loff_t))
+      regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
+      if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+                                    tdep->size_loff_t))
 	return -1;
       break;
 
@@ -2154,48 +2304,47 @@ record_linux_system_call (int num, struc
 
       /* sys_move_pages */
     case 317:
-      regcache_raw_read (regcache, tdep->arg5, (gdb_byte *) & tmpu32);
-      if (tmpu32)
+      regcache_raw_read_unsigned (regcache, tdep->arg5, &tmpulongest);
+      if (tmpulongest)
 	{
-	  uint32_t nr_pages;
-	  regcache_raw_read (regcache, tdep->arg2,
-			     (gdb_byte *) & nr_pages);
-	  if (record_arch_list_add_mem (tmpu32, nr_pages * tdep->size_int))
+	  ULONGEST nr_pages;
+	  regcache_raw_read_unsigned (regcache, tdep->arg2, &nr_pages);
+	  if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+                                        nr_pages * tdep->size_int))
 	    return -1;
 	}
       break;
 
       /* sys_getcpu */
     case 318:
-      regcache_raw_read (regcache, tdep->arg1, (gdb_byte *) & tmpu32);
-      if (record_arch_list_add_mem (tmpu32, tdep->size_int))
+      regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
+      if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest, tdep->size_int))
 	return -1;
-      regcache_raw_read (regcache, tdep->arg2, (gdb_byte *) & tmpu32);
-      if (record_arch_list_add_mem (tmpu32, tdep->size_int))
+      regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
+      if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest, tdep->size_int))
 	return -1;
-      regcache_raw_read (regcache, tdep->arg3, (gdb_byte *) & tmpu32);
-      if (record_arch_list_add_mem (tmpu32, tdep->size_ulong * 2))
+      regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
+      if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+                                    tdep->size_ulong * 2))
 	return -1;
       break;
 
       /* sys_epoll_pwait */
     case 319:
-      regcache_raw_read (regcache, tdep->arg2, (gdb_byte *) & tmpu32);
-      if (tmpu32)
+      regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
+      if (tmpulongest)
 	{
-	  int32_t maxevents;
-	  regcache_raw_read (regcache, tdep->arg3,
-			     (gdb_byte *) & maxevents);
-	  if (record_arch_list_add_mem
-	      (tmpu32, maxevents * tdep->size_epoll_event))
+	  ULONGEST maxevents;
+	  regcache_raw_read_unsigned (regcache, tdep->arg3, &maxevents);
+	  if (record_arch_list_add_mem ((CORE_ADDR)tmpulongest,
+                                        (int)maxevents * tdep->size_epoll_event))
 	    return -1;
 	}
       break;
 
     default:
       printf_unfiltered (_("Process record and replay target doesn't "
-			   "support syscall number %u\n"),
-			 (int)tmpu32);
+			   "support syscall number %u\n"), num);
       return -1;
       break;
     }
--- a/linux-record.h
+++ b/linux-record.h
@@ -23,6 +23,7 @@
 struct linux_record_tdep
 {
   /* The size of the type that will be used in a system call.  */
+  int size_pointer;
   int size__old_kernel_stat;
   int size_tms;
   int size_loff_t;
@@ -81,7 +82,6 @@ struct linux_record_tdep
   int size_itimerspec;
   int size_mq_attr;
   int size_siginfo;
-
   int size_termios;
   int size_termios2;
   int size_pid_t;
@@ -89,6 +89,8 @@ struct linux_record_tdep
   int size_serial_struct;
   int size_serial_icounter_struct;
   int size_hayes_esp_config;
+  int size_size_t;
+  int size_iovec;
 
   /* The values of the second argument of system call "sys_ioctl".  */
   int ioctl_TCGETS;