gdb/linux-record.c

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