gdb/linux-record.c

   1 /* Process record and replay target code for GNU/Linux.
   2
   3    Copyright (C) 2008, 2009 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include "defs.h"
  21 #include "target.h"
  22 #include "gdbtypes.h"
  23 #include "regcache.h"
  24 #include "record.h"
  25 #include "linux-record.h"
  26
  27 /* These macros are the values of the first argument of system call
  28    "sys_ptrace".  The values of these macros were obtained from Linux
  29    Kernel source.  */
  30
  31 #define RECORD_PTRACE_PEEKTEXT  1
  32 #define RECORD_PTRACE_PEEKDATA  2
  33 #define RECORD_PTRACE_PEEKUSR   3
  34
  35 /* These macros are the values of the first argument of system call
  36    "sys_socketcall".  The values of these macros were obtained from
  37    Linux Kernel source.  */
  38
  39 #define RECORD_SYS_SOCKET       1
  40 #define RECORD_SYS_BIND         2
  41 #define RECORD_SYS_CONNECT      3
  42 #define RECORD_SYS_LISTEN       4
  43 #define RECORD_SYS_ACCEPT       5
  44 #define RECORD_SYS_GETSOCKNAME  6
  45 #define RECORD_SYS_GETPEERNAME  7
  46 #define RECORD_SYS_SOCKETPAIR   8
  47 #define RECORD_SYS_SEND         9
  48 #define RECORD_SYS_RECV         10
  49 #define RECORD_SYS_SENDTO       11
  50 #define RECORD_SYS_RECVFROM     12
  51 #define RECORD_SYS_SHUTDOWN     13
  52 #define RECORD_SYS_SETSOCKOPT   14
  53 #define RECORD_SYS_GETSOCKOPT   15
  54 #define RECORD_SYS_SENDMSG      16
  55 #define RECORD_SYS_RECVMSG      17
  56
  57 /* These macros are the values of the first argument of system call
  58    "sys_ipc".  The values of these macros were obtained from Linux
  59    Kernel source.  */
  60
  61 #define RECORD_SEMOP            1
  62 #define RECORD_SEMGET           2
  63 #define RECORD_SEMCTL           3
  64 #define RECORD_SEMTIMEDOP       4
  65 #define RECORD_MSGSND           11
  66 #define RECORD_MSGRCV           12
  67 #define RECORD_MSGGET           13
  68 #define RECORD_MSGCTL           14
  69 #define RECORD_SHMAT            21
  70 #define RECORD_SHMDT            22
  71 #define RECORD_SHMGET           23
  72 #define RECORD_SHMCTL           24
  73
  74 /* These macros are the values of the first argument of system call
  75    "sys_quotactl".  The values of these macros were obtained from Linux
  76    Kernel source.  */
  77
  78 #define RECORD_Q_GETFMT         0x800004
  79 #define RECORD_Q_GETINFO        0x800005
  80 #define RECORD_Q_GETQUOTA       0x800007
  81 #define RECORD_Q_XGETQSTAT      (('5' << 8) + 5)
  82 #define RECORD_Q_XGETQUOTA      (('3' << 8) + 3)
  83
  84 #define OUTPUT_REG(val, num)      phex_nz ((val), \
  85     TYPE_LENGTH (gdbarch_register_type (get_regcache_arch (regcache), (num))))
  86
  87 static int
  88 record_linux_sockaddr (struct regcache *regcache,
  89                        struct linux_record_tdep *tdep, ULONGEST addr,
  90                        ULONGEST len)
  91 {
  92   gdb_byte *a;
  93   int addrlen;
  94   struct gdbarch *gdbarch = get_regcache_arch (regcache);
  95   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
  96
  97   if (!addr)
  98     return 0;
  99
 100   a = alloca (tdep->size_int);
 101
 102   if (record_arch_list_add_mem ((CORE_ADDR) len, tdep->size_int))
 103     return -1;
 104
 105   /* Get the addrlen.  */
 106   if (target_read_memory ((CORE_ADDR) len, a, tdep->size_int))
 107     {
 108       if (record_debug)
 109         fprintf_unfiltered (gdb_stdlog,
 110                             "Process record: error reading "
 111                             "memory at addr = 0x%s len = %d.\n",
 112                             phex_nz (len, tdep->size_pointer),
 113                             tdep->size_int);
 114         return -1;
 115     }
 116   addrlen = (int) extract_unsigned_integer (a, tdep->size_int, byte_order);
 117   if (addrlen <= 0 || addrlen > tdep->size_sockaddr)
 118     addrlen = tdep->size_sockaddr;
 119
 120   if (record_arch_list_add_mem ((CORE_ADDR) addr, addrlen))
 121     return -1;
 122
 123   return 0;
 124 }
 125
 126 static int
 127 record_linux_msghdr (struct regcache *regcache,
 128                      struct linux_record_tdep *tdep, ULONGEST addr)
 129 {
 130   gdb_byte *a;
 131   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 132   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 133   CORE_ADDR tmpaddr;
 134   int tmpint;
 135
 136   if (!addr)
 137     return 0;
 138
 139   if (record_arch_list_add_mem ((CORE_ADDR) addr, tdep->size_msghdr))
 140     return -1;
 141
 142   a = alloca (tdep->size_msghdr);
 143   if (target_read_memory ((CORE_ADDR) addr, a, tdep->size_msghdr))
 144     {
 145       if (record_debug)
 146         fprintf_unfiltered (gdb_stdlog,
 147                             "Process record: error reading "
 148                             "memory at addr = 0x%s "
 149                             "len = %d.\n",
 150                             phex_nz (addr, tdep->size_pointer),
 151                             tdep->size_msghdr);
 152         return -1;
 153     }
 154
 155   /* msg_name msg_namelen */
 156   addr = extract_unsigned_integer (a, tdep->size_pointer, byte_order);
 157   a += tdep->size_pointer;
 158   if (record_arch_list_add_mem ((CORE_ADDR) addr,
 159                                 (int) extract_unsigned_integer (a,
 160                                                                 tdep->size_int,
 161                                                                 byte_order)))
 162     return -1;
 163   a += tdep->size_int;
 164
 165   /* msg_iov msg_iovlen */
 166   addr = extract_unsigned_integer (a, tdep->size_pointer, byte_order);
 167   a += tdep->size_pointer;
 168   if (addr)
 169     {
 170       ULONGEST i;
 171       ULONGEST len = extract_unsigned_integer (a, tdep->size_size_t,
 172                                                byte_order);
 173       gdb_byte *iov = alloca (tdep->size_iovec);
 174
 175       for (i = 0; i < len; i++)
 176         {
 177           if (target_read_memory ((CORE_ADDR) addr, iov, tdep->size_iovec))
 178             {
 179               if (record_debug)
 180                 fprintf_unfiltered (gdb_stdlog,
 181                                     "Process record: error "
 182                                     "reading memory at "
 183                                     "addr = 0x%s "
 184                                     "len = %d.\n",
 185                                     phex_nz (addr,tdep->size_pointer),
 186                                     tdep->size_iovec);
 187                 return -1;
 188             }
 189           tmpaddr = (CORE_ADDR) extract_unsigned_integer (iov,
 190                                                           tdep->size_pointer,
 191                                                           byte_order);
 192           tmpint = (int) extract_unsigned_integer (iov + tdep->size_pointer,
 193                                                    tdep->size_size_t,
 194                                                    byte_order);
 195           if (record_arch_list_add_mem (tmpaddr, tmpint));
 196             return -1;
 197           addr += tdep->size_iovec;
 198         }
 199     }
 200   a += tdep->size_size_t;
 201
 202   /* msg_control msg_controllen */
 203   addr = extract_unsigned_integer (a, tdep->size_pointer, byte_order);
 204   a += tdep->size_pointer;
 205   tmpint = (int) extract_unsigned_integer (a, tdep->size_size_t, byte_order);
 206   if (record_arch_list_add_mem ((CORE_ADDR) addr, tmpint));
 207     return -1;
 208
 209   return 0;
 210 }
 211
 212 /* When the architecture process record get a Linux syscall
 213    instruction, it will get a Linux syscall number of this
 214    architecture and convert it to the Linux syscall number "num" which
 215    is internal to GDB.  Most Linux syscalls across architectures in
 216    Linux would be similar and mostly differ by sizes of types and
 217    structures.  This sizes are put to "tdep".
 218
 219    Record the values of the registers and memory that will be changed
 220    in current system call.
 221
 222    Return -1 if something wrong.  */
 223
 224 int
 225 record_linux_system_call (int num, struct regcache *regcache,
 226                           struct linux_record_tdep *tdep)
 227 {
 228   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 229   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 230   ULONGEST tmpulongest;
 231   CORE_ADDR tmpaddr;
 232   int tmpint;
 233
 234   switch (num)
 235     {
 236       /* sys_restart_syscall */
 237     case 0:
 238       break;
 239
 240       /* sys_exit */
 241     case 1:
 242       {
 243         int q;
 244         target_terminal_ours ();
 245         q = yquery (_("The next instruction is syscall exit.  "
 246                       "It will make the program exit.  "
 247                       "Do you want to stop the program?"));
 248         target_terminal_inferior ();
 249         if (q)
 250           return 1;
 251       }
 252       break;
 253
 254       /* sys_fork */
 255     case 2:
 256       break;
 257
 258       /* sys_read */
 259     case 3:
 260       {
 261         ULONGEST addr, count;
 262         regcache_raw_read_unsigned (regcache, tdep->arg2, &addr);
 263         regcache_raw_read_unsigned (regcache, tdep->arg3, &count);
 264         if (record_arch_list_add_mem ((CORE_ADDR) addr, (int) count))
 265           return -1;
 266       }
 267       break;
 268
 269       /* sys_write */
 270     case 4:
 271       /* sys_open */
 272     case 5:
 273       /* sys_close */
 274     case 6:
 275       /* sys_waitpid */
 276     case 7:
 277       /* sys_creat */
 278     case 8:
 279       /* sys_link */
 280     case 9:
 281       /* sys_unlink */
 282     case 10:
 283       /* sys_execve */
 284     case 11:
 285       /* sys_chdir */
 286     case 12:
 287       /* sys_time */
 288     case 13:
 289       /* sys_mknod */
 290     case 14:
 291       /* sys_chmod */
 292     case 15:
 293       /* sys_lchown16 */
 294     case 16:
 295       /* sys_ni_syscall */
 296     case 17:
 297       break;
 298
 299       /* sys_stat */
 300     case 18:
 301       /* sys_fstat */
 302     case 28:
 303       /* sys_lstat */
 304     case 84:
 305       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
 306       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 307                                     tdep->size__old_kernel_stat))
 308         return -1;
 309       break;
 310
 311       /* sys_lseek */
 312     case 19:
 313       /* sys_getpid */
 314     case 20:
 315       /* sys_mount */
 316     case 21:
 317       /* sys_oldumount */
 318     case 22:
 319       /* sys_setuid16 */
 320     case 23:
 321       /* sys_getuid16 */
 322     case 24:
 323       /* sys_stime */
 324     case 25:
 325       break;
 326
 327       /* sys_ptrace */
 328     case 26:
 329       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
 330       if (tmpulongest == RECORD_PTRACE_PEEKTEXT
 331           || tmpulongest == RECORD_PTRACE_PEEKDATA
 332           || tmpulongest == RECORD_PTRACE_PEEKUSR)
 333         {
 334           regcache_raw_read_unsigned (regcache, tdep->arg4,
 335                                       &tmpulongest);
 336           if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 4))
 337             return -1;
 338         }
 339       break;
 340
 341       /* sys_alarm */
 342     case 27:
 343       /* sys_pause */
 344     case 29:
 345       /* sys_utime    */
 346     case 30:
 347       /* sys_ni_syscall */
 348     case 31:
 349       /* sys_ni_syscall */
 350     case 32:
 351       /* sys_access */
 352     case 33:
 353       /* sys_nice */
 354     case 34:
 355       /* sys_ni_syscall */
 356     case 35:
 357       /* sys_sync */
 358     case 36:
 359       /* sys_kill */
 360     case 37:
 361       /* sys_rename */
 362     case 38:
 363       /* sys_mkdir */
 364     case 39:
 365       /* sys_rmdir */
 366     case 40:
 367       /* sys_dup */
 368     case 41:
 369       /* sys_pipe */
 370     case 42:
 371       break;
 372
 373       /* sys_times */
 374     case 43:
 375       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
 376       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_tms))
 377         return -1;
 378       break;
 379
 380       /* sys_ni_syscall */
 381     case 44:
 382       /* sys_brk */
 383     case 45:
 384       /* sys_setgid16 */
 385     case 46:
 386       /* sys_getgid16 */
 387     case 47:
 388       /* sys_signal */
 389     case 48:
 390       /* sys_geteuid16 */
 391     case 49:
 392       /* sys_getegid16 */
 393     case 50:
 394       /* sys_acct */
 395     case 51:
 396       /* sys_umount */
 397     case 52:
 398       /* sys_ni_syscall */
 399     case 53:
 400       break;
 401
 402       /* sys_ioctl */
 403     case 54:
 404       /* XXX Need to add a lot of support of other ioctl requests.  */
 405       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
 406       if (tmpulongest == tdep->ioctl_FIOCLEX
 407           || tmpulongest == tdep->ioctl_FIONCLEX
 408           || tmpulongest == tdep->ioctl_FIONBIO
 409           || tmpulongest == tdep->ioctl_FIOASYNC
 410           || tmpulongest == tdep->ioctl_TCSETS
 411           || tmpulongest == tdep->ioctl_TCSETSW
 412           || tmpulongest == tdep->ioctl_TCSETSF
 413           || tmpulongest == tdep->ioctl_TCSETA
 414           || tmpulongest == tdep->ioctl_TCSETAW
 415           || tmpulongest == tdep->ioctl_TCSETAF
 416           || tmpulongest == tdep->ioctl_TCSBRK
 417           || tmpulongest == tdep->ioctl_TCXONC
 418           || tmpulongest == tdep->ioctl_TCFLSH
 419           || tmpulongest == tdep->ioctl_TIOCEXCL
 420           || tmpulongest == tdep->ioctl_TIOCNXCL
 421           || tmpulongest == tdep->ioctl_TIOCSCTTY
 422           || tmpulongest == tdep->ioctl_TIOCSPGRP
 423           || tmpulongest == tdep->ioctl_TIOCSTI
 424           || tmpulongest == tdep->ioctl_TIOCSWINSZ
 425           || tmpulongest == tdep->ioctl_TIOCMBIS
 426           || tmpulongest == tdep->ioctl_TIOCMBIC
 427           || tmpulongest == tdep->ioctl_TIOCMSET
 428           || tmpulongest == tdep->ioctl_TIOCSSOFTCAR
 429           || tmpulongest == tdep->ioctl_TIOCCONS
 430           || tmpulongest == tdep->ioctl_TIOCSSERIAL
 431           || tmpulongest == tdep->ioctl_TIOCPKT
 432           || tmpulongest == tdep->ioctl_TIOCNOTTY
 433           || tmpulongest == tdep->ioctl_TIOCSETD
 434           || tmpulongest == tdep->ioctl_TCSBRKP
 435           || tmpulongest == tdep->ioctl_TIOCTTYGSTRUCT
 436           || tmpulongest == tdep->ioctl_TIOCSBRK
 437           || tmpulongest == tdep->ioctl_TIOCCBRK
 438           || tmpulongest == tdep->ioctl_TCSETS2
 439           || tmpulongest == tdep->ioctl_TCSETSW2
 440           || tmpulongest == tdep->ioctl_TCSETSF2
 441           || tmpulongest == tdep->ioctl_TIOCSPTLCK
 442           || tmpulongest == tdep->ioctl_TIOCSERCONFIG
 443           || tmpulongest == tdep->ioctl_TIOCSERGWILD
 444           || tmpulongest == tdep->ioctl_TIOCSERSWILD
 445           || tmpulongest == tdep->ioctl_TIOCSLCKTRMIOS
 446           || tmpulongest == tdep->ioctl_TIOCSERGETMULTI
 447           || tmpulongest == tdep->ioctl_TIOCSERSETMULTI
 448           || tmpulongest == tdep->ioctl_TIOCMIWAIT
 449           || tmpulongest == tdep->ioctl_TIOCSHAYESESP)
 450         {
 451           /* Nothing to do.  */
 452         }
 453       else if (tmpulongest == tdep->ioctl_TCGETS
 454                || tmpulongest == tdep->ioctl_TCGETA
 455                || tmpulongest == tdep->ioctl_TIOCGLCKTRMIOS)
 456         {
 457           regcache_raw_read_unsigned (regcache, tdep->arg3,
 458                                       &tmpulongest);
 459           if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 460                                         tdep->size_termios))
 461             return -1;
 462         }
 463       else if (tmpulongest == tdep->ioctl_TIOCGPGRP
 464                || tmpulongest == tdep->ioctl_TIOCGSID)
 465         {
 466           regcache_raw_read_unsigned (regcache, tdep->arg3,
 467                                       &tmpulongest);
 468           if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 469                                         tdep->size_pid_t))
 470             return -1;
 471         }
 472       else if (tmpulongest == tdep->ioctl_TIOCOUTQ
 473                || tmpulongest == tdep->ioctl_TIOCMGET
 474                || tmpulongest == tdep->ioctl_TIOCGSOFTCAR
 475                || tmpulongest == tdep->ioctl_FIONREAD
 476                || tmpulongest == tdep->ioctl_TIOCINQ
 477                || tmpulongest == tdep->ioctl_TIOCGETD
 478                || tmpulongest == tdep->ioctl_TIOCGPTN
 479                || tmpulongest == tdep->ioctl_TIOCSERGETLSR)
 480         {
 481           regcache_raw_read_unsigned (regcache, tdep->arg3,
 482                                       &tmpulongest);
 483           if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 484                                         tdep->size_int))
 485             return -1;
 486         }
 487       else if (tmpulongest == tdep->ioctl_TIOCGWINSZ)
 488         {
 489           regcache_raw_read_unsigned (regcache, tdep->arg3,
 490                                       &tmpulongest);
 491           if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 492                                         tdep->size_winsize))
 493             return -1;
 494         }
 495       else if (tmpulongest == tdep->ioctl_TIOCLINUX)
 496         {
 497           regcache_raw_read_unsigned (regcache, tdep->arg3,
 498                                       &tmpulongest);
 499           /* This syscall affect a char size memory.  */
 500           if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 1))
 501             return -1;
 502         }
 503       else if (tmpulongest == tdep->ioctl_TIOCGSERIAL)
 504         {
 505           regcache_raw_read_unsigned (regcache, tdep->arg3,
 506                                       &tmpulongest);
 507           if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 508                                         tdep->size_serial_struct))
 509             return -1;
 510         }
 511       else if (tmpulongest == tdep->ioctl_TCGETS2)
 512         {
 513           regcache_raw_read_unsigned (regcache, tdep->arg3,
 514                                       &tmpulongest);
 515           if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 516                                         tdep->size_termios2))
 517             return -1;
 518         }
 519       else if (tmpulongest == tdep->ioctl_FIOQSIZE)
 520         {
 521           regcache_raw_read_unsigned (regcache, tdep->arg3,
 522                                       &tmpulongest);
 523           if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 524                                         tdep->size_loff_t))
 525             return -1;
 526         }
 527       else if (tmpulongest == tdep->ioctl_TIOCGICOUNT)
 528         {
 529           regcache_raw_read_unsigned (regcache, tdep->arg3,
 530                                       &tmpulongest);
 531           if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 532                                         tdep->size_serial_icounter_struct))
 533             return -1;
 534         }
 535       else if (tmpulongest == tdep->ioctl_TIOCGHAYESESP)
 536         {
 537           regcache_raw_read_unsigned (regcache, tdep->arg3,
 538                                       &tmpulongest);
 539           if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 540                                         tdep->size_hayes_esp_config))
 541             return -1;
 542         }
 543       else if (tmpulongest == tdep->ioctl_TIOCSERGSTRUCT)
 544         {
 545           printf_unfiltered (_("Process record and replay target doesn't "
 546                                "support ioctl request TIOCSERGSTRUCT\n"));
 547           return 1;
 548         }
 549       else
 550         {
 551           printf_unfiltered (_("Process record and replay target doesn't "
 552                                "support ioctl request 0x%s.\n"),
 553                              OUTPUT_REG (tmpulongest, tdep->arg2));
 554           return 1;
 555         }
 556       break;
 557
 558       /* sys_fcntl */
 559     case 55:
 560       /* XXX */
 561       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
 562     sys_fcntl:
 563       if (tmpulongest == tdep->fcntl_F_GETLK)
 564         {
 565           regcache_raw_read_unsigned (regcache, tdep->arg3,
 566                                       &tmpulongest);
 567           if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 568                                         tdep->size_flock))
 569             return -1;
 570         }
 571       break;
 572
 573       /* sys_ni_syscall */
 574     case 56:
 575       /* sys_setpgid */
 576     case 57:
 577       /* sys_ni_syscall */
 578     case 58:
 579       break;
 580
 581       /* sys_olduname */
 582     case 59:
 583       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
 584       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 585                                     tdep->size_oldold_utsname))
 586         return -1;
 587       break;
 588
 589       /* sys_umask */
 590     case 60:
 591       /* sys_chroot */
 592     case 61:
 593       break;
 594
 595       /* sys_ustat */
 596     case 62:
 597       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
 598       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 599                                     tdep->size_ustat))
 600         return -1;
 601       break;
 602
 603       /* sys_dup2 */
 604     case 63:
 605       /* sys_getppid */
 606     case 64:
 607       /* sys_getpgrp */
 608     case 65:
 609       /* sys_setsid */
 610     case 66:
 611       break;
 612
 613       /* sys_sigaction */
 614     case 67:
 615       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
 616       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 617                                     tdep->size_old_sigaction))
 618         return -1;
 619       break;
 620
 621       /* sys_sgetmask */
 622     case 68:
 623       /* sys_ssetmask */
 624     case 69:
 625       /* sys_setreuid16 */
 626     case 70:
 627       /* sys_setregid16 */
 628     case 71:
 629       /* sys_sigsuspend */
 630     case 72:
 631       break;
 632
 633       /* sys_sigpending */
 634     case 73:
 635       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
 636       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 637                                     tdep->size_old_sigset_t))
 638         return -1;
 639       break;
 640
 641       /* sys_sethostname */
 642     case 74:
 643       /* sys_setrlimit */
 644     case 75:
 645       break;
 646
 647       /* sys_old_getrlimit */
 648     case 76:
 649       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
 650       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 651                                     tdep->size_rlimit))
 652         return -1;
 653       break;
 654
 655       /* sys_getrusage */
 656     case 77:
 657       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
 658       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 659                                     tdep->size_rusage))
 660         return -1;
 661       break;
 662
 663       /* sys_gettimeofday */
 664     case 78:
 665       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
 666       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 667                                     tdep->size_timeval))
 668         return -1;
 669       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
 670       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 671                                     tdep->size_timezone))
 672         return -1;
 673       break;
 674
 675       /* sys_settimeofday */
 676     case 79:
 677       break;
 678
 679       /* sys_getgroups16 */
 680     case 80:
 681       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
 682       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 683                                     tdep->size_old_gid_t))
 684         return -1;
 685       break;
 686
 687       /* sys_setgroups16 */
 688     case 81:
 689       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
 690       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 691                                     tdep->size_old_gid_t))
 692         return -1;
 693       break;
 694
 695       /* old_select */
 696     case 82:
 697       {
 698         struct sel_arg_struct
 699         {
 700           CORE_ADDR n;
 701           CORE_ADDR inp;
 702           CORE_ADDR outp;
 703           CORE_ADDR exp;
 704           CORE_ADDR tvp;
 705         } sel;
 706
 707         regcache_raw_read_unsigned (regcache, tdep->arg1,
 708                                     &tmpulongest);
 709         if (tmpulongest)
 710           {
 711             if (target_read_memory (tmpulongest, (gdb_byte *) &sel,
 712                                     sizeof(sel)))
 713               {
 714                 if (record_debug)
 715                   fprintf_unfiltered (gdb_stdlog,
 716                                       "Process record: error reading memory "
 717                                       "at addr = 0x%s len = %lu.\n",
 718                                       OUTPUT_REG (tmpulongest, tdep->arg1),
 719                                       (unsigned long) sizeof (sel));
 720                 return -1;
 721               }
 722             if (record_arch_list_add_mem (sel.inp, tdep->size_fd_set))
 723               return -1;
 724             if (record_arch_list_add_mem (sel.outp, tdep->size_fd_set))
 725               return -1;
 726             if (record_arch_list_add_mem (sel.exp, tdep->size_fd_set))
 727               return -1;
 728             if (record_arch_list_add_mem (sel.tvp, tdep->size_timeval))
 729               return -1;
 730           }
 731       }
 732       break;
 733
 734       /* sys_symlink */
 735     case 83:
 736       break;
 737
 738       /* sys_readlink */
 739     case 85:
 740       {
 741         ULONGEST len;
 742         regcache_raw_read_unsigned (regcache, tdep->arg2,
 743                                     &tmpulongest);
 744         regcache_raw_read_unsigned (regcache, tdep->arg3, &len);
 745         if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, (int) len))
 746           return -1;
 747       }
 748       break;
 749
 750       /* sys_uselib */
 751     case 86:
 752       /* sys_swapon */
 753     case 87:
 754       break;
 755
 756       /* sys_reboot */
 757     case 88:
 758       {
 759         int q;
 760         target_terminal_ours ();
 761         q =
 762           yquery (_("The next instruction is syscall reboot.  "
 763                     "It will restart the computer.  "
 764                     "Do you want to stop the program?"));
 765         target_terminal_inferior ();
 766         if (q)
 767           return 1;
 768       }
 769       break;
 770
 771       /* old_readdir */
 772     case 89:
 773       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
 774       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 775                                     tdep->size_dirent))
 776         return -1;
 777       break;
 778
 779       /* old_mmap */
 780     case 90:
 781       break;
 782
 783       /* sys_munmap */
 784     case 91:
 785       {
 786         int q;
 787         ULONGEST len;
 788
 789         regcache_raw_read_unsigned (regcache, tdep->arg1,
 790                                     &tmpulongest);
 791         regcache_raw_read_unsigned (regcache, tdep->arg2, &len);
 792         target_terminal_ours ();
 793         q = yquery (_("The next instruction is syscall munmap.  "
 794                       "It will free the memory addr = 0x%s len = %u.  "
 795                       "It will make record target get error.  "
 796                       "Do you want to stop the program?"),
 797                     OUTPUT_REG (tmpulongest, tdep->arg1), (int) len);
 798         target_terminal_inferior ();
 799         if (q)
 800           return 1;
 801       }
 802       break;
 803
 804       /* sys_truncate */
 805     case 92:
 806       /* sys_ftruncate */
 807     case 93:
 808       /* sys_fchmod */
 809     case 94:
 810       /* sys_fchown16 */
 811     case 95:
 812       /* sys_getpriority */
 813     case 96:
 814       /* sys_setpriority */
 815     case 97:
 816       /* sys_ni_syscall */
 817     case 98:
 818       break;
 819
 820       /* sys_statfs */
 821     case 99:
 822       /* sys_fstatfs */
 823     case 100:
 824       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
 825       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 826                                     tdep->size_statfs))
 827         return -1;
 828       break;
 829
 830       /* sys_ioperm */
 831     case 101:
 832       break;
 833
 834       /* sys_socket */
 835     case 500:
 836       /* sys_sendto */
 837     case 503:
 838       /* sys_sendmsg */
 839     case 505:
 840       /* sys_shutdown */
 841     case 507:
 842       /* sys_bind */
 843     case 508:
 844       /* sys_connect */
 845     case 501:
 846       /* sys_listen */
 847     case 509:
 848       /* sys_setsockopt */
 849     case 513:
 850       break;
 851
 852       /* sys_accept */
 853     case 502:
 854       /* sys_getsockname */
 855     case 510:
 856       /* sys_getpeername */
 857     case 511:
 858       {
 859         ULONGEST len;
 860         regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
 861         regcache_raw_read_unsigned (regcache, tdep->arg3, &len);
 862         if (record_linux_sockaddr (regcache, tdep, tmpulongest, len))
 863           return -1;
 864       }
 865       break;
 866
 867       /* sys_recvfrom */
 868     case 504:
 869       {
 870         ULONGEST len;
 871         regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
 872         regcache_raw_read_unsigned (regcache, tdep->arg5, &len);
 873         if (record_linux_sockaddr (regcache, tdep, tmpulongest, len))
 874           return -1;
 875       }
 876       /* sys_recv */
 877     case 515:
 878       {
 879         ULONGEST size;
 880         regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
 881         regcache_raw_read_unsigned (regcache, tdep->arg3, &size);
 882         if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, (int) size))
 883           return -1;
 884       }
 885       break;
 886
 887       /* sys_recvmsg */
 888     case 506:
 889       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
 890       if (record_linux_msghdr (regcache, tdep, tmpulongest))
 891         return -1;
 892       break;
 893
 894       /* sys_socketpair */
 895     case 512:
 896       regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
 897       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_int))
 898         return -1;
 899       break;
 900
 901       /* sys_getsockopt */
 902     case 514:
 903       regcache_raw_read_unsigned (regcache, tdep->arg5, &tmpulongest);
 904       if (tmpulongest)
 905         {
 906           ULONGEST optvalp;
 907           gdb_byte *optlenp = alloca (tdep->size_int);
 908           if (target_read_memory ((CORE_ADDR) tmpulongest, optlenp,
 909                                   tdep->size_int))
 910             {
 911               if (record_debug)
 912                 fprintf_unfiltered (gdb_stdlog,
 913                                     "Process record: error reading "
 914                                     "memory at addr = 0x%s "
 915                                     "len = %d.\n",
 916                                     OUTPUT_REG (tmpulongest, tdep->arg5),
 917                                     tdep->size_int);
 918               return -1;
 919             }
 920           regcache_raw_read_unsigned (regcache, tdep->arg4, &optvalp);
 921           tmpint = (int) extract_signed_integer (optlenp, tdep->size_int,
 922                                                  byte_order);
 923           if (record_arch_list_add_mem ((CORE_ADDR) optvalp, tmpint))
 924             return -1;
 925           if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
 926                                         tdep->size_int))
 927             return -1;
 928         }
 929       break;
 930
 931       /* sys_socketcall */
 932     case 102:
 933       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
 934       switch (tmpulongest)
 935         {
 936         case RECORD_SYS_SOCKET:
 937         case RECORD_SYS_BIND:
 938         case RECORD_SYS_CONNECT:
 939         case RECORD_SYS_LISTEN:
 940           break;
 941         case RECORD_SYS_ACCEPT:
 942         case RECORD_SYS_GETSOCKNAME:
 943         case RECORD_SYS_GETPEERNAME:
 944           {
 945             regcache_raw_read_unsigned (regcache, tdep->arg2,
 946                                         &tmpulongest);
 947             if (tmpulongest)
 948               {
 949                 gdb_byte *a = alloca (tdep->size_ulong * 2);
 950                 int addrlen;
 951                 gdb_byte *addrlenp;
 952                 ULONGEST len;
 953
 954                 tmpulongest += tdep->size_ulong;
 955                 if (target_read_memory ((CORE_ADDR) tmpulongest, a,
 956                                         tdep->size_ulong * 2))
 957                   {
 958                     if (record_debug)
 959                       fprintf_unfiltered (gdb_stdlog,
 960                                           "Process record: error reading "
 961                                           "memory at addr = 0x%s len = %d.\n",
 962                                           OUTPUT_REG (tmpulongest, tdep->arg2),
 963                                           tdep->size_ulong * 2);
 964                     return -1;
 965                   }
 966                 tmpulongest = extract_unsigned_integer (a,
 967                                                         tdep->size_ulong,
 968                                                         byte_order);
 969                 len = extract_unsigned_integer (a + tdep->size_ulong,
 970                                                 tdep->size_ulong, byte_order);
 971                 if (record_linux_sockaddr (regcache, tdep, tmpulongest, len))
 972                   return -1;
 973               }
 974           }
 975           break;
 976
 977         case RECORD_SYS_SOCKETPAIR:
 978           {
 979             gdb_byte *a = alloca (tdep->size_ulong);
 980             regcache_raw_read_unsigned (regcache, tdep->arg2,
 981                                         &tmpulongest);
 982             if (tmpulongest)
 983               {
 984                 tmpulongest += tdep->size_ulong * 3;
 985                 if (target_read_memory ((CORE_ADDR) tmpulongest, a,
 986                                         tdep->size_ulong))
 987                   {
 988                     if (record_debug)
 989                       fprintf_unfiltered (gdb_stdlog,
 990                                           "Process record: error reading "
 991                                           "memory at addr = 0x%s len = %d.\n",
 992                                           OUTPUT_REG (tmpulongest, tdep->arg2),
 993                                           tdep->size_ulong);
 994                     return -1;
 995                   }
 996                 tmpaddr
 997                   = (CORE_ADDR) extract_unsigned_integer (a, tdep->size_ulong,
 998                                                           byte_order);
 999                 if (record_arch_list_add_mem (tmpaddr, tdep->size_int))
1000                   return -1;
1001               }
1002           }
1003           break;
1004         case RECORD_SYS_SEND:
1005         case RECORD_SYS_SENDTO:
1006           break;
1007         case RECORD_SYS_RECVFROM:
1008           regcache_raw_read_unsigned (regcache, tdep->arg2,
1009                                       &tmpulongest);
1010           if (tmpulongest)
1011             {
1012               gdb_byte *a = alloca (tdep->size_ulong * 2);
1013               int addrlen;
1014               gdb_byte *addrlenp;
1015               ULONGEST len;
1016
1017               tmpulongest += tdep->size_ulong * 4;
1018               if (target_read_memory ((CORE_ADDR) tmpulongest, a,
1019                                       tdep->size_ulong * 2))
1020                 {
1021                   if (record_debug)
1022                     fprintf_unfiltered (gdb_stdlog,
1023                                         "Process record: error reading "
1024                                         "memory at addr = 0x%s len = %d.\n",
1025                                         OUTPUT_REG (tmpulongest, tdep->arg2),
1026                                         tdep->size_ulong * 2);
1027                   return -1;
1028                 }
1029               tmpulongest = extract_unsigned_integer (a, tdep->size_ulong,
1030                                                       byte_order);
1031               len = extract_unsigned_integer (a + tdep->size_ulong,
1032                                               tdep->size_ulong, byte_order);
1033               if (record_linux_sockaddr (regcache, tdep, tmpulongest, len))
1034                 return -1;
1035             }
1036         case RECORD_SYS_RECV:
1037           regcache_raw_read_unsigned (regcache, tdep->arg2,
1038                                       &tmpulongest);
1039           if (tmpulongest)
1040             {
1041               gdb_byte *a = alloca (tdep->size_ulong * 2);
1042
1043               tmpulongest += tdep->size_ulong;
1044               if (target_read_memory ((CORE_ADDR) tmpulongest, a,
1045                                       tdep->size_ulong))
1046                 {
1047                   if (record_debug)
1048                     fprintf_unfiltered (gdb_stdlog,
1049                                         "Process record: error reading "
1050                                         "memory at addr = 0x%s len = %d.\n",
1051                                         OUTPUT_REG (tmpulongest, tdep->arg2),
1052                                         tdep->size_ulong);
1053                     return -1;
1054                 }
1055               tmpulongest = extract_unsigned_integer (a, tdep->size_ulong,
1056                                                       byte_order);
1057               if (tmpulongest)
1058                 {
1059                   a += tdep->size_ulong;
1060                   tmpint = (int) extract_unsigned_integer (a, tdep->size_ulong,
1061                                                            byte_order);
1062                   if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1063                                                 tmpint))
1064                     return -1;
1065                 }
1066             }
1067           break;
1068         case RECORD_SYS_SHUTDOWN:
1069         case RECORD_SYS_SETSOCKOPT:
1070           break;
1071         case RECORD_SYS_GETSOCKOPT:
1072           {
1073             gdb_byte *a = alloca (tdep->size_ulong * 2);
1074             gdb_byte *av = alloca (tdep->size_int);
1075
1076             regcache_raw_read_unsigned (regcache, tdep->arg2,
1077                                         &tmpulongest);
1078             if (tmpulongest)
1079               {
1080                 tmpulongest += tdep->size_ulong * 3;
1081                 if (target_read_memory ((CORE_ADDR) tmpulongest, a,
1082                                         tdep->size_ulong * 2))
1083                   {
1084                     if (record_debug)
1085                       fprintf_unfiltered (gdb_stdlog,
1086                                           "Process record: error reading "
1087                                           "memory at addr = 0x%s len = %d.\n",
1088                                           OUTPUT_REG (tmpulongest, tdep->arg2),
1089                                           tdep->size_ulong * 2);
1090                     return -1;
1091                   }
1092                 tmpulongest = extract_unsigned_integer (a + tdep->size_ulong,
1093                                                         tdep->size_ulong,
1094                                                         byte_order);
1095                 if (tmpulongest)
1096                   {
1097                     if (target_read_memory ((CORE_ADDR) tmpulongest, av,
1098                                             tdep->size_int))
1099                       {
1100                         if (record_debug)
1101                           fprintf_unfiltered (gdb_stdlog,
1102                                               "Process record: error reading "
1103                                               "memory at addr = 0x%s "
1104                                               "len = %d.\n",
1105                                               phex_nz (tmpulongest,
1106                                                        tdep->size_ulong),
1107                                               tdep->size_int);
1108                         return -1;
1109                       }
1110                     tmpaddr
1111                       = (CORE_ADDR) extract_unsigned_integer (a,
1112                                                               tdep->size_ulong,
1113                                                               byte_order);
1114                     tmpint = (int) extract_unsigned_integer (av,
1115                                                              tdep->size_int,
1116                                                              byte_order);
1117                     if (record_arch_list_add_mem (tmpaddr, tmpint))
1118                       return -1;
1119                     a += tdep->size_ulong;
1120                     tmpaddr
1121                       = (CORE_ADDR) extract_unsigned_integer (a,
1122                                                               tdep->size_ulong,
1123                                                               byte_order);
1124                     if (record_arch_list_add_mem (tmpaddr, tdep->size_int))
1125                       return -1;
1126                   }
1127               }
1128           }
1129           break;
1130         case RECORD_SYS_SENDMSG:
1131           break;
1132         case RECORD_SYS_RECVMSG:
1133           {
1134             gdb_byte *a = alloca (tdep->size_ulong);
1135
1136             regcache_raw_read_unsigned (regcache, tdep->arg2,
1137                                         &tmpulongest);
1138             if (tmpulongest)
1139               {
1140                 tmpulongest += tdep->size_ulong;
1141                 if (target_read_memory ((CORE_ADDR) tmpulongest, a,
1142                                         tdep->size_ulong))
1143                   {
1144                     if (record_debug)
1145                       fprintf_unfiltered (gdb_stdlog,
1146                                           "Process record: error reading "
1147                                           "memory at addr = 0x%s len = %d.\n",
1148                                           OUTPUT_REG (tmpulongest, tdep->arg2),
1149                                           tdep->size_ulong);
1150                     return -1;
1151                   }
1152                 tmpulongest = extract_unsigned_integer (a, tdep->size_ulong,
1153                                                         byte_order);
1154                 if (record_linux_msghdr (regcache, tdep, tmpulongest))
1155                   return -1;
1156               }
1157           }
1158           break;
1159         default:
1160           printf_unfiltered (_("Process record and replay target "
1161                                "doesn't support socketcall call 0x%s\n"),
1162                              OUTPUT_REG (tmpulongest, tdep->arg1));
1163           return -1;
1164           break;
1165         }
1166       break;
1167
1168       /* sys_syslog */
1169     case 103:
1170       break;
1171
1172       /* sys_setitimer */
1173     case 104:
1174       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1175       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1176                                     tdep->size_itimerval))
1177         return -1;
1178       break;
1179
1180       /* sys_getitimer */
1181     case 105:
1182       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1183       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1184                                     tdep->size_itimerval))
1185         return -1;
1186       break;
1187
1188       /* sys_newstat */
1189     case 106:
1190       /* sys_newlstat */
1191     case 107:
1192       /* sys_newfstat */
1193     case 108:
1194       /* sys_newfstatat */
1195     case 540:
1196       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1197       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_stat))
1198         return -1;
1199       break;
1200
1201       /* sys_uname */
1202     case 109:
1203       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1204       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1205                                     tdep->size_old_utsname))
1206         return -1;
1207       break;
1208
1209       /* sys_iopl */
1210     case 110:
1211       /* sys_vhangup */
1212     case 111:
1213       /* sys_ni_syscall */
1214     case 112:
1215       /* sys_vm86old */
1216     case 113:
1217       break;
1218
1219       /* sys_wait4 */
1220     case 114:
1221       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1222       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1223                                     tdep->size_int))
1224         return -1;
1225       regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
1226       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1227                                     tdep->size_rusage))
1228         return -1;
1229       break;
1230
1231       /* sys_swapoff */
1232     case 115:
1233       break;
1234
1235       /* sys_sysinfo */
1236     case 116:
1237       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1238       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1239                                     tdep->size_sysinfo))
1240         return -1;
1241       break;
1242
1243       /* sys_shmget */
1244     case 520:
1245       /* sys_semget */
1246     case 523:
1247       /* sys_semop */
1248     case 524:
1249       /* sys_msgget */
1250     case 528:
1251       /* sys_shmdt */
1252       /* XXX maybe need do some record works with sys_shmdt.  */
1253     case 527:
1254       /* sys_msgsnd */
1255     case 529:
1256       /* sys_semtimedop */
1257     case 532:
1258       break;
1259
1260       /* sys_shmat */
1261     case 521:
1262       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1263       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1264                                     tdep->size_ulong))
1265         return -1;
1266       break;
1267
1268       /* sys_shmctl */
1269     case 522:
1270       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1271       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1272                                     tdep->size_shmid_ds))
1273         return -1;
1274       break;
1275
1276       /* sys_semctl */
1277       /* XXX sys_semctl 525 still not support.  */
1278
1279       /* sys_msgrcv */
1280     case 530:
1281       {
1282         ULONGEST msgp;
1283         regcache_raw_read_signed (regcache, tdep->arg3, &tmpulongest);
1284         regcache_raw_read_unsigned (regcache, tdep->arg2, &msgp);
1285         tmpint = (int) tmpulongest + tdep->size_long;
1286         if (record_arch_list_add_mem ((CORE_ADDR) msgp, tmpint))
1287           return -1;
1288       }
1289       break;
1290
1291       /* sys_msgctl */
1292     case 531:
1293       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1294       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1295                                     tdep->size_msqid_ds))
1296         return -1;
1297       break;
1298
1299       /* sys_ipc */
1300     case 117:
1301       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1302       tmpulongest &= 0xffff;
1303       switch (tmpulongest)
1304         {
1305         case RECORD_SEMOP:
1306         case RECORD_SEMGET:
1307         case RECORD_SEMTIMEDOP:
1308         case RECORD_MSGSND:
1309         case RECORD_MSGGET:
1310           /* XXX maybe need do some record works with RECORD_SHMDT.  */
1311         case RECORD_SHMDT:
1312         case RECORD_SHMGET:
1313           break;
1314         case RECORD_MSGRCV:
1315           {
1316             ULONGEST second;
1317             ULONGEST ptr;
1318             regcache_raw_read_signed (regcache, tdep->arg3, &second);
1319             regcache_raw_read_unsigned (regcache, tdep->arg5, &ptr);
1320             tmpint = (int) second + tdep->size_long;
1321             if (record_arch_list_add_mem ((CORE_ADDR) ptr, tmpint))
1322               return -1;
1323           }
1324           break;
1325         case RECORD_MSGCTL:
1326           regcache_raw_read_unsigned (regcache, tdep->arg5,
1327                                       &tmpulongest);
1328           if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1329                                         tdep->size_msqid_ds))
1330             return -1;
1331           break;
1332         case RECORD_SHMAT:
1333           regcache_raw_read_unsigned (regcache, tdep->arg4,
1334                                       &tmpulongest);
1335           if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1336                                         tdep->size_ulong))
1337             return -1;
1338           break;
1339         case RECORD_SHMCTL:
1340           regcache_raw_read_unsigned (regcache, tdep->arg5,
1341                                       &tmpulongest);
1342           if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1343                                         tdep->size_shmid_ds))
1344             return -1;
1345           break;
1346         default:
1347           /* XXX RECORD_SEMCTL still not support.  */
1348           printf_unfiltered (_("Process record and replay target doesn't "
1349                                "support ipc number %d\n"), (int) tmpulongest);
1350           break;
1351         }
1352       break;
1353
1354       /* sys_fsync */
1355     case 118:
1356       /* sys_sigreturn */
1357     case 119:
1358       /* sys_clone */
1359     case 120:
1360       /* sys_setdomainname */
1361     case 121:
1362       break;
1363
1364       /* sys_newuname */
1365     case 122:
1366       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1367       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1368                                     tdep->size_new_utsname))
1369         return -1;
1370       break;
1371
1372       /* sys_modify_ldt */
1373     case 123:
1374       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1375       if (tmpulongest == 0 || tmpulongest == 2)
1376         {
1377           ULONGEST ptr, bytecount;
1378           regcache_raw_read_unsigned (regcache, tdep->arg2, &ptr);
1379           regcache_raw_read_unsigned (regcache, tdep->arg3, &bytecount);
1380           if (record_arch_list_add_mem ((CORE_ADDR) ptr, (int) bytecount))
1381             return -1;
1382         }
1383       break;
1384
1385       /* sys_adjtimex */
1386     case 124:
1387       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1388       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_timex))
1389         return -1;
1390       break;
1391
1392       /* sys_mprotect */
1393     case 125:
1394       break;
1395
1396       /* sys_sigprocmask */
1397     case 126:
1398       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1399       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1400                                     tdep->size_old_sigset_t))
1401         return -1;
1402       break;
1403
1404       /* sys_ni_syscall */
1405     case 127:
1406       /* sys_init_module */
1407     case 128:
1408       /* sys_delete_module */
1409     case 129:
1410       /* sys_ni_syscall */
1411     case 130:
1412       break;
1413
1414       /* sys_quotactl */
1415     case 131:
1416       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1417       switch (tmpulongest)
1418         {
1419         case RECORD_Q_GETFMT:
1420           regcache_raw_read_unsigned (regcache, tdep->arg4,
1421                                       &tmpulongest);
1422           /* __u32 */
1423           if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 4))
1424             return -1;
1425           break;
1426         case RECORD_Q_GETINFO:
1427           regcache_raw_read_unsigned (regcache, tdep->arg4,
1428                                       &tmpulongest);
1429           if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1430                                         tdep->size_mem_dqinfo))
1431             return -1;
1432           break;
1433         case RECORD_Q_GETQUOTA:
1434           regcache_raw_read_unsigned (regcache, tdep->arg4,
1435                                       &tmpulongest);
1436           if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1437                                         tdep->size_if_dqblk))
1438             return -1;
1439           break;
1440         case RECORD_Q_XGETQSTAT:
1441         case RECORD_Q_XGETQUOTA:
1442           regcache_raw_read_unsigned (regcache, tdep->arg4,
1443                                       &tmpulongest);
1444           if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1445                                         tdep->size_fs_quota_stat))
1446             return -1;
1447           break;
1448         }
1449       break;
1450
1451       /* sys_getpgid */
1452     case 132:
1453       /* sys_fchdir */
1454     case 133:
1455       /* sys_bdflush */
1456     case 134:
1457       break;
1458
1459       /* sys_sysfs */
1460     case 135:
1461       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1462       if (tmpulongest == 2)
1463         {
1464           regcache_raw_read_unsigned (regcache, tdep->arg3,
1465                                       &tmpulongest);
1466           /*XXX the size of memory is not very clear.  */
1467           if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 10))
1468             return -1;
1469         }
1470       break;
1471
1472       /* sys_personality */
1473     case 136:
1474       /* sys_ni_syscall */
1475     case 137:
1476       /* sys_setfsuid16 */
1477     case 138:
1478       /* sys_setfsgid16 */
1479     case 139:
1480       break;
1481
1482       /* sys_llseek */
1483     case 140:
1484       regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
1485       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1486                                     tdep->size_loff_t))
1487         return -1;
1488       break;
1489
1490       /* sys_getdents */
1491     case 141:
1492       {
1493         ULONGEST count;
1494         regcache_raw_read_unsigned (regcache, tdep->arg2,
1495                                     &tmpulongest);
1496         regcache_raw_read_unsigned (regcache, tdep->arg3, &count);
1497         if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1498                                       tdep->size_dirent * count))
1499           return -1;
1500       }
1501       break;
1502
1503       /* sys_select */
1504     case 142:
1505       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1506       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1507                                     tdep->size_fd_set))
1508         return -1;
1509       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1510       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1511                                     tdep->size_fd_set))
1512         return -1;
1513       regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
1514       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1515                                     tdep->size_fd_set))
1516         return -1;
1517       regcache_raw_read_unsigned (regcache, tdep->arg5, &tmpulongest);
1518       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1519                                     tdep->size_timeval))
1520         return -1;
1521       break;
1522
1523       /* sys_flock */
1524     case 143:
1525       /* sys_msync */
1526     case 144:
1527       break;
1528
1529       /* sys_readv */
1530     case 145:
1531       {
1532         ULONGEST vec, vlen;
1533
1534         regcache_raw_read_unsigned (regcache, tdep->arg2, &vec);
1535         if (vec)
1536           {
1537             gdb_byte *iov = alloca (tdep->size_iovec);
1538
1539             regcache_raw_read_unsigned (regcache, tdep->arg3, &vlen);
1540             for (tmpulongest = 0; tmpulongest < vlen; tmpulongest++)
1541               {
1542                 if (target_read_memory ((CORE_ADDR) vec, iov,
1543                                         tdep->size_iovec))
1544                   {
1545                     if (record_debug)
1546                       fprintf_unfiltered (gdb_stdlog,
1547                                           "Process record: error reading "
1548                                           "memory at addr = 0x%s len = %d.\n",
1549                                           OUTPUT_REG (vec, tdep->arg2),
1550                                           tdep->size_iovec);
1551                     return -1;
1552                   }
1553                 tmpaddr
1554                   = (CORE_ADDR) extract_unsigned_integer (iov,
1555                                                           tdep->size_pointer,
1556                                                           byte_order);
1557                 tmpint
1558                   = (int) extract_unsigned_integer (iov + tdep->size_pointer,
1559                                                     tdep->size_size_t,
1560                                                     byte_order);
1561                 if (record_arch_list_add_mem (tmpaddr, tmpint))
1562                   return -1;
1563                 vec += tdep->size_iovec;
1564               }
1565           }
1566       }
1567       break;
1568
1569       /* sys_writev */
1570     case 146:
1571       /* sys_getsid */
1572     case 147:
1573       /* sys_fdatasync */
1574     case 148:
1575       /* sys_sysctl */
1576     case 149:
1577       /* sys_mlock */
1578     case 150:
1579       /* sys_munlock */
1580     case 151:
1581       /* sys_mlockall */
1582     case 152:
1583       /* sys_munlockall */
1584     case 153:
1585       /* sys_sched_setparam */
1586     case 154:
1587       break;
1588
1589       /* sys_sched_getparam */
1590     case 155:
1591       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1592       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_int))
1593         return -1;
1594       break;
1595
1596       /* sys_sched_setscheduler */
1597     case 156:
1598       /* sys_sched_getscheduler */
1599     case 157:
1600       /* sys_sched_yield */
1601     case 158:
1602       /* sys_sched_get_priority_max */
1603     case 159:
1604       /* sys_sched_get_priority_min */
1605     case 160:
1606       break;
1607
1608       /* sys_sched_rr_get_interval */
1609     case 161:
1610       /* sys_nanosleep */
1611     case 162:
1612       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1613       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1614                                     tdep->size_timespec))
1615         return -1;
1616       break;
1617
1618       /* sys_mremap */
1619     case 163:
1620       /* sys_setresuid16 */
1621     case 164:
1622       break;
1623
1624       /* sys_getresuid16 */
1625     case 165:
1626       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1627       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1628                                     tdep->size_old_uid_t))
1629         return -1;
1630       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1631       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1632                                     tdep->size_old_uid_t))
1633         return -1;
1634       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1635       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1636                                     tdep->size_old_uid_t))
1637         return -1;
1638       break;
1639
1640       /* sys_vm86 */
1641     case 166:
1642       /* sys_ni_syscall */
1643     case 167:
1644       break;
1645
1646       /* sys_poll */
1647     case 168:
1648       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1649       if (tmpulongest)
1650         {
1651           ULONGEST nfds;
1652           regcache_raw_read_unsigned (regcache, tdep->arg2, &nfds);
1653           if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1654                                         tdep->size_pollfd * nfds))
1655             return -1;
1656         }
1657       break;
1658
1659       /* sys_nfsservctl */
1660     case 169:
1661       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1662       if (tmpulongest == 7 || tmpulongest == 8)
1663         {
1664           int rsize;
1665           if (tmpulongest == 7)
1666             rsize = tdep->size_NFS_FHSIZE;
1667           else
1668             rsize = tdep->size_knfsd_fh;
1669           regcache_raw_read_unsigned (regcache, tdep->arg3,
1670                                       &tmpulongest);
1671           if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, rsize))
1672             return -1;
1673         }
1674       break;
1675
1676       /* sys_setresgid16 */
1677     case 170:
1678       break;
1679
1680       /* sys_getresgid16 */
1681     case 171:
1682       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1683       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1684                                     tdep->size_old_gid_t))
1685         return -1;
1686       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1687       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1688                                     tdep->size_old_gid_t))
1689         return -1;
1690       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1691       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1692                                     tdep->size_old_gid_t))
1693         return -1;
1694       break;
1695
1696       /* sys_prctl */
1697     case 172:
1698       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1699       switch (tmpulongest)
1700         {
1701         case 2:
1702           regcache_raw_read_unsigned (regcache, tdep->arg2,
1703                                       &tmpulongest);
1704           if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1705                                         tdep->size_int))
1706             return -1;
1707           break;
1708         case 16:
1709           regcache_raw_read_unsigned (regcache, tdep->arg2,
1710                                       &tmpulongest);
1711           if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1712                                         tdep->size_TASK_COMM_LEN))
1713             return -1;
1714           break;
1715         }
1716       break;
1717
1718       /* sys_rt_sigreturn */
1719     case 173:
1720       break;
1721
1722       /* sys_rt_sigaction */
1723     case 174:
1724       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1725       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1726                                     tdep->size_sigaction))
1727         return -1;
1728       break;
1729
1730       /* sys_rt_sigprocmask */
1731     case 175:
1732       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1733       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1734                                     tdep->size_sigset_t))
1735         return -1;
1736       break;
1737
1738       /* sys_rt_sigpending */
1739     case 176:
1740       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1741       if (tmpulongest)
1742         {
1743           ULONGEST sigsetsize;
1744           regcache_raw_read_unsigned (regcache, tdep->arg2,&sigsetsize);
1745           if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1746                                         (int) sigsetsize))
1747             return -1;
1748         }
1749       break;
1750
1751       /* sys_rt_sigtimedwait */
1752     case 177:
1753       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1754       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1755                                     tdep->size_siginfo_t))
1756         return -1;
1757       break;
1758
1759       /* sys_rt_sigqueueinfo */
1760     case 178:
1761       /* sys_rt_sigsuspend */
1762     case 179:
1763       break;
1764
1765       /* sys_pread64 */
1766     case 180:
1767       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1768       if (tmpulongest)
1769         {
1770           ULONGEST count;
1771           regcache_raw_read_unsigned (regcache, tdep->arg3,&count);
1772           if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, (int) count))
1773             return -1;
1774         }
1775       break;
1776
1777       /* sys_pwrite64 */
1778     case 181:
1779       /* sys_chown16 */
1780     case 182:
1781       break;
1782
1783       /* sys_getcwd */
1784     case 183:
1785       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1786       if (tmpulongest)
1787         {
1788           ULONGEST size;
1789           regcache_raw_read_unsigned (regcache, tdep->arg2, &size);
1790           if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, (int) size))
1791             return -1;
1792         }
1793       break;
1794
1795       /* sys_capget */
1796     case 184:
1797       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1798       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1799                                     tdep->size_cap_user_data_t))
1800         return -1;
1801       break;
1802
1803       /* sys_capset */
1804     case 185:
1805       break;
1806
1807       /* sys_sigaltstack */
1808     case 186:
1809       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1810       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1811                                     tdep->size_stack_t))
1812         return -1;
1813       break;
1814
1815       /* sys_sendfile */
1816     case 187:
1817       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1818       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1819                                     tdep->size_off_t))
1820         return -1;
1821       break;
1822
1823       /* sys_ni_syscall */
1824     case 188:
1825       /* sys_ni_syscall */
1826     case 189:
1827       /* sys_vfork */
1828     case 190:
1829       break;
1830
1831       /* sys_getrlimit */
1832     case 191:
1833       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1834       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1835                                     tdep->size_rlimit))
1836         return -1;
1837       break;
1838
1839       /* sys_mmap2 */
1840     case 192:
1841       break;
1842
1843       /* sys_truncate64 */
1844     case 193:
1845       /* sys_ftruncate64 */
1846     case 194:
1847       break;
1848
1849       /* sys_stat64 */
1850     case 195:
1851       /* sys_lstat64 */
1852     case 196:
1853       /* sys_fstat64 */
1854     case 197:
1855       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1856       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1857                                     tdep->size_stat64))
1858         return -1;
1859       break;
1860
1861       /* sys_lchown */
1862     case 198:
1863       /* sys_getuid */
1864     case 199:
1865       /* sys_getgid */
1866     case 200:
1867       /* sys_geteuid */
1868     case 201:
1869       /* sys_getegid */
1870     case 202:
1871       /* sys_setreuid */
1872     case 203:
1873       /* sys_setregid */
1874     case 204:
1875       break;
1876
1877       /* sys_getgroups */
1878     case 205:
1879       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1880       if (tmpulongest)
1881         {
1882           ULONGEST gidsetsize;
1883           regcache_raw_read_unsigned (regcache, tdep->arg1,
1884                                       &gidsetsize);
1885           tmpint = tdep->size_gid_t * (int) gidsetsize;
1886           if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tmpint))
1887             return -1;
1888         }
1889       break;
1890
1891       /* sys_setgroups */
1892     case 206:
1893       /* sys_fchown */
1894     case 207:
1895       /* sys_setresuid */
1896     case 208:
1897       break;
1898
1899       /* sys_getresuid */
1900     case 209:
1901       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1902       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_uid_t))
1903         return -1;
1904       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1905       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_uid_t))
1906         return -1;
1907       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1908       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_uid_t))
1909         return -1;
1910       break;
1911
1912       /* sys_setresgid */
1913     case 210:
1914       break;
1915
1916       /* sys_getresgid */
1917     case 211:
1918       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1919       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_gid_t))
1920         return -1;
1921       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1922       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_gid_t))
1923         return -1;
1924       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1925       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_gid_t))
1926         return -1;
1927       break;
1928
1929       /* sys_chown */
1930     case 212:
1931       /* sys_setuid */
1932     case 213:
1933       /* sys_setgid */
1934     case 214:
1935       /* sys_setfsuid */
1936     case 215:
1937       /* sys_setfsgid */
1938     case 216:
1939       /* sys_pivot_root */
1940     case 217:
1941       break;
1942
1943       /* sys_mincore */
1944     case 218:
1945       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1946       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1947                                     tdep->size_PAGE_SIZE))
1948         return -1;
1949       break;
1950
1951       /* sys_madvise */
1952     case 219:
1953       break;
1954
1955       /* sys_getdents64 */
1956     case 220:
1957       {
1958         ULONGEST count;
1959         regcache_raw_read_unsigned (regcache, tdep->arg2,
1960                                     &tmpulongest);
1961         regcache_raw_read_unsigned (regcache, tdep->arg3, &count);
1962         if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1963                                       tdep->size_dirent64 * count))
1964           return -1;
1965       }
1966       break;
1967
1968       /* sys_fcntl64 */
1969     case 221:
1970       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1971       if (tmpulongest == tdep->fcntl_F_GETLK64)
1972         {
1973           regcache_raw_read_unsigned (regcache, tdep->arg3,
1974                                       &tmpulongest);
1975           if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1976                                         tdep->size_flock64))
1977             return -1;
1978         }
1979       else if (tmpulongest != tdep->fcntl_F_SETLK64
1980                && tmpulongest != tdep->fcntl_F_SETLKW64)
1981         {
1982           goto sys_fcntl;
1983         }
1984       break;
1985
1986       /* sys_ni_syscall */
1987     case 222:
1988       /* sys_ni_syscall */
1989     case 223:
1990       /* sys_gettid */
1991     case 224:
1992       /* sys_readahead */
1993     case 225:
1994       /* sys_setxattr */
1995     case 226:
1996       /* sys_lsetxattr */
1997     case 227:
1998       /* sys_fsetxattr */
1999     case 228:
2000       break;
2001
2002       /* sys_getxattr */
2003     case 229:
2004       /* sys_lgetxattr */
2005     case 230:
2006       /* sys_fgetxattr */
2007     case 231:
2008       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
2009       if (tmpulongest)
2010         {
2011           ULONGEST size;
2012           regcache_raw_read_unsigned (regcache, tdep->arg4, &size);
2013           if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, (int) size))
2014             return -1;
2015         }
2016       break;
2017
2018       /* sys_listxattr */
2019     case 232:
2020       /* sys_llistxattr */
2021     case 233:
2022       /* sys_flistxattr */
2023     case 234:
2024       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
2025       if (tmpulongest)
2026         {
2027           ULONGEST size;
2028           regcache_raw_read_unsigned (regcache, tdep->arg3, &size);
2029           if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, (int) size))
2030             return -1;
2031         }
2032       break;
2033
2034       /* sys_removexattr */
2035     case 235:
2036       /* sys_lremovexattr */
2037     case 236:
2038       /* sys_fremovexattr */
2039     case 237:
2040       /* sys_tkill */
2041     case 238:
2042       break;
2043
2044       /* sys_sendfile64 */
2045     case 239:
2046       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
2047       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2048                                     tdep->size_loff_t))
2049         return -1;
2050       break;
2051
2052       /* sys_futex */
2053     case 240:
2054       /* sys_sched_setaffinity */
2055     case 241:
2056       break;
2057
2058       /* sys_sched_getaffinity */
2059     case 242:
2060       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
2061       if (tmpulongest)
2062         {
2063           ULONGEST len;
2064           regcache_raw_read_unsigned (regcache, tdep->arg2, &len);
2065           if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, (int) len))
2066             return -1;
2067         }
2068       break;
2069
2070       /* sys_set_thread_area */
2071     case 243:
2072       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
2073       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_int))
2074         return -1;
2075       break;
2076
2077       /* sys_get_thread_area */
2078     case 244:
2079       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
2080       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2081                                     tdep->size_user_desc))
2082         return -1;
2083       break;
2084
2085       /* sys_io_setup */
2086     case 245:
2087       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
2088       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_long))
2089         return -1;
2090       break;
2091
2092       /* sys_io_destroy */
2093     case 246:
2094       break;
2095
2096       /* sys_io_getevents */
2097     case 247:
2098       regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
2099       if (tmpulongest)
2100         {
2101           ULONGEST nr;
2102           regcache_raw_read_unsigned (regcache, tdep->arg3, &nr);
2103           if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2104                                         nr * tdep->size_io_event))
2105             return -1;
2106         }
2107       break;
2108
2109       /* sys_io_submit */
2110     case 248:
2111       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
2112       if (tmpulongest)
2113         {
2114           ULONGEST nr, i;
2115           gdb_byte *iocbp;
2116
2117           regcache_raw_read_unsigned (regcache, tdep->arg2, &nr);
2118           iocbp = alloca (nr * tdep->size_pointer);
2119           if (target_read_memory ((CORE_ADDR) tmpulongest, iocbp,
2120                                   nr * tdep->size_pointer))
2121             {
2122               if (record_debug)
2123                 fprintf_unfiltered (gdb_stdlog,
2124                                     "Process record: error reading memory "
2125                                     "at addr = 0x%s len = %u.\n",
2126                                     OUTPUT_REG (tmpulongest, tdep->arg2),
2127                                     (int) (nr * tdep->size_pointer));
2128               return -1;
2129             }
2130           for (i = 0; i < nr; i++)
2131             {
2132               tmpaddr
2133                 = (CORE_ADDR) extract_unsigned_integer (iocbp,
2134                                                         tdep->size_pointer,
2135                                                         byte_order);
2136               if (record_arch_list_add_mem (tmpaddr, tdep->size_iocb))
2137                 return -1;
2138               iocbp += tdep->size_pointer;
2139             }
2140         }
2141       break;
2142
2143       /* sys_io_cancel */
2144     case 249:
2145       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
2146       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2147                                     tdep->size_io_event))
2148         return -1;
2149       break;
2150
2151       /* sys_fadvise64 */
2152     case 250:
2153       /* sys_ni_syscall */
2154     case 251:
2155       break;
2156
2157       /* sys_exit_group */
2158     case 252:
2159       {
2160         int q;
2161         target_terminal_ours ();
2162         q = yquery (_("The next instruction is syscall exit_group.  "
2163                       "It will make the program exit.  "
2164                       "Do you want to stop the program?"));
2165         target_terminal_inferior ();
2166         if (q)
2167           return 1;
2168       }
2169       break;
2170
2171       /* sys_lookup_dcookie */
2172     case 253:
2173       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
2174       if (tmpulongest)
2175         {
2176           ULONGEST len;
2177           regcache_raw_read_unsigned (regcache, tdep->arg3, &len);
2178           if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, (int) len))
2179             return -1;
2180         }
2181       break;
2182
2183       /* sys_epoll_create */
2184     case 254:
2185       /* sys_epoll_ctl */
2186     case 255:
2187       break;
2188
2189       /* sys_epoll_wait */
2190     case 256:
2191       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
2192       if (tmpulongest)
2193         {
2194           ULONGEST maxevents;
2195           regcache_raw_read_unsigned (regcache, tdep->arg3, &maxevents);
2196           if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2197                                         maxevents * tdep->size_epoll_event))
2198             return -1;
2199         }
2200       break;
2201
2202       /* sys_remap_file_pages */
2203     case 257:
2204       /* sys_set_tid_address */
2205     case 258:
2206       break;
2207
2208       /* sys_timer_create */
2209     case 259:
2210       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
2211       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_int))
2212         return -1;
2213       break;
2214
2215       /* sys_timer_settime */
2216     case 260:
2217       regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
2218       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2219                                     tdep->size_itimerspec))
2220         return -1;
2221       break;
2222
2223       /* sys_timer_gettime */
2224     case 261:
2225       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
2226       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2227                                     tdep->size_itimerspec))
2228         return -1;
2229       break;
2230
2231       /* sys_timer_getoverrun */
2232     case 262:
2233       /* sys_timer_delete */
2234     case 263:
2235       /* sys_clock_settime */
2236     case 264:
2237       break;
2238
2239       /* sys_clock_gettime */
2240     case 265:
2241       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
2242       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2243                                     tdep->size_timespec))
2244         return -1;
2245       break;
2246
2247       /* sys_clock_getres */
2248     case 266:
2249       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
2250       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2251                                     tdep->size_timespec))
2252         return -1;
2253       break;
2254
2255       /* sys_clock_nanosleep */
2256     case 267:
2257       regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
2258       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2259                                     tdep->size_timespec))
2260         return -1;
2261       break;
2262
2263       /* sys_statfs64 */
2264     case 268:
2265       /* sys_fstatfs64 */
2266     case 269:
2267       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
2268       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2269                                     tdep->size_statfs64))
2270         return -1;
2271       break;
2272
2273       /* sys_tgkill */
2274     case 270:
2275       /* sys_utimes */
2276     case 271:
2277       /* sys_fadvise64_64 */
2278     case 272:
2279       /* sys_ni_syscall */
2280     case 273:
2281       /* sys_mbind */
2282     case 274:
2283       break;
2284
2285       /* sys_get_mempolicy */
2286     case 275:
2287       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
2288       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_int))
2289         return -1;
2290       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
2291       if (tmpulongest)
2292         {
2293           ULONGEST maxnode;
2294           regcache_raw_read_unsigned (regcache, tdep->arg3, &maxnode);
2295           if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2296                                         maxnode * tdep->size_long))
2297             return -1;
2298         }
2299       break;
2300
2301       /* sys_set_mempolicy */
2302     case 276:
2303       /* sys_mq_open */
2304     case 277:
2305       /* sys_mq_unlink */
2306     case 278:
2307       /* sys_mq_timedsend */
2308     case 279:
2309       break;
2310
2311       /* sys_mq_timedreceive */
2312     case 280:
2313       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
2314       if (tmpulongest)
2315         {
2316           ULONGEST msg_len;
2317           regcache_raw_read_unsigned (regcache, tdep->arg3, &msg_len);
2318           if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2319                                         (int) msg_len))
2320             return -1;
2321         }
2322       regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
2323       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_int))
2324         return -1;
2325       break;
2326
2327       /* sys_mq_notify */
2328     case 281:
2329       break;
2330
2331       /* sys_mq_getsetattr */
2332     case 282:
2333       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
2334       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2335                                     tdep->size_mq_attr))
2336         return -1;
2337       break;
2338
2339       /* sys_kexec_load */
2340     case 283:
2341       break;
2342
2343       /* sys_waitid */
2344     case 284:
2345       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
2346       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2347                                     tdep->size_siginfo))
2348         return -1;
2349       regcache_raw_read_unsigned (regcache, tdep->arg5, &tmpulongest);
2350       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2351                                     tdep->size_rusage))
2352         return -1;
2353       break;
2354
2355       /* sys_ni_syscall */
2356     case 285:
2357       /* sys_add_key */
2358     case 286:
2359       /* sys_request_key */
2360     case 287:
2361       break;
2362
2363       /* sys_keyctl */
2364     case 288:
2365       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
2366       if (tmpulongest == 6 || tmpulongest == 11)
2367         {
2368           regcache_raw_read_unsigned (regcache, tdep->arg3,
2369                                       &tmpulongest);
2370           if (tmpulongest)
2371             {
2372               ULONGEST buflen;
2373               regcache_raw_read_unsigned (regcache, tdep->arg4, &buflen);
2374               if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2375                                             (int) buflen))
2376                 return -1;
2377             }
2378         }
2379       break;
2380
2381       /* sys_ioprio_set */
2382     case 289:
2383       /* sys_ioprio_get */
2384     case 290:
2385       /* sys_inotify_init */
2386     case 291:
2387       /* sys_inotify_add_watch */
2388     case 292:
2389       /* sys_inotify_rm_watch */
2390     case 293:
2391       /* sys_migrate_pages */
2392     case 294:
2393       /* sys_openat */
2394     case 295:
2395       /* sys_mkdirat */
2396     case 296:
2397       /* sys_mknodat */
2398     case 297:
2399       /* sys_fchownat */
2400     case 298:
2401       /* sys_futimesat */
2402     case 299:
2403       break;
2404
2405       /* sys_fstatat64 */
2406     case 300:
2407       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
2408       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2409                                     tdep->size_stat64))
2410         return -1;
2411       break;
2412
2413       /* sys_unlinkat */
2414     case 301:
2415       /* sys_renameat */
2416     case 302:
2417       /* sys_linkat */
2418     case 303:
2419       /* sys_symlinkat */
2420     case 304:
2421       break;
2422
2423       /* sys_readlinkat */
2424     case 305:
2425       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
2426       if (tmpulongest)
2427         {
2428           ULONGEST bufsiz;
2429           regcache_raw_read_unsigned (regcache, tdep->arg4, &bufsiz);
2430           if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, (int) bufsiz))
2431             return -1;
2432         }
2433       break;
2434
2435       /* sys_fchmodat */
2436     case 306:
2437       /* sys_faccessat */
2438     case 307:
2439       break;
2440
2441       /* sys_pselect6 */
2442     case 308:
2443       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
2444       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2445                                     tdep->size_fd_set))
2446         return -1;
2447       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
2448       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2449                                     tdep->size_fd_set))
2450         return -1;
2451       regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
2452       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2453                                     tdep->size_fd_set))
2454         return -1;
2455       regcache_raw_read_unsigned (regcache, tdep->arg5, &tmpulongest);
2456       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2457                                     tdep->size_timespec))
2458         return -1;
2459       break;
2460
2461       /* sys_ppoll */
2462     case 309:
2463       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
2464       if (tmpulongest)
2465         {
2466           ULONGEST nfds;
2467           regcache_raw_read_unsigned (regcache, tdep->arg2, &nfds);
2468           if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2469                                         tdep->size_pollfd * nfds))
2470             return -1;
2471         }
2472       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
2473       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2474                                     tdep->size_timespec))
2475         return -1;
2476       break;
2477
2478       /* sys_unshare */
2479     case 310:
2480       /* sys_set_robust_list */
2481     case 311:
2482       break;
2483
2484       /* sys_get_robust_list */
2485     case 312:
2486       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
2487       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_int))
2488         return -1;
2489       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
2490       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_int))
2491         return -1;
2492       break;
2493
2494       /* sys_splice */
2495     case 313:
2496       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
2497       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2498                                     tdep->size_loff_t))
2499         return -1;
2500       regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
2501       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2502                                     tdep->size_loff_t))
2503         return -1;
2504       break;
2505
2506       /* sys_sync_file_range */
2507     case 314:
2508       /* sys_tee */
2509     case 315:
2510       /* sys_vmsplice */
2511     case 316:
2512       break;
2513
2514       /* sys_move_pages */
2515     case 317:
2516       regcache_raw_read_unsigned (regcache, tdep->arg5, &tmpulongest);
2517       if (tmpulongest)
2518         {
2519           ULONGEST nr_pages;
2520           regcache_raw_read_unsigned (regcache, tdep->arg2, &nr_pages);
2521           if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2522                                         nr_pages * tdep->size_int))
2523             return -1;
2524         }
2525       break;
2526
2527       /* sys_getcpu */
2528     case 318:
2529       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
2530       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_int))
2531         return -1;
2532       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
2533       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_int))
2534         return -1;
2535       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
2536       if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2537                                     tdep->size_ulong * 2))
2538         return -1;
2539       break;
2540
2541       /* sys_epoll_pwait */
2542     case 319:
2543       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
2544       if (tmpulongest)
2545         {
2546           ULONGEST maxevents;
2547           regcache_raw_read_unsigned (regcache, tdep->arg3, &maxevents);
2548           tmpint = (int) maxevents * tdep->size_epoll_event;
2549           if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tmpint))
2550             return -1;
2551         }
2552       break;
2553
2554     default:
2555       printf_unfiltered (_("Process record and replay target doesn't "
2556                            "support syscall number %u\n"), num);
2557       return -1;
2558       break;
2559     }
2560
2561   return 0;
2562 }