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       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1116       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1117                                          tdep->size_stat))
1118         return -1;
1119       break;
1120
1121     case gdb_sys_newfstatat:
1122       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1123       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1124                                          tdep->size_stat))
1125         return -1;
1126       break;
1127
1128     case gdb_sys_uname:
1129       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1130       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1131                                          tdep->size_old_utsname))
1132         return -1;
1133       break;
1134
1135     case gdb_sys_iopl:
1136     case gdb_sys_vhangup:
1137     case gdb_sys_ni_syscall112:
1138     case gdb_sys_vm86old:
1139       break;
1140
1141     case gdb_sys_wait4:
1142       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1143       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1144                                          tdep->size_int))
1145         return -1;
1146       regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
1147       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1148                                          tdep->size_rusage))
1149         return -1;
1150       break;
1151
1152     case gdb_sys_swapoff:
1153       break;
1154
1155     case gdb_sys_sysinfo:
1156       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1157       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1158                                          tdep->size_sysinfo))
1159         return -1;
1160       break;
1161
1162     case gdb_sys_shmget:
1163     case gdb_sys_semget:
1164     case gdb_sys_semop:
1165     case gdb_sys_msgget:
1166       /* XXX maybe need do some record works with sys_shmdt.  */
1167     case gdb_sys_shmdt:
1168     case gdb_sys_msgsnd:
1169     case gdb_sys_semtimedop:
1170       break;
1171
1172     case gdb_sys_shmat:
1173       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1174       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1175                                          tdep->size_ulong))
1176         return -1;
1177       break;
1178
1179     case gdb_sys_shmctl:
1180       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1181       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1182                                          tdep->size_shmid_ds))
1183         return -1;
1184       break;
1185
1186       /* XXX sys_semctl 525 still not supported.  */
1187       /* sys_semctl */
1188
1189     case gdb_sys_msgrcv:
1190       {
1191         ULONGEST msgp;
1192         LONGEST l;
1193
1194         regcache_raw_read_signed (regcache, tdep->arg3, &l);
1195         regcache_raw_read_unsigned (regcache, tdep->arg2, &msgp);
1196         tmpint = l + tdep->size_long;
1197         if (record_full_arch_list_add_mem ((CORE_ADDR) msgp, tmpint))
1198           return -1;
1199       }
1200       break;
1201
1202     case gdb_sys_msgctl:
1203       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1204       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1205                                          tdep->size_msqid_ds))
1206         return -1;
1207       break;
1208
1209     case gdb_sys_ipc:
1210       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1211       tmpulongest &= 0xffff;
1212       switch (tmpulongest)
1213         {
1214         case RECORD_SEMOP:
1215         case RECORD_SEMGET:
1216         case RECORD_SEMTIMEDOP:
1217         case RECORD_MSGSND:
1218         case RECORD_MSGGET:
1219           /* XXX maybe need do some record works with RECORD_SHMDT.  */
1220         case RECORD_SHMDT:
1221         case RECORD_SHMGET:
1222           break;
1223         case RECORD_MSGRCV:
1224           {
1225             LONGEST second;
1226             ULONGEST ptr;
1227
1228             regcache_raw_read_signed (regcache, tdep->arg3, &second);
1229             regcache_raw_read_unsigned (regcache, tdep->arg5, &ptr);
1230             tmpint = (int) second + tdep->size_long;
1231             if (record_full_arch_list_add_mem ((CORE_ADDR) ptr, tmpint))
1232               return -1;
1233           }
1234           break;
1235         case RECORD_MSGCTL:
1236           regcache_raw_read_unsigned (regcache, tdep->arg5,
1237                                       &tmpulongest);
1238           if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1239                                              tdep->size_msqid_ds))
1240             return -1;
1241           break;
1242         case RECORD_SHMAT:
1243           regcache_raw_read_unsigned (regcache, tdep->arg4,
1244                                       &tmpulongest);
1245           if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1246                                              tdep->size_ulong))
1247             return -1;
1248           break;
1249         case RECORD_SHMCTL:
1250           regcache_raw_read_unsigned (regcache, tdep->arg5,
1251                                       &tmpulongest);
1252           if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1253                                              tdep->size_shmid_ds))
1254             return -1;
1255           break;
1256         default:
1257           /* XXX RECORD_SEMCTL still not supported.  */
1258           printf_unfiltered (_("Process record and replay target doesn't "
1259                                "support ipc number %s\n"),
1260                              pulongest (tmpulongest));
1261           break;
1262         }
1263       break;
1264
1265     case gdb_sys_fsync:
1266     case gdb_sys_sigreturn:
1267     case gdb_sys_clone:
1268     case gdb_sys_setdomainname:
1269       break;
1270
1271     case gdb_sys_newuname:
1272       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1273       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1274                                          tdep->size_new_utsname))
1275         return -1;
1276       break;
1277
1278     case gdb_sys_modify_ldt:
1279       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1280       if (tmpulongest == 0 || tmpulongest == 2)
1281         {
1282           ULONGEST ptr, bytecount;
1283
1284           regcache_raw_read_unsigned (regcache, tdep->arg2, &ptr);
1285           regcache_raw_read_unsigned (regcache, tdep->arg3, &bytecount);
1286           if (record_full_arch_list_add_mem ((CORE_ADDR) ptr, (int) bytecount))
1287             return -1;
1288         }
1289       break;
1290
1291     case gdb_sys_adjtimex:
1292       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1293       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1294                                          tdep->size_timex))
1295         return -1;
1296       break;
1297
1298     case gdb_sys_mprotect:
1299       break;
1300
1301     case gdb_sys_sigprocmask:
1302       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1303       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1304                                          tdep->size_old_sigset_t))
1305         return -1;
1306       break;
1307
1308     case gdb_sys_ni_syscall127:
1309     case gdb_sys_init_module:
1310     case gdb_sys_delete_module:
1311     case gdb_sys_ni_syscall130:
1312       break;
1313
1314     case gdb_sys_quotactl:
1315       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1316       switch (tmpulongest)
1317         {
1318         case RECORD_Q_GETFMT:
1319           regcache_raw_read_unsigned (regcache, tdep->arg4,
1320                                       &tmpulongest);
1321           /* __u32 */
1322           if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest, 4))
1323             return -1;
1324           break;
1325         case RECORD_Q_GETINFO:
1326           regcache_raw_read_unsigned (regcache, tdep->arg4,
1327                                       &tmpulongest);
1328           if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1329                                              tdep->size_mem_dqinfo))
1330             return -1;
1331           break;
1332         case RECORD_Q_GETQUOTA:
1333           regcache_raw_read_unsigned (regcache, tdep->arg4,
1334                                       &tmpulongest);
1335           if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1336                                              tdep->size_if_dqblk))
1337             return -1;
1338           break;
1339         case RECORD_Q_XGETQSTAT:
1340         case RECORD_Q_XGETQUOTA:
1341           regcache_raw_read_unsigned (regcache, tdep->arg4,
1342                                       &tmpulongest);
1343           if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1344                                              tdep->size_fs_quota_stat))
1345             return -1;
1346           break;
1347         }
1348       break;
1349
1350     case gdb_sys_getpgid:
1351     case gdb_sys_fchdir:
1352     case gdb_sys_bdflush:
1353       break;
1354
1355     case gdb_sys_sysfs:
1356       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1357       if (tmpulongest == 2)
1358         {
1359           regcache_raw_read_unsigned (regcache, tdep->arg3,
1360                                       &tmpulongest);
1361           /*XXX the size of memory is not very clear.  */
1362           if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest, 10))
1363             return -1;
1364         }
1365       break;
1366
1367     case gdb_sys_personality:
1368     case gdb_sys_ni_syscall137:
1369     case gdb_sys_setfsuid16:
1370     case gdb_sys_setfsgid16:
1371       break;
1372
1373     case gdb_sys_llseek:
1374       regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
1375       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1376                                          tdep->size_loff_t))
1377         return -1;
1378       break;
1379
1380     case gdb_sys_getdents:
1381     case gdb_sys_getdents64:
1382       {
1383         ULONGEST count;
1384
1385         regcache_raw_read_unsigned (regcache, tdep->arg2,
1386                                     &tmpulongest);
1387         regcache_raw_read_unsigned (regcache, tdep->arg3, &count);
1388         if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest, count))
1389           return -1;
1390       }
1391       break;
1392
1393     case gdb_sys_select:
1394       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1395       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1396                                          tdep->size_fd_set))
1397         return -1;
1398       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1399       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1400                                          tdep->size_fd_set))
1401         return -1;
1402       regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
1403       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1404                                          tdep->size_fd_set))
1405         return -1;
1406       regcache_raw_read_unsigned (regcache, tdep->arg5, &tmpulongest);
1407       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1408                                          tdep->size_timeval))
1409         return -1;
1410       break;
1411
1412     case gdb_sys_flock:
1413     case gdb_sys_msync:
1414       break;
1415
1416     case gdb_sys_readv:
1417       {
1418         ULONGEST vec, vlen;
1419
1420         regcache_raw_read_unsigned (regcache, tdep->arg2, &vec);
1421         if (vec)
1422           {
1423             gdb_byte *iov = (gdb_byte *) alloca (tdep->size_iovec);
1424
1425             regcache_raw_read_unsigned (regcache, tdep->arg3, &vlen);
1426             for (tmpulongest = 0; tmpulongest < vlen; tmpulongest++)
1427               {
1428                 if (target_read_memory ((CORE_ADDR) vec, iov,
1429                                         tdep->size_iovec))
1430                   {
1431                     if (record_debug)
1432                       fprintf_unfiltered (gdb_stdlog,
1433                                           "Process record: error reading "
1434                                           "memory at addr = 0x%s len = %d.\n",
1435                                           OUTPUT_REG (vec, tdep->arg2),
1436                                           tdep->size_iovec);
1437                     return -1;
1438                   }
1439                 tmpaddr
1440                   = (CORE_ADDR) extract_unsigned_integer (iov,
1441                                                           tdep->size_pointer,
1442                                                           byte_order);
1443                 tmpint
1444                   = (int) extract_unsigned_integer (iov + tdep->size_pointer,
1445                                                     tdep->size_size_t,
1446                                                     byte_order);
1447                 if (record_full_arch_list_add_mem (tmpaddr, tmpint))
1448                   return -1;
1449                 vec += tdep->size_iovec;
1450               }
1451           }
1452       }
1453       break;
1454
1455     case gdb_sys_writev:
1456     case gdb_sys_getsid:
1457     case gdb_sys_fdatasync:
1458     case gdb_sys_sysctl:
1459     case gdb_sys_mlock:
1460     case gdb_sys_munlock:
1461     case gdb_sys_mlockall:
1462     case gdb_sys_munlockall:
1463     case gdb_sys_sched_setparam:
1464       break;
1465
1466     case gdb_sys_sched_getparam:
1467       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1468       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1469                                          tdep->size_int))
1470         return -1;
1471       break;
1472
1473     case gdb_sys_sched_setscheduler:
1474     case gdb_sys_sched_getscheduler:
1475     case gdb_sys_sched_yield:
1476     case gdb_sys_sched_get_priority_max:
1477     case gdb_sys_sched_get_priority_min:
1478       break;
1479
1480     case gdb_sys_sched_rr_get_interval:
1481     case gdb_sys_nanosleep:
1482       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1483       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1484                                          tdep->size_timespec))
1485         return -1;
1486       break;
1487
1488     case gdb_sys_mremap:
1489     case gdb_sys_setresuid16:
1490       break;
1491
1492     case gdb_sys_getresuid16:
1493       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1494       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1495                                          tdep->size_old_uid_t))
1496         return -1;
1497       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1498       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1499                                          tdep->size_old_uid_t))
1500         return -1;
1501       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1502       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1503                                          tdep->size_old_uid_t))
1504         return -1;
1505       break;
1506
1507     case gdb_sys_vm86:
1508     case gdb_sys_ni_syscall167:
1509       break;
1510
1511     case gdb_sys_poll:
1512       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1513       if (tmpulongest)
1514         {
1515           ULONGEST nfds;
1516
1517           regcache_raw_read_unsigned (regcache, tdep->arg2, &nfds);
1518           if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1519                                              tdep->size_pollfd * nfds))
1520             return -1;
1521         }
1522       break;
1523
1524     case gdb_sys_nfsservctl:
1525       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1526       if (tmpulongest == 7 || tmpulongest == 8)
1527         {
1528           int rsize;
1529
1530           if (tmpulongest == 7)
1531             rsize = tdep->size_NFS_FHSIZE;
1532           else
1533             rsize = tdep->size_knfsd_fh;
1534           regcache_raw_read_unsigned (regcache, tdep->arg3,
1535                                       &tmpulongest);
1536           if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest, rsize))
1537             return -1;
1538         }
1539       break;
1540
1541     case gdb_sys_setresgid16:
1542       break;
1543
1544     case gdb_sys_getresgid16:
1545       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1546       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1547                                          tdep->size_old_gid_t))
1548         return -1;
1549       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1550       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1551                                          tdep->size_old_gid_t))
1552         return -1;
1553       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1554       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1555                                          tdep->size_old_gid_t))
1556         return -1;
1557       break;
1558
1559     case gdb_sys_prctl:
1560       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1561       switch (tmpulongest)
1562         {
1563         case 2:
1564           regcache_raw_read_unsigned (regcache, tdep->arg2,
1565                                       &tmpulongest);
1566           if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1567                                              tdep->size_int))
1568             return -1;
1569           break;
1570         case 16:
1571           regcache_raw_read_unsigned (regcache, tdep->arg2,
1572                                       &tmpulongest);
1573           if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1574                                              tdep->size_TASK_COMM_LEN))
1575             return -1;
1576           break;
1577         }
1578       break;
1579
1580     case gdb_sys_rt_sigreturn:
1581       break;
1582
1583     case gdb_sys_rt_sigaction:
1584       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1585       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1586                                          tdep->size_sigaction))
1587         return -1;
1588       break;
1589
1590     case gdb_sys_rt_sigprocmask:
1591       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1592       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1593                                          tdep->size_sigset_t))
1594         return -1;
1595       break;
1596
1597     case gdb_sys_rt_sigpending:
1598       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1599       if (tmpulongest)
1600         {
1601           ULONGEST sigsetsize;
1602
1603           regcache_raw_read_unsigned (regcache, tdep->arg2,&sigsetsize);
1604           if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1605                                              (int) sigsetsize))
1606             return -1;
1607         }
1608       break;
1609
1610     case gdb_sys_rt_sigtimedwait:
1611       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1612       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1613                                          tdep->size_siginfo_t))
1614         return -1;
1615       break;
1616
1617     case gdb_sys_rt_sigqueueinfo:
1618     case gdb_sys_rt_sigsuspend:
1619       break;
1620
1621     case gdb_sys_pread64:
1622       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1623       if (tmpulongest)
1624         {
1625           ULONGEST count;
1626
1627           regcache_raw_read_unsigned (regcache, tdep->arg3,&count);
1628           if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1629                                              (int) count))
1630             return -1;
1631         }
1632       break;
1633
1634     case gdb_sys_pwrite64:
1635     case gdb_sys_chown16:
1636       break;
1637
1638     case gdb_sys_getcwd:
1639       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1640       if (tmpulongest)
1641         {
1642           ULONGEST size;
1643
1644           regcache_raw_read_unsigned (regcache, tdep->arg2, &size);
1645           if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1646                                              (int) size))
1647             return -1;
1648         }
1649       break;
1650
1651     case gdb_sys_capget:
1652       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1653       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1654                                          tdep->size_cap_user_data_t))
1655         return -1;
1656       break;
1657
1658     case gdb_sys_capset:
1659       break;
1660
1661     case gdb_sys_sigaltstack:
1662       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1663       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1664                                          tdep->size_stack_t))
1665         return -1;
1666       break;
1667
1668     case gdb_sys_sendfile:
1669       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1670       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1671                                          tdep->size_off_t))
1672         return -1;
1673       break;
1674
1675     case gdb_sys_ni_syscall188:
1676     case gdb_sys_ni_syscall189:
1677     case gdb_sys_vfork:
1678       break;
1679
1680     case gdb_sys_getrlimit:
1681       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1682       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1683                                          tdep->size_rlimit))
1684         return -1;
1685       break;
1686
1687     case gdb_sys_mmap2:
1688       break;
1689
1690     case gdb_sys_truncate64:
1691     case gdb_sys_ftruncate64:
1692       break;
1693
1694     case gdb_sys_stat64:
1695     case gdb_sys_lstat64:
1696     case gdb_sys_fstat64:
1697       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1698       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1699                                          tdep->size_stat64))
1700         return -1;
1701       break;
1702
1703     case gdb_sys_lchown:
1704     case gdb_sys_getuid:
1705     case gdb_sys_getgid:
1706     case gdb_sys_geteuid:
1707     case gdb_sys_getegid:
1708     case gdb_sys_setreuid:
1709     case gdb_sys_setregid:
1710       break;
1711
1712     case gdb_sys_getgroups:
1713       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1714       if (tmpulongest)
1715         {
1716           ULONGEST gidsetsize;
1717
1718           regcache_raw_read_unsigned (regcache, tdep->arg1,
1719                                       &gidsetsize);
1720           tmpint = tdep->size_gid_t * (int) gidsetsize;
1721           if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest, tmpint))
1722             return -1;
1723         }
1724       break;
1725
1726     case gdb_sys_setgroups:
1727     case gdb_sys_fchown:
1728     case gdb_sys_setresuid:
1729       break;
1730
1731     case gdb_sys_getresuid:
1732       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1733       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1734                                          tdep->size_uid_t))
1735         return -1;
1736       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1737       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1738                                          tdep->size_uid_t))
1739         return -1;
1740       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1741       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1742                                          tdep->size_uid_t))
1743         return -1;
1744       break;
1745
1746     case gdb_sys_setresgid:
1747       break;
1748
1749     case gdb_sys_getresgid:
1750       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1751       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1752                                          tdep->size_gid_t))
1753         return -1;
1754       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1755       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1756                                          tdep->size_gid_t))
1757         return -1;
1758       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1759       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1760                                          tdep->size_gid_t))
1761         return -1;
1762       break;
1763
1764     case gdb_sys_chown:
1765     case gdb_sys_setuid:
1766     case gdb_sys_setgid:
1767     case gdb_sys_setfsuid:
1768     case gdb_sys_setfsgid:
1769     case gdb_sys_pivot_root:
1770       break;
1771
1772     case gdb_sys_mincore:
1773       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1774       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1775                                          tdep->size_PAGE_SIZE))
1776         return -1;
1777       break;
1778
1779     case gdb_sys_madvise:
1780       break;
1781
1782     case gdb_sys_fcntl64:
1783       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1784       if (tmpulongest == tdep->fcntl_F_GETLK64)
1785         {
1786           regcache_raw_read_unsigned (regcache, tdep->arg3,
1787                                       &tmpulongest);
1788           if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1789                                              tdep->size_flock64))
1790             return -1;
1791         }
1792       else if (tmpulongest != tdep->fcntl_F_SETLK64
1793                && tmpulongest != tdep->fcntl_F_SETLKW64)
1794         {
1795           goto sys_fcntl;
1796         }
1797       break;
1798
1799     case gdb_sys_ni_syscall222:
1800     case gdb_sys_ni_syscall223:
1801     case gdb_sys_gettid:
1802     case gdb_sys_readahead:
1803     case gdb_sys_setxattr:
1804     case gdb_sys_lsetxattr:
1805     case gdb_sys_fsetxattr:
1806       break;
1807
1808     case gdb_sys_getxattr:
1809     case gdb_sys_lgetxattr:
1810     case gdb_sys_fgetxattr:
1811       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1812       if (tmpulongest)
1813         {
1814           ULONGEST size;
1815
1816           regcache_raw_read_unsigned (regcache, tdep->arg4, &size);
1817           if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1818                                              (int) size))
1819             return -1;
1820         }
1821       break;
1822
1823     case gdb_sys_listxattr:
1824     case gdb_sys_llistxattr:
1825     case gdb_sys_flistxattr:
1826       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1827       if (tmpulongest)
1828         {
1829           ULONGEST size;
1830
1831           regcache_raw_read_unsigned (regcache, tdep->arg3, &size);
1832           if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1833                                              (int) size))
1834             return -1;
1835         }
1836       break;
1837
1838     case gdb_sys_removexattr:
1839     case gdb_sys_lremovexattr:
1840     case gdb_sys_fremovexattr:
1841     case gdb_sys_tkill:
1842       break;
1843
1844     case gdb_sys_sendfile64:
1845       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1846       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1847                                          tdep->size_loff_t))
1848         return -1;
1849       break;
1850
1851     case gdb_sys_futex:
1852     case gdb_sys_sched_setaffinity:
1853       break;
1854
1855     case gdb_sys_sched_getaffinity:
1856       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1857       if (tmpulongest)
1858         {
1859           ULONGEST len;
1860
1861           regcache_raw_read_unsigned (regcache, tdep->arg2, &len);
1862           if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1863                                              (int) len))
1864             return -1;
1865         }
1866       break;
1867
1868     case gdb_sys_set_thread_area:
1869       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1870       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1871                                          tdep->size_int))
1872         return -1;
1873       break;
1874
1875     case gdb_sys_get_thread_area:
1876       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1877       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1878                                          tdep->size_user_desc))
1879         return -1;
1880       break;
1881
1882     case gdb_sys_io_setup:
1883       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1884       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1885                                          tdep->size_long))
1886         return -1;
1887       break;
1888
1889     case gdb_sys_io_destroy:
1890       break;
1891
1892     case gdb_sys_io_getevents:
1893       regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
1894       if (tmpulongest)
1895         {
1896           ULONGEST nr;
1897
1898           regcache_raw_read_unsigned (regcache, tdep->arg3, &nr);
1899           if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1900                                              nr * tdep->size_io_event))
1901             return -1;
1902         }
1903       break;
1904
1905     case gdb_sys_io_submit:
1906       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1907       if (tmpulongest)
1908         {
1909           ULONGEST nr, i;
1910           gdb_byte *iocbp;
1911
1912           regcache_raw_read_unsigned (regcache, tdep->arg2, &nr);
1913           iocbp = (gdb_byte *) alloca (nr * tdep->size_pointer);
1914           if (target_read_memory ((CORE_ADDR) tmpulongest, iocbp,
1915                                   nr * tdep->size_pointer))
1916             {
1917               if (record_debug)
1918                 fprintf_unfiltered (gdb_stdlog,
1919                                     "Process record: error reading memory "
1920                                     "at addr = 0x%s len = %u.\n",
1921                                     OUTPUT_REG (tmpulongest, tdep->arg2),
1922                                     (int) (nr * tdep->size_pointer));
1923               return -1;
1924             }
1925           for (i = 0; i < nr; i++)
1926             {
1927               tmpaddr
1928                 = (CORE_ADDR) extract_unsigned_integer (iocbp,
1929                                                         tdep->size_pointer,
1930                                                         byte_order);
1931               if (record_full_arch_list_add_mem (tmpaddr, tdep->size_iocb))
1932                 return -1;
1933               iocbp += tdep->size_pointer;
1934             }
1935         }
1936       break;
1937
1938     case gdb_sys_io_cancel:
1939       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1940       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1941                                          tdep->size_io_event))
1942         return -1;
1943       break;
1944
1945     case gdb_sys_fadvise64:
1946     case gdb_sys_ni_syscall251:
1947       break;
1948
1949     case gdb_sys_exit_group:
1950       {
1951         int q;
1952
1953         target_terminal_ours ();
1954         q = yquery (_("The next instruction is syscall exit_group.  "
1955                       "It will make the program exit.  "
1956                       "Do you want to stop the program?"));
1957         target_terminal_inferior ();
1958         if (q)
1959           return 1;
1960       }
1961       break;
1962
1963     case gdb_sys_lookup_dcookie:
1964       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1965       if (tmpulongest)
1966         {
1967           ULONGEST len;
1968
1969           regcache_raw_read_unsigned (regcache, tdep->arg3, &len);
1970           if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1971                                              (int) len))
1972             return -1;
1973         }
1974       break;
1975
1976     case gdb_sys_epoll_create:
1977     case gdb_sys_epoll_ctl:
1978       break;
1979
1980     case gdb_sys_epoll_wait:
1981       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1982       if (tmpulongest)
1983         {
1984           ULONGEST maxevents;
1985
1986           regcache_raw_read_unsigned (regcache, tdep->arg3, &maxevents);
1987           if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1988                                              (maxevents
1989                                               * tdep->size_epoll_event)))
1990             return -1;
1991         }
1992       break;
1993
1994     case gdb_sys_remap_file_pages:
1995     case gdb_sys_set_tid_address:
1996       break;
1997
1998     case gdb_sys_timer_create:
1999       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
2000       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2001                                          tdep->size_int))
2002         return -1;
2003       break;
2004
2005     case gdb_sys_timer_settime:
2006       regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
2007       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2008                                          tdep->size_itimerspec))
2009         return -1;
2010       break;
2011
2012     case gdb_sys_timer_gettime:
2013       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
2014       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2015                                          tdep->size_itimerspec))
2016         return -1;
2017       break;
2018
2019     case gdb_sys_timer_getoverrun:
2020     case gdb_sys_timer_delete:
2021     case gdb_sys_clock_settime:
2022       break;
2023
2024     case gdb_sys_clock_gettime:
2025       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
2026       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2027                                          tdep->size_timespec))
2028         return -1;
2029       break;
2030
2031     case gdb_sys_clock_getres:
2032       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
2033       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2034                                          tdep->size_timespec))
2035         return -1;
2036       break;
2037
2038     case gdb_sys_clock_nanosleep:
2039       regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
2040       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2041                                          tdep->size_timespec))
2042         return -1;
2043       break;
2044
2045     case gdb_sys_statfs64:
2046     case gdb_sys_fstatfs64:
2047       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
2048       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2049                                          tdep->size_statfs64))
2050         return -1;
2051       break;
2052
2053     case gdb_sys_tgkill:
2054     case gdb_sys_utimes:
2055     case gdb_sys_fadvise64_64:
2056     case gdb_sys_ni_syscall273:
2057     case gdb_sys_mbind:
2058       break;
2059
2060     case gdb_sys_get_mempolicy:
2061       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
2062       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2063                                          tdep->size_int))
2064         return -1;
2065       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
2066       if (tmpulongest)
2067         {
2068           ULONGEST maxnode;
2069
2070           regcache_raw_read_unsigned (regcache, tdep->arg3, &maxnode);
2071           if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2072                                              maxnode * tdep->size_long))
2073             return -1;
2074         }
2075       break;
2076
2077     case gdb_sys_set_mempolicy:
2078     case gdb_sys_mq_open:
2079     case gdb_sys_mq_unlink:
2080     case gdb_sys_mq_timedsend:
2081       break;
2082
2083     case gdb_sys_mq_timedreceive:
2084       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
2085       if (tmpulongest)
2086         {
2087           ULONGEST msg_len;
2088
2089           regcache_raw_read_unsigned (regcache, tdep->arg3, &msg_len);
2090           if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2091                                              (int) msg_len))
2092             return -1;
2093         }
2094       regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
2095       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2096                                          tdep->size_int))
2097         return -1;
2098       break;
2099
2100     case gdb_sys_mq_notify:
2101       break;
2102
2103     case gdb_sys_mq_getsetattr:
2104       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
2105       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2106                                          tdep->size_mq_attr))
2107         return -1;
2108       break;
2109
2110     case gdb_sys_kexec_load:
2111       break;
2112
2113     case gdb_sys_waitid:
2114       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
2115       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2116                                          tdep->size_siginfo_t))
2117         return -1;
2118       regcache_raw_read_unsigned (regcache, tdep->arg5, &tmpulongest);
2119       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2120                                          tdep->size_rusage))
2121         return -1;
2122       break;
2123
2124     case gdb_sys_ni_syscall285:
2125     case gdb_sys_add_key:
2126     case gdb_sys_request_key:
2127       break;
2128
2129     case gdb_sys_keyctl:
2130       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
2131       if (tmpulongest == 6 || tmpulongest == 11)
2132         {
2133           regcache_raw_read_unsigned (regcache, tdep->arg3,
2134                                       &tmpulongest);
2135           if (tmpulongest)
2136             {
2137               ULONGEST buflen;
2138
2139               regcache_raw_read_unsigned (regcache, tdep->arg4, &buflen);
2140               if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2141                                                  (int) buflen))
2142                 return -1;
2143             }
2144         }
2145       break;
2146
2147     case gdb_sys_ioprio_set:
2148     case gdb_sys_ioprio_get:
2149     case gdb_sys_inotify_init:
2150     case gdb_sys_inotify_add_watch:
2151     case gdb_sys_inotify_rm_watch:
2152     case gdb_sys_migrate_pages:
2153     case gdb_sys_openat:
2154     case gdb_sys_mkdirat:
2155     case gdb_sys_mknodat:
2156     case gdb_sys_fchownat:
2157     case gdb_sys_futimesat:
2158       break;
2159
2160     case gdb_sys_fstatat64:
2161       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
2162       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2163                                          tdep->size_stat64))
2164         return -1;
2165       break;
2166
2167     case gdb_sys_unlinkat:
2168     case gdb_sys_renameat:
2169     case gdb_sys_linkat:
2170     case gdb_sys_symlinkat:
2171       break;
2172
2173     case gdb_sys_readlinkat:
2174       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
2175       if (tmpulongest)
2176         {
2177           ULONGEST bufsiz;
2178
2179           regcache_raw_read_unsigned (regcache, tdep->arg4, &bufsiz);
2180           if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2181                                              (int) bufsiz))
2182             return -1;
2183         }
2184       break;
2185
2186     case gdb_sys_fchmodat:
2187     case gdb_sys_faccessat:
2188       break;
2189
2190     case gdb_sys_pselect6:
2191       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
2192       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2193                                          tdep->size_fd_set))
2194         return -1;
2195       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
2196       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2197                                          tdep->size_fd_set))
2198         return -1;
2199       regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
2200       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2201                                          tdep->size_fd_set))
2202         return -1;
2203       regcache_raw_read_unsigned (regcache, tdep->arg5, &tmpulongest);
2204       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2205                                          tdep->size_timespec))
2206         return -1;
2207       break;
2208
2209     case gdb_sys_ppoll:
2210       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
2211       if (tmpulongest)
2212         {
2213           ULONGEST nfds;
2214
2215           regcache_raw_read_unsigned (regcache, tdep->arg2, &nfds);
2216           if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2217                                              tdep->size_pollfd * nfds))
2218             return -1;
2219         }
2220       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
2221       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2222                                          tdep->size_timespec))
2223         return -1;
2224       break;
2225
2226     case gdb_sys_unshare:
2227     case gdb_sys_set_robust_list:
2228       break;
2229
2230     case gdb_sys_get_robust_list:
2231       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
2232       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2233                                          tdep->size_int))
2234         return -1;
2235       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
2236       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2237                                          tdep->size_int))
2238         return -1;
2239       break;
2240
2241     case gdb_sys_splice:
2242       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
2243       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2244                                          tdep->size_loff_t))
2245         return -1;
2246       regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
2247       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2248                                          tdep->size_loff_t))
2249         return -1;
2250       break;
2251
2252     case gdb_sys_sync_file_range:
2253     case gdb_sys_tee:
2254     case gdb_sys_vmsplice:
2255       break;
2256
2257     case gdb_sys_move_pages:
2258       regcache_raw_read_unsigned (regcache, tdep->arg5, &tmpulongest);
2259       if (tmpulongest)
2260         {
2261           ULONGEST nr_pages;
2262
2263           regcache_raw_read_unsigned (regcache, tdep->arg2, &nr_pages);
2264           if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2265                                              nr_pages * tdep->size_int))
2266             return -1;
2267         }
2268       break;
2269
2270     case gdb_sys_getcpu:
2271       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
2272       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2273                                          tdep->size_int))
2274         return -1;
2275       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
2276       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2277                                          tdep->size_int))
2278         return -1;
2279       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
2280       if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2281                                          tdep->size_ulong * 2))
2282         return -1;
2283       break;
2284
2285     case gdb_sys_epoll_pwait:
2286       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
2287       if (tmpulongest)
2288         {
2289           ULONGEST maxevents;
2290
2291           regcache_raw_read_unsigned (regcache, tdep->arg3, &maxevents);
2292           tmpint = (int) maxevents * tdep->size_epoll_event;
2293           if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest, tmpint))
2294             return -1;
2295         }
2296       break;
2297
2298     default:
2299       printf_unfiltered (_("Process record and replay target doesn't "
2300                            "support syscall number %d\n"), syscall);
2301       return -1;
2302       break;
2303     }
2304
2305   return 0;
2306 }