gdb/linux-record.c

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