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