Don't rely on inferior_ptid in record_full_wait
[deliverable/binutils-gdb.git] / gdb / linux-record.c
index 46f904cb1c704ef65a7870aeff9a54fe373b9ce0..7e1897d5d6e3011808f5b6009145e9cd397adbde 100644 (file)
@@ -1,6 +1,6 @@
 /* Process record and replay target code for GNU/Linux.
 
-   Copyright (C) 2008, 2009 Free Software Foundation, Inc.
+   Copyright (C) 2008-2020 Free Software Foundation, Inc.
 
    This file is part of GDB.
 
@@ -22,7 +22,9 @@
 #include "gdbtypes.h"
 #include "regcache.h"
 #include "record.h"
+#include "record-full.h"
 #include "linux-record.h"
+#include "gdbarch.h"
 
 /* These macros are the values of the first argument of system call
    "sys_ptrace".  The values of these macros were obtained from Linux
 #define RECORD_Q_XGETQUOTA     (('3' << 8) + 3)
 
 #define OUTPUT_REG(val, num)      phex_nz ((val), \
-    TYPE_LENGTH (gdbarch_register_type (get_regcache_arch (regcache), (num))))
+    TYPE_LENGTH (gdbarch_register_type (regcache->arch (), (num))))
+
+/* Record a memory area of length LEN pointed to by register
+   REGNUM.  */
+
+static int
+record_mem_at_reg (struct regcache *regcache, int regnum, int len)
+{
+  ULONGEST addr;
+
+  regcache_raw_read_unsigned (regcache, regnum, &addr);
+  return record_full_arch_list_add_mem ((CORE_ADDR) addr, len);
+}
 
 static int
 record_linux_sockaddr (struct regcache *regcache,
-                       struct linux_record_tdep *tdep, ULONGEST addr,
-                       ULONGEST len)
+                      struct linux_record_tdep *tdep, ULONGEST addr,
+                      ULONGEST len)
 {
   gdb_byte *a;
   int addrlen;
-  struct gdbarch *gdbarch = get_regcache_arch (regcache);
+  struct gdbarch *gdbarch = regcache->arch ();
   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 
   if (!addr)
     return 0;
 
-  a = alloca (tdep->size_int);
+  a = (gdb_byte *) alloca (tdep->size_int);
 
-  if (record_arch_list_add_mem ((CORE_ADDR) len, tdep->size_int))
+  if (record_full_arch_list_add_mem ((CORE_ADDR) len, tdep->size_int))
     return -1;
 
   /* Get the addrlen.  */
   if (target_read_memory ((CORE_ADDR) len, a, tdep->size_int))
     {
       if (record_debug)
-        fprintf_unfiltered (gdb_stdlog,
-                            "Process record: error reading "
-                            "memory at addr = 0x%s len = %d.\n",
-                            phex_nz (len, tdep->size_pointer),
-                            tdep->size_int);
-        return -1;
+       fprintf_unfiltered (gdb_stdlog,
+                           "Process record: error reading "
+                           "memory at addr = 0x%s len = %d.\n",
+                           phex_nz (len, tdep->size_pointer),
+                           tdep->size_int);
+      return -1;
     }
   addrlen = (int) extract_unsigned_integer (a, tdep->size_int, byte_order);
   if (addrlen <= 0 || addrlen > tdep->size_sockaddr)
     addrlen = tdep->size_sockaddr;
 
-  if (record_arch_list_add_mem ((CORE_ADDR) addr, addrlen))
+  if (record_full_arch_list_add_mem ((CORE_ADDR) addr, addrlen))
     return -1;
 
   return 0;
@@ -125,10 +139,10 @@ record_linux_sockaddr (struct regcache *regcache,
 
 static int
 record_linux_msghdr (struct regcache *regcache,
-                     struct linux_record_tdep *tdep, ULONGEST addr)
+                    struct linux_record_tdep *tdep, ULONGEST addr)
 {
   gdb_byte *a;
-  struct gdbarch *gdbarch = get_regcache_arch (regcache);
+  struct gdbarch *gdbarch = regcache->arch ();
   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
   CORE_ADDR tmpaddr;
   int tmpint;
@@ -136,31 +150,34 @@ record_linux_msghdr (struct regcache *regcache,
   if (!addr)
     return 0;
 
-  if (record_arch_list_add_mem ((CORE_ADDR) addr, tdep->size_msghdr))
+  if (record_full_arch_list_add_mem ((CORE_ADDR) addr, tdep->size_msghdr))
     return -1;
 
-  a = alloca (tdep->size_msghdr);
+  a = (gdb_byte *) alloca (tdep->size_msghdr);
   if (target_read_memory ((CORE_ADDR) addr, a, tdep->size_msghdr))
     {
       if (record_debug)
-        fprintf_unfiltered (gdb_stdlog,
-                            "Process record: error reading "
-                            "memory at addr = 0x%s "
-                            "len = %d.\n",
-                            phex_nz (addr, tdep->size_pointer),
-                            tdep->size_msghdr);
-        return -1;
+       fprintf_unfiltered (gdb_stdlog,
+                           "Process record: error reading "
+                           "memory at addr = 0x%s "
+                           "len = %d.\n",
+                           phex_nz (addr, tdep->size_pointer),
+                           tdep->size_msghdr);
+      return -1;
     }
 
   /* msg_name msg_namelen */
   addr = extract_unsigned_integer (a, tdep->size_pointer, byte_order);
   a += tdep->size_pointer;
-  if (record_arch_list_add_mem ((CORE_ADDR) addr,
-                                (int) extract_unsigned_integer (a,
-                                                               tdep->size_int,
-                                                               byte_order)))
+  if (record_full_arch_list_add_mem
+      ((CORE_ADDR) addr,
+       (int) extract_unsigned_integer (a,
+                                      tdep->size_int,
+                                      byte_order)))
     return -1;
-  a += tdep->size_int;
+  /* We have read an int, but skip size_pointer bytes to account for alignment
+     of the next field on 64-bit targets. */
+  a += tdep->size_pointer;
 
   /* msg_iov msg_iovlen */
   addr = extract_unsigned_integer (a, tdep->size_pointer, byte_order);
@@ -169,33 +186,33 @@ record_linux_msghdr (struct regcache *regcache,
     {
       ULONGEST i;
       ULONGEST len = extract_unsigned_integer (a, tdep->size_size_t,
-                                               byte_order);
-      gdb_byte *iov = alloca (tdep->size_iovec);
+                                              byte_order);
+      gdb_byte *iov = (gdb_byte *) alloca (tdep->size_iovec);
 
       for (i = 0; i < len; i++)
-        {
-          if (target_read_memory ((CORE_ADDR) addr, iov, tdep->size_iovec))
-            {
-              if (record_debug)
-                fprintf_unfiltered (gdb_stdlog,
-                                    "Process record: error "
-                                    "reading memory at "
-                                    "addr = 0x%s "
-                                    "len = %d.\n",
-                                    phex_nz (addr,tdep->size_pointer),
-                                    tdep->size_iovec);
-                return -1;
-            }
-          tmpaddr = (CORE_ADDR) extract_unsigned_integer (iov,
-                                                          tdep->size_pointer,
-                                                          byte_order);
-          tmpint = (int) extract_unsigned_integer (iov + tdep->size_pointer,
-                                                   tdep->size_size_t,
-                                                   byte_order);
-          if (record_arch_list_add_mem (tmpaddr, tmpint));
-            return -1;
-          addr += tdep->size_iovec;
-        }
+       {
+         if (target_read_memory ((CORE_ADDR) addr, iov, tdep->size_iovec))
+           {
+             if (record_debug)
+               fprintf_unfiltered (gdb_stdlog,
+                                   "Process record: error "
+                                   "reading memory at "
+                                   "addr = 0x%s "
+                                   "len = %d.\n",
+                                   phex_nz (addr,tdep->size_pointer),
+                                   tdep->size_iovec);
+             return -1;
+           }
+         tmpaddr = (CORE_ADDR) extract_unsigned_integer (iov,
+                                                         tdep->size_pointer,
+                                                         byte_order);
+         tmpint = (int) extract_unsigned_integer (iov + tdep->size_pointer,
+                                                  tdep->size_size_t,
+                                                  byte_order);
+         if (record_full_arch_list_add_mem (tmpaddr, tmpint))
+           return -1;
+         addr += tdep->size_iovec;
+       }
     }
   a += tdep->size_size_t;
 
@@ -203,7 +220,7 @@ record_linux_msghdr (struct regcache *regcache,
   addr = extract_unsigned_integer (a, tdep->size_pointer, byte_order);
   a += tdep->size_pointer;
   tmpint = (int) extract_unsigned_integer (a, tdep->size_size_t, byte_order);
-  if (record_arch_list_add_mem ((CORE_ADDR) addr, tmpint));
+  if (record_full_arch_list_add_mem ((CORE_ADDR) addr, tmpint))
     return -1;
 
   return 0;
@@ -222,2338 +239,1801 @@ record_linux_msghdr (struct regcache *regcache,
    Return -1 if something wrong.  */
 
 int
-record_linux_system_call (int num, struct regcache *regcache,
-                          struct linux_record_tdep *tdep)
+record_linux_system_call (enum gdb_syscall syscall,
+                         struct regcache *regcache,
+                         struct linux_record_tdep *tdep)
 {
-  struct gdbarch *gdbarch = get_regcache_arch (regcache);
+  struct gdbarch *gdbarch = regcache->arch ();
   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
   ULONGEST tmpulongest;
   CORE_ADDR tmpaddr;
   int tmpint;
 
-  switch (num)
+  switch (syscall)
     {
-      /* sys_restart_syscall */
-    case 0:
+    case gdb_sys_restart_syscall:
       break;
 
-      /* sys_exit */
-    case 1:
-      {
-        int q;
-        target_terminal_ours ();
-        q = yquery (_("The next instruction is syscall exit.  "
-                      "It will make the program exit.  "
-                      "Do you want to stop the program?"));
-        target_terminal_inferior ();
-        if (q)
-          return 1;
-      }
+    case gdb_sys_exit:
+      if (yquery (_("The next instruction is syscall exit.  "
+                   "It will make the program exit.  "
+                   "Do you want to stop the program?")))
+       return 1;
       break;
 
-      /* sys_fork */
-    case 2:
+    case gdb_sys_fork:
       break;
 
-      /* sys_read */
-    case 3:
-      {
-        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;
-      }
+    case gdb_sys_read:
+    case gdb_sys_readlink:
+    case gdb_sys_recv:
+      regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
+      if (record_mem_at_reg (regcache, tdep->arg2, (int) tmpulongest))
+       return -1;
+      break;
+
+    case gdb_sys_write:
+    case gdb_sys_open:
+    case gdb_sys_close:
       break;
 
-      /* sys_write */
-    case 4:
-      /* sys_open */
-    case 5:
-      /* sys_close */
-    case 6:
-      /* sys_waitpid */
-    case 7:
-      /* sys_creat */
-    case 8:
-      /* sys_link */
-    case 9:
-      /* sys_unlink */
-    case 10:
-      /* sys_execve */
-    case 11:
-      /* sys_chdir */
-    case 12:
-      /* sys_time */
-    case 13:
-      /* sys_mknod */
-    case 14:
-      /* sys_chmod */
-    case 15:
-      /* sys_lchown16 */
-    case 16:
-      /* sys_ni_syscall */
-    case 17:
-      break;
-
-      /* sys_stat */
-    case 18:
-      /* sys_fstat */
-    case 28:
-      /* sys_lstat */
-    case 84:
+    case gdb_sys_waitpid:
       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;
-
-      /* sys_lseek */
-    case 19:
-      /* sys_getpid */
-    case 20:
-      /* sys_mount */
-    case 21:
-      /* sys_oldumount */
-    case 22:
-      /* sys_setuid16 */
-    case 23:
-      /* sys_getuid16 */
-    case 24:
-      /* sys_stime */
-    case 25:
-      break;
-
-      /* sys_ptrace */
-    case 26:
+      if (tmpulongest)
+       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+                                          tdep->size_int))
+         return -1;
+      break;
+
+    case gdb_sys_creat:
+    case gdb_sys_link:
+    case gdb_sys_unlink:
+    case gdb_sys_execve:
+    case gdb_sys_chdir:
+      break;
+
+    case gdb_sys_time:
       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
-      if (tmpulongest == RECORD_PTRACE_PEEKTEXT
-          || tmpulongest == RECORD_PTRACE_PEEKDATA
-          || tmpulongest == RECORD_PTRACE_PEEKUSR)
-        {
-          regcache_raw_read_unsigned (regcache, tdep->arg4,
-                                      &tmpulongest);
-          if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 4))
-            return -1;
-        }
-      break;
-
-      /* sys_alarm */
-    case 27:
-      /* sys_pause */
-    case 29:
-      /* sys_utime    */
-    case 30:
-      /* sys_ni_syscall */
-    case 31:
-      /* sys_ni_syscall */
-    case 32:
-      /* sys_access */
-    case 33:
-      /* sys_nice */
-    case 34:
-      /* sys_ni_syscall */
-    case 35:
-      /* sys_sync */
-    case 36:
-      /* sys_kill */
-    case 37:
-      /* sys_rename */
-    case 38:
-      /* sys_mkdir */
-    case 39:
-      /* sys_rmdir */
-    case 40:
-      /* sys_dup */
-    case 41:
-      /* sys_pipe */
-    case 42:
-      break;
-
-      /* sys_times */
-    case 43:
+      if (tmpulongest)
+       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+                                          tdep->size_time_t))
+         return -1;
+      break;
+
+    case gdb_sys_mknod:
+    case gdb_sys_chmod:
+    case gdb_sys_lchown16:
+    case gdb_sys_ni_syscall17:
+      break;
+
+    case gdb_sys_stat:
+    case gdb_sys_fstat:
+    case gdb_sys_lstat:
+      if (record_mem_at_reg (regcache, tdep->arg2,
+                            tdep->size__old_kernel_stat))
+       return -1;
+      break;
+
+    case gdb_sys_lseek:
+    case gdb_sys_getpid:
+    case gdb_sys_mount:
+    case gdb_sys_oldumount:
+    case gdb_sys_setuid16:
+    case gdb_sys_getuid16:
+    case gdb_sys_stime:
+      break;
+
+    case gdb_sys_ptrace:
       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_tms))
-        return -1;
-      break;
-
-      /* sys_ni_syscall */
-    case 44:
-      /* sys_brk */
-    case 45:
-      /* sys_setgid16 */
-    case 46:
-      /* sys_getgid16 */
-    case 47:
-      /* sys_signal */
-    case 48:
-      /* sys_geteuid16 */
-    case 49:
-      /* sys_getegid16 */
-    case 50:
-      /* sys_acct */
-    case 51:
-      /* sys_umount */
-    case 52:
-      /* sys_ni_syscall */
-    case 53:
-      break;
-
-      /* sys_ioctl */
-    case 54:
+      if (tmpulongest == RECORD_PTRACE_PEEKTEXT
+         || tmpulongest == RECORD_PTRACE_PEEKDATA
+         || tmpulongest == RECORD_PTRACE_PEEKUSR)
+       {
+         if (record_mem_at_reg (regcache, tdep->arg4, 4))
+           return -1;
+       }
+      break;
+
+    case gdb_sys_alarm:
+    case gdb_sys_pause:
+    case gdb_sys_utime:
+    case gdb_sys_ni_syscall31:
+    case gdb_sys_ni_syscall32:
+    case gdb_sys_access:
+    case gdb_sys_nice:
+    case gdb_sys_ni_syscall35:
+    case gdb_sys_sync:
+    case gdb_sys_kill:
+    case gdb_sys_rename:
+    case gdb_sys_mkdir:
+    case gdb_sys_rmdir:
+    case gdb_sys_dup:
+      break;
+
+    case gdb_sys_pipe:
+    case gdb_sys_pipe2:
+      if (record_mem_at_reg (regcache, tdep->arg1, tdep->size_int * 2))
+       return -1;
+      break;
+
+    case gdb_sys_times:
+      if (record_mem_at_reg (regcache, tdep->arg1, tdep->size_tms))
+       return -1;
+      break;
+
+    case gdb_sys_ni_syscall44:
+    case gdb_sys_brk:
+    case gdb_sys_setgid16:
+    case gdb_sys_getgid16:
+    case gdb_sys_signal:
+    case gdb_sys_geteuid16:
+    case gdb_sys_getegid16:
+    case gdb_sys_acct:
+    case gdb_sys_umount:
+    case gdb_sys_ni_syscall53:
+      break;
+
+    case gdb_sys_ioctl:
       /* XXX Need to add a lot of support of other ioctl requests.  */
       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.  */
-        }
+         || 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 (tmpulongest == tdep->ioctl_TCGETS
-               || tmpulongest == tdep->ioctl_TCGETA
-               || tmpulongest == tdep->ioctl_TIOCGLCKTRMIOS)
-        {
-          regcache_raw_read_unsigned (regcache, tdep->arg3,
-                                      &tmpulongest);
-          if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                        tdep->size_termios))
-            return -1;
-        }
+              || tmpulongest == tdep->ioctl_TCGETA
+              || tmpulongest == tdep->ioctl_TIOCGLCKTRMIOS)
+       {
+         if (record_mem_at_reg (regcache, tdep->arg3,
+                                tdep->size_termios))
+           return -1;
+       }
       else if (tmpulongest == tdep->ioctl_TIOCGPGRP
-               || tmpulongest == tdep->ioctl_TIOCGSID)
-        {
-          regcache_raw_read_unsigned (regcache, tdep->arg3,
-                                      &tmpulongest);
-          if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                        tdep->size_pid_t))
-            return -1;
-        }
+              || tmpulongest == tdep->ioctl_TIOCGSID)
+       {
+         if (record_mem_at_reg (regcache, tdep->arg3, tdep->size_pid_t))
+           return -1;
+       }
       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_unsigned (regcache, tdep->arg3,
-                                      &tmpulongest);
-          if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                        tdep->size_int))
-            return -1;
-        }
+              || 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)
+       {
+         if (record_mem_at_reg (regcache, tdep->arg3, tdep->size_int))
+           return -1;
+       }
       else if (tmpulongest == tdep->ioctl_TIOCGWINSZ)
-        {
-          regcache_raw_read_unsigned (regcache, tdep->arg3,
-                                      &tmpulongest);
-          if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                        tdep->size_winsize))
-            return -1;
-        }
+       {
+         if (record_mem_at_reg (regcache, tdep->arg3,
+                                tdep->size_winsize))
+           return -1;
+       }
       else if (tmpulongest == tdep->ioctl_TIOCLINUX)
-        {
-          regcache_raw_read_unsigned (regcache, tdep->arg3,
-                                      &tmpulongest);
-          /* This syscall affect a char size memory.  */
-          if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 1))
-            return -1;
-        }
+       {
+         /* This syscall affects a char-size memory.  */
+         if (record_mem_at_reg (regcache, tdep->arg3, 1))
+           return -1;
+       }
       else if (tmpulongest == tdep->ioctl_TIOCGSERIAL)
-        {
-          regcache_raw_read_unsigned (regcache, tdep->arg3,
-                                      &tmpulongest);
-          if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                        tdep->size_serial_struct))
-            return -1;
-        }
+       {
+         if (record_mem_at_reg (regcache, tdep->arg3,
+                                tdep->size_serial_struct))
+           return -1;
+       }
       else if (tmpulongest == tdep->ioctl_TCGETS2)
-        {
-          regcache_raw_read_unsigned (regcache, tdep->arg3,
-                                      &tmpulongest);
-          if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                        tdep->size_termios2))
-            return -1;
-        }
+       {
+         if (record_mem_at_reg (regcache, tdep->arg3,
+                                tdep->size_termios2))
+           return -1;
+       }
       else if (tmpulongest == tdep->ioctl_FIOQSIZE)
-        {
-          regcache_raw_read_unsigned (regcache, tdep->arg3,
-                                      &tmpulongest);
-          if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                        tdep->size_loff_t))
-            return -1;
-        }
+       {
+         if (record_mem_at_reg (regcache, tdep->arg3, tdep->size_loff_t))
+           return -1;
+       }
       else if (tmpulongest == tdep->ioctl_TIOCGICOUNT)
-        {
-          regcache_raw_read_unsigned (regcache, tdep->arg3,
-                                      &tmpulongest);
-          if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                        tdep->size_serial_icounter_struct))
-            return -1;
-        }
+       {
+         if (record_mem_at_reg (regcache, tdep->arg3,
+                                tdep->size_serial_icounter_struct))
+           return -1;
+       }
       else if (tmpulongest == tdep->ioctl_TIOCGHAYESESP)
-        {
-          regcache_raw_read_unsigned (regcache, tdep->arg3,
-                                      &tmpulongest);
-          if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                        tdep->size_hayes_esp_config))
-            return -1;
-        }
+       {
+         if (record_mem_at_reg (regcache, tdep->arg3,
+                                tdep->size_hayes_esp_config))
+           return -1;
+       }
       else if (tmpulongest == tdep->ioctl_TIOCSERGSTRUCT)
-        {
-          printf_unfiltered (_("Process record and replay target doesn't "
-                               "support ioctl request TIOCSERGSTRUCT\n"));
-          return 1;
-        }
+       {
+         printf_unfiltered (_("Process record and replay target doesn't "
+                              "support ioctl request TIOCSERGSTRUCT\n"));
+         return 1;
+       }
       else
-        {
-          printf_unfiltered (_("Process record and replay target doesn't "
-                               "support ioctl request 0x%s.\n"),
-                             OUTPUT_REG (tmpulongest, tdep->arg2));
-          return 1;
-        }
+       {
+         printf_unfiltered (_("Process record and replay target doesn't "
+                              "support ioctl request 0x%s.\n"),
+                            OUTPUT_REG (tmpulongest, tdep->arg2));
+         return 1;
+       }
       break;
 
-      /* sys_fcntl */
-    case 55:
+    case gdb_sys_fcntl:
       /* XXX */
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
     sys_fcntl:
       if (tmpulongest == tdep->fcntl_F_GETLK)
-        {
-          regcache_raw_read_unsigned (regcache, tdep->arg3,
-                                      &tmpulongest);
-          if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                        tdep->size_flock))
-            return -1;
-        }
+       {
+         if (record_mem_at_reg (regcache, tdep->arg3, tdep->size_flock))
+           return -1;
+       }
       break;
 
-      /* sys_ni_syscall */
-    case 56:
-      /* sys_setpgid */
-    case 57:
-      /* sys_ni_syscall */
-    case 58:
+    case gdb_sys_ni_syscall56:
+    case gdb_sys_setpgid:
+    case gdb_sys_ni_syscall58:
       break;
 
-      /* sys_olduname */
-    case 59:
-      regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_oldold_utsname))
-        return -1;
+    case gdb_sys_olduname:
+      if (record_mem_at_reg (regcache, tdep->arg1,
+                            tdep->size_oldold_utsname))
+       return -1;
       break;
 
-      /* sys_umask */
-    case 60:
-      /* sys_chroot */
-    case 61:
+    case gdb_sys_umask:
+    case gdb_sys_chroot:
       break;
 
-      /* sys_ustat */
-    case 62:
-      regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_ustat))
-        return -1;
+    case gdb_sys_ustat:
+      if (record_mem_at_reg (regcache, tdep->arg2, tdep->size_ustat))
+       return -1;
       break;
 
-      /* sys_dup2 */
-    case 63:
-      /* sys_getppid */
-    case 64:
-      /* sys_getpgrp */
-    case 65:
-      /* sys_setsid */
-    case 66:
+    case gdb_sys_dup2:
+    case gdb_sys_getppid:
+    case gdb_sys_getpgrp:
+    case gdb_sys_setsid:
       break;
 
-      /* sys_sigaction */
-    case 67:
-      regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_old_sigaction))
-        return -1;
+    case gdb_sys_sigaction:
+      if (record_mem_at_reg (regcache, tdep->arg3,
+                            tdep->size_old_sigaction))
+       return -1;
       break;
 
-      /* sys_sgetmask */
-    case 68:
-      /* sys_ssetmask */
-    case 69:
-      /* sys_setreuid16 */
-    case 70:
-      /* sys_setregid16 */
-    case 71:
-      /* sys_sigsuspend */
-    case 72:
+    case gdb_sys_sgetmask:
+    case gdb_sys_ssetmask:
+    case gdb_sys_setreuid16:
+    case gdb_sys_setregid16:
+    case gdb_sys_sigsuspend:
       break;
 
-      /* sys_sigpending */
-    case 73:
-      regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_old_sigset_t))
-        return -1;
+    case gdb_sys_sigpending:
+      if (record_mem_at_reg (regcache, tdep->arg1,
+                            tdep->size_old_sigset_t))
+       return -1;
       break;
 
-      /* sys_sethostname */
-    case 74:
-      /* sys_setrlimit */
-    case 75:
+    case gdb_sys_sethostname:
+    case gdb_sys_setrlimit:
       break;
 
-      /* sys_old_getrlimit */
-    case 76:
-      regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_rlimit))
-        return -1;
+    case gdb_sys_old_getrlimit:
+      if (record_mem_at_reg (regcache, tdep->arg2, tdep->size_rlimit))
+       return -1;
       break;
 
-      /* sys_getrusage */
-    case 77:
-      regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_rusage))
-        return -1;
+    case gdb_sys_getrusage:
+      if (record_mem_at_reg (regcache, tdep->arg2, tdep->size_rusage))
+       return -1;
       break;
 
-      /* sys_gettimeofday */
-    case 78:
-      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_unsigned (regcache, tdep->arg2, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_timezone))
-        return -1;
+    case gdb_sys_gettimeofday:
+      if (record_mem_at_reg (regcache, tdep->arg1, tdep->size_timeval)
+         || record_mem_at_reg (regcache, tdep->arg2, tdep->size_timezone))
+       return -1;
       break;
 
-      /* sys_settimeofday */
-    case 79:
+    case gdb_sys_settimeofday:
       break;
 
-      /* sys_getgroups16 */
-    case 80:
+    case gdb_sys_getgroups16:
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_old_gid_t))
-        return -1;
+      if (tmpulongest)
+       {
+         ULONGEST gidsetsize;
+
+         regcache_raw_read_unsigned (regcache, tdep->arg1,
+                                     &gidsetsize);
+         tmpint = tdep->size_old_gid_t * (int) gidsetsize;
+         if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest, tmpint))
+           return -1;
+       }
       break;
 
-      /* sys_setgroups16 */
-    case 81:
-      regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_old_gid_t))
-        return -1;
+    case gdb_sys_setgroups16:
       break;
 
-      /* old_select */
-    case 82:
+    case gdb_old_select:
       {
-        struct sel_arg_struct
-        {
-          CORE_ADDR n;
-          CORE_ADDR inp;
-          CORE_ADDR outp;
-          CORE_ADDR exp;
-          CORE_ADDR tvp;
-        } sel;
-
-        regcache_raw_read_unsigned (regcache, tdep->arg1,
-                                    &tmpulongest);
-        if (tmpulongest)
-          {
-            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",
-                                      OUTPUT_REG (tmpulongest, tdep->arg1),
-                                      (unsigned long) sizeof (sel));
-                return -1;
-              }
-            if (record_arch_list_add_mem (sel.inp, tdep->size_fd_set))
-              return -1;
-            if (record_arch_list_add_mem (sel.outp, tdep->size_fd_set))
-              return -1;
-            if (record_arch_list_add_mem (sel.exp, tdep->size_fd_set))
-              return -1;
-            if (record_arch_list_add_mem (sel.tvp, tdep->size_timeval))
-              return -1;
-          }
+       unsigned long sz_sel_arg = tdep->size_long + tdep->size_pointer * 4;
+       gdb_byte *a = (gdb_byte *) alloca (sz_sel_arg);
+       CORE_ADDR inp, outp, exp, tvp;
+
+       regcache_raw_read_unsigned (regcache, tdep->arg1,
+                                   &tmpulongest);
+       if (tmpulongest)
+         {
+           if (target_read_memory (tmpulongest, a, sz_sel_arg))
+             {
+               if (record_debug)
+                 fprintf_unfiltered (gdb_stdlog,
+                                     "Process record: error reading memory "
+                                     "at addr = 0x%s len = %lu.\n",
+                                     OUTPUT_REG (tmpulongest, tdep->arg1),
+                                     sz_sel_arg);
+               return -1;
+             }
+           /* Skip n. */
+           a += tdep->size_long;
+           inp = extract_unsigned_integer (a, tdep->size_pointer, byte_order);
+           a += tdep->size_pointer;
+           outp = extract_unsigned_integer (a, tdep->size_pointer, byte_order);
+           a += tdep->size_pointer;
+           exp = extract_unsigned_integer (a, tdep->size_pointer, byte_order);
+           a += tdep->size_pointer;
+           tvp = extract_unsigned_integer (a, tdep->size_pointer, byte_order);
+           if (inp)
+             if (record_full_arch_list_add_mem (inp, tdep->size_fd_set))
+               return -1;
+           if (outp)
+             if (record_full_arch_list_add_mem (outp, tdep->size_fd_set))
+               return -1;
+           if (exp)
+             if (record_full_arch_list_add_mem (exp, tdep->size_fd_set))
+               return -1;
+           if (tvp)
+             if (record_full_arch_list_add_mem (tvp, tdep->size_timeval))
+               return -1;
+         }
       }
       break;
 
-      /* sys_symlink */
-    case 83:
+    case gdb_sys_symlink:
       break;
 
-      /* sys_readlink */
-    case 85:
-      {
-        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;
-      }
+    case gdb_sys_uselib:
+    case gdb_sys_swapon:
       break;
 
-      /* sys_uselib */
-    case 86:
-      /* sys_swapon */
-    case 87:
+    case gdb_sys_reboot:
+      if (yquery (_("The next instruction is syscall reboot.  "
+                   "It will restart the computer.  "
+                   "Do you want to stop the program?")))
+       return 1;
       break;
 
-      /* sys_reboot */
-    case 88:
+    case gdb_old_readdir:
+      if (record_mem_at_reg (regcache, tdep->arg2, tdep->size_old_dirent))
+       return -1;
+      break;
+
+    case gdb_old_mmap:
+      break;
+
+    case gdb_sys_munmap:
       {
-        int q;
-        target_terminal_ours ();
-        q =
-          yquery (_("The next instruction is syscall reboot.  "
-                    "It will restart the computer.  "
-                    "Do you want to stop the program?"));
-        target_terminal_inferior ();
-        if (q)
-          return 1;
+       ULONGEST len;
+
+       regcache_raw_read_unsigned (regcache, tdep->arg1,
+                                   &tmpulongest);
+       regcache_raw_read_unsigned (regcache, tdep->arg2, &len);
+       if (record_full_memory_query)
+         {
+           if (yquery (_("\
+The next instruction is syscall munmap.\n\
+It will free the memory addr = 0x%s len = %u.\n\
+It will make record target cannot record some memory change.\n\
+Do you want to stop the program?"),
+                       OUTPUT_REG (tmpulongest, tdep->arg1), (int) len))
+             return 1;
+         }
       }
       break;
 
-      /* old_readdir */
-    case 89:
-      regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_dirent))
-        return -1;
+    case gdb_sys_truncate:
+    case gdb_sys_ftruncate:
+    case gdb_sys_fchmod:
+    case gdb_sys_fchown16:
+    case gdb_sys_getpriority:
+    case gdb_sys_setpriority:
+    case gdb_sys_ni_syscall98:
       break;
 
-      /* old_mmap */
-    case 90:
+    case gdb_sys_statfs:
+    case gdb_sys_fstatfs:
+      if (record_mem_at_reg (regcache, tdep->arg2, tdep->size_statfs))
+       return -1;
       break;
 
-      /* sys_munmap */
-    case 91:
-      {
-        int q;
-        ULONGEST 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?"),
-                    OUTPUT_REG (tmpulongest, tdep->arg1), (int) len);
-        target_terminal_inferior ();
-        if (q)
-          return 1;
-      }
+    case gdb_sys_ioperm:
       break;
 
-      /* sys_truncate */
-    case 92:
-      /* sys_ftruncate */
-    case 93:
-      /* sys_fchmod */
-    case 94:
-      /* sys_fchown16 */
-    case 95:
-      /* sys_getpriority */
-    case 96:
-      /* sys_setpriority */
-    case 97:
-      /* sys_ni_syscall */
-    case 98:
-      break;
-
-      /* sys_statfs */
-    case 99:
-      /* sys_fstatfs */
-    case 100:
-      regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_statfs))
-        return -1;
-      break;
-
-      /* sys_ioperm */
-    case 101:
-      break;
-
-      /* sys_socket */
-    case 500:
-      /* sys_sendto */
-    case 503:
-      /* sys_sendmsg */
-    case 505:
-      /* sys_shutdown */
-    case 507:
-      /* sys_bind */
-    case 508:
-      /* sys_connect */
-    case 501:
-      /* sys_listen */
-    case 509:
-      /* sys_setsockopt */
-    case 513:
-      break;
-
-      /* sys_accept */
-    case 502:
-      /* sys_getsockname */
-    case 510:
-      /* sys_getpeername */
-    case 511:
-      {
-        ULONGEST len;
-        regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
-        regcache_raw_read_unsigned (regcache, tdep->arg3, &len);
-        if (record_linux_sockaddr (regcache, tdep, tmpulongest, len))
-          return -1;
-      }
+    case gdb_sys_socket:
+    case gdb_sys_sendto:
+    case gdb_sys_sendmsg:
+    case gdb_sys_shutdown:
+    case gdb_sys_bind:
+    case gdb_sys_connect:
+    case gdb_sys_listen:
+    case gdb_sys_setsockopt:
       break;
 
-      /* sys_recvfrom */
-    case 504:
+    case gdb_sys_accept:
+    case gdb_sys_getsockname:
+    case gdb_sys_getpeername:
       {
-        ULONGEST len;
-        regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
-        regcache_raw_read_unsigned (regcache, tdep->arg5, &len);
-        if (record_linux_sockaddr (regcache, tdep, tmpulongest, len))
-          return -1;
+       ULONGEST len;
+
+       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
+       regcache_raw_read_unsigned (regcache, tdep->arg3, &len);
+       if (record_linux_sockaddr (regcache, tdep, tmpulongest, len))
+         return -1;
       }
-      /* sys_recv */
-    case 515:
+      break;
+
+    case gdb_sys_recvfrom:
       {
-        ULONGEST size;
-        regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
-        regcache_raw_read_unsigned (regcache, tdep->arg3, &size);
-        if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, (int) size))
-          return -1;
+       ULONGEST len;
+
+       regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
+       regcache_raw_read_unsigned (regcache, tdep->arg5, &len);
+       if (record_linux_sockaddr (regcache, tdep, tmpulongest, len))
+         return -1;
       }
       break;
 
-      /* sys_recvmsg */
-    case 506:
+    case gdb_sys_recvmsg:
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
       if (record_linux_msghdr (regcache, tdep, tmpulongest))
-        return -1;
+       return -1;
       break;
 
-      /* sys_socketpair */
-    case 512:
-      regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_int))
-        return -1;
+    case gdb_sys_socketpair:
+      if (record_mem_at_reg (regcache, tdep->arg4, tdep->size_int))
+       return -1;
       break;
 
-      /* sys_getsockopt */
-    case 514:
+    case gdb_sys_getsockopt:
       regcache_raw_read_unsigned (regcache, tdep->arg5, &tmpulongest);
       if (tmpulongest)
-        {
-          ULONGEST optvalp;
-          gdb_byte *optlenp = alloca (tdep->size_int);
-          if (target_read_memory ((CORE_ADDR) tmpulongest, optlenp,
-                                  tdep->size_int))
-            {
-              if (record_debug)
-                fprintf_unfiltered (gdb_stdlog,
-                                    "Process record: error reading "
-                                    "memory at addr = 0x%s "
-                                    "len = %d.\n",
-                                    OUTPUT_REG (tmpulongest, tdep->arg5),
-                                    tdep->size_int);
-              return -1;
-            }
-          regcache_raw_read_unsigned (regcache, tdep->arg4, &optvalp);
-          tmpint = (int) extract_signed_integer (optlenp, tdep->size_int,
-                                                 byte_order);
-          if (record_arch_list_add_mem ((CORE_ADDR) optvalp, tmpint))
-            return -1;
-          if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                        tdep->size_int))
-            return -1;
-        }
-      break;
-
-      /* sys_socketcall */
-    case 102:
+       {
+         ULONGEST optvalp;
+         gdb_byte *optlenp = (gdb_byte *) alloca (tdep->size_int);
+
+         if (target_read_memory ((CORE_ADDR) tmpulongest, optlenp,
+                                 tdep->size_int))
+           {
+             if (record_debug)
+               fprintf_unfiltered (gdb_stdlog,
+                                   "Process record: error reading "
+                                   "memory at addr = 0x%s "
+                                   "len = %d.\n",
+                                   OUTPUT_REG (tmpulongest, tdep->arg5),
+                                   tdep->size_int);
+             return -1;
+           }
+         regcache_raw_read_unsigned (regcache, tdep->arg4, &optvalp);
+         tmpint = (int) extract_signed_integer (optlenp, tdep->size_int,
+                                                byte_order);
+         if (record_full_arch_list_add_mem ((CORE_ADDR) optvalp, tmpint))
+           return -1;
+         if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+                                            tdep->size_int))
+           return -1;
+       }
+      break;
+
+    case gdb_sys_socketcall:
       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
       switch (tmpulongest)
-        {
-        case RECORD_SYS_SOCKET:
-        case RECORD_SYS_BIND:
-        case RECORD_SYS_CONNECT:
-        case RECORD_SYS_LISTEN:
-          break;
-        case RECORD_SYS_ACCEPT:
-        case RECORD_SYS_GETSOCKNAME:
-        case RECORD_SYS_GETPEERNAME:
-          {
-            regcache_raw_read_unsigned (regcache, tdep->arg2,
-                                        &tmpulongest);
-            if (tmpulongest)
-              {
-                gdb_byte *a = alloca (tdep->size_ulong * 2);
-                int addrlen;
-                gdb_byte *addrlenp;
-                ULONGEST len;
-
-                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 = %d.\n",
-                                          OUTPUT_REG (tmpulongest, tdep->arg2),
-                                          tdep->size_ulong * 2);
-                    return -1;
-                  }
-                tmpulongest = extract_unsigned_integer (a,
-                                                        tdep->size_ulong,
-                                                        byte_order);
-                len = extract_unsigned_integer (a + tdep->size_ulong,
-                                                tdep->size_ulong, byte_order);
-                if (record_linux_sockaddr (regcache, tdep, tmpulongest, len))
-                  return -1;
-              }
-          }
-          break;
-
-        case RECORD_SYS_SOCKETPAIR:
-          {
-            gdb_byte *a = alloca (tdep->size_ulong);
-            regcache_raw_read_unsigned (regcache, tdep->arg2,
-                                        &tmpulongest);
-            if (tmpulongest)
-              {
-                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 = %d.\n",
-                                          OUTPUT_REG (tmpulongest, tdep->arg2),
-                                          tdep->size_ulong);
-                    return -1;
-                  }
-                tmpaddr
-                  = (CORE_ADDR) extract_unsigned_integer (a, tdep->size_ulong,
-                                                          byte_order);
-                if (record_arch_list_add_mem (tmpaddr, tdep->size_int))
-                  return -1;
-              }
-          }
-          break;
-        case RECORD_SYS_SEND:
-        case RECORD_SYS_SENDTO:
-          break;
-        case RECORD_SYS_RECVFROM:
-          regcache_raw_read_unsigned (regcache, tdep->arg2,
-                                      &tmpulongest);
-          if (tmpulongest)
-            {
-              gdb_byte *a = alloca (tdep->size_ulong * 2);
-              int addrlen;
-              gdb_byte *addrlenp;
-              ULONGEST len;
-
-              tmpulongest += tdep->size_ulong * 4;
-              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 = %d.\n",
-                                        OUTPUT_REG (tmpulongest, tdep->arg2),
-                                        tdep->size_ulong * 2);
-                  return -1;
-                }
-              tmpulongest = extract_unsigned_integer (a, tdep->size_ulong,
-                                                      byte_order);
-              len = extract_unsigned_integer (a + tdep->size_ulong,
-                                              tdep->size_ulong, byte_order);
-              if (record_linux_sockaddr (regcache, tdep, tmpulongest, len))
-                return -1;
-            }
-        case RECORD_SYS_RECV:
-          regcache_raw_read_unsigned (regcache, tdep->arg2,
-                                      &tmpulongest);
-          if (tmpulongest)
-            {
-              gdb_byte *a = alloca (tdep->size_ulong * 2);
-
-              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 = %d.\n",
-                                        OUTPUT_REG (tmpulongest, tdep->arg2),
-                                        tdep->size_ulong);
-                    return -1;
-                }
-              tmpulongest = extract_unsigned_integer (a, tdep->size_ulong,
-                                                      byte_order);
-              if (tmpulongest)
-                {
-                  a += tdep->size_ulong;
-                  tmpint = (int) extract_unsigned_integer (a, tdep->size_ulong,
-                                                           byte_order);
-                  if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                                tmpint))
-                    return -1;
-                }
-            }
-          break;
-        case RECORD_SYS_SHUTDOWN:
-        case RECORD_SYS_SETSOCKOPT:
-          break;
-        case RECORD_SYS_GETSOCKOPT:
-          {
-            gdb_byte *a = alloca (tdep->size_ulong * 2);
-            gdb_byte *av = alloca (tdep->size_int);
-
-            regcache_raw_read_unsigned (regcache, tdep->arg2,
-                                        &tmpulongest);
-            if (tmpulongest)
-              {
-                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 = %d.\n",
-                                          OUTPUT_REG (tmpulongest, tdep->arg2),
-                                          tdep->size_ulong * 2);
-                    return -1;
-                  }
-                tmpulongest = extract_unsigned_integer (a + tdep->size_ulong,
-                                                        tdep->size_ulong,
-                                                        byte_order);
-                if (tmpulongest)
-                  {
-                    if (target_read_memory ((CORE_ADDR) tmpulongest, av,
-                                            tdep->size_int))
-                      {
-                        if (record_debug)
-                          fprintf_unfiltered (gdb_stdlog,
-                                              "Process record: error reading "
-                                              "memory at addr = 0x%s "
-                                              "len = %d.\n",
-                                              phex_nz (tmpulongest,
-                                                       tdep->size_ulong),
-                                              tdep->size_int);
-                        return -1;
-                      }
-                    tmpaddr
-                      = (CORE_ADDR) extract_unsigned_integer (a,
-                                                              tdep->size_ulong,
-                                                              byte_order);
-                    tmpint = (int) extract_unsigned_integer (av,
-                                                             tdep->size_int,
-                                                             byte_order);
-                    if (record_arch_list_add_mem (tmpaddr, tmpint))
-                      return -1;
-                    a += tdep->size_ulong;
-                    tmpaddr
-                      = (CORE_ADDR) extract_unsigned_integer (a,
-                                                              tdep->size_ulong,
-                                                              byte_order);
-                    if (record_arch_list_add_mem (tmpaddr, tdep->size_int))
-                      return -1;
-                  }
-              }
-          }
-          break;
-        case RECORD_SYS_SENDMSG:
-          break;
-        case RECORD_SYS_RECVMSG:
-          {
-            gdb_byte *a = alloca (tdep->size_ulong);
-
-            regcache_raw_read_unsigned (regcache, tdep->arg2,
-                                        &tmpulongest);
-            if (tmpulongest)
-              {
-                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 = %d.\n",
-                                          OUTPUT_REG (tmpulongest, tdep->arg2),
-                                          tdep->size_ulong);
-                    return -1;
-                  }
-                tmpulongest = extract_unsigned_integer (a, tdep->size_ulong,
-                                                        byte_order);
-                if (record_linux_msghdr (regcache, tdep, tmpulongest))
-                  return -1;
-              }
-          }
-          break;
-        default:
-          printf_unfiltered (_("Process record and replay target "
-                               "doesn't support socketcall call 0x%s\n"),
-                             OUTPUT_REG (tmpulongest, tdep->arg1));
-          return -1;
-          break;
-        }
-      break;
-
-      /* sys_syslog */
-    case 103:
-      break;
-
-      /* sys_setitimer */
-    case 104:
+       {
+       case RECORD_SYS_SOCKET:
+       case RECORD_SYS_BIND:
+       case RECORD_SYS_CONNECT:
+       case RECORD_SYS_LISTEN:
+         break;
+       case RECORD_SYS_ACCEPT:
+       case RECORD_SYS_GETSOCKNAME:
+       case RECORD_SYS_GETPEERNAME:
+         {
+           regcache_raw_read_unsigned (regcache, tdep->arg2,
+                                       &tmpulongest);
+           if (tmpulongest)
+             {
+               gdb_byte *a = (gdb_byte *) alloca (tdep->size_ulong * 2);
+               ULONGEST len;
+
+               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 = %d.\n",
+                                         OUTPUT_REG (tmpulongest, tdep->arg2),
+                                         tdep->size_ulong * 2);
+                   return -1;
+                 }
+               tmpulongest = extract_unsigned_integer (a,
+                                                       tdep->size_ulong,
+                                                       byte_order);
+               len = extract_unsigned_integer (a + tdep->size_ulong,
+                                               tdep->size_ulong, byte_order);
+               if (record_linux_sockaddr (regcache, tdep, tmpulongest, len))
+                 return -1;
+             }
+         }
+         break;
+
+       case RECORD_SYS_SOCKETPAIR:
+         {
+           gdb_byte *a = (gdb_byte *) alloca (tdep->size_ulong);
+
+           regcache_raw_read_unsigned (regcache, tdep->arg2,
+                                       &tmpulongest);
+           if (tmpulongest)
+             {
+               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 = %d.\n",
+                                         OUTPUT_REG (tmpulongest, tdep->arg2),
+                                         tdep->size_ulong);
+                   return -1;
+                 }
+               tmpaddr
+                 = (CORE_ADDR) extract_unsigned_integer (a, tdep->size_ulong,
+                                                         byte_order);
+               if (record_full_arch_list_add_mem (tmpaddr, tdep->size_int))
+                 return -1;
+             }
+         }
+         break;
+       case RECORD_SYS_SEND:
+       case RECORD_SYS_SENDTO:
+         break;
+       case RECORD_SYS_RECVFROM:
+         regcache_raw_read_unsigned (regcache, tdep->arg2,
+                                     &tmpulongest);
+         if (tmpulongest)
+           {
+             gdb_byte *a = (gdb_byte *) alloca (tdep->size_ulong * 2);
+             ULONGEST len;
+
+             tmpulongest += tdep->size_ulong * 4;
+             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 = %d.\n",
+                                       OUTPUT_REG (tmpulongest, tdep->arg2),
+                                       tdep->size_ulong * 2);
+                 return -1;
+               }
+             tmpulongest = extract_unsigned_integer (a, tdep->size_ulong,
+                                                     byte_order);
+             len = extract_unsigned_integer (a + tdep->size_ulong,
+                                             tdep->size_ulong, byte_order);
+             if (record_linux_sockaddr (regcache, tdep, tmpulongest, len))
+               return -1;
+           }
+         break;
+       case RECORD_SYS_RECV:
+         regcache_raw_read_unsigned (regcache, tdep->arg2,
+                                     &tmpulongest);
+         if (tmpulongest)
+           {
+             gdb_byte *a = (gdb_byte *) alloca (tdep->size_ulong * 2);
+
+             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 = %d.\n",
+                                       OUTPUT_REG (tmpulongest, tdep->arg2),
+                                       tdep->size_ulong);
+                 return -1;
+               }
+             tmpulongest = extract_unsigned_integer (a, tdep->size_ulong,
+                                                     byte_order);
+             if (tmpulongest)
+               {
+                 a += tdep->size_ulong;
+                 tmpint = (int) extract_unsigned_integer (a, tdep->size_ulong,
+                                                          byte_order);
+                 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+                                                    tmpint))
+                   return -1;
+               }
+           }
+         break;
+       case RECORD_SYS_SHUTDOWN:
+       case RECORD_SYS_SETSOCKOPT:
+         break;
+       case RECORD_SYS_GETSOCKOPT:
+         {
+           gdb_byte *a = (gdb_byte *) alloca (tdep->size_ulong * 2);
+           gdb_byte *av = (gdb_byte *) alloca (tdep->size_int);
+
+           regcache_raw_read_unsigned (regcache, tdep->arg2,
+                                       &tmpulongest);
+           if (tmpulongest)
+             {
+               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 = %d.\n",
+                                         OUTPUT_REG (tmpulongest, tdep->arg2),
+                                         tdep->size_ulong * 2);
+                   return -1;
+                 }
+               tmpulongest = extract_unsigned_integer (a + tdep->size_ulong,
+                                                       tdep->size_ulong,
+                                                       byte_order);
+               if (tmpulongest)
+                 {
+                   if (target_read_memory ((CORE_ADDR) tmpulongest, av,
+                                           tdep->size_int))
+                     {
+                       if (record_debug)
+                         fprintf_unfiltered (gdb_stdlog,
+                                             "Process record: error reading "
+                                             "memory at addr = 0x%s "
+                                             "len = %d.\n",
+                                             phex_nz (tmpulongest,
+                                                      tdep->size_ulong),
+                                             tdep->size_int);
+                       return -1;
+                     }
+                   tmpaddr
+                     = (CORE_ADDR) extract_unsigned_integer (a,
+                                                             tdep->size_ulong,
+                                                             byte_order);
+                   tmpint = (int) extract_unsigned_integer (av,
+                                                            tdep->size_int,
+                                                            byte_order);
+                   if (record_full_arch_list_add_mem (tmpaddr, tmpint))
+                     return -1;
+                   a += tdep->size_ulong;
+                   tmpaddr
+                     = (CORE_ADDR) extract_unsigned_integer (a,
+                                                             tdep->size_ulong,
+                                                             byte_order);
+                   if (record_full_arch_list_add_mem (tmpaddr,
+                                                      tdep->size_int))
+                     return -1;
+                 }
+             }
+         }
+         break;
+       case RECORD_SYS_SENDMSG:
+         break;
+       case RECORD_SYS_RECVMSG:
+         {
+           gdb_byte *a = (gdb_byte *) alloca (tdep->size_ulong);
+
+           regcache_raw_read_unsigned (regcache, tdep->arg2,
+                                       &tmpulongest);
+           if (tmpulongest)
+             {
+               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 = %d.\n",
+                                         OUTPUT_REG (tmpulongest, tdep->arg2),
+                                         tdep->size_ulong);
+                   return -1;
+                 }
+               tmpulongest = extract_unsigned_integer (a, tdep->size_ulong,
+                                                       byte_order);
+               if (record_linux_msghdr (regcache, tdep, tmpulongest))
+                 return -1;
+             }
+         }
+         break;
+       default:
+         printf_unfiltered (_("Process record and replay target "
+                              "doesn't support socketcall call 0x%s\n"),
+                            OUTPUT_REG (tmpulongest, tdep->arg1));
+         return -1;
+         break;
+       }
+      break;
+
+    case gdb_sys_syslog:
+      break;
+
+    case gdb_sys_setitimer:
+      if (record_mem_at_reg (regcache, tdep->arg3, tdep->size_itimerval))
+       return -1;
+      break;
+
+    case gdb_sys_getitimer:
+      if (record_mem_at_reg (regcache, tdep->arg2, tdep->size_itimerval))
+       return -1;
+      break;
+
+    case gdb_sys_newstat:
+    case gdb_sys_newlstat:
+    case gdb_sys_newfstat:
+      if (record_mem_at_reg (regcache, tdep->arg2, tdep->size_stat))
+       return -1;
+      break;
+
+    case gdb_sys_newfstatat:
       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_itimerval))
-        return -1;
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+                                        tdep->size_stat))
+       return -1;
       break;
 
-      /* sys_getitimer */
-    case 105:
-      regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_itimerval))
-        return -1;
-      break;
-
-      /* sys_newstat */
-    case 106:
-      /* sys_newlstat */
-    case 107:
-      /* sys_newfstat */
-    case 108:
-      /* sys_newfstatat */
-    case 540:
-      regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_stat))
-        return -1;
+    case gdb_sys_uname:
+      if (record_mem_at_reg (regcache, tdep->arg1,
+                            tdep->size_old_utsname))
+       return -1;
       break;
 
-      /* sys_uname */
-    case 109:
-      regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_old_utsname))
-        return -1;
+    case gdb_sys_iopl:
+    case gdb_sys_vhangup:
+    case gdb_sys_ni_syscall112:
+    case gdb_sys_vm86old:
       break;
 
-      /* sys_iopl */
-    case 110:
-      /* sys_vhangup */
-    case 111:
-      /* sys_ni_syscall */
-    case 112:
-      /* sys_vm86old */
-    case 113:
+    case gdb_sys_wait4:
+      if (record_mem_at_reg (regcache, tdep->arg2, tdep->size_int)
+         || record_mem_at_reg (regcache, tdep->arg4, tdep->size_rusage))
+       return -1;
       break;
 
-      /* sys_wait4 */
-    case 114:
-      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_unsigned (regcache, tdep->arg4, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_rusage))
-        return -1;
+    case gdb_sys_swapoff:
       break;
 
-      /* sys_swapoff */
-    case 115:
+    case gdb_sys_sysinfo:
+      if (record_mem_at_reg (regcache, tdep->arg1, tdep->size_sysinfo))
+       return -1;
       break;
 
-      /* sys_sysinfo */
-    case 116:
-      regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_sysinfo))
-        return -1;
-      break;
-
-      /* sys_shmget */
-    case 520:
-      /* sys_semget */
-    case 523:
-      /* sys_semop */
-    case 524:
-      /* sys_msgget */
-    case 528:
-      /* sys_shmdt */
+    case gdb_sys_shmget:
+    case gdb_sys_semget:
+    case gdb_sys_semop:
+    case gdb_sys_msgget:
       /* XXX maybe need do some record works with sys_shmdt.  */
-    case 527:
-      /* sys_msgsnd */
-    case 529:
-      /* sys_semtimedop */
-    case 532:
+    case gdb_sys_shmdt:
+    case gdb_sys_msgsnd:
+    case gdb_sys_semtimedop:
       break;
 
-      /* sys_shmat */
-    case 521:
-      regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_ulong))
-        return -1;
+    case gdb_sys_shmat:
+      if (record_mem_at_reg (regcache, tdep->arg3, tdep->size_ulong))
+       return -1;
       break;
 
-      /* sys_shmctl */
-    case 522:
-      regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_shmid_ds))
-        return -1;
+    case gdb_sys_shmctl:
+      if (record_mem_at_reg (regcache, tdep->arg3, tdep->size_shmid_ds))
+       return -1;
       break;
 
+      /* XXX sys_semctl 525 still not supported.  */
       /* sys_semctl */
-      /* XXX sys_semctl 525 still not support.  */
 
-      /* sys_msgrcv */
-    case 530:
+    case gdb_sys_msgrcv:
       {
-        ULONGEST msgp;
-        regcache_raw_read_signed (regcache, tdep->arg3, &tmpulongest);
-        regcache_raw_read_unsigned (regcache, tdep->arg2, &msgp);
-        tmpint = (int) tmpulongest + tdep->size_long;
-        if (record_arch_list_add_mem ((CORE_ADDR) msgp, tmpint))
-          return -1;
+       LONGEST l;
+
+       regcache_raw_read_signed (regcache, tdep->arg3, &l);
+       tmpint = l + tdep->size_long;
+       if (record_mem_at_reg (regcache, tdep->arg2, tmpint))
+         return -1;
       }
       break;
 
-      /* sys_msgctl */
-    case 531:
-      regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_msqid_ds))
-        return -1;
+    case gdb_sys_msgctl:
+      if (record_mem_at_reg (regcache, tdep->arg3, tdep->size_msqid_ds))
+       return -1;
       break;
 
-      /* sys_ipc */
-    case 117:
+    case gdb_sys_ipc:
       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
       tmpulongest &= 0xffff;
       switch (tmpulongest)
-        {
-        case RECORD_SEMOP:
-        case RECORD_SEMGET:
-        case RECORD_SEMTIMEDOP:
-        case RECORD_MSGSND:
-        case RECORD_MSGGET:
-          /* XXX maybe need do some record works with RECORD_SHMDT.  */
-        case RECORD_SHMDT:
-        case RECORD_SHMGET:
-          break;
-        case RECORD_MSGRCV:
-          {
-            ULONGEST second;
-            ULONGEST ptr;
-            regcache_raw_read_signed (regcache, tdep->arg3, &second);
-            regcache_raw_read_unsigned (regcache, tdep->arg5, &ptr);
-            tmpint = (int) second + tdep->size_long;
-            if (record_arch_list_add_mem ((CORE_ADDR) ptr, tmpint))
-              return -1;
-          }
-          break;
-        case RECORD_MSGCTL:
-          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_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_unsigned (regcache, tdep->arg5,
-                                      &tmpulongest);
-          if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                        tdep->size_shmid_ds))
-            return -1;
-          break;
-        default:
-          /* XXX RECORD_SEMCTL still not support.  */
-          printf_unfiltered (_("Process record and replay target doesn't "
-                               "support ipc number %d\n"), (int) tmpulongest);
-          break;
-        }
-      break;
-
-      /* sys_fsync */
-    case 118:
-      /* sys_sigreturn */
-    case 119:
-      /* sys_clone */
-    case 120:
-      /* sys_setdomainname */
-    case 121:
-      break;
-
-      /* sys_newuname */
-    case 122:
-      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:
+       {
+       case RECORD_SEMOP:
+       case RECORD_SEMGET:
+       case RECORD_SEMTIMEDOP:
+       case RECORD_MSGSND:
+       case RECORD_MSGGET:
+         /* XXX maybe need do some record works with RECORD_SHMDT.  */
+       case RECORD_SHMDT:
+       case RECORD_SHMGET:
+         break;
+       case RECORD_MSGRCV:
+         {
+           LONGEST second;
+
+           regcache_raw_read_signed (regcache, tdep->arg3, &second);
+           tmpint = (int) second + tdep->size_long;
+           if (record_mem_at_reg (regcache, tdep->arg5, tmpint))
+             return -1;
+         }
+         break;
+       case RECORD_MSGCTL:
+         if (record_mem_at_reg (regcache, tdep->arg5,
+                                tdep->size_msqid_ds))
+           return -1;
+         break;
+       case RECORD_SHMAT:
+         if (record_mem_at_reg (regcache, tdep->arg4, tdep->size_ulong))
+           return -1;
+         break;
+       case RECORD_SHMCTL:
+         if (record_mem_at_reg (regcache, tdep->arg5,
+                                tdep->size_shmid_ds))
+           return -1;
+         break;
+       default:
+         /* XXX RECORD_SEMCTL still not supported.  */
+         printf_unfiltered (_("Process record and replay target doesn't "
+                              "support ipc number %s\n"),
+                            pulongest (tmpulongest));
+         break;
+       }
+      break;
+
+    case gdb_sys_fsync:
+    case gdb_sys_sigreturn:
+    case gdb_sys_clone:
+    case gdb_sys_setdomainname:
+      break;
+
+    case gdb_sys_newuname:
+      if (record_mem_at_reg (regcache, tdep->arg1,
+                            tdep->size_new_utsname))
+       return -1;
+      break;
+
+    case gdb_sys_modify_ldt:
       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
       if (tmpulongest == 0 || tmpulongest == 2)
-        {
-          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;
-        }
+       {
+         ULONGEST bytecount;
+
+         regcache_raw_read_unsigned (regcache, tdep->arg3, &bytecount);
+         if (record_mem_at_reg (regcache, tdep->arg2, (int) bytecount))
+           return -1;
+       }
       break;
 
-      /* sys_adjtimex */
-    case 124:
-      regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_timex))
-        return -1;
+    case gdb_sys_adjtimex:
+      if (record_mem_at_reg (regcache, tdep->arg1, tdep->size_timex))
+       return -1;
       break;
 
-      /* sys_mprotect */
-    case 125:
+    case gdb_sys_mprotect:
       break;
 
-      /* sys_sigprocmask */
-    case 126:
-      regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_old_sigset_t))
-        return -1;
+    case gdb_sys_sigprocmask:
+      if (record_mem_at_reg (regcache, tdep->arg3,
+                            tdep->size_old_sigset_t))
+       return -1;
       break;
 
-      /* sys_ni_syscall */
-    case 127:
-      /* sys_init_module */
-    case 128:
-      /* sys_delete_module */
-    case 129:
-      /* sys_ni_syscall */
-    case 130:
+    case gdb_sys_ni_syscall127:
+    case gdb_sys_init_module:
+    case gdb_sys_delete_module:
+    case gdb_sys_ni_syscall130:
       break;
 
-      /* sys_quotactl */
-    case 131:
+    case gdb_sys_quotactl:
       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
       switch (tmpulongest)
-        {
-        case RECORD_Q_GETFMT:
-          regcache_raw_read_unsigned (regcache, tdep->arg4,
-                                      &tmpulongest);
-          /* __u32 */
-          if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 4))
-            return -1;
-          break;
-        case RECORD_Q_GETINFO:
-          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_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_unsigned (regcache, tdep->arg4,
-                                      &tmpulongest);
-          if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                        tdep->size_fs_quota_stat))
-            return -1;
-          break;
-        }
-      break;
-
-      /* sys_getpgid */
-    case 132:
-      /* sys_fchdir */
-    case 133:
-      /* sys_bdflush */
-    case 134:
-      break;
-
-      /* sys_sysfs */
-    case 135:
+       {
+       case RECORD_Q_GETFMT:
+         /* __u32 */
+         if (record_mem_at_reg (regcache, tdep->arg4, 4))
+           return -1;
+         break;
+       case RECORD_Q_GETINFO:
+         if (record_mem_at_reg (regcache, tdep->arg4,
+                                tdep->size_mem_dqinfo))
+           return -1;
+         break;
+       case RECORD_Q_GETQUOTA:
+         if (record_mem_at_reg (regcache, tdep->arg4,
+                                tdep->size_if_dqblk))
+           return -1;
+         break;
+       case RECORD_Q_XGETQSTAT:
+       case RECORD_Q_XGETQUOTA:
+         if (record_mem_at_reg (regcache, tdep->arg4,
+                                tdep->size_fs_quota_stat))
+           return -1;
+         break;
+       }
+      break;
+
+    case gdb_sys_getpgid:
+    case gdb_sys_fchdir:
+    case gdb_sys_bdflush:
+      break;
+
+    case gdb_sys_sysfs:
       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
       if (tmpulongest == 2)
-        {
-          regcache_raw_read_unsigned (regcache, tdep->arg3,
-                                      &tmpulongest);
-          /*XXX the size of memory is not very clear.  */
-          if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 10))
-            return -1;
-        }
-      break;
-
-      /* sys_personality */
-    case 136:
-      /* sys_ni_syscall */
-    case 137:
-      /* sys_setfsuid16 */
-    case 138:
-      /* sys_setfsgid16 */
-    case 139:
-      break;
-
-      /* sys_llseek */
-    case 140:
-      regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_loff_t))
-        return -1;
+       {
+         /*XXX the size of memory is not very clear.  */
+         if (record_mem_at_reg (regcache, tdep->arg3, 10))
+           return -1;
+       }
       break;
 
-      /* sys_getdents */
-    case 141:
-      {
-        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;
-      }
+    case gdb_sys_personality:
+    case gdb_sys_ni_syscall137:
+    case gdb_sys_setfsuid16:
+    case gdb_sys_setfsgid16:
       break;
 
-      /* sys_select */
-    case 142:
-      regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_fd_set))
-        return -1;
+    case gdb_sys_llseek:
+      if (record_mem_at_reg (regcache, tdep->arg4, tdep->size_loff_t))
+       return -1;
+      break;
+
+    case gdb_sys_getdents:
+    case gdb_sys_getdents64:
       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_unsigned (regcache, tdep->arg4, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_fd_set))
-        return -1;
-      regcache_raw_read_unsigned (regcache, tdep->arg5, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_timeval))
-        return -1;
+      if (record_mem_at_reg (regcache, tdep->arg2, tmpulongest))
+       return -1;
       break;
 
-      /* sys_flock */
-    case 143:
-      /* sys_msync */
-    case 144:
+    case gdb_sys_select:
+      if (record_mem_at_reg (regcache, tdep->arg2, tdep->size_fd_set)
+         || record_mem_at_reg (regcache, tdep->arg3, tdep->size_fd_set)
+         || record_mem_at_reg (regcache, tdep->arg4, tdep->size_fd_set)
+         || record_mem_at_reg (regcache, tdep->arg5, tdep->size_timeval))
+       return -1;
       break;
 
-      /* sys_readv */
-    case 145:
+    case gdb_sys_flock:
+    case gdb_sys_msync:
+      break;
+
+    case gdb_sys_readv:
       {
-        ULONGEST vec, vlen;
-
-        regcache_raw_read_unsigned (regcache, tdep->arg2, &vec);
-        if (vec)
-          {
-            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 ((CORE_ADDR) vec, iov,
-                                        tdep->size_iovec))
-                  {
-                    if (record_debug)
-                      fprintf_unfiltered (gdb_stdlog,
-                                          "Process record: error reading "
-                                          "memory at addr = 0x%s len = %d.\n",
-                                          OUTPUT_REG (vec, tdep->arg2),
-                                          tdep->size_iovec);
-                    return -1;
-                  }
-                tmpaddr
-                  = (CORE_ADDR) extract_unsigned_integer (iov,
-                                                          tdep->size_pointer,
-                                                          byte_order);
-                tmpint
-                  = (int) extract_unsigned_integer (iov + tdep->size_pointer,
-                                                    tdep->size_size_t,
-                                                    byte_order);
-                if (record_arch_list_add_mem (tmpaddr, tmpint))
-                  return -1;
-                vec += tdep->size_iovec;
-              }
-          }
+       ULONGEST vec, vlen;
+
+       regcache_raw_read_unsigned (regcache, tdep->arg2, &vec);
+       if (vec)
+         {
+           gdb_byte *iov = (gdb_byte *) alloca (tdep->size_iovec);
+
+           regcache_raw_read_unsigned (regcache, tdep->arg3, &vlen);
+           for (tmpulongest = 0; tmpulongest < vlen; tmpulongest++)
+             {
+               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 = %d.\n",
+                                         OUTPUT_REG (vec, tdep->arg2),
+                                         tdep->size_iovec);
+                   return -1;
+                 }
+               tmpaddr
+                 = (CORE_ADDR) extract_unsigned_integer (iov,
+                                                         tdep->size_pointer,
+                                                         byte_order);
+               tmpint
+                 = (int) extract_unsigned_integer (iov + tdep->size_pointer,
+                                                   tdep->size_size_t,
+                                                   byte_order);
+               if (record_full_arch_list_add_mem (tmpaddr, tmpint))
+                 return -1;
+               vec += tdep->size_iovec;
+             }
+         }
       }
       break;
 
-      /* sys_writev */
-    case 146:
-      /* sys_getsid */
-    case 147:
-      /* sys_fdatasync */
-    case 148:
-      /* sys_sysctl */
-    case 149:
-      /* sys_mlock */
-    case 150:
-      /* sys_munlock */
-    case 151:
-      /* sys_mlockall */
-    case 152:
-      /* sys_munlockall */
-    case 153:
-      /* sys_sched_setparam */
-    case 154:
-      break;
-
-      /* sys_sched_getparam */
-    case 155:
-      regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_int))
-        return -1;
-      break;
-
-      /* sys_sched_setscheduler */
-    case 156:
-      /* sys_sched_getscheduler */
-    case 157:
-      /* sys_sched_yield */
-    case 158:
-      /* sys_sched_get_priority_max */
-    case 159:
-      /* sys_sched_get_priority_min */
-    case 160:
-      break;
-
-      /* sys_sched_rr_get_interval */
-    case 161:
-      /* sys_nanosleep */
-    case 162:
-      regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_timespec))
-        return -1;
+    case gdb_sys_writev:
+    case gdb_sys_getsid:
+    case gdb_sys_fdatasync:
+    case gdb_sys_sysctl:
+    case gdb_sys_mlock:
+    case gdb_sys_munlock:
+    case gdb_sys_mlockall:
+    case gdb_sys_munlockall:
+    case gdb_sys_sched_setparam:
       break;
 
-      /* sys_mremap */
-    case 163:
-      /* sys_setresuid16 */
-    case 164:
+    case gdb_sys_sched_getparam:
+      if (record_mem_at_reg (regcache, tdep->arg2, tdep->size_int))
+       return -1;
       break;
 
-      /* sys_getresuid16 */
-    case 165:
-      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_unsigned (regcache, tdep->arg2, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_old_uid_t))
-        return -1;
-      regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_old_uid_t))
-        return -1;
+    case gdb_sys_sched_setscheduler:
+    case gdb_sys_sched_getscheduler:
+    case gdb_sys_sched_yield:
+    case gdb_sys_sched_get_priority_max:
+    case gdb_sys_sched_get_priority_min:
       break;
 
-      /* sys_vm86 */
-    case 166:
-      /* sys_ni_syscall */
-    case 167:
+    case gdb_sys_sched_rr_get_interval:
+    case gdb_sys_nanosleep:
+      if (record_mem_at_reg (regcache, tdep->arg2, tdep->size_timespec))
+       return -1;
       break;
 
-      /* sys_poll */
-    case 168:
+    case gdb_sys_mremap:
+    case gdb_sys_setresuid16:
+      break;
+
+    case gdb_sys_getresuid16:
+      if (record_mem_at_reg (regcache, tdep->arg1, tdep->size_old_uid_t)
+         || record_mem_at_reg (regcache, tdep->arg2,
+                               tdep->size_old_uid_t)
+         || record_mem_at_reg (regcache, tdep->arg3,
+                               tdep->size_old_uid_t))
+       return -1;
+      break;
+
+    case gdb_sys_vm86:
+    case gdb_sys_ni_syscall167:
+      break;
+
+    case gdb_sys_poll:
       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
       if (tmpulongest)
-        {
-          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;
-        }
+       {
+         ULONGEST nfds;
+
+         regcache_raw_read_unsigned (regcache, tdep->arg2, &nfds);
+         if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+                                            tdep->size_pollfd * nfds))
+           return -1;
+       }
       break;
 
-      /* sys_nfsservctl */
-    case 169:
+    case gdb_sys_nfsservctl:
       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
       if (tmpulongest == 7 || tmpulongest == 8)
-        {
-          int rsize;
-          if (tmpulongest == 7)
-            rsize = tdep->size_NFS_FHSIZE;
-          else
-            rsize = tdep->size_knfsd_fh;
-          regcache_raw_read_unsigned (regcache, tdep->arg3,
-                                      &tmpulongest);
-          if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, rsize))
-            return -1;
-        }
+       {
+         int rsize;
+
+         if (tmpulongest == 7)
+           rsize = tdep->size_NFS_FHSIZE;
+         else
+           rsize = tdep->size_knfsd_fh;
+         if (record_mem_at_reg (regcache, tdep->arg3, rsize))
+           return -1;
+       }
       break;
 
-      /* sys_setresgid16 */
-    case 170:
+    case gdb_sys_setresgid16:
       break;
 
-      /* sys_getresgid16 */
-    case 171:
-      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_unsigned (regcache, tdep->arg2, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_old_gid_t))
-        return -1;
-      regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_old_gid_t))
-        return -1;
+    case gdb_sys_getresgid16:
+      if (record_mem_at_reg (regcache, tdep->arg1, tdep->size_old_gid_t)
+         || record_mem_at_reg (regcache, tdep->arg2,
+                               tdep->size_old_gid_t)
+         || record_mem_at_reg (regcache, tdep->arg3,
+                               tdep->size_old_gid_t))
+       return -1;
       break;
 
-      /* sys_prctl */
-    case 172:
+    case gdb_sys_prctl:
       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
       switch (tmpulongest)
-        {
-        case 2:
-          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_unsigned (regcache, tdep->arg2,
-                                      &tmpulongest);
-          if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                        tdep->size_TASK_COMM_LEN))
-            return -1;
-          break;
-        }
-      break;
-
-      /* sys_rt_sigreturn */
-    case 173:
-      break;
-
-      /* sys_rt_sigaction */
-    case 174:
-      regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_sigaction))
-        return -1;
+       {
+       case 2:
+         if (record_mem_at_reg (regcache, tdep->arg2, tdep->size_int))
+           return -1;
+         break;
+       case 16:
+         if (record_mem_at_reg (regcache, tdep->arg2,
+                                tdep->size_TASK_COMM_LEN))
+           return -1;
+         break;
+       }
       break;
 
-      /* sys_rt_sigprocmask */
-    case 175:
-      regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_sigset_t))
-        return -1;
+    case gdb_sys_rt_sigreturn:
       break;
 
-      /* sys_rt_sigpending */
-    case 176:
+    case gdb_sys_rt_sigaction:
+      if (record_mem_at_reg (regcache, tdep->arg3, tdep->size_sigaction))
+       return -1;
+      break;
+
+    case gdb_sys_rt_sigprocmask:
+      if (record_mem_at_reg (regcache, tdep->arg3, tdep->size_sigset_t))
+       return -1;
+      break;
+
+    case gdb_sys_rt_sigpending:
       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
       if (tmpulongest)
-        {
-          ULONGEST sigsetsize;
-          regcache_raw_read_unsigned (regcache, tdep->arg2,&sigsetsize);
-          if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                        (int) sigsetsize))
-            return -1;
-        }
+       {
+         ULONGEST sigsetsize;
+
+         regcache_raw_read_unsigned (regcache, tdep->arg2,&sigsetsize);
+         if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+                                            (int) sigsetsize))
+           return -1;
+       }
       break;
 
-      /* sys_rt_sigtimedwait */
-    case 177:
-      regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_siginfo_t))
-        return -1;
+    case gdb_sys_rt_sigtimedwait:
+      if (record_mem_at_reg (regcache, tdep->arg2, tdep->size_siginfo_t))
+       return -1;
       break;
 
-      /* sys_rt_sigqueueinfo */
-    case 178:
-      /* sys_rt_sigsuspend */
-    case 179:
+    case gdb_sys_rt_sigqueueinfo:
+    case gdb_sys_rt_sigsuspend:
       break;
 
-      /* sys_pread64 */
-    case 180:
+    case gdb_sys_pread64:
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
       if (tmpulongest)
-        {
-          ULONGEST count;
-          regcache_raw_read_unsigned (regcache, tdep->arg3,&count);
-          if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, (int) count))
-            return -1;
-        }
+       {
+         ULONGEST count;
+
+         regcache_raw_read_unsigned (regcache, tdep->arg3,&count);
+         if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+                                            (int) count))
+           return -1;
+       }
       break;
 
-      /* sys_pwrite64 */
-    case 181:
-      /* sys_chown16 */
-    case 182:
+    case gdb_sys_pwrite64:
+    case gdb_sys_chown16:
       break;
 
-      /* sys_getcwd */
-    case 183:
+    case gdb_sys_getcwd:
       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
       if (tmpulongest)
-        {
-          ULONGEST size;
-          regcache_raw_read_unsigned (regcache, tdep->arg2, &size);
-          if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, (int) size))
-            return -1;
-        }
+       {
+         ULONGEST size;
+
+         regcache_raw_read_unsigned (regcache, tdep->arg2, &size);
+         if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+                                            (int) size))
+           return -1;
+       }
       break;
 
-      /* sys_capget */
-    case 184:
-      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;
+    case gdb_sys_capget:
+      if (record_mem_at_reg (regcache, tdep->arg2,
+                            tdep->size_cap_user_data_t))
+       return -1;
       break;
 
-      /* sys_capset */
-    case 185:
+    case gdb_sys_capset:
       break;
 
-      /* sys_sigaltstack */
-    case 186:
-      regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_stack_t))
-        return -1;
+    case gdb_sys_sigaltstack:
+      if (record_mem_at_reg (regcache, tdep->arg2, tdep->size_stack_t))
+       return -1;
       break;
 
-      /* sys_sendfile */
-    case 187:
-      regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_off_t))
-        return -1;
+    case gdb_sys_sendfile:
+      if (record_mem_at_reg (regcache, tdep->arg3, tdep->size_off_t))
+       return -1;
       break;
 
-      /* sys_ni_syscall */
-    case 188:
-      /* sys_ni_syscall */
-    case 189:
-      /* sys_vfork */
-    case 190:
+    case gdb_sys_ni_syscall188:
+    case gdb_sys_ni_syscall189:
+    case gdb_sys_vfork:
       break;
 
-      /* sys_getrlimit */
-    case 191:
-      regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_rlimit))
-        return -1;
+    case gdb_sys_getrlimit:
+      if (record_mem_at_reg (regcache, tdep->arg2, tdep->size_rlimit))
+       return -1;
       break;
 
-      /* sys_mmap2 */
-    case 192:
+    case gdb_sys_mmap2:
       break;
 
-      /* sys_truncate64 */
-    case 193:
-      /* sys_ftruncate64 */
-    case 194:
+    case gdb_sys_truncate64:
+    case gdb_sys_ftruncate64:
       break;
 
-      /* sys_stat64 */
-    case 195:
-      /* sys_lstat64 */
-    case 196:
-      /* sys_fstat64 */
-    case 197:
-      regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_stat64))
-        return -1;
-      break;
-
-      /* sys_lchown */
-    case 198:
-      /* sys_getuid */
-    case 199:
-      /* sys_getgid */
-    case 200:
-      /* sys_geteuid */
-    case 201:
-      /* sys_getegid */
-    case 202:
-      /* sys_setreuid */
-    case 203:
-      /* sys_setregid */
-    case 204:
-      break;
-
-      /* sys_getgroups */
-    case 205:
+    case gdb_sys_stat64:
+    case gdb_sys_lstat64:
+    case gdb_sys_fstat64:
+      if (record_mem_at_reg (regcache, tdep->arg2, tdep->size_stat64))
+       return -1;
+      break;
+
+    case gdb_sys_lchown:
+    case gdb_sys_getuid:
+    case gdb_sys_getgid:
+    case gdb_sys_geteuid:
+    case gdb_sys_getegid:
+    case gdb_sys_setreuid:
+    case gdb_sys_setregid:
+      break;
+
+    case gdb_sys_getgroups:
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
       if (tmpulongest)
-        {
-          ULONGEST gidsetsize;
-          regcache_raw_read_unsigned (regcache, tdep->arg1,
-                                      &gidsetsize);
-          tmpint = tdep->size_gid_t * (int) gidsetsize;
-          if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tmpint))
-            return -1;
-        }
-      break;
-
-      /* sys_setgroups */
-    case 206:
-      /* sys_fchown */
-    case 207:
-      /* sys_setresuid */
-    case 208:
-      break;
-
-      /* sys_getresuid */
-    case 209:
-      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_unsigned (regcache, tdep->arg2, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_uid_t))
-        return -1;
-      regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_uid_t))
-        return -1;
+       {
+         ULONGEST gidsetsize;
+
+         regcache_raw_read_unsigned (regcache, tdep->arg1,
+                                     &gidsetsize);
+         tmpint = tdep->size_gid_t * (int) gidsetsize;
+         if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest, tmpint))
+           return -1;
+       }
       break;
 
-      /* sys_setresgid */
-    case 210:
+    case gdb_sys_setgroups:
+    case gdb_sys_fchown:
+    case gdb_sys_setresuid:
       break;
 
-      /* sys_getresgid */
-    case 211:
-      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_unsigned (regcache, tdep->arg2, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_gid_t))
-        return -1;
-      regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_gid_t))
-        return -1;
-      break;
-
-      /* sys_chown */
-    case 212:
-      /* sys_setuid */
-    case 213:
-      /* sys_setgid */
-    case 214:
-      /* sys_setfsuid */
-    case 215:
-      /* sys_setfsgid */
-    case 216:
-      /* sys_pivot_root */
-    case 217:
-      break;
-
-      /* sys_mincore */
-    case 218:
-      regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_PAGE_SIZE))
-        return -1;
+    case gdb_sys_getresuid:
+      if (record_mem_at_reg (regcache, tdep->arg1, tdep->size_uid_t)
+         || record_mem_at_reg (regcache, tdep->arg2, tdep->size_uid_t)
+         || record_mem_at_reg (regcache, tdep->arg3, tdep->size_uid_t))
+       return -1;
       break;
 
-      /* sys_madvise */
-    case 219:
+    case gdb_sys_setresgid:
       break;
 
-      /* sys_getdents64 */
-    case 220:
-      {
-        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;
-      }
+    case gdb_sys_getresgid:
+      if (record_mem_at_reg (regcache, tdep->arg1, tdep->size_gid_t)
+         || record_mem_at_reg (regcache, tdep->arg2, tdep->size_gid_t)
+         || record_mem_at_reg (regcache, tdep->arg3, tdep->size_gid_t))
+       return -1;
+      break;
+
+    case gdb_sys_chown:
+    case gdb_sys_setuid:
+    case gdb_sys_setgid:
+    case gdb_sys_setfsuid:
+    case gdb_sys_setfsgid:
+    case gdb_sys_pivot_root:
+      break;
+
+    case gdb_sys_mincore:
+      if (record_mem_at_reg (regcache, tdep->arg3, tdep->size_PAGE_SIZE))
+       return -1;
+      break;
+
+    case gdb_sys_madvise:
       break;
 
-      /* sys_fcntl64 */
-    case 221:
+    case gdb_sys_fcntl64:
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
       if (tmpulongest == tdep->fcntl_F_GETLK64)
-        {
-          regcache_raw_read_unsigned (regcache, tdep->arg3,
-                                      &tmpulongest);
-          if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                        tdep->size_flock64))
-            return -1;
-        }
+       {
+         if (record_mem_at_reg (regcache, tdep->arg3,
+                                tdep->size_flock64))
+           return -1;
+       }
       else if (tmpulongest != tdep->fcntl_F_SETLK64
-               && tmpulongest != tdep->fcntl_F_SETLKW64)
-        {
-          goto sys_fcntl;
-        }
-      break;
-
-      /* sys_ni_syscall */
-    case 222:
-      /* sys_ni_syscall */
-    case 223:
-      /* sys_gettid */
-    case 224:
-      /* sys_readahead */
-    case 225:
-      /* sys_setxattr */
-    case 226:
-      /* sys_lsetxattr */
-    case 227:
-      /* sys_fsetxattr */
-    case 228:
-      break;
-
-      /* sys_getxattr */
-    case 229:
-      /* sys_lgetxattr */
-    case 230:
-      /* sys_fgetxattr */
-    case 231:
+              && tmpulongest != tdep->fcntl_F_SETLKW64)
+       {
+         goto sys_fcntl;
+       }
+      break;
+
+    case gdb_sys_ni_syscall222:
+    case gdb_sys_ni_syscall223:
+    case gdb_sys_gettid:
+    case gdb_sys_readahead:
+    case gdb_sys_setxattr:
+    case gdb_sys_lsetxattr:
+    case gdb_sys_fsetxattr:
+      break;
+
+    case gdb_sys_getxattr:
+    case gdb_sys_lgetxattr:
+    case gdb_sys_fgetxattr:
       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
       if (tmpulongest)
-        {
-          ULONGEST size;
-          regcache_raw_read_unsigned (regcache, tdep->arg4, &size);
-          if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, (int) size))
-            return -1;
-        }
-      break;
-
-      /* sys_listxattr */
-    case 232:
-      /* sys_llistxattr */
-    case 233:
-      /* sys_flistxattr */
-    case 234:
+       {
+         ULONGEST size;
+
+         regcache_raw_read_unsigned (regcache, tdep->arg4, &size);
+         if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+                                            (int) size))
+           return -1;
+       }
+      break;
+
+    case gdb_sys_listxattr:
+    case gdb_sys_llistxattr:
+    case gdb_sys_flistxattr:
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
       if (tmpulongest)
-        {
-          ULONGEST size;
-          regcache_raw_read_unsigned (regcache, tdep->arg3, &size);
-          if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, (int) size))
-            return -1;
-        }
-      break;
-
-      /* sys_removexattr */
-    case 235:
-      /* sys_lremovexattr */
-    case 236:
-      /* sys_fremovexattr */
-    case 237:
-      /* sys_tkill */
-    case 238:
-      break;
-
-      /* sys_sendfile64 */
-    case 239:
-      regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_loff_t))
-        return -1;
+       {
+         ULONGEST size;
+
+         regcache_raw_read_unsigned (regcache, tdep->arg3, &size);
+         if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+                                            (int) size))
+           return -1;
+       }
+      break;
+
+    case gdb_sys_removexattr:
+    case gdb_sys_lremovexattr:
+    case gdb_sys_fremovexattr:
+    case gdb_sys_tkill:
+      break;
+
+    case gdb_sys_sendfile64:
+      if (record_mem_at_reg (regcache, tdep->arg3, tdep->size_loff_t))
+       return -1;
       break;
 
-      /* sys_futex */
-    case 240:
-      /* sys_sched_setaffinity */
-    case 241:
+    case gdb_sys_futex:
+    case gdb_sys_sched_setaffinity:
       break;
 
-      /* sys_sched_getaffinity */
-    case 242:
+    case gdb_sys_sched_getaffinity:
       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
       if (tmpulongest)
-        {
-          ULONGEST len;
-          regcache_raw_read_unsigned (regcache, tdep->arg2, &len);
-          if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, (int) len))
-            return -1;
-        }
+       {
+         ULONGEST len;
+
+         regcache_raw_read_unsigned (regcache, tdep->arg2, &len);
+         if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+                                            (int) len))
+           return -1;
+       }
       break;
 
-      /* sys_set_thread_area */
-    case 243:
-      regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_int))
-        return -1;
+    case gdb_sys_set_thread_area:
+      if (record_mem_at_reg (regcache, tdep->arg1, tdep->size_int))
+       return -1;
       break;
 
-      /* sys_get_thread_area */
-    case 244:
-      regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_user_desc))
-        return -1;
+    case gdb_sys_get_thread_area:
+      if (record_mem_at_reg (regcache, tdep->arg1, tdep->size_user_desc))
+       return -1;
       break;
 
-      /* sys_io_setup */
-    case 245:
-      regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_long))
-        return -1;
+    case gdb_sys_io_setup:
+      if (record_mem_at_reg (regcache, tdep->arg2, tdep->size_long))
+       return -1;
       break;
 
-      /* sys_io_destroy */
-    case 246:
+    case gdb_sys_io_destroy:
       break;
 
-      /* sys_io_getevents */
-    case 247:
+    case gdb_sys_io_getevents:
       regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
       if (tmpulongest)
-        {
-          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;
-        }
+       {
+         ULONGEST nr;
+
+         regcache_raw_read_unsigned (regcache, tdep->arg3, &nr);
+         if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+                                            nr * tdep->size_io_event))
+           return -1;
+       }
       break;
 
-      /* sys_io_submit */
-    case 248:
+    case gdb_sys_io_submit:
       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
       if (tmpulongest)
-        {
-          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",
-                                    OUTPUT_REG (tmpulongest, tdep->arg2),
-                                    (int) (nr * tdep->size_pointer));
-              return -1;
-            }
-          for (i = 0; i < nr; i++)
-            {
-              tmpaddr
-                = (CORE_ADDR) extract_unsigned_integer (iocbp,
-                                                        tdep->size_pointer,
-                                                        byte_order);
-              if (record_arch_list_add_mem (tmpaddr, tdep->size_iocb))
-                return -1;
-              iocbp += tdep->size_pointer;
-            }
-        }
-      break;
-
-      /* sys_io_cancel */
-    case 249:
-      regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_io_event))
-        return -1;
-      break;
+       {
+         ULONGEST nr, i;
+         gdb_byte *iocbp;
+
+         regcache_raw_read_unsigned (regcache, tdep->arg2, &nr);
+         iocbp = (gdb_byte *) 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",
+                                   OUTPUT_REG (tmpulongest, tdep->arg2),
+                                   (int) (nr * tdep->size_pointer));
+             return -1;
+           }
+         for (i = 0; i < nr; i++)
+           {
+             tmpaddr
+               = (CORE_ADDR) extract_unsigned_integer (iocbp,
+                                                       tdep->size_pointer,
+                                                       byte_order);
+             if (record_full_arch_list_add_mem (tmpaddr, tdep->size_iocb))
+               return -1;
+             iocbp += tdep->size_pointer;
+           }
+       }
+      break;
+
+    case gdb_sys_io_cancel:
+      if (record_mem_at_reg (regcache, tdep->arg3, tdep->size_io_event))
+       return -1;
+      break;
+
+    case gdb_sys_fadvise64:
+    case gdb_sys_ni_syscall251:
+      break;
+
+    case gdb_sys_exit_group:
+      if (yquery (_("The next instruction is syscall exit_group.  "
+                   "It will make the program exit.  "
+                   "Do you want to stop the program?")))
+       return 1;
+      break;
+
+    case gdb_sys_lookup_dcookie:
+      regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
+      if (tmpulongest)
+       {
+         ULONGEST len;
 
-      /* sys_fadvise64 */
-    case 250:
-      /* sys_ni_syscall */
-    case 251:
+         regcache_raw_read_unsigned (regcache, tdep->arg3, &len);
+         if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+                                            (int) len))
+           return -1;
+       }
       break;
 
-      /* sys_exit_group */
-    case 252:
-      {
-        int q;
-        target_terminal_ours ();
-        q = yquery (_("The next instruction is syscall exit_group.  "
-                      "It will make the program exit.  "
-                      "Do you want to stop the program?"));
-        target_terminal_inferior ();
-        if (q)
-          return 1;
-      }
+    case gdb_sys_epoll_create:
+    case gdb_sys_epoll_ctl:
       break;
 
-      /* sys_lookup_dcookie */
-    case 253:
+    case gdb_sys_epoll_wait:
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
       if (tmpulongest)
-        {
-          ULONGEST len;
-          regcache_raw_read_unsigned (regcache, tdep->arg3, &len);
-          if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, (int) len))
-            return -1;
-        }
+       {
+         ULONGEST maxevents;
+
+         regcache_raw_read_unsigned (regcache, tdep->arg3, &maxevents);
+         if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+                                            (maxevents
+                                             * tdep->size_epoll_event)))
+           return -1;
+       }
       break;
 
-      /* sys_epoll_create */
-    case 254:
-      /* sys_epoll_ctl */
-    case 255:
+    case gdb_sys_remap_file_pages:
+    case gdb_sys_set_tid_address:
       break;
 
-      /* sys_epoll_wait */
-    case 256:
-      regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
-      if (tmpulongest)
-        {
-          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;
-        }
+    case gdb_sys_timer_create:
+      if (record_mem_at_reg (regcache, tdep->arg3, tdep->size_int))
+       return -1;
       break;
 
-      /* sys_remap_file_pages */
-    case 257:
-      /* sys_set_tid_address */
-    case 258:
+    case gdb_sys_timer_settime:
+      if (record_mem_at_reg (regcache, tdep->arg4, tdep->size_itimerspec))
+       return -1;
       break;
 
-      /* sys_timer_create */
-    case 259:
-      regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_int))
-        return -1;
+    case gdb_sys_timer_gettime:
+      if (record_mem_at_reg (regcache, tdep->arg2, tdep->size_itimerspec))
+       return -1;
       break;
 
-      /* sys_timer_settime */
-    case 260:
-      regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_itimerspec))
-        return -1;
+    case gdb_sys_timer_getoverrun:
+    case gdb_sys_timer_delete:
+    case gdb_sys_clock_settime:
       break;
 
-      /* sys_timer_gettime */
-    case 261:
-      regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_itimerspec))
-        return -1;
+    case gdb_sys_clock_gettime:
+      if (record_mem_at_reg (regcache, tdep->arg2, tdep->size_timespec))
+       return -1;
       break;
 
-      /* sys_timer_getoverrun */
-    case 262:
-      /* sys_timer_delete */
-    case 263:
-      /* sys_clock_settime */
-    case 264:
+    case gdb_sys_clock_getres:
+      if (record_mem_at_reg (regcache, tdep->arg2, tdep->size_timespec))
+       return -1;
       break;
 
-      /* sys_clock_gettime */
-    case 265:
-      regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_timespec))
-        return -1;
+    case gdb_sys_clock_nanosleep:
+      if (record_mem_at_reg (regcache, tdep->arg4, tdep->size_timespec))
+       return -1;
       break;
 
-      /* sys_clock_getres */
-    case 266:
-      regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_timespec))
-        return -1;
+    case gdb_sys_statfs64:
+    case gdb_sys_fstatfs64:
+      if (record_mem_at_reg (regcache, tdep->arg3, tdep->size_statfs64))
+       return -1;
       break;
 
-      /* sys_clock_nanosleep */
-    case 267:
-      regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_timespec))
-        return -1;
+    case gdb_sys_tgkill:
+    case gdb_sys_utimes:
+    case gdb_sys_fadvise64_64:
+    case gdb_sys_ni_syscall273:
+    case gdb_sys_mbind:
       break;
 
-      /* sys_statfs64 */
-    case 268:
-      /* sys_fstatfs64 */
-    case 269:
-      regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_statfs64))
-        return -1;
+    case gdb_sys_get_mempolicy:
+      if (record_mem_at_reg (regcache, tdep->arg1, tdep->size_int))
+       return -1;
+      regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
+      if (tmpulongest)
+       {
+         ULONGEST maxnode;
+
+         regcache_raw_read_unsigned (regcache, tdep->arg3, &maxnode);
+         if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+                                            maxnode * tdep->size_long))
+           return -1;
+       }
       break;
 
-      /* sys_tgkill */
-    case 270:
-      /* sys_utimes */
-    case 271:
-      /* sys_fadvise64_64 */
-    case 272:
-      /* sys_ni_syscall */
-    case 273:
-      /* sys_mbind */
-    case 274:
+    case gdb_sys_set_mempolicy:
+    case gdb_sys_mq_open:
+    case gdb_sys_mq_unlink:
+    case gdb_sys_mq_timedsend:
       break;
 
-      /* sys_get_mempolicy */
-    case 275:
-      regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_int))
-        return -1;
+    case gdb_sys_mq_timedreceive:
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
       if (tmpulongest)
-        {
-          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;
-
-      /* sys_set_mempolicy */
-    case 276:
-      /* sys_mq_open */
-    case 277:
-      /* sys_mq_unlink */
-    case 278:
-      /* sys_mq_timedsend */
-    case 279:
-      break;
-
-      /* sys_mq_timedreceive */
-    case 280:
-      regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
-      if (tmpulongest)
-        {
-          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_unsigned (regcache, tdep->arg4, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_int))
-        return -1;
+       {
+         ULONGEST msg_len;
+
+         regcache_raw_read_unsigned (regcache, tdep->arg3, &msg_len);
+         if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+                                            (int) msg_len))
+           return -1;
+       }
+      if (record_mem_at_reg (regcache, tdep->arg4, tdep->size_int))
+       return -1;
       break;
 
-      /* sys_mq_notify */
-    case 281:
+    case gdb_sys_mq_notify:
       break;
 
-      /* sys_mq_getsetattr */
-    case 282:
-      regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_mq_attr))
-        return -1;
+    case gdb_sys_mq_getsetattr:
+      if (record_mem_at_reg (regcache, tdep->arg3, tdep->size_mq_attr))
+       return -1;
       break;
 
-      /* sys_kexec_load */
-    case 283:
+    case gdb_sys_kexec_load:
       break;
 
-      /* sys_waitid */
-    case 284:
-      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_unsigned (regcache, tdep->arg5, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_rusage))
-        return -1;
+    case gdb_sys_waitid:
+      if (record_mem_at_reg (regcache, tdep->arg3, tdep->size_siginfo_t)
+         || record_mem_at_reg (regcache, tdep->arg5, tdep->size_rusage))
+       return -1;
       break;
 
-      /* sys_ni_syscall */
-    case 285:
-      /* sys_add_key */
-    case 286:
-      /* sys_request_key */
-    case 287:
+    case gdb_sys_ni_syscall285:
+    case gdb_sys_add_key:
+    case gdb_sys_request_key:
       break;
 
-      /* sys_keyctl */
-    case 288:
+    case gdb_sys_keyctl:
       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
       if (tmpulongest == 6 || tmpulongest == 11)
-        {
-          regcache_raw_read_unsigned (regcache, tdep->arg3,
-                                      &tmpulongest);
-          if (tmpulongest)
-            {
-              ULONGEST buflen;
-              regcache_raw_read_unsigned (regcache, tdep->arg4, &buflen);
-              if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                            (int) buflen))
-                return -1;
-            }
-        }
-      break;
-
-      /* sys_ioprio_set */
-    case 289:
-      /* sys_ioprio_get */
-    case 290:
-      /* sys_inotify_init */
-    case 291:
-      /* sys_inotify_add_watch */
-    case 292:
-      /* sys_inotify_rm_watch */
-    case 293:
-      /* sys_migrate_pages */
-    case 294:
-      /* sys_openat */
-    case 295:
-      /* sys_mkdirat */
-    case 296:
-      /* sys_mknodat */
-    case 297:
-      /* sys_fchownat */
-    case 298:
-      /* sys_futimesat */
-    case 299:
-      break;
-
-      /* sys_fstatat64 */
-    case 300:
+       {
+         regcache_raw_read_unsigned (regcache, tdep->arg3,
+                                     &tmpulongest);
+         if (tmpulongest)
+           {
+             ULONGEST buflen;
+
+             regcache_raw_read_unsigned (regcache, tdep->arg4, &buflen);
+             if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+                                                (int) buflen))
+               return -1;
+           }
+       }
+      break;
+
+    case gdb_sys_ioprio_set:
+    case gdb_sys_ioprio_get:
+    case gdb_sys_inotify_init:
+    case gdb_sys_inotify_add_watch:
+    case gdb_sys_inotify_rm_watch:
+    case gdb_sys_migrate_pages:
+    case gdb_sys_openat:
+    case gdb_sys_mkdirat:
+    case gdb_sys_mknodat:
+    case gdb_sys_fchownat:
+    case gdb_sys_futimesat:
+      break;
+
+    case gdb_sys_fstatat64:
+      if (record_mem_at_reg (regcache, tdep->arg3, tdep->size_stat64))
+       return -1;
+      break;
+
+    case gdb_sys_unlinkat:
+    case gdb_sys_renameat:
+    case gdb_sys_linkat:
+    case gdb_sys_symlinkat:
+      break;
+
+    case gdb_sys_readlinkat:
       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_stat64))
-        return -1;
-      break;
+      if (tmpulongest)
+       {
+         ULONGEST bufsiz;
 
-      /* sys_unlinkat */
-    case 301:
-      /* sys_renameat */
-    case 302:
-      /* sys_linkat */
-    case 303:
-      /* sys_symlinkat */
-    case 304:
+         regcache_raw_read_unsigned (regcache, tdep->arg4, &bufsiz);
+         if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+                                            (int) bufsiz))
+           return -1;
+       }
       break;
 
-      /* sys_readlinkat */
-    case 305:
-      regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
-      if (tmpulongest)
-        {
-          ULONGEST bufsiz;
-          regcache_raw_read_unsigned (regcache, tdep->arg4, &bufsiz);
-          if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, (int) bufsiz))
-            return -1;
-        }
+    case gdb_sys_fchmodat:
+    case gdb_sys_faccessat:
       break;
 
-      /* sys_fchmodat */
-    case 306:
-      /* sys_faccessat */
-    case 307:
+    case gdb_sys_pselect6:
+      if (record_mem_at_reg (regcache, tdep->arg2, tdep->size_fd_set)
+         || record_mem_at_reg (regcache, tdep->arg3, tdep->size_fd_set)
+         || record_mem_at_reg (regcache, tdep->arg4, tdep->size_fd_set)
+         || record_mem_at_reg (regcache, tdep->arg5, tdep->size_timespec))
+       return -1;
       break;
 
-      /* sys_pselect6 */
-    case 308:
-      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_unsigned (regcache, tdep->arg3, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_fd_set))
-        return -1;
-      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_unsigned (regcache, tdep->arg5, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_timespec))
-        return -1;
-      break;
-
-      /* sys_ppoll */
-    case 309:
+    case gdb_sys_ppoll:
       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
       if (tmpulongest)
-        {
-          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_unsigned (regcache, tdep->arg3, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_timespec))
-        return -1;
+       {
+         ULONGEST nfds;
+
+         regcache_raw_read_unsigned (regcache, tdep->arg2, &nfds);
+         if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+                                            tdep->size_pollfd * nfds))
+           return -1;
+       }
+      if (record_mem_at_reg (regcache, tdep->arg3, tdep->size_timespec))
+       return -1;
       break;
 
-      /* sys_unshare */
-    case 310:
-      /* sys_set_robust_list */
-    case 311:
+    case gdb_sys_unshare:
+    case gdb_sys_set_robust_list:
       break;
 
-      /* sys_get_robust_list */
-    case 312:
-      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_unsigned (regcache, tdep->arg3, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_int))
-        return -1;
+    case gdb_sys_get_robust_list:
+      if (record_mem_at_reg (regcache, tdep->arg2, tdep->size_int)
+         || record_mem_at_reg (regcache, tdep->arg3, tdep->size_int))
+       return -1;
       break;
 
-      /* sys_splice */
-    case 313:
-      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_unsigned (regcache, tdep->arg4, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_loff_t))
-        return -1;
+    case gdb_sys_splice:
+      if (record_mem_at_reg (regcache, tdep->arg2, tdep->size_loff_t)
+         || record_mem_at_reg (regcache, tdep->arg4, tdep->size_loff_t))
+       return -1;
       break;
 
-      /* sys_sync_file_range */
-    case 314:
-      /* sys_tee */
-    case 315:
-      /* sys_vmsplice */
-    case 316:
+    case gdb_sys_sync_file_range:
+    case gdb_sys_tee:
+    case gdb_sys_vmsplice:
       break;
 
-      /* sys_move_pages */
-    case 317:
+    case gdb_sys_move_pages:
       regcache_raw_read_unsigned (regcache, tdep->arg5, &tmpulongest);
       if (tmpulongest)
-        {
-          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;
-        }
+       {
+         ULONGEST nr_pages;
+
+         regcache_raw_read_unsigned (regcache, tdep->arg2, &nr_pages);
+         if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+                                            nr_pages * tdep->size_int))
+           return -1;
+       }
       break;
 
-      /* sys_getcpu */
-    case 318:
-      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_unsigned (regcache, tdep->arg2, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_int))
-        return -1;
-      regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_ulong * 2))
-        return -1;
+    case gdb_sys_getcpu:
+      if (record_mem_at_reg (regcache, tdep->arg1, tdep->size_int)
+         || record_mem_at_reg (regcache, tdep->arg2, tdep->size_int)
+         || record_mem_at_reg (regcache, tdep->arg3,
+                               tdep->size_ulong * 2))
+       return -1;
       break;
 
-      /* sys_epoll_pwait */
-    case 319:
+    case gdb_sys_epoll_pwait:
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
       if (tmpulongest)
-        {
-          ULONGEST maxevents;
-          regcache_raw_read_unsigned (regcache, tdep->arg3, &maxevents);
-          tmpint = (int) maxevents * tdep->size_epoll_event;
-          if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tmpint))
-            return -1;
-        }
+       {
+         ULONGEST maxevents;
+
+         regcache_raw_read_unsigned (regcache, tdep->arg3, &maxevents);
+         tmpint = (int) maxevents * tdep->size_epoll_event;
+         if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest, tmpint))
+           return -1;
+       }
+      break;
+
+    case gdb_sys_fallocate:
+    case gdb_sys_eventfd2:
+    case gdb_sys_epoll_create1:
+    case gdb_sys_dup3:
+      break;
+
+    case gdb_sys_inotify_init1:
       break;
 
     default:
       printf_unfiltered (_("Process record and replay target doesn't "
-                           "support syscall number %u\n"), num);
+                          "support syscall number %d\n"), syscall);
       return -1;
       break;
     }
This page took 0.067128 seconds and 4 git commands to generate.