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