gdb/linux-record.c

   1 /* Process record and replay target code for GNU/Linux.
   2
   3    Copyright (C) 2008, 2009, 2010 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include "defs.h"
  21 #include "target.h"
  22 #include "gdbtypes.h"
  23 #include "regcache.h"
  24 #include "record.h"
  25 #include "linux-record.h"
  26
  27 /* These macros are the values of the first argument of system call
  28    "sys_ptrace".  The values of these macros were obtained from Linux
  29    Kernel source.  */
  30
  31 #define RECORD_PTRACE_PEEKTEXT  1
  32 #define RECORD_PTRACE_PEEKDATA  2
  33 #define RECORD_PTRACE_PEEKUSR   3
  34
  35 /* These macros are the values of the first argument of system call
  36    "sys_socketcall".  The values of these macros were obtained from
  37    Linux Kernel source.  */
  38
  39 #define RECORD_SYS_SOCKET       1
  40 #define RECORD_SYS_BIND         2
  41 #define RECORD_SYS_CONNECT      3
  42 #define RECORD_SYS_LISTEN       4
  43 #define RECORD_SYS_ACCEPT       5
  44 #define RECORD_SYS_GETSOCKNAME  6
  45 #define RECORD_SYS_GETPEERNAME  7
  46 #define RECORD_SYS_SOCKETPAIR   8
  47 #define RECORD_SYS_SEND         9
  48 #define RECORD_SYS_RECV         10
  49 #define RECORD_SYS_SENDTO       11
  50 #define RECORD_SYS_RECVFROM     12
  51 #define RECORD_SYS_SHUTDOWN     13
  52 #define RECORD_SYS_SETSOCKOPT   14
  53 #define RECORD_SYS_GETSOCKOPT   15
  54 #define RECORD_SYS_SENDMSG      16
  55 #define RECORD_SYS_RECVMSG      17
  56
  57 /* These macros are the values of the first argument of system call
  58    "sys_ipc".  The values of these macros were obtained from Linux
  59    Kernel source.  */
  60
  61 #define RECORD_SEMOP            1
  62 #define RECORD_SEMGET           2
  63 #define RECORD_SEMCTL           3
  64 #define RECORD_SEMTIMEDOP       4
  65 #define RECORD_MSGSND           11
  66 #define RECORD_MSGRCV           12
  67 #define RECORD_MSGGET           13
  68 #define RECORD_MSGCTL           14
  69 #define RECORD_SHMAT            21
  70 #define RECORD_SHMDT            22
  71 #define RECORD_SHMGET           23
  72 #define RECORD_SHMCTL           24
  73
  74 /* These macros are the values of the first argument of system call
  75    "sys_quotactl".  The values of these macros were obtained from Linux
  76    Kernel source.  */
  77
  78 #define RECORD_Q_GETFMT         0x800004
  79 #define RECORD_Q_GETINFO        0x800005
  80 #define RECORD_Q_GETQUOTA       0x800007
  81 #define RECORD_Q_XGETQSTAT      (('5' << 8) + 5)
  82 #define RECORD_Q_XGETQUOTA      (('3' << 8) + 3)
  83
  84 #define OUTPUT_REG(val, num)      phex_nz ((val), \
  85     TYPE_LENGTH (gdbarch_register_type (get_regcache_arch (regcache), (num))))
  86
  87 static int
  88 record_linux_sockaddr (struct regcache *regcache,
  89                        struct linux_record_tdep *tdep, ULONGEST addr,
  90                        ULONGEST len)
  91 {
  92   gdb_byte *a;
  93   int addrlen;
  94   struct gdbarch *gdbarch = get_regcache_arch (regcache);
  95   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
  96
  97   if (!addr)
  98     return 0;
  99
 100   a = alloca (tdep->size_int);
 101
 102   if (record_arch_list_add_mem ((CORE_ADDR) len, tdep->size_int))
 103     return -1;
 104
 105   /* Get the addrlen.  */
 106   if (target_read_memory ((CORE_ADDR) len, a, tdep->size_int))
 107     {
 108       if (record_debug)
 109         fprintf_unfiltered (gdb_stdlog,
 110                             "Process record: error reading "
 111                             "memory at addr = 0x%s len = %d.\n",
 112                             phex_nz (len, tdep->size_pointer),
 113                             tdep->size_int);
 114         return -1;
 115     }
 116   addrlen = (int) extract_unsigned_integer (a, tdep->size_int, byte_order);
 117   if (addrlen <= 0 || addrlen > tdep->size_sockaddr)
 118     addrlen = tdep->size_sockaddr;
 119
 120   if (record_arch_list_add_mem ((CORE_ADDR) addr, addrlen))
 121     return -1;
 122
 123   return 0;
 124 }
 125
 126 static int
 127 record_linux_msghdr (struct regcache *regcache,
 128                      struct linux_record_tdep *tdep, ULONGEST addr)
 129 {
 130   gdb_byte *a;
 131   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 132   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 133   CORE_ADDR tmpaddr;
 134   int tmpint;
 135
 136   if (!addr)
 137     return 0;
 138
 139   if (record_arch_list_add_mem ((CORE_ADDR) addr, tdep->size_msghdr))
 140     return -1;
 141
 142   a = alloca (tdep->size_msghdr);
 143   if (target_read_memory ((CORE_ADDR) addr, a, tdep->size_msghdr))
 144     {
 145       if (record_debug)
 146         fprintf_unfiltered (gdb_stdlog,
 147                             "Process record: error reading "
 148                             "memory at addr = 0x%s "
 149                             "len = %d.\n",
 150                             phex_nz (addr, tdep->size_pointer),
 151                             tdep->size_msghdr);
 152         return -1;
 153     }
 154
 155   /* msg_name msg_namelen */
 156   addr = extract_unsigned_integer (a, tdep->size_pointer, byte_order);
 157   a += tdep->size_pointer;
 158   if (record_arch_list_add_mem ((CORE_ADDR) addr,
 159                                 (int) extract_unsigned_integer (a,
 160                                                                 tdep->size_int,
 161                                                                 byte_order)))
 162     return -1;
 163   a += tdep->size_int;
 164
 165   /* msg_iov msg_iovlen */
 166   addr = extract_unsigned_integer (a, tdep->size_pointer, byte_order);
 167   a += tdep->size_pointer;
 168   if (addr)
 169     {
 170       ULONGEST i;
 171       ULONGEST len = extract_unsigned_integer (a, tdep->size_size_t,
 172                                                byte_order);
 173       gdb_byte *iov = alloca (tdep->size_iovec);
 174
 175       for (i = 0; i < len; i++)
 176         {
 177           if (target_read_memory ((CORE_ADDR) addr, iov, tdep->size_iovec))
 178             {
 179               if (record_debug)
 180                 fprintf_unfiltered (gdb_stdlog,
 181                                     "Process record: error "
 182                                     "reading memory at "
 183                                     "addr = 0x%s "
 184                                     "len = %d.\n",
 185                                     phex_nz (addr,tdep->size_pointer),
 186                                     tdep->size_iovec);
 187                 return -1;
 188             }
 189           tmpaddr = (CORE_ADDR) extract_unsigned_integer (iov,
 190                                                           tdep->size_pointer,
 191                                                           byte_order);
 192           tmpint = (int) extract_unsigned_integer (iov + tdep->size_pointer,
 193                                                    tdep->size_size_t,
 194                                                    byte_order);
 195           if (record_arch_list_add_mem (tmpaddr, tmpint))
 196             return -1;
 197           addr += tdep->size_iovec;
 198         }
 199     }
 200   a += tdep->size_size_t;
 201
 202   /* msg_control msg_controllen */
 203   addr = extract_unsigned_integer (a, tdep->size_pointer, byte_order);
 204   a += tdep->size_pointer;
 205   tmpint = (int) extract_unsigned_integer (a, tdep->size_size_t, byte_order);
 206   if (record_arch_list_add_mem ((CORE_ADDR) addr, tmpint))
 207     return -1;
 208
 209   return 0;
 210 }
 211
 212 /* When the architecture process record get a Linux syscall
 213    instruction, it will get a Linux syscall number of this
 214    architecture and convert it to the Linux syscall number "num" which
 215    is internal to GDB.  Most Linux syscalls across architectures in
 216    Linux would be similar and mostly differ by sizes of types and
 217    structures.  This sizes are put to "tdep".
 218
 219    Record the values of the registers and memory that will be changed
 220    in current system call.
 221
 222    Return -1 if something wrong.  */
 223
 224 int
 225 record_linux_system_call (enum gdb_syscall syscall,
 226                           struct regcache *regcache,
 227                           struct linux_record_tdep *tdep)
 228 {
 229   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 230   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 231   ULONGEST tmpulongest;
 232   CORE_ADDR tmpaddr;
 233   int tmpint;
 234
 235   switch (syscall)
 236     {
 237     case gdb_sys_restart_syscall:
 238       break;
 239
 240     case gdb_sys_exit:
 241       {
 242         int q;
 243         target_terminal_ours ();
 244         q = yquery (_("The next instruction is syscall exit.  "
 245                       "It will make the program exit.  "
 246                       "Do you want to stop the program?"));
 247         target_terminal_inferior ();
 248         if (q)
 249           return 1;
 250       }
 251       break;
 252
 253     case gdb_sys_fork:
 254       break;
 255
 256     case gdb_sys_read:
 257       {
 258         ULONGEST addr, count;
 259         regcache_raw_read_unsigned (regcache, tdep->arg2, &addr);
 260         regcache_raw_read_unsigned (regcache, tdep->arg3, &count);
 261         if (record_arch_list_add_mem ((CORE_ADDR) addr, (int) count))
 262           return -1;
 263       }
 264       break;
 265
 266     case gdb_sys_write:
 267     case gdb_sys_open:
 268     case gdb_sys_close:
 269     case gdb_sys_waitpid:
 270     case gdb_sys_creat:
 271     case gdb_sys_link:
 272     case gdb_sys_unlink:
 273     case gdb_sys_execve:
 274     case gdb_sys_chdir:
 275     case gdb_sys_time:
 276     case gdb_sys_mknod:
 277     case gdb_sys_chmod:
 278     case gdb_sys_lchown16:
 279     case gdb_sys_ni_syscall17:
 280       break;
 281
 282     case gdb_sys_stat:
 283     case gdb_sys_fstat:
 284     case gdb_sys_lstat:
 285       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
 286       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 287                                     tdep->size__old_kernel_stat))
 288         return -1;
 289       break;
 290
 291     case gdb_sys_lseek:
 292     case gdb_sys_getpid:
 293     case gdb_sys_mount:
 294     case gdb_sys_oldumount:
 295     case gdb_sys_setuid16:
 296     case gdb_sys_getuid16:
 297     case gdb_sys_stime:
 298       break;
 299
 300     case gdb_sys_ptrace:
 301       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
 302       if (tmpulongest == RECORD_PTRACE_PEEKTEXT
 303           || tmpulongest == RECORD_PTRACE_PEEKDATA
 304           || tmpulongest == RECORD_PTRACE_PEEKUSR)
 305         {
 306           regcache_raw_read_unsigned (regcache, tdep->arg4,
 307                                       &tmpulongest);
 308           if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 4))
 309             return -1;
 310         }
 311       break;
 312
 313     case gdb_sys_alarm:
 314     case gdb_sys_pause:
 315     case gdb_sys_utime:
 316     case gdb_sys_ni_syscall31:
 317     case gdb_sys_ni_syscall32:
 318     case gdb_sys_access:
 319     case gdb_sys_nice:
 320     case gdb_sys_ni_syscall35:
 321     case gdb_sys_sync:
 322     case gdb_sys_kill:
 323     case gdb_sys_rename:
 324     case gdb_sys_mkdir:
 325     case gdb_sys_rmdir:
 326     case gdb_sys_dup:
 327     case gdb_sys_pipe:
 328       break;
 329
 330     case gdb_sys_times:
 331       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
 332       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_tms))
 333         return -1;
 334       break;
 335
 336     case gdb_sys_ni_syscall44:
 337     case gdb_sys_brk:
 338     case gdb_sys_setgid16:
 339     case gdb_sys_getgid16:
 340     case gdb_sys_signal:
 341     case gdb_sys_geteuid16:
 342     case gdb_sys_getegid16:
 343     case gdb_sys_acct:
 344     case gdb_sys_umount:
 345     case gdb_sys_ni_syscall53:
 346       break;
 347
 348     case gdb_sys_ioctl:
 349       /* XXX Need to add a lot of support of other ioctl requests.  */
 350       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
 351       if (tmpulongest == tdep->ioctl_FIOCLEX
 352           || tmpulongest == tdep->ioctl_FIONCLEX
 353           || tmpulongest == tdep->ioctl_FIONBIO
 354           || tmpulongest == tdep->ioctl_FIOASYNC
 355           || tmpulongest == tdep->ioctl_TCSETS
 356           || tmpulongest == tdep->ioctl_TCSETSW
 357           || tmpulongest == tdep->ioctl_TCSETSF
 358           || tmpulongest == tdep->ioctl_TCSETA
 359           || tmpulongest == tdep->ioctl_TCSETAW
 360           || tmpulongest == tdep->ioctl_TCSETAF
 361           || tmpulongest == tdep->ioctl_TCSBRK
 362           || tmpulongest == tdep->ioctl_TCXONC
 363           || tmpulongest == tdep->ioctl_TCFLSH
 364           || tmpulongest == tdep->ioctl_TIOCEXCL
 365           || tmpulongest == tdep->ioctl_TIOCNXCL
 366           || tmpulongest == tdep->ioctl_TIOCSCTTY
 367           || tmpulongest == tdep->ioctl_TIOCSPGRP
 368           || tmpulongest == tdep->ioctl_TIOCSTI
 369           || tmpulongest == tdep->ioctl_TIOCSWINSZ
 370           || tmpulongest == tdep->ioctl_TIOCMBIS
 371           || tmpulongest == tdep->ioctl_TIOCMBIC
 372           || tmpulongest == tdep->ioctl_TIOCMSET
 373           || tmpulongest == tdep->ioctl_TIOCSSOFTCAR
 374           || tmpulongest == tdep->ioctl_TIOCCONS
 375           || tmpulongest == tdep->ioctl_TIOCSSERIAL
 376           || tmpulongest == tdep->ioctl_TIOCPKT
 377           || tmpulongest == tdep->ioctl_TIOCNOTTY
 378           || tmpulongest == tdep->ioctl_TIOCSETD
 379           || tmpulongest == tdep->ioctl_TCSBRKP
 380           || tmpulongest == tdep->ioctl_TIOCTTYGSTRUCT
 381           || tmpulongest == tdep->ioctl_TIOCSBRK
 382           || tmpulongest == tdep->ioctl_TIOCCBRK
 383           || tmpulongest == tdep->ioctl_TCSETS2
 384           || tmpulongest == tdep->ioctl_TCSETSW2
 385           || tmpulongest == tdep->ioctl_TCSETSF2
 386           || tmpulongest == tdep->ioctl_TIOCSPTLCK
 387           || tmpulongest == tdep->ioctl_TIOCSERCONFIG
 388           || tmpulongest == tdep->ioctl_TIOCSERGWILD
 389           || tmpulongest == tdep->ioctl_TIOCSERSWILD
 390           || tmpulongest == tdep->ioctl_TIOCSLCKTRMIOS
 391           || tmpulongest == tdep->ioctl_TIOCSERGETMULTI
 392           || tmpulongest == tdep->ioctl_TIOCSERSETMULTI
 393           || tmpulongest == tdep->ioctl_TIOCMIWAIT
 394           || tmpulongest == tdep->ioctl_TIOCSHAYESESP)
 395         {
 396           /* Nothing to do.  */
 397         }
 398       else if (tmpulongest == tdep->ioctl_TCGETS
 399                || tmpulongest == tdep->ioctl_TCGETA
 400                || tmpulongest == tdep->ioctl_TIOCGLCKTRMIOS)
 401         {
 402           regcache_raw_read_unsigned (regcache, tdep->arg3,
 403                                       &tmpulongest);
 404           if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 405                                         tdep->size_termios))
 406             return -1;
 407         }
 408       else if (tmpulongest == tdep->ioctl_TIOCGPGRP
 409                || tmpulongest == tdep->ioctl_TIOCGSID)
 410         {
 411           regcache_raw_read_unsigned (regcache, tdep->arg3,
 412                                       &tmpulongest);
 413           if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 414                                         tdep->size_pid_t))
 415             return -1;
 416         }
 417       else if (tmpulongest == tdep->ioctl_TIOCOUTQ
 418                || tmpulongest == tdep->ioctl_TIOCMGET
 419                || tmpulongest == tdep->ioctl_TIOCGSOFTCAR
 420                || tmpulongest == tdep->ioctl_FIONREAD
 421                || tmpulongest == tdep->ioctl_TIOCINQ
 422                || tmpulongest == tdep->ioctl_TIOCGETD
 423                || tmpulongest == tdep->ioctl_TIOCGPTN
 424                || tmpulongest == tdep->ioctl_TIOCSERGETLSR)
 425         {
 426           regcache_raw_read_unsigned (regcache, tdep->arg3,
 427                                       &tmpulongest);
 428           if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 429                                         tdep->size_int))
 430             return -1;
 431         }
 432       else if (tmpulongest == tdep->ioctl_TIOCGWINSZ)
 433         {
 434           regcache_raw_read_unsigned (regcache, tdep->arg3,
 435                                       &tmpulongest);
 436           if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 437                                         tdep->size_winsize))
 438             return -1;
 439         }
 440       else if (tmpulongest == tdep->ioctl_TIOCLINUX)
 441         {
 442           regcache_raw_read_unsigned (regcache, tdep->arg3,
 443                                       &tmpulongest);
 444           /* This syscall affects a char-size memory.  */
 445           if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 1))
 446             return -1;
 447         }
 448       else if (tmpulongest == tdep->ioctl_TIOCGSERIAL)
 449         {
 450           regcache_raw_read_unsigned (regcache, tdep->arg3,
 451                                       &tmpulongest);
 452           if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 453                                         tdep->size_serial_struct))
 454             return -1;
 455         }
 456       else if (tmpulongest == tdep->ioctl_TCGETS2)
 457         {
 458           regcache_raw_read_unsigned (regcache, tdep->arg3,
 459                                       &tmpulongest);
 460           if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 461                                         tdep->size_termios2))
 462             return -1;
 463         }
 464       else if (tmpulongest == tdep->ioctl_FIOQSIZE)
 465         {
 466           regcache_raw_read_unsigned (regcache, tdep->arg3,
 467                                       &tmpulongest);
 468           if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 469                                         tdep->size_loff_t))
 470             return -1;
 471         }
 472       else if (tmpulongest == tdep->ioctl_TIOCGICOUNT)
 473         {
 474           regcache_raw_read_unsigned (regcache, tdep->arg3,
 475                                       &tmpulongest);
 476           if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 477                                         tdep->size_serial_icounter_struct))
 478             return -1;
 479         }
 480       else if (tmpulongest == tdep->ioctl_TIOCGHAYESESP)
 481         {
 482           regcache_raw_read_unsigned (regcache, tdep->arg3,
 483                                       &tmpulongest);
 484           if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 485                                         tdep->size_hayes_esp_config))
 486             return -1;
 487         }
 488       else if (tmpulongest == tdep->ioctl_TIOCSERGSTRUCT)
 489         {
 490           printf_unfiltered (_("Process record and replay target doesn't "
 491                                "support ioctl request TIOCSERGSTRUCT\n"));
 492           return 1;
 493         }
 494       else
 495         {
 496           printf_unfiltered (_("Process record and replay target doesn't "
 497                                "support ioctl request 0x%s.\n"),
 498                              OUTPUT_REG (tmpulongest, tdep->arg2));
 499           return 1;
 500         }
 501       break;
 502
 503     case gdb_sys_fcntl:
 504       /* XXX */
 505       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
 506     sys_fcntl:
 507       if (tmpulongest == tdep->fcntl_F_GETLK)
 508         {
 509           regcache_raw_read_unsigned (regcache, tdep->arg3,
 510                                       &tmpulongest);
 511           if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 512                                         tdep->size_flock))
 513             return -1;
 514         }
 515       break;
 516
 517     case gdb_sys_ni_syscall56:
 518     case gdb_sys_setpgid:
 519     case gdb_sys_ni_syscall58:
 520       break;
 521
 522     case gdb_sys_olduname:
 523       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
 524       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 525                                     tdep->size_oldold_utsname))
 526         return -1;
 527       break;
 528
 529     case gdb_sys_umask:
 530     case gdb_sys_chroot:
 531       break;
 532
 533     case gdb_sys_ustat:
 534       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
 535       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 536                                     tdep->size_ustat))
 537         return -1;
 538       break;
 539
 540     case gdb_sys_dup2:
 541     case gdb_sys_getppid:
 542     case gdb_sys_getpgrp:
 543     case gdb_sys_setsid:
 544       break;
 545
 546     case gdb_sys_sigaction:
 547       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
 548       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 549                                     tdep->size_old_sigaction))
 550         return -1;
 551       break;
 552
 553     case gdb_sys_sgetmask:
 554     case gdb_sys_ssetmask:
 555     case gdb_sys_setreuid16:
 556     case gdb_sys_setregid16:
 557     case gdb_sys_sigsuspend:
 558       break;
 559
 560     case gdb_sys_sigpending:
 561       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
 562       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 563                                     tdep->size_old_sigset_t))
 564         return -1;
 565       break;
 566
 567     case gdb_sys_sethostname:
 568     case gdb_sys_setrlimit:
 569       break;
 570
 571     case gdb_sys_old_getrlimit:
 572       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
 573       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 574                                     tdep->size_rlimit))
 575         return -1;
 576       break;
 577
 578     case gdb_sys_getrusage:
 579       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
 580       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 581                                     tdep->size_rusage))
 582         return -1;
 583       break;
 584
 585     case gdb_sys_gettimeofday:
 586       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
 587       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 588                                     tdep->size_timeval))
 589         return -1;
 590       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
 591       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 592                                     tdep->size_timezone))
 593         return -1;
 594       break;
 595
 596     case gdb_sys_settimeofday:
 597       break;
 598
 599     case gdb_sys_getgroups16:
 600       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
 601       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 602                                     tdep->size_old_gid_t))
 603         return -1;
 604       break;
 605
 606     case gdb_sys_setgroups16:
 607       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
 608       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 609                                     tdep->size_old_gid_t))
 610         return -1;
 611       break;
 612
 613     case gdb_old_select:
 614       {
 615         struct sel_arg_struct
 616         {
 617           CORE_ADDR n;
 618           CORE_ADDR inp;
 619           CORE_ADDR outp;
 620           CORE_ADDR exp;
 621           CORE_ADDR tvp;
 622         } sel;
 623
 624         regcache_raw_read_unsigned (regcache, tdep->arg1,
 625                                     &tmpulongest);
 626         if (tmpulongest)
 627           {
 628             if (target_read_memory (tmpulongest, (gdb_byte *) &sel,
 629                                     sizeof(sel)))
 630               {
 631                 if (record_debug)
 632                   fprintf_unfiltered (gdb_stdlog,
 633                                       "Process record: error reading memory "
 634                                       "at addr = 0x%s len = %lu.\n",
 635                                       OUTPUT_REG (tmpulongest, tdep->arg1),
 636                                       (unsigned long) sizeof (sel));
 637                 return -1;
 638               }
 639             if (record_arch_list_add_mem (sel.inp, tdep->size_fd_set))
 640               return -1;
 641             if (record_arch_list_add_mem (sel.outp, tdep->size_fd_set))
 642               return -1;
 643             if (record_arch_list_add_mem (sel.exp, tdep->size_fd_set))
 644               return -1;
 645             if (record_arch_list_add_mem (sel.tvp, tdep->size_timeval))
 646               return -1;
 647           }
 648       }
 649       break;
 650
 651     case gdb_sys_symlink:
 652       break;
 653
 654     case gdb_sys_readlink:
 655       {
 656         ULONGEST len;
 657         regcache_raw_read_unsigned (regcache, tdep->arg2,
 658                                     &tmpulongest);
 659         regcache_raw_read_unsigned (regcache, tdep->arg3, &len);
 660         if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, (int) len))
 661           return -1;
 662       }
 663       break;
 664
 665     case gdb_sys_uselib:
 666     case gdb_sys_swapon:
 667       break;
 668
 669     case gdb_sys_reboot:
 670       {
 671         int q;
 672         target_terminal_ours ();
 673         q =
 674           yquery (_("The next instruction is syscall reboot.  "
 675                     "It will restart the computer.  "
 676                     "Do you want to stop the program?"));
 677         target_terminal_inferior ();
 678         if (q)
 679           return 1;
 680       }
 681       break;
 682
 683     case gdb_old_readdir:
 684       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
 685       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 686                                     tdep->size_dirent))
 687         return -1;
 688       break;
 689
 690     case gdb_old_mmap:
 691       break;
 692
 693     case gdb_sys_munmap:
 694       {
 695         int q;
 696         ULONGEST len;
 697
 698         regcache_raw_read_unsigned (regcache, tdep->arg1,
 699                                     &tmpulongest);
 700         regcache_raw_read_unsigned (regcache, tdep->arg2, &len);
 701         target_terminal_ours ();
 702         q = yquery (_("The next instruction is syscall munmap.  "
 703                       "It will free the memory addr = 0x%s len = %u.  "
 704                       "It will make record target get error.  "
 705                       "Do you want to stop the program?"),
 706                     OUTPUT_REG (tmpulongest, tdep->arg1), (int) len);
 707         target_terminal_inferior ();
 708         if (q)
 709           return 1;
 710       }
 711       break;
 712
 713     case gdb_sys_truncate:
 714     case gdb_sys_ftruncate:
 715     case gdb_sys_fchmod:
 716     case gdb_sys_fchown16:
 717     case gdb_sys_getpriority:
 718     case gdb_sys_setpriority:
 719     case gdb_sys_ni_syscall98:
 720       break;
 721
 722     case gdb_sys_statfs:
 723     case gdb_sys_fstatfs:
 724       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
 725       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 726                                     tdep->size_statfs))
 727         return -1;
 728       break;
 729
 730     case gdb_sys_ioperm:
 731       break;
 732
 733     case gdb_sys_socket:
 734     case gdb_sys_sendto:
 735     case gdb_sys_sendmsg:
 736     case gdb_sys_shutdown:
 737     case gdb_sys_bind:
 738     case gdb_sys_connect:
 739     case gdb_sys_listen:
 740     case gdb_sys_setsockopt:
 741       break;
 742
 743     case gdb_sys_accept:
 744     case gdb_sys_getsockname:
 745     case gdb_sys_getpeername:
 746       {
 747         ULONGEST len;
 748         regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
 749         regcache_raw_read_unsigned (regcache, tdep->arg3, &len);
 750         if (record_linux_sockaddr (regcache, tdep, tmpulongest, len))
 751           return -1;
 752       }
 753       break;
 754
 755     case gdb_sys_recvfrom:
 756       {
 757         ULONGEST len;
 758         regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
 759         regcache_raw_read_unsigned (regcache, tdep->arg5, &len);
 760         if (record_linux_sockaddr (regcache, tdep, tmpulongest, len))
 761           return -1;
 762       }
 763     case gdb_sys_recv:
 764       {
 765         ULONGEST size;
 766         regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
 767         regcache_raw_read_unsigned (regcache, tdep->arg3, &size);
 768         if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, (int) size))
 769           return -1;
 770       }
 771       break;
 772
 773     case gdb_sys_recvmsg:
 774       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
 775       if (record_linux_msghdr (regcache, tdep, tmpulongest))
 776         return -1;
 777       break;
 778
 779     case gdb_sys_socketpair:
 780       regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
 781       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_int))
 782         return -1;
 783       break;
 784
 785     case gdb_sys_getsockopt:
 786       regcache_raw_read_unsigned (regcache, tdep->arg5, &tmpulongest);
 787       if (tmpulongest)
 788         {
 789           ULONGEST optvalp;
 790           gdb_byte *optlenp = alloca (tdep->size_int);
 791           if (target_read_memory ((CORE_ADDR) tmpulongest, optlenp,
 792                                   tdep->size_int))
 793             {
 794               if (record_debug)
 795                 fprintf_unfiltered (gdb_stdlog,
 796                                     "Process record: error reading "
 797                                     "memory at addr = 0x%s "
 798                                     "len = %d.\n",
 799                                     OUTPUT_REG (tmpulongest, tdep->arg5),
 800                                     tdep->size_int);
 801               return -1;
 802             }
 803           regcache_raw_read_unsigned (regcache, tdep->arg4, &optvalp);
 804           tmpint = (int) extract_signed_integer (optlenp, tdep->size_int,
 805                                                  byte_order);
 806           if (record_arch_list_add_mem ((CORE_ADDR) optvalp, tmpint))
 807             return -1;
 808           if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 809                                         tdep->size_int))
 810             return -1;
 811         }
 812       break;
 813
 814     case gdb_sys_socketcall:
 815       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
 816       switch (tmpulongest)
 817         {
 818         case RECORD_SYS_SOCKET:
 819         case RECORD_SYS_BIND:
 820         case RECORD_SYS_CONNECT:
 821         case RECORD_SYS_LISTEN:
 822           break;
 823         case RECORD_SYS_ACCEPT:
 824         case RECORD_SYS_GETSOCKNAME:
 825         case RECORD_SYS_GETPEERNAME:
 826           {
 827             regcache_raw_read_unsigned (regcache, tdep->arg2,
 828                                         &tmpulongest);
 829             if (tmpulongest)
 830               {
 831                 gdb_byte *a = alloca (tdep->size_ulong * 2);
 832                 ULONGEST len;
 833
 834                 tmpulongest += tdep->size_ulong;
 835                 if (target_read_memory ((CORE_ADDR) tmpulongest, a,
 836                                         tdep->size_ulong * 2))
 837                   {
 838                     if (record_debug)
 839                       fprintf_unfiltered (gdb_stdlog,
 840                                           "Process record: error reading "
 841                                           "memory at addr = 0x%s len = %d.\n",
 842                                           OUTPUT_REG (tmpulongest, tdep->arg2),
 843                                           tdep->size_ulong * 2);
 844                     return -1;
 845                   }
 846                 tmpulongest = extract_unsigned_integer (a,
 847                                                         tdep->size_ulong,
 848                                                         byte_order);
 849                 len = extract_unsigned_integer (a + tdep->size_ulong,
 850                                                 tdep->size_ulong, byte_order);
 851                 if (record_linux_sockaddr (regcache, tdep, tmpulongest, len))
 852                   return -1;
 853               }
 854           }
 855           break;
 856
 857         case RECORD_SYS_SOCKETPAIR:
 858           {
 859             gdb_byte *a = alloca (tdep->size_ulong);
 860             regcache_raw_read_unsigned (regcache, tdep->arg2,
 861                                         &tmpulongest);
 862             if (tmpulongest)
 863               {
 864                 tmpulongest += tdep->size_ulong * 3;
 865                 if (target_read_memory ((CORE_ADDR) tmpulongest, a,
 866                                         tdep->size_ulong))
 867                   {
 868                     if (record_debug)
 869                       fprintf_unfiltered (gdb_stdlog,
 870                                           "Process record: error reading "
 871                                           "memory at addr = 0x%s len = %d.\n",
 872                                           OUTPUT_REG (tmpulongest, tdep->arg2),
 873                                           tdep->size_ulong);
 874                     return -1;
 875                   }
 876                 tmpaddr
 877                   = (CORE_ADDR) extract_unsigned_integer (a, tdep->size_ulong,
 878                                                           byte_order);
 879                 if (record_arch_list_add_mem (tmpaddr, tdep->size_int))
 880                   return -1;
 881               }
 882           }
 883           break;
 884         case RECORD_SYS_SEND:
 885         case RECORD_SYS_SENDTO:
 886           break;
 887         case RECORD_SYS_RECVFROM:
 888           regcache_raw_read_unsigned (regcache, tdep->arg2,
 889                                       &tmpulongest);
 890           if (tmpulongest)
 891             {
 892               gdb_byte *a = alloca (tdep->size_ulong * 2);
 893               ULONGEST len;
 894
 895               tmpulongest += tdep->size_ulong * 4;
 896               if (target_read_memory ((CORE_ADDR) tmpulongest, a,
 897                                       tdep->size_ulong * 2))
 898                 {
 899                   if (record_debug)
 900                     fprintf_unfiltered (gdb_stdlog,
 901                                         "Process record: error reading "
 902                                         "memory at addr = 0x%s len = %d.\n",
 903                                         OUTPUT_REG (tmpulongest, tdep->arg2),
 904                                         tdep->size_ulong * 2);
 905                   return -1;
 906                 }
 907               tmpulongest = extract_unsigned_integer (a, tdep->size_ulong,
 908                                                       byte_order);
 909               len = extract_unsigned_integer (a + tdep->size_ulong,
 910                                               tdep->size_ulong, byte_order);
 911               if (record_linux_sockaddr (regcache, tdep, tmpulongest, len))
 912                 return -1;
 913             }
 914         case RECORD_SYS_RECV:
 915           regcache_raw_read_unsigned (regcache, tdep->arg2,
 916                                       &tmpulongest);
 917           if (tmpulongest)
 918             {
 919               gdb_byte *a = alloca (tdep->size_ulong * 2);
 920
 921               tmpulongest += tdep->size_ulong;
 922               if (target_read_memory ((CORE_ADDR) tmpulongest, a,
 923                                       tdep->size_ulong))
 924                 {
 925                   if (record_debug)
 926                     fprintf_unfiltered (gdb_stdlog,
 927                                         "Process record: error reading "
 928                                         "memory at addr = 0x%s len = %d.\n",
 929                                         OUTPUT_REG (tmpulongest, tdep->arg2),
 930                                         tdep->size_ulong);
 931                     return -1;
 932                 }
 933               tmpulongest = extract_unsigned_integer (a, tdep->size_ulong,
 934                                                       byte_order);
 935               if (tmpulongest)
 936                 {
 937                   a += tdep->size_ulong;
 938                   tmpint = (int) extract_unsigned_integer (a, tdep->size_ulong,
 939                                                            byte_order);
 940                   if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 941                                                 tmpint))
 942                     return -1;
 943                 }
 944             }
 945           break;
 946         case RECORD_SYS_SHUTDOWN:
 947         case RECORD_SYS_SETSOCKOPT:
 948           break;
 949         case RECORD_SYS_GETSOCKOPT:
 950           {
 951             gdb_byte *a = alloca (tdep->size_ulong * 2);
 952             gdb_byte *av = alloca (tdep->size_int);
 953
 954             regcache_raw_read_unsigned (regcache, tdep->arg2,
 955                                         &tmpulongest);
 956             if (tmpulongest)
 957               {
 958                 tmpulongest += tdep->size_ulong * 3;
 959                 if (target_read_memory ((CORE_ADDR) tmpulongest, a,
 960                                         tdep->size_ulong * 2))
 961                   {
 962                     if (record_debug)
 963                       fprintf_unfiltered (gdb_stdlog,
 964                                           "Process record: error reading "
 965                                           "memory at addr = 0x%s len = %d.\n",
 966                                           OUTPUT_REG (tmpulongest, tdep->arg2),
 967                                           tdep->size_ulong * 2);
 968                     return -1;
 969                   }
 970                 tmpulongest = extract_unsigned_integer (a + tdep->size_ulong,
 971                                                         tdep->size_ulong,
 972                                                         byte_order);
 973                 if (tmpulongest)
 974                   {
 975                     if (target_read_memory ((CORE_ADDR) tmpulongest, av,
 976                                             tdep->size_int))
 977                       {
 978                         if (record_debug)
 979                           fprintf_unfiltered (gdb_stdlog,
 980                                               "Process record: error reading "
 981                                               "memory at addr = 0x%s "
 982                                               "len = %d.\n",
 983                                               phex_nz (tmpulongest,
 984                                                        tdep->size_ulong),
 985                                               tdep->size_int);
 986                         return -1;
 987                       }
 988                     tmpaddr
 989                       = (CORE_ADDR) extract_unsigned_integer (a,
 990                                                               tdep->size_ulong,
 991                                                               byte_order);
 992                     tmpint = (int) extract_unsigned_integer (av,
 993                                                              tdep->size_int,
 994                                                              byte_order);
 995                     if (record_arch_list_add_mem (tmpaddr, tmpint))
 996                       return -1;
 997                     a += tdep->size_ulong;
 998                     tmpaddr
 999                       = (CORE_ADDR) extract_unsigned_integer (a,
1000                                                               tdep->size_ulong,
1001                                                               byte_order);
1002                     if (record_arch_list_add_mem (tmpaddr, tdep->size_int))
1003                       return -1;
1004                   }
1005               }
1006           }
1007           break;
1008         case RECORD_SYS_SENDMSG:
1009           break;
1010         case RECORD_SYS_RECVMSG:
1011           {
1012             gdb_byte *a = alloca (tdep->size_ulong);
1013
1014             regcache_raw_read_unsigned (regcache, tdep->arg2,
1015                                         &tmpulongest);
1016             if (tmpulongest)
1017               {
1018                 tmpulongest += tdep->size_ulong;
1019                 if (target_read_memory ((CORE_ADDR) tmpulongest, a,
1020                                         tdep->size_ulong))
1021                   {
1022                     if (record_debug)
1023                       fprintf_unfiltered (gdb_stdlog,
1024                                           "Process record: error reading "
1025                                           "memory at addr = 0x%s len = %d.\n",
1026                                           OUTPUT_REG (tmpulongest, tdep->arg2),
1027                                           tdep->size_ulong);
1028                     return -1;
1029                   }
1030                 tmpulongest = extract_unsigned_integer (a, tdep->size_ulong,
1031                                                         byte_order);
1032                 if (record_linux_msghdr (regcache, tdep, tmpulongest))
1033                   return -1;
1034               }
1035           }
1036           break;
1037         default:
1038           printf_unfiltered (_("Process record and replay target "
1039                                "doesn't support socketcall call 0x%s\n"),
1040                              OUTPUT_REG (tmpulongest, tdep->arg1));
1041           return -1;
1042           break;
1043         }
1044       break;
1045
1046     case gdb_sys_syslog:
1047       break;
1048
1049     case gdb_sys_setitimer:
1050       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1051       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1052                                     tdep->size_itimerval))
1053         return -1;
1054       break;
1055
1056     case gdb_sys_getitimer:
1057       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1058       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1059                                     tdep->size_itimerval))
1060         return -1;
1061       break;
1062
1063     case gdb_sys_newstat:
1064     case gdb_sys_newlstat:
1065     case gdb_sys_newfstat:
1066     case gdb_sys_newfstatat:
1067       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1068       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_stat))
1069         return -1;
1070       break;
1071
1072     case gdb_sys_uname:
1073       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1074       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1075                                     tdep->size_old_utsname))
1076         return -1;
1077       break;
1078
1079     case gdb_sys_iopl:
1080     case gdb_sys_vhangup:
1081     case gdb_sys_ni_syscall112:
1082     case gdb_sys_vm86old:
1083       break;
1084
1085     case gdb_sys_wait4:
1086       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1087       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1088                                     tdep->size_int))
1089         return -1;
1090       regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
1091       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1092                                     tdep->size_rusage))
1093         return -1;
1094       break;
1095
1096     case gdb_sys_swapoff:
1097       break;
1098
1099     case gdb_sys_sysinfo:
1100       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1101       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1102                                     tdep->size_sysinfo))
1103         return -1;
1104       break;
1105
1106     case gdb_sys_shmget:
1107     case gdb_sys_semget:
1108     case gdb_sys_semop:
1109     case gdb_sys_msgget:
1110       /* XXX maybe need do some record works with sys_shmdt.  */
1111     case gdb_sys_shmdt:
1112     case gdb_sys_msgsnd:
1113     case gdb_sys_semtimedop:
1114       break;
1115
1116     case gdb_sys_shmat:
1117       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1118       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1119                                     tdep->size_ulong))
1120         return -1;
1121       break;
1122
1123     case gdb_sys_shmctl:
1124       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1125       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1126                                     tdep->size_shmid_ds))
1127         return -1;
1128       break;
1129
1130       /* XXX sys_semctl 525 still not supported.  */
1131       /* sys_semctl */
1132
1133     case gdb_sys_msgrcv:
1134       {
1135         ULONGEST msgp;
1136         regcache_raw_read_signed (regcache, tdep->arg3, &tmpulongest);
1137         regcache_raw_read_unsigned (regcache, tdep->arg2, &msgp);
1138         tmpint = (int) tmpulongest + tdep->size_long;
1139         if (record_arch_list_add_mem ((CORE_ADDR) msgp, tmpint))
1140           return -1;
1141       }
1142       break;
1143
1144     case gdb_sys_msgctl:
1145       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1146       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1147                                     tdep->size_msqid_ds))
1148         return -1;
1149       break;
1150
1151     case gdb_sys_ipc:
1152       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1153       tmpulongest &= 0xffff;
1154       switch (tmpulongest)
1155         {
1156         case RECORD_SEMOP:
1157         case RECORD_SEMGET:
1158         case RECORD_SEMTIMEDOP:
1159         case RECORD_MSGSND:
1160         case RECORD_MSGGET:
1161           /* XXX maybe need do some record works with RECORD_SHMDT.  */
1162         case RECORD_SHMDT:
1163         case RECORD_SHMGET:
1164           break;
1165         case RECORD_MSGRCV:
1166           {
1167             ULONGEST second;
1168             ULONGEST ptr;
1169             regcache_raw_read_signed (regcache, tdep->arg3, &second);
1170             regcache_raw_read_unsigned (regcache, tdep->arg5, &ptr);
1171             tmpint = (int) second + tdep->size_long;
1172             if (record_arch_list_add_mem ((CORE_ADDR) ptr, tmpint))
1173               return -1;
1174           }
1175           break;
1176         case RECORD_MSGCTL:
1177           regcache_raw_read_unsigned (regcache, tdep->arg5,
1178                                       &tmpulongest);
1179           if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1180                                         tdep->size_msqid_ds))
1181             return -1;
1182           break;
1183         case RECORD_SHMAT:
1184           regcache_raw_read_unsigned (regcache, tdep->arg4,
1185                                       &tmpulongest);
1186           if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1187                                         tdep->size_ulong))
1188             return -1;
1189           break;
1190         case RECORD_SHMCTL:
1191           regcache_raw_read_unsigned (regcache, tdep->arg5,
1192                                       &tmpulongest);
1193           if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1194                                         tdep->size_shmid_ds))
1195             return -1;
1196           break;
1197         default:
1198           /* XXX RECORD_SEMCTL still not supported.  */
1199           printf_unfiltered (_("Process record and replay target doesn't "
1200                                "support ipc number %s\n"),
1201                              pulongest (tmpulongest));
1202           break;
1203         }
1204       break;
1205
1206     case gdb_sys_fsync:
1207     case gdb_sys_sigreturn:
1208     case gdb_sys_clone:
1209     case gdb_sys_setdomainname:
1210       break;
1211
1212     case gdb_sys_newuname:
1213       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1214       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1215                                     tdep->size_new_utsname))
1216         return -1;
1217       break;
1218
1219     case gdb_sys_modify_ldt:
1220       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1221       if (tmpulongest == 0 || tmpulongest == 2)
1222         {
1223           ULONGEST ptr, bytecount;
1224           regcache_raw_read_unsigned (regcache, tdep->arg2, &ptr);
1225           regcache_raw_read_unsigned (regcache, tdep->arg3, &bytecount);
1226           if (record_arch_list_add_mem ((CORE_ADDR) ptr, (int) bytecount))
1227             return -1;
1228         }
1229       break;
1230
1231     case gdb_sys_adjtimex:
1232       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1233       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_timex))
1234         return -1;
1235       break;
1236
1237     case gdb_sys_mprotect:
1238       break;
1239
1240     case gdb_sys_sigprocmask:
1241       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1242       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1243                                     tdep->size_old_sigset_t))
1244         return -1;
1245       break;
1246
1247     case gdb_sys_ni_syscall127:
1248     case gdb_sys_init_module:
1249     case gdb_sys_delete_module:
1250     case gdb_sys_ni_syscall130:
1251       break;
1252
1253     case gdb_sys_quotactl:
1254       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1255       switch (tmpulongest)
1256         {
1257         case RECORD_Q_GETFMT:
1258           regcache_raw_read_unsigned (regcache, tdep->arg4,
1259                                       &tmpulongest);
1260           /* __u32 */
1261           if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 4))
1262             return -1;
1263           break;
1264         case RECORD_Q_GETINFO:
1265           regcache_raw_read_unsigned (regcache, tdep->arg4,
1266                                       &tmpulongest);
1267           if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1268                                         tdep->size_mem_dqinfo))
1269             return -1;
1270           break;
1271         case RECORD_Q_GETQUOTA:
1272           regcache_raw_read_unsigned (regcache, tdep->arg4,
1273                                       &tmpulongest);
1274           if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1275                                         tdep->size_if_dqblk))
1276             return -1;
1277           break;
1278         case RECORD_Q_XGETQSTAT:
1279         case RECORD_Q_XGETQUOTA:
1280           regcache_raw_read_unsigned (regcache, tdep->arg4,
1281                                       &tmpulongest);
1282           if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1283                                         tdep->size_fs_quota_stat))
1284             return -1;
1285           break;
1286         }
1287       break;
1288
1289     case gdb_sys_getpgid:
1290     case gdb_sys_fchdir:
1291     case gdb_sys_bdflush:
1292       break;
1293
1294     case gdb_sys_sysfs:
1295       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1296       if (tmpulongest == 2)
1297         {
1298           regcache_raw_read_unsigned (regcache, tdep->arg3,
1299                                       &tmpulongest);
1300           /*XXX the size of memory is not very clear.  */
1301           if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 10))
1302             return -1;
1303         }
1304       break;
1305
1306     case gdb_sys_personality:
1307     case gdb_sys_ni_syscall137:
1308     case gdb_sys_setfsuid16:
1309     case gdb_sys_setfsgid16:
1310       break;
1311
1312     case gdb_sys_llseek:
1313       regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
1314       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1315                                     tdep->size_loff_t))
1316         return -1;
1317       break;
1318
1319     case gdb_sys_getdents:
1320       {
1321         ULONGEST count;
1322         regcache_raw_read_unsigned (regcache, tdep->arg2,
1323                                     &tmpulongest);
1324         regcache_raw_read_unsigned (regcache, tdep->arg3, &count);
1325         if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1326                                       tdep->size_dirent * count))
1327           return -1;
1328       }
1329       break;
1330
1331     case gdb_sys_select:
1332       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1333       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1334                                     tdep->size_fd_set))
1335         return -1;
1336       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1337       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1338                                     tdep->size_fd_set))
1339         return -1;
1340       regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
1341       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1342                                     tdep->size_fd_set))
1343         return -1;
1344       regcache_raw_read_unsigned (regcache, tdep->arg5, &tmpulongest);
1345       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1346                                     tdep->size_timeval))
1347         return -1;
1348       break;
1349
1350     case gdb_sys_flock:
1351     case gdb_sys_msync:
1352       break;
1353
1354     case gdb_sys_readv:
1355       {
1356         ULONGEST vec, vlen;
1357
1358         regcache_raw_read_unsigned (regcache, tdep->arg2, &vec);
1359         if (vec)
1360           {
1361             gdb_byte *iov = alloca (tdep->size_iovec);
1362
1363             regcache_raw_read_unsigned (regcache, tdep->arg3, &vlen);
1364             for (tmpulongest = 0; tmpulongest < vlen; tmpulongest++)
1365               {
1366                 if (target_read_memory ((CORE_ADDR) vec, iov,
1367                                         tdep->size_iovec))
1368                   {
1369                     if (record_debug)
1370                       fprintf_unfiltered (gdb_stdlog,
1371                                           "Process record: error reading "
1372                                           "memory at addr = 0x%s len = %d.\n",
1373                                           OUTPUT_REG (vec, tdep->arg2),
1374                                           tdep->size_iovec);
1375                     return -1;
1376                   }
1377                 tmpaddr
1378                   = (CORE_ADDR) extract_unsigned_integer (iov,
1379                                                           tdep->size_pointer,
1380                                                           byte_order);
1381                 tmpint
1382                   = (int) extract_unsigned_integer (iov + tdep->size_pointer,
1383                                                     tdep->size_size_t,
1384                                                     byte_order);
1385                 if (record_arch_list_add_mem (tmpaddr, tmpint))
1386                   return -1;
1387                 vec += tdep->size_iovec;
1388               }
1389           }
1390       }
1391       break;
1392
1393     case gdb_sys_writev:
1394     case gdb_sys_getsid:
1395     case gdb_sys_fdatasync:
1396     case gdb_sys_sysctl:
1397     case gdb_sys_mlock:
1398     case gdb_sys_munlock:
1399     case gdb_sys_mlockall:
1400     case gdb_sys_munlockall:
1401     case gdb_sys_sched_setparam:
1402       break;
1403
1404     case gdb_sys_sched_getparam:
1405       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1406       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_int))
1407         return -1;
1408       break;
1409
1410     case gdb_sys_sched_setscheduler:
1411     case gdb_sys_sched_getscheduler:
1412     case gdb_sys_sched_yield:
1413     case gdb_sys_sched_get_priority_max:
1414     case gdb_sys_sched_get_priority_min:
1415       break;
1416
1417     case gdb_sys_sched_rr_get_interval:
1418     case gdb_sys_nanosleep:
1419       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1420       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1421                                     tdep->size_timespec))
1422         return -1;
1423       break;
1424
1425     case gdb_sys_mremap:
1426     case gdb_sys_setresuid16:
1427       break;
1428
1429     case gdb_sys_getresuid16:
1430       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1431       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1432                                     tdep->size_old_uid_t))
1433         return -1;
1434       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1435       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1436                                     tdep->size_old_uid_t))
1437         return -1;
1438       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1439       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1440                                     tdep->size_old_uid_t))
1441         return -1;
1442       break;
1443
1444     case gdb_sys_vm86:
1445     case gdb_sys_ni_syscall167:
1446       break;
1447
1448     case gdb_sys_poll:
1449       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1450       if (tmpulongest)
1451         {
1452           ULONGEST nfds;
1453           regcache_raw_read_unsigned (regcache, tdep->arg2, &nfds);
1454           if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1455                                         tdep->size_pollfd * nfds))
1456             return -1;
1457         }
1458       break;
1459
1460     case gdb_sys_nfsservctl:
1461       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1462       if (tmpulongest == 7 || tmpulongest == 8)
1463         {
1464           int rsize;
1465           if (tmpulongest == 7)
1466             rsize = tdep->size_NFS_FHSIZE;
1467           else
1468             rsize = tdep->size_knfsd_fh;
1469           regcache_raw_read_unsigned (regcache, tdep->arg3,
1470                                       &tmpulongest);
1471           if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, rsize))
1472             return -1;
1473         }
1474       break;
1475
1476     case gdb_sys_setresgid16:
1477       break;
1478
1479     case gdb_sys_getresgid16:
1480       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1481       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1482                                     tdep->size_old_gid_t))
1483         return -1;
1484       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1485       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1486                                     tdep->size_old_gid_t))
1487         return -1;
1488       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1489       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1490                                     tdep->size_old_gid_t))
1491         return -1;
1492       break;
1493
1494     case gdb_sys_prctl:
1495       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1496       switch (tmpulongest)
1497         {
1498         case 2:
1499           regcache_raw_read_unsigned (regcache, tdep->arg2,
1500                                       &tmpulongest);
1501           if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1502                                         tdep->size_int))
1503             return -1;
1504           break;
1505         case 16:
1506           regcache_raw_read_unsigned (regcache, tdep->arg2,
1507                                       &tmpulongest);
1508           if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1509                                         tdep->size_TASK_COMM_LEN))
1510             return -1;
1511           break;
1512         }
1513       break;
1514
1515     case gdb_sys_rt_sigreturn:
1516       break;
1517
1518     case gdb_sys_rt_sigaction:
1519       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1520       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1521                                     tdep->size_sigaction))
1522         return -1;
1523       break;
1524
1525     case gdb_sys_rt_sigprocmask:
1526       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1527       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1528                                     tdep->size_sigset_t))
1529         return -1;
1530       break;
1531
1532     case gdb_sys_rt_sigpending:
1533       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1534       if (tmpulongest)
1535         {
1536           ULONGEST sigsetsize;
1537           regcache_raw_read_unsigned (regcache, tdep->arg2,&sigsetsize);
1538           if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1539                                         (int) sigsetsize))
1540             return -1;
1541         }
1542       break;
1543
1544     case gdb_sys_rt_sigtimedwait:
1545       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1546       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1547                                     tdep->size_siginfo_t))
1548         return -1;
1549       break;
1550
1551     case gdb_sys_rt_sigqueueinfo:
1552     case gdb_sys_rt_sigsuspend:
1553       break;
1554
1555     case gdb_sys_pread64:
1556       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1557       if (tmpulongest)
1558         {
1559           ULONGEST count;
1560           regcache_raw_read_unsigned (regcache, tdep->arg3,&count);
1561           if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, (int) count))
1562             return -1;
1563         }
1564       break;
1565
1566     case gdb_sys_pwrite64:
1567     case gdb_sys_chown16:
1568       break;
1569
1570     case gdb_sys_getcwd:
1571       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1572       if (tmpulongest)
1573         {
1574           ULONGEST size;
1575           regcache_raw_read_unsigned (regcache, tdep->arg2, &size);
1576           if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, (int) size))
1577             return -1;
1578         }
1579       break;
1580
1581     case gdb_sys_capget:
1582       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1583       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1584                                     tdep->size_cap_user_data_t))
1585         return -1;
1586       break;
1587
1588     case gdb_sys_capset:
1589       break;
1590
1591     case gdb_sys_sigaltstack:
1592       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1593       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1594                                     tdep->size_stack_t))
1595         return -1;
1596       break;
1597
1598     case gdb_sys_sendfile:
1599       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1600       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1601                                     tdep->size_off_t))
1602         return -1;
1603       break;
1604
1605     case gdb_sys_ni_syscall188:
1606     case gdb_sys_ni_syscall189:
1607     case gdb_sys_vfork:
1608       break;
1609
1610     case gdb_sys_getrlimit:
1611       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1612       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1613                                     tdep->size_rlimit))
1614         return -1;
1615       break;
1616
1617     case gdb_sys_mmap2:
1618       break;
1619
1620     case gdb_sys_truncate64:
1621     case gdb_sys_ftruncate64:
1622       break;
1623
1624     case gdb_sys_stat64:
1625     case gdb_sys_lstat64:
1626     case gdb_sys_fstat64:
1627       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1628       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1629                                     tdep->size_stat64))
1630         return -1;
1631       break;
1632
1633     case gdb_sys_lchown:
1634     case gdb_sys_getuid:
1635     case gdb_sys_getgid:
1636     case gdb_sys_geteuid:
1637     case gdb_sys_getegid:
1638     case gdb_sys_setreuid:
1639     case gdb_sys_setregid:
1640       break;
1641
1642     case gdb_sys_getgroups:
1643       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1644       if (tmpulongest)
1645         {
1646           ULONGEST gidsetsize;
1647           regcache_raw_read_unsigned (regcache, tdep->arg1,
1648                                       &gidsetsize);
1649           tmpint = tdep->size_gid_t * (int) gidsetsize;
1650           if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tmpint))
1651             return -1;
1652         }
1653       break;
1654
1655     case gdb_sys_setgroups:
1656     case gdb_sys_fchown:
1657     case gdb_sys_setresuid:
1658       break;
1659
1660     case gdb_sys_getresuid:
1661       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1662       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_uid_t))
1663         return -1;
1664       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1665       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_uid_t))
1666         return -1;
1667       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1668       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_uid_t))
1669         return -1;
1670       break;
1671
1672     case gdb_sys_setresgid:
1673       break;
1674
1675     case gdb_sys_getresgid:
1676       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1677       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_gid_t))
1678         return -1;
1679       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1680       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_gid_t))
1681         return -1;
1682       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1683       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_gid_t))
1684         return -1;
1685       break;
1686
1687     case gdb_sys_chown:
1688     case gdb_sys_setuid:
1689     case gdb_sys_setgid:
1690     case gdb_sys_setfsuid:
1691     case gdb_sys_setfsgid:
1692     case gdb_sys_pivot_root:
1693       break;
1694
1695     case gdb_sys_mincore:
1696       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1697       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1698                                     tdep->size_PAGE_SIZE))
1699         return -1;
1700       break;
1701
1702     case gdb_sys_madvise:
1703       break;
1704
1705     case gdb_sys_getdents64:
1706       {
1707         ULONGEST count;
1708         regcache_raw_read_unsigned (regcache, tdep->arg2,
1709                                     &tmpulongest);
1710         regcache_raw_read_unsigned (regcache, tdep->arg3, &count);
1711         if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1712                                       tdep->size_dirent64 * count))
1713           return -1;
1714       }
1715       break;
1716
1717     case gdb_sys_fcntl64:
1718       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1719       if (tmpulongest == tdep->fcntl_F_GETLK64)
1720         {
1721           regcache_raw_read_unsigned (regcache, tdep->arg3,
1722                                       &tmpulongest);
1723           if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1724                                         tdep->size_flock64))
1725             return -1;
1726         }
1727       else if (tmpulongest != tdep->fcntl_F_SETLK64
1728                && tmpulongest != tdep->fcntl_F_SETLKW64)
1729         {
1730           goto sys_fcntl;
1731         }
1732       break;
1733
1734     case gdb_sys_ni_syscall222:
1735     case gdb_sys_ni_syscall223:
1736     case gdb_sys_gettid:
1737     case gdb_sys_readahead:
1738     case gdb_sys_setxattr:
1739     case gdb_sys_lsetxattr:
1740     case gdb_sys_fsetxattr:
1741       break;
1742
1743     case gdb_sys_getxattr:
1744     case gdb_sys_lgetxattr:
1745     case gdb_sys_fgetxattr:
1746       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1747       if (tmpulongest)
1748         {
1749           ULONGEST size;
1750           regcache_raw_read_unsigned (regcache, tdep->arg4, &size);
1751           if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, (int) size))
1752             return -1;
1753         }
1754       break;
1755
1756     case gdb_sys_listxattr:
1757     case gdb_sys_llistxattr:
1758     case gdb_sys_flistxattr:
1759       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1760       if (tmpulongest)
1761         {
1762           ULONGEST size;
1763           regcache_raw_read_unsigned (regcache, tdep->arg3, &size);
1764           if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, (int) size))
1765             return -1;
1766         }
1767       break;
1768
1769     case gdb_sys_removexattr:
1770     case gdb_sys_lremovexattr:
1771     case gdb_sys_fremovexattr:
1772     case gdb_sys_tkill:
1773       break;
1774
1775     case gdb_sys_sendfile64:
1776       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1777       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1778                                     tdep->size_loff_t))
1779         return -1;
1780       break;
1781
1782     case gdb_sys_futex:
1783     case gdb_sys_sched_setaffinity:
1784       break;
1785
1786     case gdb_sys_sched_getaffinity:
1787       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1788       if (tmpulongest)
1789         {
1790           ULONGEST len;
1791           regcache_raw_read_unsigned (regcache, tdep->arg2, &len);
1792           if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, (int) len))
1793             return -1;
1794         }
1795       break;
1796
1797     case gdb_sys_set_thread_area:
1798       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1799       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_int))
1800         return -1;
1801       break;
1802
1803     case gdb_sys_get_thread_area:
1804       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1805       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1806                                     tdep->size_user_desc))
1807         return -1;
1808       break;
1809
1810     case gdb_sys_io_setup:
1811       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1812       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_long))
1813         return -1;
1814       break;
1815
1816     case gdb_sys_io_destroy:
1817       break;
1818
1819     case gdb_sys_io_getevents:
1820       regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
1821       if (tmpulongest)
1822         {
1823           ULONGEST nr;
1824           regcache_raw_read_unsigned (regcache, tdep->arg3, &nr);
1825           if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1826                                         nr * tdep->size_io_event))
1827             return -1;
1828         }
1829       break;
1830
1831     case gdb_sys_io_submit:
1832       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1833       if (tmpulongest)
1834         {
1835           ULONGEST nr, i;
1836           gdb_byte *iocbp;
1837
1838           regcache_raw_read_unsigned (regcache, tdep->arg2, &nr);
1839           iocbp = alloca (nr * tdep->size_pointer);
1840           if (target_read_memory ((CORE_ADDR) tmpulongest, iocbp,
1841                                   nr * tdep->size_pointer))
1842             {
1843               if (record_debug)
1844                 fprintf_unfiltered (gdb_stdlog,
1845                                     "Process record: error reading memory "
1846                                     "at addr = 0x%s len = %u.\n",
1847                                     OUTPUT_REG (tmpulongest, tdep->arg2),
1848                                     (int) (nr * tdep->size_pointer));
1849               return -1;
1850             }
1851           for (i = 0; i < nr; i++)
1852             {
1853               tmpaddr
1854                 = (CORE_ADDR) extract_unsigned_integer (iocbp,
1855                                                         tdep->size_pointer,
1856                                                         byte_order);
1857               if (record_arch_list_add_mem (tmpaddr, tdep->size_iocb))
1858                 return -1;
1859               iocbp += tdep->size_pointer;
1860             }
1861         }
1862       break;
1863
1864     case gdb_sys_io_cancel:
1865       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1866       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1867                                     tdep->size_io_event))
1868         return -1;
1869       break;
1870
1871     case gdb_sys_fadvise64:
1872     case gdb_sys_ni_syscall251:
1873       break;
1874
1875     case gdb_sys_exit_group:
1876       {
1877         int q;
1878         target_terminal_ours ();
1879         q = yquery (_("The next instruction is syscall exit_group.  "
1880                       "It will make the program exit.  "
1881                       "Do you want to stop the program?"));
1882         target_terminal_inferior ();
1883         if (q)
1884           return 1;
1885       }
1886       break;
1887
1888     case gdb_sys_lookup_dcookie:
1889       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1890       if (tmpulongest)
1891         {
1892           ULONGEST len;
1893           regcache_raw_read_unsigned (regcache, tdep->arg3, &len);
1894           if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, (int) len))
1895             return -1;
1896         }
1897       break;
1898
1899     case gdb_sys_epoll_create:
1900     case gdb_sys_epoll_ctl:
1901       break;
1902
1903     case gdb_sys_epoll_wait:
1904       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1905       if (tmpulongest)
1906         {
1907           ULONGEST maxevents;
1908           regcache_raw_read_unsigned (regcache, tdep->arg3, &maxevents);
1909           if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1910                                         maxevents * tdep->size_epoll_event))
1911             return -1;
1912         }
1913       break;
1914
1915     case gdb_sys_remap_file_pages:
1916     case gdb_sys_set_tid_address:
1917       break;
1918
1919     case gdb_sys_timer_create:
1920       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1921       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_int))
1922         return -1;
1923       break;
1924
1925     case gdb_sys_timer_settime:
1926       regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
1927       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1928                                     tdep->size_itimerspec))
1929         return -1;
1930       break;
1931
1932     case gdb_sys_timer_gettime:
1933       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1934       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1935                                     tdep->size_itimerspec))
1936         return -1;
1937       break;
1938
1939     case gdb_sys_timer_getoverrun:
1940     case gdb_sys_timer_delete:
1941     case gdb_sys_clock_settime:
1942       break;
1943
1944     case gdb_sys_clock_gettime:
1945       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1946       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1947                                     tdep->size_timespec))
1948         return -1;
1949       break;
1950
1951     case gdb_sys_clock_getres:
1952       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1953       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1954                                     tdep->size_timespec))
1955         return -1;
1956       break;
1957
1958     case gdb_sys_clock_nanosleep:
1959       regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
1960       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1961                                     tdep->size_timespec))
1962         return -1;
1963       break;
1964
1965     case gdb_sys_statfs64:
1966     case gdb_sys_fstatfs64:
1967       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1968       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1969                                     tdep->size_statfs64))
1970         return -1;
1971       break;
1972
1973     case gdb_sys_tgkill:
1974     case gdb_sys_utimes:
1975     case gdb_sys_fadvise64_64:
1976     case gdb_sys_ni_syscall273:
1977     case gdb_sys_mbind:
1978       break;
1979
1980     case gdb_sys_get_mempolicy:
1981       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1982       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_int))
1983         return -1;
1984       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1985       if (tmpulongest)
1986         {
1987           ULONGEST maxnode;
1988           regcache_raw_read_unsigned (regcache, tdep->arg3, &maxnode);
1989           if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1990                                         maxnode * tdep->size_long))
1991             return -1;
1992         }
1993       break;
1994
1995     case gdb_sys_set_mempolicy:
1996     case gdb_sys_mq_open:
1997     case gdb_sys_mq_unlink:
1998     case gdb_sys_mq_timedsend:
1999       break;
2000
2001     case gdb_sys_mq_timedreceive:
2002       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
2003       if (tmpulongest)
2004         {
2005           ULONGEST msg_len;
2006           regcache_raw_read_unsigned (regcache, tdep->arg3, &msg_len);
2007           if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2008                                         (int) msg_len))
2009             return -1;
2010         }
2011       regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
2012       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_int))
2013         return -1;
2014       break;
2015
2016     case gdb_sys_mq_notify:
2017       break;
2018
2019     case gdb_sys_mq_getsetattr:
2020       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
2021       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2022                                     tdep->size_mq_attr))
2023         return -1;
2024       break;
2025
2026     case gdb_sys_kexec_load:
2027       break;
2028
2029     case gdb_sys_waitid:
2030       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
2031       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2032                                     tdep->size_siginfo))
2033         return -1;
2034       regcache_raw_read_unsigned (regcache, tdep->arg5, &tmpulongest);
2035       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2036                                     tdep->size_rusage))
2037         return -1;
2038       break;
2039
2040     case gdb_sys_ni_syscall285:
2041     case gdb_sys_add_key:
2042     case gdb_sys_request_key:
2043       break;
2044
2045     case gdb_sys_keyctl:
2046       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
2047       if (tmpulongest == 6 || tmpulongest == 11)
2048         {
2049           regcache_raw_read_unsigned (regcache, tdep->arg3,
2050                                       &tmpulongest);
2051           if (tmpulongest)
2052             {
2053               ULONGEST buflen;
2054               regcache_raw_read_unsigned (regcache, tdep->arg4, &buflen);
2055               if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2056                                             (int) buflen))
2057                 return -1;
2058             }
2059         }
2060       break;
2061
2062     case gdb_sys_ioprio_set:
2063     case gdb_sys_ioprio_get:
2064     case gdb_sys_inotify_init:
2065     case gdb_sys_inotify_add_watch:
2066     case gdb_sys_inotify_rm_watch:
2067     case gdb_sys_migrate_pages:
2068     case gdb_sys_openat:
2069     case gdb_sys_mkdirat:
2070     case gdb_sys_mknodat:
2071     case gdb_sys_fchownat:
2072     case gdb_sys_futimesat:
2073       break;
2074
2075     case gdb_sys_fstatat64:
2076       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
2077       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2078                                     tdep->size_stat64))
2079         return -1;
2080       break;
2081
2082     case gdb_sys_unlinkat:
2083     case gdb_sys_renameat:
2084     case gdb_sys_linkat:
2085     case gdb_sys_symlinkat:
2086       break;
2087
2088     case gdb_sys_readlinkat:
2089       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
2090       if (tmpulongest)
2091         {
2092           ULONGEST bufsiz;
2093           regcache_raw_read_unsigned (regcache, tdep->arg4, &bufsiz);
2094           if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, (int) bufsiz))
2095             return -1;
2096         }
2097       break;
2098
2099     case gdb_sys_fchmodat:
2100     case gdb_sys_faccessat:
2101       break;
2102
2103     case gdb_sys_pselect6:
2104       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
2105       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2106                                     tdep->size_fd_set))
2107         return -1;
2108       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
2109       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2110                                     tdep->size_fd_set))
2111         return -1;
2112       regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
2113       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2114                                     tdep->size_fd_set))
2115         return -1;
2116       regcache_raw_read_unsigned (regcache, tdep->arg5, &tmpulongest);
2117       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2118                                     tdep->size_timespec))
2119         return -1;
2120       break;
2121
2122     case gdb_sys_ppoll:
2123       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
2124       if (tmpulongest)
2125         {
2126           ULONGEST nfds;
2127           regcache_raw_read_unsigned (regcache, tdep->arg2, &nfds);
2128           if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2129                                         tdep->size_pollfd * nfds))
2130             return -1;
2131         }
2132       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
2133       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2134                                     tdep->size_timespec))
2135         return -1;
2136       break;
2137
2138     case gdb_sys_unshare:
2139     case gdb_sys_set_robust_list:
2140       break;
2141
2142     case gdb_sys_get_robust_list:
2143       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
2144       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_int))
2145         return -1;
2146       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
2147       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_int))
2148         return -1;
2149       break;
2150
2151     case gdb_sys_splice:
2152       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
2153       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2154                                     tdep->size_loff_t))
2155         return -1;
2156       regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
2157       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2158                                     tdep->size_loff_t))
2159         return -1;
2160       break;
2161
2162     case gdb_sys_sync_file_range:
2163     case gdb_sys_tee:
2164     case gdb_sys_vmsplice:
2165       break;
2166
2167     case gdb_sys_move_pages:
2168       regcache_raw_read_unsigned (regcache, tdep->arg5, &tmpulongest);
2169       if (tmpulongest)
2170         {
2171           ULONGEST nr_pages;
2172           regcache_raw_read_unsigned (regcache, tdep->arg2, &nr_pages);
2173           if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2174                                         nr_pages * tdep->size_int))
2175             return -1;
2176         }
2177       break;
2178
2179     case gdb_sys_getcpu:
2180       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
2181       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_int))
2182         return -1;
2183       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
2184       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_int))
2185         return -1;
2186       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
2187       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2188                                     tdep->size_ulong * 2))
2189         return -1;
2190       break;
2191
2192     case gdb_sys_epoll_pwait:
2193       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
2194       if (tmpulongest)
2195         {
2196           ULONGEST maxevents;
2197           regcache_raw_read_unsigned (regcache, tdep->arg3, &maxevents);
2198           tmpint = (int) maxevents * tdep->size_epoll_event;
2199           if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tmpint))
2200             return -1;
2201         }
2202       break;
2203
2204     default:
2205       printf_unfiltered (_("Process record and replay target doesn't "
2206                            "support syscall number %d\n"), syscall);
2207       return -1;
2208       break;
2209     }
2210
2211   return 0;
2212 }