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