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