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_statx:
1050       regcache_raw_read_unsigned (regcache, tdep->arg5, &tmpulongest);
1051       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest, 256))
1052         return -1;
1053       break;
1054
1055     case gdb_sys_uname:
1056       if (record_mem_at_reg (regcache, tdep->arg1,
1057                              tdep->size_old_utsname))
1058         return -1;
1059       break;
1060
1061     case gdb_sys_iopl:
1062     case gdb_sys_vhangup:
1063     case gdb_sys_ni_syscall112:
1064     case gdb_sys_vm86old:
1065       break;
1066
1067     case gdb_sys_wait4:
1068       if (record_mem_at_reg (regcache, tdep->arg2, tdep->size_int)
1069           || record_mem_at_reg (regcache, tdep->arg4, tdep->size_rusage))
1070         return -1;
1071       break;
1072
1073     case gdb_sys_swapoff:
1074       break;
1075
1076     case gdb_sys_sysinfo:
1077       if (record_mem_at_reg (regcache, tdep->arg1, tdep->size_sysinfo))
1078         return -1;
1079       break;
1080
1081     case gdb_sys_shmget:
1082     case gdb_sys_semget:
1083     case gdb_sys_semop:
1084     case gdb_sys_msgget:
1085       /* XXX maybe need do some record works with sys_shmdt.  */
1086     case gdb_sys_shmdt:
1087     case gdb_sys_msgsnd:
1088     case gdb_sys_semtimedop:
1089       break;
1090
1091     case gdb_sys_shmat:
1092       if (record_mem_at_reg (regcache, tdep->arg3, tdep->size_ulong))
1093         return -1;
1094       break;
1095
1096     case gdb_sys_shmctl:
1097       if (record_mem_at_reg (regcache, tdep->arg3, tdep->size_shmid_ds))
1098         return -1;
1099       break;
1100
1101       /* XXX sys_semctl 525 still not supported.  */
1102       /* sys_semctl */
1103
1104     case gdb_sys_msgrcv:
1105       {
1106         LONGEST l;
1107
1108         regcache_raw_read_signed (regcache, tdep->arg3, &l);
1109         tmpint = l + tdep->size_long;
1110         if (record_mem_at_reg (regcache, tdep->arg2, tmpint))
1111           return -1;
1112       }
1113       break;
1114
1115     case gdb_sys_msgctl:
1116       if (record_mem_at_reg (regcache, tdep->arg3, tdep->size_msqid_ds))
1117         return -1;
1118       break;
1119
1120     case gdb_sys_ipc:
1121       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1122       tmpulongest &= 0xffff;
1123       switch (tmpulongest)
1124         {
1125         case RECORD_SEMOP:
1126         case RECORD_SEMGET:
1127         case RECORD_SEMTIMEDOP:
1128         case RECORD_MSGSND:
1129         case RECORD_MSGGET:
1130           /* XXX maybe need do some record works with RECORD_SHMDT.  */
1131         case RECORD_SHMDT:
1132         case RECORD_SHMGET:
1133           break;
1134         case RECORD_MSGRCV:
1135           {
1136             LONGEST second;
1137
1138             regcache_raw_read_signed (regcache, tdep->arg3, &second);
1139             tmpint = (int) second + tdep->size_long;
1140             if (record_mem_at_reg (regcache, tdep->arg5, tmpint))
1141               return -1;
1142           }
1143           break;
1144         case RECORD_MSGCTL:
1145           if (record_mem_at_reg (regcache, tdep->arg5,
1146                                  tdep->size_msqid_ds))
1147             return -1;
1148           break;
1149         case RECORD_SHMAT:
1150           if (record_mem_at_reg (regcache, tdep->arg4, tdep->size_ulong))
1151             return -1;
1152           break;
1153         case RECORD_SHMCTL:
1154           if (record_mem_at_reg (regcache, tdep->arg5,
1155                                  tdep->size_shmid_ds))
1156             return -1;
1157           break;
1158         default:
1159           /* XXX RECORD_SEMCTL still not supported.  */
1160           gdb_printf (gdb_stderr,
1161                       _("Process record and replay target doesn't "
1162                         "support ipc number %s\n"),
1163                       pulongest (tmpulongest));
1164           break;
1165         }
1166       break;
1167
1168     case gdb_sys_fsync:
1169     case gdb_sys_sigreturn:
1170     case gdb_sys_clone:
1171     case gdb_sys_setdomainname:
1172       break;
1173
1174     case gdb_sys_newuname:
1175       if (record_mem_at_reg (regcache, tdep->arg1,
1176                              tdep->size_new_utsname))
1177         return -1;
1178       break;
1179
1180     case gdb_sys_modify_ldt:
1181       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1182       if (tmpulongest == 0 || tmpulongest == 2)
1183         {
1184           ULONGEST bytecount;
1185
1186           regcache_raw_read_unsigned (regcache, tdep->arg3, &bytecount);
1187           if (record_mem_at_reg (regcache, tdep->arg2, (int) bytecount))
1188             return -1;
1189         }
1190       break;
1191
1192     case gdb_sys_adjtimex:
1193       if (record_mem_at_reg (regcache, tdep->arg1, tdep->size_timex))
1194         return -1;
1195       break;
1196
1197     case gdb_sys_mprotect:
1198       break;
1199
1200     case gdb_sys_sigprocmask:
1201       if (record_mem_at_reg (regcache, tdep->arg3,
1202                              tdep->size_old_sigset_t))
1203         return -1;
1204       break;
1205
1206     case gdb_sys_ni_syscall127:
1207     case gdb_sys_init_module:
1208     case gdb_sys_delete_module:
1209     case gdb_sys_ni_syscall130:
1210       break;
1211
1212     case gdb_sys_quotactl:
1213       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1214       switch (tmpulongest)
1215         {
1216         case RECORD_Q_GETFMT:
1217           /* __u32 */
1218           if (record_mem_at_reg (regcache, tdep->arg4, 4))
1219             return -1;
1220           break;
1221         case RECORD_Q_GETINFO:
1222           if (record_mem_at_reg (regcache, tdep->arg4,
1223                                  tdep->size_mem_dqinfo))
1224             return -1;
1225           break;
1226         case RECORD_Q_GETQUOTA:
1227           if (record_mem_at_reg (regcache, tdep->arg4,
1228                                  tdep->size_if_dqblk))
1229             return -1;
1230           break;
1231         case RECORD_Q_XGETQSTAT:
1232         case RECORD_Q_XGETQUOTA:
1233           if (record_mem_at_reg (regcache, tdep->arg4,
1234                                  tdep->size_fs_quota_stat))
1235             return -1;
1236           break;
1237         }
1238       break;
1239
1240     case gdb_sys_getpgid:
1241     case gdb_sys_fchdir:
1242     case gdb_sys_bdflush:
1243       break;
1244
1245     case gdb_sys_sysfs:
1246       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1247       if (tmpulongest == 2)
1248         {
1249           /*XXX the size of memory is not very clear.  */
1250           if (record_mem_at_reg (regcache, tdep->arg3, 10))
1251             return -1;
1252         }
1253       break;
1254
1255     case gdb_sys_personality:
1256     case gdb_sys_ni_syscall137:
1257     case gdb_sys_setfsuid16:
1258     case gdb_sys_setfsgid16:
1259       break;
1260
1261     case gdb_sys_llseek:
1262       if (record_mem_at_reg (regcache, tdep->arg4, tdep->size_loff_t))
1263         return -1;
1264       break;
1265
1266     case gdb_sys_getdents:
1267     case gdb_sys_getdents64:
1268       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1269       if (record_mem_at_reg (regcache, tdep->arg2, tmpulongest))
1270         return -1;
1271       break;
1272
1273     case gdb_sys_select:
1274       if (record_mem_at_reg (regcache, tdep->arg2, tdep->size_fd_set)
1275           || record_mem_at_reg (regcache, tdep->arg3, tdep->size_fd_set)
1276           || record_mem_at_reg (regcache, tdep->arg4, tdep->size_fd_set)
1277           || record_mem_at_reg (regcache, tdep->arg5, tdep->size_timeval))
1278         return -1;
1279       break;
1280
1281     case gdb_sys_flock:
1282     case gdb_sys_msync:
1283       break;
1284
1285     case gdb_sys_readv:
1286       {
1287         ULONGEST vec, vlen;
1288
1289         regcache_raw_read_unsigned (regcache, tdep->arg2, &vec);
1290         if (vec)
1291           {
1292             gdb_byte *iov = (gdb_byte *) alloca (tdep->size_iovec);
1293
1294             regcache_raw_read_unsigned (regcache, tdep->arg3, &vlen);
1295             for (tmpulongest = 0; tmpulongest < vlen; tmpulongest++)
1296               {
1297                 if (target_read_memory ((CORE_ADDR) vec, iov,
1298                                         tdep->size_iovec))
1299                   {
1300                     if (record_debug)
1301                       gdb_printf (gdb_stdlog,
1302                                   "Process record: error reading "
1303                                   "memory at addr = 0x%s len = %d.\n",
1304                                   OUTPUT_REG (vec, tdep->arg2),
1305                                   tdep->size_iovec);
1306                     return -1;
1307                   }
1308                 tmpaddr
1309                   = (CORE_ADDR) extract_unsigned_integer (iov,
1310                                                           tdep->size_pointer,
1311                                                           byte_order);
1312                 tmpint
1313                   = (int) extract_unsigned_integer (iov + tdep->size_pointer,
1314                                                     tdep->size_size_t,
1315                                                     byte_order);
1316                 if (record_full_arch_list_add_mem (tmpaddr, tmpint))
1317                   return -1;
1318                 vec += tdep->size_iovec;
1319               }
1320           }
1321       }
1322       break;
1323
1324     case gdb_sys_writev:
1325     case gdb_sys_getsid:
1326     case gdb_sys_fdatasync:
1327     case gdb_sys_sysctl:
1328     case gdb_sys_mlock:
1329     case gdb_sys_munlock:
1330     case gdb_sys_mlockall:
1331     case gdb_sys_munlockall:
1332     case gdb_sys_sched_setparam:
1333       break;
1334
1335     case gdb_sys_sched_getparam:
1336       if (record_mem_at_reg (regcache, tdep->arg2, tdep->size_int))
1337         return -1;
1338       break;
1339
1340     case gdb_sys_sched_setscheduler:
1341     case gdb_sys_sched_getscheduler:
1342     case gdb_sys_sched_yield:
1343     case gdb_sys_sched_get_priority_max:
1344     case gdb_sys_sched_get_priority_min:
1345       break;
1346
1347     case gdb_sys_sched_rr_get_interval:
1348     case gdb_sys_nanosleep:
1349       if (record_mem_at_reg (regcache, tdep->arg2, tdep->size_timespec))
1350         return -1;
1351       break;
1352
1353     case gdb_sys_mremap:
1354     case gdb_sys_setresuid16:
1355       break;
1356
1357     case gdb_sys_getresuid16:
1358       if (record_mem_at_reg (regcache, tdep->arg1, tdep->size_old_uid_t)
1359           || record_mem_at_reg (regcache, tdep->arg2,
1360                                 tdep->size_old_uid_t)
1361           || record_mem_at_reg (regcache, tdep->arg3,
1362                                 tdep->size_old_uid_t))
1363         return -1;
1364       break;
1365
1366     case gdb_sys_vm86:
1367     case gdb_sys_ni_syscall167:
1368       break;
1369
1370     case gdb_sys_poll:
1371       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1372       if (tmpulongest)
1373         {
1374           ULONGEST nfds;
1375
1376           regcache_raw_read_unsigned (regcache, tdep->arg2, &nfds);
1377           if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1378                                              tdep->size_pollfd * nfds))
1379             return -1;
1380         }
1381       break;
1382
1383     case gdb_sys_nfsservctl:
1384       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1385       if (tmpulongest == 7 || tmpulongest == 8)
1386         {
1387           int rsize;
1388
1389           if (tmpulongest == 7)
1390             rsize = tdep->size_NFS_FHSIZE;
1391           else
1392             rsize = tdep->size_knfsd_fh;
1393           if (record_mem_at_reg (regcache, tdep->arg3, rsize))
1394             return -1;
1395         }
1396       break;
1397
1398     case gdb_sys_setresgid16:
1399       break;
1400
1401     case gdb_sys_getresgid16:
1402       if (record_mem_at_reg (regcache, tdep->arg1, tdep->size_old_gid_t)
1403           || record_mem_at_reg (regcache, tdep->arg2,
1404                                 tdep->size_old_gid_t)
1405           || record_mem_at_reg (regcache, tdep->arg3,
1406                                 tdep->size_old_gid_t))
1407         return -1;
1408       break;
1409
1410     case gdb_sys_prctl:
1411       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1412       switch (tmpulongest)
1413         {
1414         case 2:
1415           if (record_mem_at_reg (regcache, tdep->arg2, tdep->size_int))
1416             return -1;
1417           break;
1418         case 16:
1419           if (record_mem_at_reg (regcache, tdep->arg2,
1420                                  tdep->size_TASK_COMM_LEN))
1421             return -1;
1422           break;
1423         }
1424       break;
1425
1426     case gdb_sys_rt_sigreturn:
1427       break;
1428
1429     case gdb_sys_rt_sigaction:
1430       if (record_mem_at_reg (regcache, tdep->arg3, tdep->size_sigaction))
1431         return -1;
1432       break;
1433
1434     case gdb_sys_rt_sigprocmask:
1435       if (record_mem_at_reg (regcache, tdep->arg3, tdep->size_sigset_t))
1436         return -1;
1437       break;
1438
1439     case gdb_sys_rt_sigpending:
1440       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1441       if (tmpulongest)
1442         {
1443           ULONGEST sigsetsize;
1444
1445           regcache_raw_read_unsigned (regcache, tdep->arg2,&sigsetsize);
1446           if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1447                                              (int) sigsetsize))
1448             return -1;
1449         }
1450       break;
1451
1452     case gdb_sys_rt_sigtimedwait:
1453       if (record_mem_at_reg (regcache, tdep->arg2, tdep->size_siginfo_t))
1454         return -1;
1455       break;
1456
1457     case gdb_sys_rt_sigqueueinfo:
1458     case gdb_sys_rt_sigsuspend:
1459       break;
1460
1461     case gdb_sys_pread64:
1462       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1463       if (tmpulongest)
1464         {
1465           ULONGEST count;
1466
1467           regcache_raw_read_unsigned (regcache, tdep->arg3,&count);
1468           if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1469                                              (int) count))
1470             return -1;
1471         }
1472       break;
1473
1474     case gdb_sys_pwrite64:
1475     case gdb_sys_chown16:
1476       break;
1477
1478     case gdb_sys_getcwd:
1479       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1480       if (tmpulongest)
1481         {
1482           ULONGEST size;
1483
1484           regcache_raw_read_unsigned (regcache, tdep->arg2, &size);
1485           if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1486                                              (int) size))
1487             return -1;
1488         }
1489       break;
1490
1491     case gdb_sys_capget:
1492       if (record_mem_at_reg (regcache, tdep->arg2,
1493                              tdep->size_cap_user_data_t))
1494         return -1;
1495       break;
1496
1497     case gdb_sys_capset:
1498       break;
1499
1500     case gdb_sys_sigaltstack:
1501       if (record_mem_at_reg (regcache, tdep->arg2, tdep->size_stack_t))
1502         return -1;
1503       break;
1504
1505     case gdb_sys_sendfile:
1506       if (record_mem_at_reg (regcache, tdep->arg3, tdep->size_off_t))
1507         return -1;
1508       break;
1509
1510     case gdb_sys_ni_syscall188:
1511     case gdb_sys_ni_syscall189:
1512     case gdb_sys_vfork:
1513       break;
1514
1515     case gdb_sys_getrlimit:
1516       if (record_mem_at_reg (regcache, tdep->arg2, tdep->size_rlimit))
1517         return -1;
1518       break;
1519
1520     case gdb_sys_mmap2:
1521       break;
1522
1523     case gdb_sys_truncate64:
1524     case gdb_sys_ftruncate64:
1525       break;
1526
1527     case gdb_sys_stat64:
1528     case gdb_sys_lstat64:
1529     case gdb_sys_fstat64:
1530       if (record_mem_at_reg (regcache, tdep->arg2, tdep->size_stat64))
1531         return -1;
1532       break;
1533
1534     case gdb_sys_lchown:
1535     case gdb_sys_getuid:
1536     case gdb_sys_getgid:
1537     case gdb_sys_geteuid:
1538     case gdb_sys_getegid:
1539     case gdb_sys_setreuid:
1540     case gdb_sys_setregid:
1541       break;
1542
1543     case gdb_sys_getgroups:
1544       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1545       if (tmpulongest)
1546         {
1547           ULONGEST gidsetsize;
1548
1549           regcache_raw_read_unsigned (regcache, tdep->arg1,
1550                                       &gidsetsize);
1551           tmpint = tdep->size_gid_t * (int) gidsetsize;
1552           if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest, tmpint))
1553             return -1;
1554         }
1555       break;
1556
1557     case gdb_sys_setgroups:
1558     case gdb_sys_fchown:
1559     case gdb_sys_setresuid:
1560       break;
1561
1562     case gdb_sys_getresuid:
1563       if (record_mem_at_reg (regcache, tdep->arg1, tdep->size_uid_t)
1564           || record_mem_at_reg (regcache, tdep->arg2, tdep->size_uid_t)
1565           || record_mem_at_reg (regcache, tdep->arg3, tdep->size_uid_t))
1566         return -1;
1567       break;
1568
1569     case gdb_sys_setresgid:
1570       break;
1571
1572     case gdb_sys_getresgid:
1573       if (record_mem_at_reg (regcache, tdep->arg1, tdep->size_gid_t)
1574           || record_mem_at_reg (regcache, tdep->arg2, tdep->size_gid_t)
1575           || record_mem_at_reg (regcache, tdep->arg3, tdep->size_gid_t))
1576         return -1;
1577       break;
1578
1579     case gdb_sys_chown:
1580     case gdb_sys_setuid:
1581     case gdb_sys_setgid:
1582     case gdb_sys_setfsuid:
1583     case gdb_sys_setfsgid:
1584     case gdb_sys_pivot_root:
1585       break;
1586
1587     case gdb_sys_mincore:
1588       if (record_mem_at_reg (regcache, tdep->arg3, tdep->size_PAGE_SIZE))
1589         return -1;
1590       break;
1591
1592     case gdb_sys_madvise:
1593       break;
1594
1595     case gdb_sys_fcntl64:
1596       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1597       if (tmpulongest == tdep->fcntl_F_GETLK64)
1598         {
1599           if (record_mem_at_reg (regcache, tdep->arg3,
1600                                  tdep->size_flock64))
1601             return -1;
1602         }
1603       else if (tmpulongest != tdep->fcntl_F_SETLK64
1604                && tmpulongest != tdep->fcntl_F_SETLKW64)
1605         {
1606           goto sys_fcntl;
1607         }
1608       break;
1609
1610     case gdb_sys_ni_syscall222:
1611     case gdb_sys_ni_syscall223:
1612     case gdb_sys_gettid:
1613     case gdb_sys_readahead:
1614     case gdb_sys_setxattr:
1615     case gdb_sys_lsetxattr:
1616     case gdb_sys_fsetxattr:
1617       break;
1618
1619     case gdb_sys_getxattr:
1620     case gdb_sys_lgetxattr:
1621     case gdb_sys_fgetxattr:
1622       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1623       if (tmpulongest)
1624         {
1625           ULONGEST size;
1626
1627           regcache_raw_read_unsigned (regcache, tdep->arg4, &size);
1628           if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1629                                              (int) size))
1630             return -1;
1631         }
1632       break;
1633
1634     case gdb_sys_listxattr:
1635     case gdb_sys_llistxattr:
1636     case gdb_sys_flistxattr:
1637       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1638       if (tmpulongest)
1639         {
1640           ULONGEST size;
1641
1642           regcache_raw_read_unsigned (regcache, tdep->arg3, &size);
1643           if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1644                                              (int) size))
1645             return -1;
1646         }
1647       break;
1648
1649     case gdb_sys_removexattr:
1650     case gdb_sys_lremovexattr:
1651     case gdb_sys_fremovexattr:
1652     case gdb_sys_tkill:
1653       break;
1654
1655     case gdb_sys_sendfile64:
1656       if (record_mem_at_reg (regcache, tdep->arg3, tdep->size_loff_t))
1657         return -1;
1658       break;
1659
1660     case gdb_sys_futex:
1661     case gdb_sys_sched_setaffinity:
1662       break;
1663
1664     case gdb_sys_sched_getaffinity:
1665       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1666       if (tmpulongest)
1667         {
1668           ULONGEST len;
1669
1670           regcache_raw_read_unsigned (regcache, tdep->arg2, &len);
1671           if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1672                                              (int) len))
1673             return -1;
1674         }
1675       break;
1676
1677     case gdb_sys_set_thread_area:
1678       if (record_mem_at_reg (regcache, tdep->arg1, tdep->size_int))
1679         return -1;
1680       break;
1681
1682     case gdb_sys_get_thread_area:
1683       if (record_mem_at_reg (regcache, tdep->arg1, tdep->size_user_desc))
1684         return -1;
1685       break;
1686
1687     case gdb_sys_io_setup:
1688       if (record_mem_at_reg (regcache, tdep->arg2, tdep->size_long))
1689         return -1;
1690       break;
1691
1692     case gdb_sys_io_destroy:
1693       break;
1694
1695     case gdb_sys_io_getevents:
1696       regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
1697       if (tmpulongest)
1698         {
1699           ULONGEST nr;
1700
1701           regcache_raw_read_unsigned (regcache, tdep->arg3, &nr);
1702           if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1703                                              nr * tdep->size_io_event))
1704             return -1;
1705         }
1706       break;
1707
1708     case gdb_sys_io_submit:
1709       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1710       if (tmpulongest)
1711         {
1712           ULONGEST nr, i;
1713           gdb_byte *iocbp;
1714
1715           regcache_raw_read_unsigned (regcache, tdep->arg2, &nr);
1716           iocbp = (gdb_byte *) alloca (nr * tdep->size_pointer);
1717           if (target_read_memory ((CORE_ADDR) tmpulongest, iocbp,
1718                                   nr * tdep->size_pointer))
1719             {
1720               if (record_debug)
1721                 gdb_printf (gdb_stdlog,
1722                             "Process record: error reading memory "
1723                             "at addr = 0x%s len = %u.\n",
1724                             OUTPUT_REG (tmpulongest, tdep->arg2),
1725                             (int) (nr * tdep->size_pointer));
1726               return -1;
1727             }
1728           for (i = 0; i < nr; i++)
1729             {
1730               tmpaddr
1731                 = (CORE_ADDR) extract_unsigned_integer (iocbp,
1732                                                         tdep->size_pointer,
1733                                                         byte_order);
1734               if (record_full_arch_list_add_mem (tmpaddr, tdep->size_iocb))
1735                 return -1;
1736               iocbp += tdep->size_pointer;
1737             }
1738         }
1739       break;
1740
1741     case gdb_sys_io_cancel:
1742       if (record_mem_at_reg (regcache, tdep->arg3, tdep->size_io_event))
1743         return -1;
1744       break;
1745
1746     case gdb_sys_fadvise64:
1747     case gdb_sys_ni_syscall251:
1748       break;
1749
1750     case gdb_sys_exit_group:
1751       if (yquery (_("The next instruction is syscall exit_group.  "
1752                     "It will make the program exit.  "
1753                     "Do you want to stop the program?")))
1754         return 1;
1755       break;
1756
1757     case gdb_sys_lookup_dcookie:
1758       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1759       if (tmpulongest)
1760         {
1761           ULONGEST len;
1762
1763           regcache_raw_read_unsigned (regcache, tdep->arg3, &len);
1764           if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1765                                              (int) len))
1766             return -1;
1767         }
1768       break;
1769
1770     case gdb_sys_epoll_create:
1771     case gdb_sys_epoll_ctl:
1772       break;
1773
1774     case gdb_sys_epoll_wait:
1775       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1776       if (tmpulongest)
1777         {
1778           ULONGEST maxevents;
1779
1780           regcache_raw_read_unsigned (regcache, tdep->arg3, &maxevents);
1781           if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1782                                              (maxevents
1783                                               * tdep->size_epoll_event)))
1784             return -1;
1785         }
1786       break;
1787
1788     case gdb_sys_remap_file_pages:
1789     case gdb_sys_set_tid_address:
1790       break;
1791
1792     case gdb_sys_timer_create:
1793       if (record_mem_at_reg (regcache, tdep->arg3, tdep->size_int))
1794         return -1;
1795       break;
1796
1797     case gdb_sys_timer_settime:
1798       if (record_mem_at_reg (regcache, tdep->arg4, tdep->size_itimerspec))
1799         return -1;
1800       break;
1801
1802     case gdb_sys_timer_gettime:
1803       if (record_mem_at_reg (regcache, tdep->arg2, tdep->size_itimerspec))
1804         return -1;
1805       break;
1806
1807     case gdb_sys_timer_getoverrun:
1808     case gdb_sys_timer_delete:
1809     case gdb_sys_clock_settime:
1810       break;
1811
1812     case gdb_sys_clock_gettime:
1813       if (record_mem_at_reg (regcache, tdep->arg2, tdep->size_timespec))
1814         return -1;
1815       break;
1816
1817     case gdb_sys_clock_getres:
1818       if (record_mem_at_reg (regcache, tdep->arg2, tdep->size_timespec))
1819         return -1;
1820       break;
1821
1822     case gdb_sys_clock_nanosleep:
1823       if (record_mem_at_reg (regcache, tdep->arg4, tdep->size_timespec))
1824         return -1;
1825       break;
1826
1827     case gdb_sys_statfs64:
1828     case gdb_sys_fstatfs64:
1829       if (record_mem_at_reg (regcache, tdep->arg3, tdep->size_statfs64))
1830         return -1;
1831       break;
1832
1833     case gdb_sys_tgkill:
1834     case gdb_sys_utimes:
1835     case gdb_sys_fadvise64_64:
1836     case gdb_sys_ni_syscall273:
1837     case gdb_sys_mbind:
1838       break;
1839
1840     case gdb_sys_get_mempolicy:
1841       if (record_mem_at_reg (regcache, tdep->arg1, tdep->size_int))
1842         return -1;
1843       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1844       if (tmpulongest)
1845         {
1846           ULONGEST maxnode;
1847
1848           regcache_raw_read_unsigned (regcache, tdep->arg3, &maxnode);
1849           if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1850                                              maxnode * tdep->size_long))
1851             return -1;
1852         }
1853       break;
1854
1855     case gdb_sys_set_mempolicy:
1856     case gdb_sys_mq_open:
1857     case gdb_sys_mq_unlink:
1858     case gdb_sys_mq_timedsend:
1859       break;
1860
1861     case gdb_sys_mq_timedreceive:
1862       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1863       if (tmpulongest)
1864         {
1865           ULONGEST msg_len;
1866
1867           regcache_raw_read_unsigned (regcache, tdep->arg3, &msg_len);
1868           if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1869                                              (int) msg_len))
1870             return -1;
1871         }
1872       if (record_mem_at_reg (regcache, tdep->arg4, tdep->size_int))
1873         return -1;
1874       break;
1875
1876     case gdb_sys_mq_notify:
1877       break;
1878
1879     case gdb_sys_mq_getsetattr:
1880       if (record_mem_at_reg (regcache, tdep->arg3, tdep->size_mq_attr))
1881         return -1;
1882       break;
1883
1884     case gdb_sys_kexec_load:
1885       break;
1886
1887     case gdb_sys_waitid:
1888       if (record_mem_at_reg (regcache, tdep->arg3, tdep->size_siginfo_t)
1889           || record_mem_at_reg (regcache, tdep->arg5, tdep->size_rusage))
1890         return -1;
1891       break;
1892
1893     case gdb_sys_ni_syscall285:
1894     case gdb_sys_add_key:
1895     case gdb_sys_request_key:
1896       break;
1897
1898     case gdb_sys_keyctl:
1899       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1900       if (tmpulongest == 6 || tmpulongest == 11)
1901         {
1902           regcache_raw_read_unsigned (regcache, tdep->arg3,
1903                                       &tmpulongest);
1904           if (tmpulongest)
1905             {
1906               ULONGEST buflen;
1907
1908               regcache_raw_read_unsigned (regcache, tdep->arg4, &buflen);
1909               if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1910                                                  (int) buflen))
1911                 return -1;
1912             }
1913         }
1914       break;
1915
1916     case gdb_sys_ioprio_set:
1917     case gdb_sys_ioprio_get:
1918     case gdb_sys_inotify_init:
1919     case gdb_sys_inotify_add_watch:
1920     case gdb_sys_inotify_rm_watch:
1921     case gdb_sys_migrate_pages:
1922     case gdb_sys_openat:
1923     case gdb_sys_mkdirat:
1924     case gdb_sys_mknodat:
1925     case gdb_sys_fchownat:
1926     case gdb_sys_futimesat:
1927       break;
1928
1929     case gdb_sys_fstatat64:
1930       if (record_mem_at_reg (regcache, tdep->arg3, tdep->size_stat64))
1931         return -1;
1932       break;
1933
1934     case gdb_sys_unlinkat:
1935     case gdb_sys_renameat:
1936     case gdb_sys_linkat:
1937     case gdb_sys_symlinkat:
1938       break;
1939
1940     case gdb_sys_readlinkat:
1941       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1942       if (tmpulongest)
1943         {
1944           ULONGEST bufsiz;
1945
1946           regcache_raw_read_unsigned (regcache, tdep->arg4, &bufsiz);
1947           if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1948                                              (int) bufsiz))
1949             return -1;
1950         }
1951       break;
1952
1953     case gdb_sys_fchmodat:
1954     case gdb_sys_faccessat:
1955       break;
1956
1957     case gdb_sys_pselect6:
1958       if (record_mem_at_reg (regcache, tdep->arg2, tdep->size_fd_set)
1959           || record_mem_at_reg (regcache, tdep->arg3, tdep->size_fd_set)
1960           || record_mem_at_reg (regcache, tdep->arg4, tdep->size_fd_set)
1961           || record_mem_at_reg (regcache, tdep->arg5, tdep->size_timespec))
1962         return -1;
1963       break;
1964
1965     case gdb_sys_ppoll:
1966       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1967       if (tmpulongest)
1968         {
1969           ULONGEST nfds;
1970
1971           regcache_raw_read_unsigned (regcache, tdep->arg2, &nfds);
1972           if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1973                                              tdep->size_pollfd * nfds))
1974             return -1;
1975         }
1976       if (record_mem_at_reg (regcache, tdep->arg3, tdep->size_timespec))
1977         return -1;
1978       break;
1979
1980     case gdb_sys_unshare:
1981     case gdb_sys_set_robust_list:
1982       break;
1983
1984     case gdb_sys_get_robust_list:
1985       if (record_mem_at_reg (regcache, tdep->arg2, tdep->size_int)
1986           || record_mem_at_reg (regcache, tdep->arg3, tdep->size_int))
1987         return -1;
1988       break;
1989
1990     case gdb_sys_splice:
1991       if (record_mem_at_reg (regcache, tdep->arg2, tdep->size_loff_t)
1992           || record_mem_at_reg (regcache, tdep->arg4, tdep->size_loff_t))
1993         return -1;
1994       break;
1995
1996     case gdb_sys_sync_file_range:
1997     case gdb_sys_tee:
1998     case gdb_sys_vmsplice:
1999       break;
2000
2001     case gdb_sys_move_pages:
2002       regcache_raw_read_unsigned (regcache, tdep->arg5, &tmpulongest);
2003       if (tmpulongest)
2004         {
2005           ULONGEST nr_pages;
2006
2007           regcache_raw_read_unsigned (regcache, tdep->arg2, &nr_pages);
2008           if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2009                                              nr_pages * tdep->size_int))
2010             return -1;
2011         }
2012       break;
2013
2014     case gdb_sys_getcpu:
2015       if (record_mem_at_reg (regcache, tdep->arg1, tdep->size_int)
2016           || record_mem_at_reg (regcache, tdep->arg2, tdep->size_int)
2017           || record_mem_at_reg (regcache, tdep->arg3,
2018                                 tdep->size_ulong * 2))
2019         return -1;
2020       break;
2021
2022     case gdb_sys_epoll_pwait:
2023       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
2024       if (tmpulongest)
2025         {
2026           ULONGEST maxevents;
2027
2028           regcache_raw_read_unsigned (regcache, tdep->arg3, &maxevents);
2029           tmpint = (int) maxevents * tdep->size_epoll_event;
2030           if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest, tmpint))
2031             return -1;
2032         }
2033       break;
2034
2035     case gdb_sys_fallocate:
2036     case gdb_sys_eventfd2:
2037     case gdb_sys_epoll_create1:
2038     case gdb_sys_dup3:
2039       break;
2040
2041     case gdb_sys_inotify_init1:
2042       break;
2043
2044     default:
2045       gdb_printf (gdb_stderr,
2046                   _("Process record and replay target doesn't "
2047                     "support syscall number %d\n"), syscall);
2048       return -1;
2049       break;
2050     }
2051
2052   return 0;
2053 }