gdb/linux-record.c

   1 /* Process record and replay target code for GNU/Linux.
   2
   3    Copyright (C) 2008-2022 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         gdb_printf (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         gdb_printf (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                 gdb_printf (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           gdb_printf (gdb_stderr,
 496                       _("Process record and replay target doesn't "
 497                         "support ioctl request TIOCSERGSTRUCT\n"));
 498           return 1;
 499         }
 500       else
 501         {
 502           gdb_printf (gdb_stderr,
 503                       _("Process record and replay target doesn't "
 504                         "support ioctl request 0x%s.\n"),
 505                       OUTPUT_REG (tmpulongest, tdep->arg2));
 506           return 1;
 507         }
 508       break;
 509
 510     case gdb_sys_fcntl:
 511       /* XXX */
 512       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
 513     sys_fcntl:
 514       if (tmpulongest == tdep->fcntl_F_GETLK)
 515         {
 516           if (record_mem_at_reg (regcache, tdep->arg3, tdep->size_flock))
 517             return -1;
 518         }
 519       break;
 520
 521     case gdb_sys_ni_syscall56:
 522     case gdb_sys_setpgid:
 523     case gdb_sys_ni_syscall58:
 524       break;
 525
 526     case gdb_sys_olduname:
 527       if (record_mem_at_reg (regcache, tdep->arg1,
 528                              tdep->size_oldold_utsname))
 529         return -1;
 530       break;
 531
 532     case gdb_sys_umask:
 533     case gdb_sys_chroot:
 534       break;
 535
 536     case gdb_sys_ustat:
 537       if (record_mem_at_reg (regcache, tdep->arg2, tdep->size_ustat))
 538         return -1;
 539       break;
 540
 541     case gdb_sys_dup2:
 542     case gdb_sys_getppid:
 543     case gdb_sys_getpgrp:
 544     case gdb_sys_setsid:
 545       break;
 546
 547     case gdb_sys_sigaction:
 548       if (record_mem_at_reg (regcache, tdep->arg3,
 549                              tdep->size_old_sigaction))
 550         return -1;
 551       break;
 552
 553     case gdb_sys_sgetmask:
 554     case gdb_sys_ssetmask:
 555     case gdb_sys_setreuid16:
 556     case gdb_sys_setregid16:
 557     case gdb_sys_sigsuspend:
 558       break;
 559
 560     case gdb_sys_sigpending:
 561       if (record_mem_at_reg (regcache, tdep->arg1,
 562                              tdep->size_old_sigset_t))
 563         return -1;
 564       break;
 565
 566     case gdb_sys_sethostname:
 567     case gdb_sys_setrlimit:
 568       break;
 569
 570     case gdb_sys_old_getrlimit:
 571       if (record_mem_at_reg (regcache, tdep->arg2, tdep->size_rlimit))
 572         return -1;
 573       break;
 574
 575     case gdb_sys_getrusage:
 576       if (record_mem_at_reg (regcache, tdep->arg2, tdep->size_rusage))
 577         return -1;
 578       break;
 579
 580     case gdb_sys_gettimeofday:
 581       if (record_mem_at_reg (regcache, tdep->arg1, tdep->size_timeval)
 582           || record_mem_at_reg (regcache, tdep->arg2, tdep->size_timezone))
 583         return -1;
 584       break;
 585
 586     case gdb_sys_settimeofday:
 587       break;
 588
 589     case gdb_sys_getgroups16:
 590       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
 591       if (tmpulongest)
 592         {
 593           ULONGEST gidsetsize;
 594
 595           regcache_raw_read_unsigned (regcache, tdep->arg1,
 596                                       &gidsetsize);
 597           tmpint = tdep->size_old_gid_t * (int) gidsetsize;
 598           if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest, tmpint))
 599             return -1;
 600         }
 601       break;
 602
 603     case gdb_sys_setgroups16:
 604       break;
 605
 606     case gdb_old_select:
 607       {
 608         unsigned long sz_sel_arg = tdep->size_long + tdep->size_pointer * 4;
 609         gdb_byte *a = (gdb_byte *) alloca (sz_sel_arg);
 610         CORE_ADDR inp, outp, exp, tvp;
 611
 612         regcache_raw_read_unsigned (regcache, tdep->arg1,
 613                                     &tmpulongest);
 614         if (tmpulongest)
 615           {
 616             if (target_read_memory (tmpulongest, a, sz_sel_arg))
 617               {
 618                 if (record_debug)
 619                   gdb_printf (gdb_stdlog,
 620                               "Process record: error reading memory "
 621                               "at addr = 0x%s len = %lu.\n",
 622                               OUTPUT_REG (tmpulongest, tdep->arg1),
 623                               sz_sel_arg);
 624                 return -1;
 625               }
 626             /* Skip n. */
 627             a += tdep->size_long;
 628             inp = extract_unsigned_integer (a, tdep->size_pointer, byte_order);
 629             a += tdep->size_pointer;
 630             outp = extract_unsigned_integer (a, tdep->size_pointer, byte_order);
 631             a += tdep->size_pointer;
 632             exp = extract_unsigned_integer (a, tdep->size_pointer, byte_order);
 633             a += tdep->size_pointer;
 634             tvp = extract_unsigned_integer (a, tdep->size_pointer, byte_order);
 635             if (inp)
 636               if (record_full_arch_list_add_mem (inp, tdep->size_fd_set))
 637                 return -1;
 638             if (outp)
 639               if (record_full_arch_list_add_mem (outp, tdep->size_fd_set))
 640                 return -1;
 641             if (exp)
 642               if (record_full_arch_list_add_mem (exp, tdep->size_fd_set))
 643                 return -1;
 644             if (tvp)
 645               if (record_full_arch_list_add_mem (tvp, tdep->size_timeval))
 646                 return -1;
 647           }
 648       }
 649       break;
 650
 651     case gdb_sys_symlink:
 652       break;
 653
 654     case gdb_sys_uselib:
 655     case gdb_sys_swapon:
 656       break;
 657
 658     case gdb_sys_reboot:
 659       if (yquery (_("The next instruction is syscall reboot.  "
 660                     "It will restart the computer.  "
 661                     "Do you want to stop the program?")))
 662         return 1;
 663       break;
 664
 665     case gdb_old_readdir:
 666       if (record_mem_at_reg (regcache, tdep->arg2, tdep->size_old_dirent))
 667         return -1;
 668       break;
 669
 670     case gdb_old_mmap:
 671       break;
 672
 673     case gdb_sys_munmap:
 674       {
 675         ULONGEST len;
 676
 677         regcache_raw_read_unsigned (regcache, tdep->arg1,
 678                                     &tmpulongest);
 679         regcache_raw_read_unsigned (regcache, tdep->arg2, &len);
 680         if (record_full_memory_query)
 681           {
 682             if (yquery (_("\
 683 The next instruction is syscall munmap.\n\
 684 It will free the memory addr = 0x%s len = %u.\n\
 685 It will make record target cannot record some memory change.\n\
 686 Do you want to stop the program?"),
 687                         OUTPUT_REG (tmpulongest, tdep->arg1), (int) len))
 688               return 1;
 689           }
 690       }
 691       break;
 692
 693     case gdb_sys_truncate:
 694     case gdb_sys_ftruncate:
 695     case gdb_sys_fchmod:
 696     case gdb_sys_fchown16:
 697     case gdb_sys_getpriority:
 698     case gdb_sys_setpriority:
 699     case gdb_sys_ni_syscall98:
 700       break;
 701
 702     case gdb_sys_statfs:
 703     case gdb_sys_fstatfs:
 704       if (record_mem_at_reg (regcache, tdep->arg2, tdep->size_statfs))
 705         return -1;
 706       break;
 707
 708     case gdb_sys_ioperm:
 709       break;
 710
 711     case gdb_sys_socket:
 712     case gdb_sys_sendto:
 713     case gdb_sys_sendmsg:
 714     case gdb_sys_shutdown:
 715     case gdb_sys_bind:
 716     case gdb_sys_connect:
 717     case gdb_sys_listen:
 718     case gdb_sys_setsockopt:
 719       break;
 720
 721     case gdb_sys_accept:
 722     case gdb_sys_getsockname:
 723     case gdb_sys_getpeername:
 724       {
 725         ULONGEST len;
 726
 727         regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
 728         regcache_raw_read_unsigned (regcache, tdep->arg3, &len);
 729         if (record_linux_sockaddr (regcache, tdep, tmpulongest, len))
 730           return -1;
 731       }
 732       break;
 733
 734     case gdb_sys_recvfrom:
 735       {
 736         ULONGEST len;
 737
 738         regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
 739         regcache_raw_read_unsigned (regcache, tdep->arg5, &len);
 740         if (record_linux_sockaddr (regcache, tdep, tmpulongest, len))
 741           return -1;
 742       }
 743       break;
 744
 745     case gdb_sys_recvmsg:
 746       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
 747       if (record_linux_msghdr (regcache, tdep, tmpulongest))
 748         return -1;
 749       break;
 750
 751     case gdb_sys_socketpair:
 752       if (record_mem_at_reg (regcache, tdep->arg4, tdep->size_int))
 753         return -1;
 754       break;
 755
 756     case gdb_sys_getsockopt:
 757       regcache_raw_read_unsigned (regcache, tdep->arg5, &tmpulongest);
 758       if (tmpulongest)
 759         {
 760           ULONGEST optvalp;
 761           gdb_byte *optlenp = (gdb_byte *) alloca (tdep->size_int);
 762
 763           if (target_read_memory ((CORE_ADDR) tmpulongest, optlenp,
 764                                   tdep->size_int))
 765             {
 766               if (record_debug)
 767                 gdb_printf (gdb_stdlog,
 768                             "Process record: error reading "
 769                             "memory at addr = 0x%s "
 770                             "len = %d.\n",
 771                             OUTPUT_REG (tmpulongest, tdep->arg5),
 772                             tdep->size_int);
 773               return -1;
 774             }
 775           regcache_raw_read_unsigned (regcache, tdep->arg4, &optvalp);
 776           tmpint = (int) extract_signed_integer (optlenp, tdep->size_int,
 777                                                  byte_order);
 778           if (record_full_arch_list_add_mem ((CORE_ADDR) optvalp, tmpint))
 779             return -1;
 780           if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 781                                              tdep->size_int))
 782             return -1;
 783         }
 784       break;
 785
 786     case gdb_sys_socketcall:
 787       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
 788       switch (tmpulongest)
 789         {
 790         case RECORD_SYS_SOCKET:
 791         case RECORD_SYS_BIND:
 792         case RECORD_SYS_CONNECT:
 793         case RECORD_SYS_LISTEN:
 794           break;
 795         case RECORD_SYS_ACCEPT:
 796         case RECORD_SYS_GETSOCKNAME:
 797         case RECORD_SYS_GETPEERNAME:
 798           {
 799             regcache_raw_read_unsigned (regcache, tdep->arg2,
 800                                         &tmpulongest);
 801             if (tmpulongest)
 802               {
 803                 gdb_byte *a = (gdb_byte *) alloca (tdep->size_ulong * 2);
 804                 ULONGEST len;
 805
 806                 tmpulongest += tdep->size_ulong;
 807                 if (target_read_memory ((CORE_ADDR) tmpulongest, a,
 808                                         tdep->size_ulong * 2))
 809                   {
 810                     if (record_debug)
 811                       gdb_printf (gdb_stdlog,
 812                                   "Process record: error reading "
 813                                   "memory at addr = 0x%s len = %d.\n",
 814                                   OUTPUT_REG (tmpulongest, tdep->arg2),
 815                                   tdep->size_ulong * 2);
 816                     return -1;
 817                   }
 818                 tmpulongest = extract_unsigned_integer (a,
 819                                                         tdep->size_ulong,
 820                                                         byte_order);
 821                 len = extract_unsigned_integer (a + tdep->size_ulong,
 822                                                 tdep->size_ulong, byte_order);
 823                 if (record_linux_sockaddr (regcache, tdep, tmpulongest, len))
 824                   return -1;
 825               }
 826           }
 827           break;
 828
 829         case RECORD_SYS_SOCKETPAIR:
 830           {
 831             gdb_byte *a = (gdb_byte *) alloca (tdep->size_ulong);
 832
 833             regcache_raw_read_unsigned (regcache, tdep->arg2,
 834                                         &tmpulongest);
 835             if (tmpulongest)
 836               {
 837                 tmpulongest += tdep->size_ulong * 3;
 838                 if (target_read_memory ((CORE_ADDR) tmpulongest, a,
 839                                         tdep->size_ulong))
 840                   {
 841                     if (record_debug)
 842                       gdb_printf (gdb_stdlog,
 843                                   "Process record: error reading "
 844                                   "memory at addr = 0x%s len = %d.\n",
 845                                   OUTPUT_REG (tmpulongest, tdep->arg2),
 846                                   tdep->size_ulong);
 847                     return -1;
 848                   }
 849                 tmpaddr
 850                   = (CORE_ADDR) extract_unsigned_integer (a, tdep->size_ulong,
 851                                                           byte_order);
 852                 if (record_full_arch_list_add_mem (tmpaddr, tdep->size_int))
 853                   return -1;
 854               }
 855           }
 856           break;
 857         case RECORD_SYS_SEND:
 858         case RECORD_SYS_SENDTO:
 859           break;
 860         case RECORD_SYS_RECVFROM:
 861           regcache_raw_read_unsigned (regcache, tdep->arg2,
 862                                       &tmpulongest);
 863           if (tmpulongest)
 864             {
 865               gdb_byte *a = (gdb_byte *) alloca (tdep->size_ulong * 2);
 866               ULONGEST len;
 867
 868               tmpulongest += tdep->size_ulong * 4;
 869               if (target_read_memory ((CORE_ADDR) tmpulongest, a,
 870                                       tdep->size_ulong * 2))
 871                 {
 872                   if (record_debug)
 873                     gdb_printf (gdb_stdlog,
 874                                 "Process record: error reading "
 875                                 "memory at addr = 0x%s len = %d.\n",
 876                                 OUTPUT_REG (tmpulongest, tdep->arg2),
 877                                 tdep->size_ulong * 2);
 878                   return -1;
 879                 }
 880               tmpulongest = extract_unsigned_integer (a, tdep->size_ulong,
 881                                                       byte_order);
 882               len = extract_unsigned_integer (a + tdep->size_ulong,
 883                                               tdep->size_ulong, byte_order);
 884               if (record_linux_sockaddr (regcache, tdep, tmpulongest, len))
 885                 return -1;
 886             }
 887           break;
 888         case RECORD_SYS_RECV:
 889           regcache_raw_read_unsigned (regcache, tdep->arg2,
 890                                       &tmpulongest);
 891           if (tmpulongest)
 892             {
 893               gdb_byte *a = (gdb_byte *) alloca (tdep->size_ulong * 2);
 894
 895               tmpulongest += tdep->size_ulong;
 896               if (target_read_memory ((CORE_ADDR) tmpulongest, a,
 897                                       tdep->size_ulong))
 898                 {
 899                   if (record_debug)
 900                     gdb_printf (gdb_stdlog,
 901                                 "Process record: error reading "
 902                                 "memory at addr = 0x%s len = %d.\n",
 903                                 OUTPUT_REG (tmpulongest, tdep->arg2),
 904                                 tdep->size_ulong);
 905                   return -1;
 906                 }
 907               tmpulongest = extract_unsigned_integer (a, tdep->size_ulong,
 908                                                       byte_order);
 909               if (tmpulongest)
 910                 {
 911                   a += tdep->size_ulong;
 912                   tmpint = (int) extract_unsigned_integer (a, tdep->size_ulong,
 913                                                            byte_order);
 914                   if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 915                                                      tmpint))
 916                     return -1;
 917                 }
 918             }
 919           break;
 920         case RECORD_SYS_SHUTDOWN:
 921         case RECORD_SYS_SETSOCKOPT:
 922           break;
 923         case RECORD_SYS_GETSOCKOPT:
 924           {
 925             gdb_byte *a = (gdb_byte *) alloca (tdep->size_ulong * 2);
 926             gdb_byte *av = (gdb_byte *) alloca (tdep->size_int);
 927
 928             regcache_raw_read_unsigned (regcache, tdep->arg2,
 929                                         &tmpulongest);
 930             if (tmpulongest)
 931               {
 932                 tmpulongest += tdep->size_ulong * 3;
 933                 if (target_read_memory ((CORE_ADDR) tmpulongest, a,
 934                                         tdep->size_ulong * 2))
 935                   {
 936                     if (record_debug)
 937                       gdb_printf (gdb_stdlog,
 938                                   "Process record: error reading "
 939                                   "memory at addr = 0x%s len = %d.\n",
 940                                   OUTPUT_REG (tmpulongest, tdep->arg2),
 941                                   tdep->size_ulong * 2);
 942                     return -1;
 943                   }
 944                 tmpulongest = extract_unsigned_integer (a + tdep->size_ulong,
 945                                                         tdep->size_ulong,
 946                                                         byte_order);
 947                 if (tmpulongest)
 948                   {
 949                     if (target_read_memory ((CORE_ADDR) tmpulongest, av,
 950                                             tdep->size_int))
 951                       {
 952                         if (record_debug)
 953                           gdb_printf (gdb_stdlog,
 954                                       "Process record: error reading "
 955                                       "memory at addr = 0x%s "
 956                                       "len = %d.\n",
 957                                       phex_nz (tmpulongest,
 958                                                tdep->size_ulong),
 959                                       tdep->size_int);
 960                         return -1;
 961                       }
 962                     tmpaddr
 963                       = (CORE_ADDR) extract_unsigned_integer (a,
 964                                                               tdep->size_ulong,
 965                                                               byte_order);
 966                     tmpint = (int) extract_unsigned_integer (av,
 967                                                              tdep->size_int,
 968                                                              byte_order);
 969                     if (record_full_arch_list_add_mem (tmpaddr, tmpint))
 970                       return -1;
 971                     a += tdep->size_ulong;
 972                     tmpaddr
 973                       = (CORE_ADDR) extract_unsigned_integer (a,
 974                                                               tdep->size_ulong,
 975                                                               byte_order);
 976                     if (record_full_arch_list_add_mem (tmpaddr,
 977                                                        tdep->size_int))
 978                       return -1;
 979                   }
 980               }
 981           }
 982           break;
 983         case RECORD_SYS_SENDMSG:
 984           break;
 985         case RECORD_SYS_RECVMSG:
 986           {
 987             gdb_byte *a = (gdb_byte *) alloca (tdep->size_ulong);
 988
 989             regcache_raw_read_unsigned (regcache, tdep->arg2,
 990                                         &tmpulongest);
 991             if (tmpulongest)
 992               {
 993                 tmpulongest += tdep->size_ulong;
 994                 if (target_read_memory ((CORE_ADDR) tmpulongest, a,
 995                                         tdep->size_ulong))
 996                   {
 997                     if (record_debug)
 998                       gdb_printf (gdb_stdlog,
 999                                   "Process record: error reading "
1000                                   "memory at addr = 0x%s len = %d.\n",
1001                                   OUTPUT_REG (tmpulongest, tdep->arg2),
1002                                   tdep->size_ulong);
1003                     return -1;
1004                   }
1005                 tmpulongest = extract_unsigned_integer (a, tdep->size_ulong,
1006                                                         byte_order);
1007                 if (record_linux_msghdr (regcache, tdep, tmpulongest))
1008                   return -1;
1009               }
1010           }
1011           break;
1012         default:
1013           gdb_printf (gdb_stderr,
1014                       _("Process record and replay target "
1015                         "doesn't support socketcall call 0x%s\n"),
1016                       OUTPUT_REG (tmpulongest, tdep->arg1));
1017           return -1;
1018           break;
1019         }
1020       break;
1021
1022     case gdb_sys_syslog:
1023       break;
1024
1025     case gdb_sys_setitimer:
1026       if (record_mem_at_reg (regcache, tdep->arg3, tdep->size_itimerval))
1027         return -1;
1028       break;
1029
1030     case gdb_sys_getitimer:
1031       if (record_mem_at_reg (regcache, tdep->arg2, tdep->size_itimerval))
1032         return -1;
1033       break;
1034
1035     case gdb_sys_newstat:
1036     case gdb_sys_newlstat:
1037     case gdb_sys_newfstat:
1038       if (record_mem_at_reg (regcache, tdep->arg2, tdep->size_stat))
1039         return -1;
1040       break;
1041
1042     case gdb_sys_newfstatat:
1043       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1044       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1045                                          tdep->size_stat))
1046         return -1;
1047       break;
1048
1049     case gdb_sys_uname:
1050       if (record_mem_at_reg (regcache, tdep->arg1,
1051                              tdep->size_old_utsname))
1052         return -1;
1053       break;
1054
1055     case gdb_sys_iopl:
1056     case gdb_sys_vhangup:
1057     case gdb_sys_ni_syscall112:
1058     case gdb_sys_vm86old:
1059       break;
1060
1061     case gdb_sys_wait4:
1062       if (record_mem_at_reg (regcache, tdep->arg2, tdep->size_int)
1063           || record_mem_at_reg (regcache, tdep->arg4, tdep->size_rusage))
1064         return -1;
1065       break;
1066
1067     case gdb_sys_swapoff:
1068       break;
1069
1070     case gdb_sys_sysinfo:
1071       if (record_mem_at_reg (regcache, tdep->arg1, tdep->size_sysinfo))
1072         return -1;
1073       break;
1074
1075     case gdb_sys_shmget:
1076     case gdb_sys_semget:
1077     case gdb_sys_semop:
1078     case gdb_sys_msgget:
1079       /* XXX maybe need do some record works with sys_shmdt.  */
1080     case gdb_sys_shmdt:
1081     case gdb_sys_msgsnd:
1082     case gdb_sys_semtimedop:
1083       break;
1084
1085     case gdb_sys_shmat:
1086       if (record_mem_at_reg (regcache, tdep->arg3, tdep->size_ulong))
1087         return -1;
1088       break;
1089
1090     case gdb_sys_shmctl:
1091       if (record_mem_at_reg (regcache, tdep->arg3, tdep->size_shmid_ds))
1092         return -1;
1093       break;
1094
1095       /* XXX sys_semctl 525 still not supported.  */
1096       /* sys_semctl */
1097
1098     case gdb_sys_msgrcv:
1099       {
1100         LONGEST l;
1101
1102         regcache_raw_read_signed (regcache, tdep->arg3, &l);
1103         tmpint = l + tdep->size_long;
1104         if (record_mem_at_reg (regcache, tdep->arg2, tmpint))
1105           return -1;
1106       }
1107       break;
1108
1109     case gdb_sys_msgctl:
1110       if (record_mem_at_reg (regcache, tdep->arg3, tdep->size_msqid_ds))
1111         return -1;
1112       break;
1113
1114     case gdb_sys_ipc:
1115       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1116       tmpulongest &= 0xffff;
1117       switch (tmpulongest)
1118         {
1119         case RECORD_SEMOP:
1120         case RECORD_SEMGET:
1121         case RECORD_SEMTIMEDOP:
1122         case RECORD_MSGSND:
1123         case RECORD_MSGGET:
1124           /* XXX maybe need do some record works with RECORD_SHMDT.  */
1125         case RECORD_SHMDT:
1126         case RECORD_SHMGET:
1127           break;
1128         case RECORD_MSGRCV:
1129           {
1130             LONGEST second;
1131
1132             regcache_raw_read_signed (regcache, tdep->arg3, &second);
1133             tmpint = (int) second + tdep->size_long;
1134             if (record_mem_at_reg (regcache, tdep->arg5, tmpint))
1135               return -1;
1136           }
1137           break;
1138         case RECORD_MSGCTL:
1139           if (record_mem_at_reg (regcache, tdep->arg5,
1140                                  tdep->size_msqid_ds))
1141             return -1;
1142           break;
1143         case RECORD_SHMAT:
1144           if (record_mem_at_reg (regcache, tdep->arg4, tdep->size_ulong))
1145             return -1;
1146           break;
1147         case RECORD_SHMCTL:
1148           if (record_mem_at_reg (regcache, tdep->arg5,
1149                                  tdep->size_shmid_ds))
1150             return -1;
1151           break;
1152         default:
1153           /* XXX RECORD_SEMCTL still not supported.  */
1154           gdb_printf (gdb_stderr,
1155                       _("Process record and replay target doesn't "
1156                         "support ipc number %s\n"),
1157                       pulongest (tmpulongest));
1158           break;
1159         }
1160       break;
1161
1162     case gdb_sys_fsync:
1163     case gdb_sys_sigreturn:
1164     case gdb_sys_clone:
1165     case gdb_sys_setdomainname:
1166       break;
1167
1168     case gdb_sys_newuname:
1169       if (record_mem_at_reg (regcache, tdep->arg1,
1170                              tdep->size_new_utsname))
1171         return -1;
1172       break;
1173
1174     case gdb_sys_modify_ldt:
1175       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1176       if (tmpulongest == 0 || tmpulongest == 2)
1177         {
1178           ULONGEST bytecount;
1179
1180           regcache_raw_read_unsigned (regcache, tdep->arg3, &bytecount);
1181           if (record_mem_at_reg (regcache, tdep->arg2, (int) bytecount))
1182             return -1;
1183         }
1184       break;
1185
1186     case gdb_sys_adjtimex:
1187       if (record_mem_at_reg (regcache, tdep->arg1, tdep->size_timex))
1188         return -1;
1189       break;
1190
1191     case gdb_sys_mprotect:
1192       break;
1193
1194     case gdb_sys_sigprocmask:
1195       if (record_mem_at_reg (regcache, tdep->arg3,
1196                              tdep->size_old_sigset_t))
1197         return -1;
1198       break;
1199
1200     case gdb_sys_ni_syscall127:
1201     case gdb_sys_init_module:
1202     case gdb_sys_delete_module:
1203     case gdb_sys_ni_syscall130:
1204       break;
1205
1206     case gdb_sys_quotactl:
1207       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1208       switch (tmpulongest)
1209         {
1210         case RECORD_Q_GETFMT:
1211           /* __u32 */
1212           if (record_mem_at_reg (regcache, tdep->arg4, 4))
1213             return -1;
1214           break;
1215         case RECORD_Q_GETINFO:
1216           if (record_mem_at_reg (regcache, tdep->arg4,
1217                                  tdep->size_mem_dqinfo))
1218             return -1;
1219           break;
1220         case RECORD_Q_GETQUOTA:
1221           if (record_mem_at_reg (regcache, tdep->arg4,
1222                                  tdep->size_if_dqblk))
1223             return -1;
1224           break;
1225         case RECORD_Q_XGETQSTAT:
1226         case RECORD_Q_XGETQUOTA:
1227           if (record_mem_at_reg (regcache, tdep->arg4,
1228                                  tdep->size_fs_quota_stat))
1229             return -1;
1230           break;
1231         }
1232       break;
1233
1234     case gdb_sys_getpgid:
1235     case gdb_sys_fchdir:
1236     case gdb_sys_bdflush:
1237       break;
1238
1239     case gdb_sys_sysfs:
1240       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1241       if (tmpulongest == 2)
1242         {
1243           /*XXX the size of memory is not very clear.  */
1244           if (record_mem_at_reg (regcache, tdep->arg3, 10))
1245             return -1;
1246         }
1247       break;
1248
1249     case gdb_sys_personality:
1250     case gdb_sys_ni_syscall137:
1251     case gdb_sys_setfsuid16:
1252     case gdb_sys_setfsgid16:
1253       break;
1254
1255     case gdb_sys_llseek:
1256       if (record_mem_at_reg (regcache, tdep->arg4, tdep->size_loff_t))
1257         return -1;
1258       break;
1259
1260     case gdb_sys_getdents:
1261     case gdb_sys_getdents64:
1262       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1263       if (record_mem_at_reg (regcache, tdep->arg2, tmpulongest))
1264         return -1;
1265       break;
1266
1267     case gdb_sys_select:
1268       if (record_mem_at_reg (regcache, tdep->arg2, tdep->size_fd_set)
1269           || record_mem_at_reg (regcache, tdep->arg3, tdep->size_fd_set)
1270           || record_mem_at_reg (regcache, tdep->arg4, tdep->size_fd_set)
1271           || record_mem_at_reg (regcache, tdep->arg5, tdep->size_timeval))
1272         return -1;
1273       break;
1274
1275     case gdb_sys_flock:
1276     case gdb_sys_msync:
1277       break;
1278
1279     case gdb_sys_readv:
1280       {
1281         ULONGEST vec, vlen;
1282
1283         regcache_raw_read_unsigned (regcache, tdep->arg2, &vec);
1284         if (vec)
1285           {
1286             gdb_byte *iov = (gdb_byte *) alloca (tdep->size_iovec);
1287
1288             regcache_raw_read_unsigned (regcache, tdep->arg3, &vlen);
1289             for (tmpulongest = 0; tmpulongest < vlen; tmpulongest++)
1290               {
1291                 if (target_read_memory ((CORE_ADDR) vec, iov,
1292                                         tdep->size_iovec))
1293                   {
1294                     if (record_debug)
1295                       gdb_printf (gdb_stdlog,
1296                                   "Process record: error reading "
1297                                   "memory at addr = 0x%s len = %d.\n",
1298                                   OUTPUT_REG (vec, tdep->arg2),
1299                                   tdep->size_iovec);
1300                     return -1;
1301                   }
1302                 tmpaddr
1303                   = (CORE_ADDR) extract_unsigned_integer (iov,
1304                                                           tdep->size_pointer,
1305                                                           byte_order);
1306                 tmpint
1307                   = (int) extract_unsigned_integer (iov + tdep->size_pointer,
1308                                                     tdep->size_size_t,
1309                                                     byte_order);
1310                 if (record_full_arch_list_add_mem (tmpaddr, tmpint))
1311                   return -1;
1312                 vec += tdep->size_iovec;
1313               }
1314           }
1315       }
1316       break;
1317
1318     case gdb_sys_writev:
1319     case gdb_sys_getsid:
1320     case gdb_sys_fdatasync:
1321     case gdb_sys_sysctl:
1322     case gdb_sys_mlock:
1323     case gdb_sys_munlock:
1324     case gdb_sys_mlockall:
1325     case gdb_sys_munlockall:
1326     case gdb_sys_sched_setparam:
1327       break;
1328
1329     case gdb_sys_sched_getparam:
1330       if (record_mem_at_reg (regcache, tdep->arg2, tdep->size_int))
1331         return -1;
1332       break;
1333
1334     case gdb_sys_sched_setscheduler:
1335     case gdb_sys_sched_getscheduler:
1336     case gdb_sys_sched_yield:
1337     case gdb_sys_sched_get_priority_max:
1338     case gdb_sys_sched_get_priority_min:
1339       break;
1340
1341     case gdb_sys_sched_rr_get_interval:
1342     case gdb_sys_nanosleep:
1343       if (record_mem_at_reg (regcache, tdep->arg2, tdep->size_timespec))
1344         return -1;
1345       break;
1346
1347     case gdb_sys_mremap:
1348     case gdb_sys_setresuid16:
1349       break;
1350
1351     case gdb_sys_getresuid16:
1352       if (record_mem_at_reg (regcache, tdep->arg1, tdep->size_old_uid_t)
1353           || record_mem_at_reg (regcache, tdep->arg2,
1354                                 tdep->size_old_uid_t)
1355           || record_mem_at_reg (regcache, tdep->arg3,
1356                                 tdep->size_old_uid_t))
1357         return -1;
1358       break;
1359
1360     case gdb_sys_vm86:
1361     case gdb_sys_ni_syscall167:
1362       break;
1363
1364     case gdb_sys_poll:
1365       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1366       if (tmpulongest)
1367         {
1368           ULONGEST nfds;
1369
1370           regcache_raw_read_unsigned (regcache, tdep->arg2, &nfds);
1371           if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1372                                              tdep->size_pollfd * nfds))
1373             return -1;
1374         }
1375       break;
1376
1377     case gdb_sys_nfsservctl:
1378       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1379       if (tmpulongest == 7 || tmpulongest == 8)
1380         {
1381           int rsize;
1382
1383           if (tmpulongest == 7)
1384             rsize = tdep->size_NFS_FHSIZE;
1385           else
1386             rsize = tdep->size_knfsd_fh;
1387           if (record_mem_at_reg (regcache, tdep->arg3, rsize))
1388             return -1;
1389         }
1390       break;
1391
1392     case gdb_sys_setresgid16:
1393       break;
1394
1395     case gdb_sys_getresgid16:
1396       if (record_mem_at_reg (regcache, tdep->arg1, tdep->size_old_gid_t)
1397           || record_mem_at_reg (regcache, tdep->arg2,
1398                                 tdep->size_old_gid_t)
1399           || record_mem_at_reg (regcache, tdep->arg3,
1400                                 tdep->size_old_gid_t))
1401         return -1;
1402       break;
1403
1404     case gdb_sys_prctl:
1405       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1406       switch (tmpulongest)
1407         {
1408         case 2:
1409           if (record_mem_at_reg (regcache, tdep->arg2, tdep->size_int))
1410             return -1;
1411           break;
1412         case 16:
1413           if (record_mem_at_reg (regcache, tdep->arg2,
1414                                  tdep->size_TASK_COMM_LEN))
1415             return -1;
1416           break;
1417         }
1418       break;
1419
1420     case gdb_sys_rt_sigreturn:
1421       break;
1422
1423     case gdb_sys_rt_sigaction:
1424       if (record_mem_at_reg (regcache, tdep->arg3, tdep->size_sigaction))
1425         return -1;
1426       break;
1427
1428     case gdb_sys_rt_sigprocmask:
1429       if (record_mem_at_reg (regcache, tdep->arg3, tdep->size_sigset_t))
1430         return -1;
1431       break;
1432
1433     case gdb_sys_rt_sigpending:
1434       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1435       if (tmpulongest)
1436         {
1437           ULONGEST sigsetsize;
1438
1439           regcache_raw_read_unsigned (regcache, tdep->arg2,&sigsetsize);
1440           if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1441                                              (int) sigsetsize))
1442             return -1;
1443         }
1444       break;
1445
1446     case gdb_sys_rt_sigtimedwait:
1447       if (record_mem_at_reg (regcache, tdep->arg2, tdep->size_siginfo_t))
1448         return -1;
1449       break;
1450
1451     case gdb_sys_rt_sigqueueinfo:
1452     case gdb_sys_rt_sigsuspend:
1453       break;
1454
1455     case gdb_sys_pread64:
1456       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1457       if (tmpulongest)
1458         {
1459           ULONGEST count;
1460
1461           regcache_raw_read_unsigned (regcache, tdep->arg3,&count);
1462           if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1463                                              (int) count))
1464             return -1;
1465         }
1466       break;
1467
1468     case gdb_sys_pwrite64:
1469     case gdb_sys_chown16:
1470       break;
1471
1472     case gdb_sys_getcwd:
1473       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1474       if (tmpulongest)
1475         {
1476           ULONGEST size;
1477
1478           regcache_raw_read_unsigned (regcache, tdep->arg2, &size);
1479           if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1480                                              (int) size))
1481             return -1;
1482         }
1483       break;
1484
1485     case gdb_sys_capget:
1486       if (record_mem_at_reg (regcache, tdep->arg2,
1487                              tdep->size_cap_user_data_t))
1488         return -1;
1489       break;
1490
1491     case gdb_sys_capset:
1492       break;
1493
1494     case gdb_sys_sigaltstack:
1495       if (record_mem_at_reg (regcache, tdep->arg2, tdep->size_stack_t))
1496         return -1;
1497       break;
1498
1499     case gdb_sys_sendfile:
1500       if (record_mem_at_reg (regcache, tdep->arg3, tdep->size_off_t))
1501         return -1;
1502       break;
1503
1504     case gdb_sys_ni_syscall188:
1505     case gdb_sys_ni_syscall189:
1506     case gdb_sys_vfork:
1507       break;
1508
1509     case gdb_sys_getrlimit:
1510       if (record_mem_at_reg (regcache, tdep->arg2, tdep->size_rlimit))
1511         return -1;
1512       break;
1513
1514     case gdb_sys_mmap2:
1515       break;
1516
1517     case gdb_sys_truncate64:
1518     case gdb_sys_ftruncate64:
1519       break;
1520
1521     case gdb_sys_stat64:
1522     case gdb_sys_lstat64:
1523     case gdb_sys_fstat64:
1524       if (record_mem_at_reg (regcache, tdep->arg2, tdep->size_stat64))
1525         return -1;
1526       break;
1527
1528     case gdb_sys_lchown:
1529     case gdb_sys_getuid:
1530     case gdb_sys_getgid:
1531     case gdb_sys_geteuid:
1532     case gdb_sys_getegid:
1533     case gdb_sys_setreuid:
1534     case gdb_sys_setregid:
1535       break;
1536
1537     case gdb_sys_getgroups:
1538       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1539       if (tmpulongest)
1540         {
1541           ULONGEST gidsetsize;
1542
1543           regcache_raw_read_unsigned (regcache, tdep->arg1,
1544                                       &gidsetsize);
1545           tmpint = tdep->size_gid_t * (int) gidsetsize;
1546           if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest, tmpint))
1547             return -1;
1548         }
1549       break;
1550
1551     case gdb_sys_setgroups:
1552     case gdb_sys_fchown:
1553     case gdb_sys_setresuid:
1554       break;
1555
1556     case gdb_sys_getresuid:
1557       if (record_mem_at_reg (regcache, tdep->arg1, tdep->size_uid_t)
1558           || record_mem_at_reg (regcache, tdep->arg2, tdep->size_uid_t)
1559           || record_mem_at_reg (regcache, tdep->arg3, tdep->size_uid_t))
1560         return -1;
1561       break;
1562
1563     case gdb_sys_setresgid:
1564       break;
1565
1566     case gdb_sys_getresgid:
1567       if (record_mem_at_reg (regcache, tdep->arg1, tdep->size_gid_t)
1568           || record_mem_at_reg (regcache, tdep->arg2, tdep->size_gid_t)
1569           || record_mem_at_reg (regcache, tdep->arg3, tdep->size_gid_t))
1570         return -1;
1571       break;
1572
1573     case gdb_sys_chown:
1574     case gdb_sys_setuid:
1575     case gdb_sys_setgid:
1576     case gdb_sys_setfsuid:
1577     case gdb_sys_setfsgid:
1578     case gdb_sys_pivot_root:
1579       break;
1580
1581     case gdb_sys_mincore:
1582       if (record_mem_at_reg (regcache, tdep->arg3, tdep->size_PAGE_SIZE))
1583         return -1;
1584       break;
1585
1586     case gdb_sys_madvise:
1587       break;
1588
1589     case gdb_sys_fcntl64:
1590       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1591       if (tmpulongest == tdep->fcntl_F_GETLK64)
1592         {
1593           if (record_mem_at_reg (regcache, tdep->arg3,
1594                                  tdep->size_flock64))
1595             return -1;
1596         }
1597       else if (tmpulongest != tdep->fcntl_F_SETLK64
1598                && tmpulongest != tdep->fcntl_F_SETLKW64)
1599         {
1600           goto sys_fcntl;
1601         }
1602       break;
1603
1604     case gdb_sys_ni_syscall222:
1605     case gdb_sys_ni_syscall223:
1606     case gdb_sys_gettid:
1607     case gdb_sys_readahead:
1608     case gdb_sys_setxattr:
1609     case gdb_sys_lsetxattr:
1610     case gdb_sys_fsetxattr:
1611       break;
1612
1613     case gdb_sys_getxattr:
1614     case gdb_sys_lgetxattr:
1615     case gdb_sys_fgetxattr:
1616       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1617       if (tmpulongest)
1618         {
1619           ULONGEST size;
1620
1621           regcache_raw_read_unsigned (regcache, tdep->arg4, &size);
1622           if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1623                                              (int) size))
1624             return -1;
1625         }
1626       break;
1627
1628     case gdb_sys_listxattr:
1629     case gdb_sys_llistxattr:
1630     case gdb_sys_flistxattr:
1631       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1632       if (tmpulongest)
1633         {
1634           ULONGEST size;
1635
1636           regcache_raw_read_unsigned (regcache, tdep->arg3, &size);
1637           if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1638                                              (int) size))
1639             return -1;
1640         }
1641       break;
1642
1643     case gdb_sys_removexattr:
1644     case gdb_sys_lremovexattr:
1645     case gdb_sys_fremovexattr:
1646     case gdb_sys_tkill:
1647       break;
1648
1649     case gdb_sys_sendfile64:
1650       if (record_mem_at_reg (regcache, tdep->arg3, tdep->size_loff_t))
1651         return -1;
1652       break;
1653
1654     case gdb_sys_futex:
1655     case gdb_sys_sched_setaffinity:
1656       break;
1657
1658     case gdb_sys_sched_getaffinity:
1659       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1660       if (tmpulongest)
1661         {
1662           ULONGEST len;
1663
1664           regcache_raw_read_unsigned (regcache, tdep->arg2, &len);
1665           if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1666                                              (int) len))
1667             return -1;
1668         }
1669       break;
1670
1671     case gdb_sys_set_thread_area:
1672       if (record_mem_at_reg (regcache, tdep->arg1, tdep->size_int))
1673         return -1;
1674       break;
1675
1676     case gdb_sys_get_thread_area:
1677       if (record_mem_at_reg (regcache, tdep->arg1, tdep->size_user_desc))
1678         return -1;
1679       break;
1680
1681     case gdb_sys_io_setup:
1682       if (record_mem_at_reg (regcache, tdep->arg2, tdep->size_long))
1683         return -1;
1684       break;
1685
1686     case gdb_sys_io_destroy:
1687       break;
1688
1689     case gdb_sys_io_getevents:
1690       regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
1691       if (tmpulongest)
1692         {
1693           ULONGEST nr;
1694
1695           regcache_raw_read_unsigned (regcache, tdep->arg3, &nr);
1696           if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1697                                              nr * tdep->size_io_event))
1698             return -1;
1699         }
1700       break;
1701
1702     case gdb_sys_io_submit:
1703       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1704       if (tmpulongest)
1705         {
1706           ULONGEST nr, i;
1707           gdb_byte *iocbp;
1708
1709           regcache_raw_read_unsigned (regcache, tdep->arg2, &nr);
1710           iocbp = (gdb_byte *) alloca (nr * tdep->size_pointer);
1711           if (target_read_memory ((CORE_ADDR) tmpulongest, iocbp,
1712                                   nr * tdep->size_pointer))
1713             {
1714               if (record_debug)
1715                 gdb_printf (gdb_stdlog,
1716                             "Process record: error reading memory "
1717                             "at addr = 0x%s len = %u.\n",
1718                             OUTPUT_REG (tmpulongest, tdep->arg2),
1719                             (int) (nr * tdep->size_pointer));
1720               return -1;
1721             }
1722           for (i = 0; i < nr; i++)
1723             {
1724               tmpaddr
1725                 = (CORE_ADDR) extract_unsigned_integer (iocbp,
1726                                                         tdep->size_pointer,
1727                                                         byte_order);
1728               if (record_full_arch_list_add_mem (tmpaddr, tdep->size_iocb))
1729                 return -1;
1730               iocbp += tdep->size_pointer;
1731             }
1732         }
1733       break;
1734
1735     case gdb_sys_io_cancel:
1736       if (record_mem_at_reg (regcache, tdep->arg3, tdep->size_io_event))
1737         return -1;
1738       break;
1739
1740     case gdb_sys_fadvise64:
1741     case gdb_sys_ni_syscall251:
1742       break;
1743
1744     case gdb_sys_exit_group:
1745       if (yquery (_("The next instruction is syscall exit_group.  "
1746                     "It will make the program exit.  "
1747                     "Do you want to stop the program?")))
1748         return 1;
1749       break;
1750
1751     case gdb_sys_lookup_dcookie:
1752       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1753       if (tmpulongest)
1754         {
1755           ULONGEST len;
1756
1757           regcache_raw_read_unsigned (regcache, tdep->arg3, &len);
1758           if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1759                                              (int) len))
1760             return -1;
1761         }
1762       break;
1763
1764     case gdb_sys_epoll_create:
1765     case gdb_sys_epoll_ctl:
1766       break;
1767
1768     case gdb_sys_epoll_wait:
1769       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1770       if (tmpulongest)
1771         {
1772           ULONGEST maxevents;
1773
1774           regcache_raw_read_unsigned (regcache, tdep->arg3, &maxevents);
1775           if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1776                                              (maxevents
1777                                               * tdep->size_epoll_event)))
1778             return -1;
1779         }
1780       break;
1781
1782     case gdb_sys_remap_file_pages:
1783     case gdb_sys_set_tid_address:
1784       break;
1785
1786     case gdb_sys_timer_create:
1787       if (record_mem_at_reg (regcache, tdep->arg3, tdep->size_int))
1788         return -1;
1789       break;
1790
1791     case gdb_sys_timer_settime:
1792       if (record_mem_at_reg (regcache, tdep->arg4, tdep->size_itimerspec))
1793         return -1;
1794       break;
1795
1796     case gdb_sys_timer_gettime:
1797       if (record_mem_at_reg (regcache, tdep->arg2, tdep->size_itimerspec))
1798         return -1;
1799       break;
1800
1801     case gdb_sys_timer_getoverrun:
1802     case gdb_sys_timer_delete:
1803     case gdb_sys_clock_settime:
1804       break;
1805
1806     case gdb_sys_clock_gettime:
1807       if (record_mem_at_reg (regcache, tdep->arg2, tdep->size_timespec))
1808         return -1;
1809       break;
1810
1811     case gdb_sys_clock_getres:
1812       if (record_mem_at_reg (regcache, tdep->arg2, tdep->size_timespec))
1813         return -1;
1814       break;
1815
1816     case gdb_sys_clock_nanosleep:
1817       if (record_mem_at_reg (regcache, tdep->arg4, tdep->size_timespec))
1818         return -1;
1819       break;
1820
1821     case gdb_sys_statfs64:
1822     case gdb_sys_fstatfs64:
1823       if (record_mem_at_reg (regcache, tdep->arg3, tdep->size_statfs64))
1824         return -1;
1825       break;
1826
1827     case gdb_sys_tgkill:
1828     case gdb_sys_utimes:
1829     case gdb_sys_fadvise64_64:
1830     case gdb_sys_ni_syscall273:
1831     case gdb_sys_mbind:
1832       break;
1833
1834     case gdb_sys_get_mempolicy:
1835       if (record_mem_at_reg (regcache, tdep->arg1, tdep->size_int))
1836         return -1;
1837       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1838       if (tmpulongest)
1839         {
1840           ULONGEST maxnode;
1841
1842           regcache_raw_read_unsigned (regcache, tdep->arg3, &maxnode);
1843           if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1844                                              maxnode * tdep->size_long))
1845             return -1;
1846         }
1847       break;
1848
1849     case gdb_sys_set_mempolicy:
1850     case gdb_sys_mq_open:
1851     case gdb_sys_mq_unlink:
1852     case gdb_sys_mq_timedsend:
1853       break;
1854
1855     case gdb_sys_mq_timedreceive:
1856       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1857       if (tmpulongest)
1858         {
1859           ULONGEST msg_len;
1860
1861           regcache_raw_read_unsigned (regcache, tdep->arg3, &msg_len);
1862           if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1863                                              (int) msg_len))
1864             return -1;
1865         }
1866       if (record_mem_at_reg (regcache, tdep->arg4, tdep->size_int))
1867         return -1;
1868       break;
1869
1870     case gdb_sys_mq_notify:
1871       break;
1872
1873     case gdb_sys_mq_getsetattr:
1874       if (record_mem_at_reg (regcache, tdep->arg3, tdep->size_mq_attr))
1875         return -1;
1876       break;
1877
1878     case gdb_sys_kexec_load:
1879       break;
1880
1881     case gdb_sys_waitid:
1882       if (record_mem_at_reg (regcache, tdep->arg3, tdep->size_siginfo_t)
1883           || record_mem_at_reg (regcache, tdep->arg5, tdep->size_rusage))
1884         return -1;
1885       break;
1886
1887     case gdb_sys_ni_syscall285:
1888     case gdb_sys_add_key:
1889     case gdb_sys_request_key:
1890       break;
1891
1892     case gdb_sys_keyctl:
1893       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1894       if (tmpulongest == 6 || tmpulongest == 11)
1895         {
1896           regcache_raw_read_unsigned (regcache, tdep->arg3,
1897                                       &tmpulongest);
1898           if (tmpulongest)
1899             {
1900               ULONGEST buflen;
1901
1902               regcache_raw_read_unsigned (regcache, tdep->arg4, &buflen);
1903               if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1904                                                  (int) buflen))
1905                 return -1;
1906             }
1907         }
1908       break;
1909
1910     case gdb_sys_ioprio_set:
1911     case gdb_sys_ioprio_get:
1912     case gdb_sys_inotify_init:
1913     case gdb_sys_inotify_add_watch:
1914     case gdb_sys_inotify_rm_watch:
1915     case gdb_sys_migrate_pages:
1916     case gdb_sys_openat:
1917     case gdb_sys_mkdirat:
1918     case gdb_sys_mknodat:
1919     case gdb_sys_fchownat:
1920     case gdb_sys_futimesat:
1921       break;
1922
1923     case gdb_sys_fstatat64:
1924       if (record_mem_at_reg (regcache, tdep->arg3, tdep->size_stat64))
1925         return -1;
1926       break;
1927
1928     case gdb_sys_unlinkat:
1929     case gdb_sys_renameat:
1930     case gdb_sys_linkat:
1931     case gdb_sys_symlinkat:
1932       break;
1933
1934     case gdb_sys_readlinkat:
1935       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1936       if (tmpulongest)
1937         {
1938           ULONGEST bufsiz;
1939
1940           regcache_raw_read_unsigned (regcache, tdep->arg4, &bufsiz);
1941           if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1942                                              (int) bufsiz))
1943             return -1;
1944         }
1945       break;
1946
1947     case gdb_sys_fchmodat:
1948     case gdb_sys_faccessat:
1949       break;
1950
1951     case gdb_sys_pselect6:
1952       if (record_mem_at_reg (regcache, tdep->arg2, tdep->size_fd_set)
1953           || record_mem_at_reg (regcache, tdep->arg3, tdep->size_fd_set)
1954           || record_mem_at_reg (regcache, tdep->arg4, tdep->size_fd_set)
1955           || record_mem_at_reg (regcache, tdep->arg5, tdep->size_timespec))
1956         return -1;
1957       break;
1958
1959     case gdb_sys_ppoll:
1960       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1961       if (tmpulongest)
1962         {
1963           ULONGEST nfds;
1964
1965           regcache_raw_read_unsigned (regcache, tdep->arg2, &nfds);
1966           if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1967                                              tdep->size_pollfd * nfds))
1968             return -1;
1969         }
1970       if (record_mem_at_reg (regcache, tdep->arg3, tdep->size_timespec))
1971         return -1;
1972       break;
1973
1974     case gdb_sys_unshare:
1975     case gdb_sys_set_robust_list:
1976       break;
1977
1978     case gdb_sys_get_robust_list:
1979       if (record_mem_at_reg (regcache, tdep->arg2, tdep->size_int)
1980           || record_mem_at_reg (regcache, tdep->arg3, tdep->size_int))
1981         return -1;
1982       break;
1983
1984     case gdb_sys_splice:
1985       if (record_mem_at_reg (regcache, tdep->arg2, tdep->size_loff_t)
1986           || record_mem_at_reg (regcache, tdep->arg4, tdep->size_loff_t))
1987         return -1;
1988       break;
1989
1990     case gdb_sys_sync_file_range:
1991     case gdb_sys_tee:
1992     case gdb_sys_vmsplice:
1993       break;
1994
1995     case gdb_sys_move_pages:
1996       regcache_raw_read_unsigned (regcache, tdep->arg5, &tmpulongest);
1997       if (tmpulongest)
1998         {
1999           ULONGEST nr_pages;
2000
2001           regcache_raw_read_unsigned (regcache, tdep->arg2, &nr_pages);
2002           if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2003                                              nr_pages * tdep->size_int))
2004             return -1;
2005         }
2006       break;
2007
2008     case gdb_sys_getcpu:
2009       if (record_mem_at_reg (regcache, tdep->arg1, tdep->size_int)
2010           || record_mem_at_reg (regcache, tdep->arg2, tdep->size_int)
2011           || record_mem_at_reg (regcache, tdep->arg3,
2012                                 tdep->size_ulong * 2))
2013         return -1;
2014       break;
2015
2016     case gdb_sys_epoll_pwait:
2017       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
2018       if (tmpulongest)
2019         {
2020           ULONGEST maxevents;
2021
2022           regcache_raw_read_unsigned (regcache, tdep->arg3, &maxevents);
2023           tmpint = (int) maxevents * tdep->size_epoll_event;
2024           if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest, tmpint))
2025             return -1;
2026         }
2027       break;
2028
2029     case gdb_sys_fallocate:
2030     case gdb_sys_eventfd2:
2031     case gdb_sys_epoll_create1:
2032     case gdb_sys_dup3:
2033       break;
2034
2035     case gdb_sys_inotify_init1:
2036       break;
2037
2038     default:
2039       gdb_printf (gdb_stderr,
2040                   _("Process record and replay target doesn't "
2041                     "support syscall number %d\n"), syscall);
2042       return -1;
2043       break;
2044     }
2045
2046   return 0;
2047 }