gdb/linux-record.c

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