gdb/linux-record.c

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