gdb/linux-record.c

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