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