gdb/linux-record.c

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