Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(282)

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: gdb/linux-record.c

Issue 124383005: GDB 7.6.50 (Closed) Base URL: http://git.chromium.org/native_client/nacl-gdb.git@upstream
Patch Set: Created 6 years, 11 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « gdb/linux-record.h ('k') | gdb/linux-tdep.h » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 /* Process record and replay target code for GNU/Linux. 1 /* Process record and replay target code for GNU/Linux.
2 2
3 Copyright (C) 2008-2012 Free Software Foundation, Inc. 3 Copyright (C) 2008-2013 Free Software Foundation, Inc.
4 4
5 This file is part of GDB. 5 This file is part of GDB.
6 6
7 This program is free software; you can redistribute it and/or modify 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 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 9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version. 10 (at your option) any later version.
11 11
12 This program is distributed in the hope that it will be useful, 12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of 13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details. 15 GNU General Public License for more details.
16 16
17 You should have received a copy of the GNU General Public License 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/>. */ 18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
19 19
20 #include "defs.h" 20 #include "defs.h"
21 #include "target.h" 21 #include "target.h"
22 #include "gdbtypes.h" 22 #include "gdbtypes.h"
23 #include "regcache.h" 23 #include "regcache.h"
24 #include "record.h" 24 #include "record.h"
25 #include "record-full.h"
25 #include "linux-record.h" 26 #include "linux-record.h"
26 27
27 /* These macros are the values of the first argument of system call 28 /* 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 "sys_ptrace". The values of these macros were obtained from Linux
29 Kernel source. */ 30 Kernel source. */
30 31
31 #define RECORD_PTRACE_PEEKTEXT 1 32 #define RECORD_PTRACE_PEEKTEXT 1
32 #define RECORD_PTRACE_PEEKDATA 2 33 #define RECORD_PTRACE_PEEKDATA 2
33 #define RECORD_PTRACE_PEEKUSR 3 34 #define RECORD_PTRACE_PEEKUSR 3
34 35
(...skipping 57 matching lines...) Expand 10 before | Expand all | Expand 10 after
92 gdb_byte *a; 93 gdb_byte *a;
93 int addrlen; 94 int addrlen;
94 struct gdbarch *gdbarch = get_regcache_arch (regcache); 95 struct gdbarch *gdbarch = get_regcache_arch (regcache);
95 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 96 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
96 97
97 if (!addr) 98 if (!addr)
98 return 0; 99 return 0;
99 100
100 a = alloca (tdep->size_int); 101 a = alloca (tdep->size_int);
101 102
102 if (record_arch_list_add_mem ((CORE_ADDR) len, tdep->size_int)) 103 if (record_full_arch_list_add_mem ((CORE_ADDR) len, tdep->size_int))
103 return -1; 104 return -1;
104 105
105 /* Get the addrlen. */ 106 /* Get the addrlen. */
106 if (target_read_memory ((CORE_ADDR) len, a, tdep->size_int)) 107 if (target_read_memory ((CORE_ADDR) len, a, tdep->size_int))
107 { 108 {
108 if (record_debug) 109 if (record_debug)
109 fprintf_unfiltered (gdb_stdlog, 110 fprintf_unfiltered (gdb_stdlog,
110 "Process record: error reading " 111 "Process record: error reading "
111 "memory at addr = 0x%s len = %d.\n", 112 "memory at addr = 0x%s len = %d.\n",
112 phex_nz (len, tdep->size_pointer), 113 phex_nz (len, tdep->size_pointer),
113 tdep->size_int); 114 tdep->size_int);
114 return -1; 115 return -1;
115 } 116 }
116 addrlen = (int) extract_unsigned_integer (a, tdep->size_int, byte_order); 117 addrlen = (int) extract_unsigned_integer (a, tdep->size_int, byte_order);
117 if (addrlen <= 0 || addrlen > tdep->size_sockaddr) 118 if (addrlen <= 0 || addrlen > tdep->size_sockaddr)
118 addrlen = tdep->size_sockaddr; 119 addrlen = tdep->size_sockaddr;
119 120
120 if (record_arch_list_add_mem ((CORE_ADDR) addr, addrlen)) 121 if (record_full_arch_list_add_mem ((CORE_ADDR) addr, addrlen))
121 return -1; 122 return -1;
122 123
123 return 0; 124 return 0;
124 } 125 }
125 126
126 static int 127 static int
127 record_linux_msghdr (struct regcache *regcache, 128 record_linux_msghdr (struct regcache *regcache,
128 struct linux_record_tdep *tdep, ULONGEST addr) 129 struct linux_record_tdep *tdep, ULONGEST addr)
129 { 130 {
130 gdb_byte *a; 131 gdb_byte *a;
131 struct gdbarch *gdbarch = get_regcache_arch (regcache); 132 struct gdbarch *gdbarch = get_regcache_arch (regcache);
132 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 133 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
133 CORE_ADDR tmpaddr; 134 CORE_ADDR tmpaddr;
134 int tmpint; 135 int tmpint;
135 136
136 if (!addr) 137 if (!addr)
137 return 0; 138 return 0;
138 139
139 if (record_arch_list_add_mem ((CORE_ADDR) addr, tdep->size_msghdr)) 140 if (record_full_arch_list_add_mem ((CORE_ADDR) addr, tdep->size_msghdr))
140 return -1; 141 return -1;
141 142
142 a = alloca (tdep->size_msghdr); 143 a = alloca (tdep->size_msghdr);
143 if (target_read_memory ((CORE_ADDR) addr, a, tdep->size_msghdr)) 144 if (target_read_memory ((CORE_ADDR) addr, a, tdep->size_msghdr))
144 { 145 {
145 if (record_debug) 146 if (record_debug)
146 fprintf_unfiltered (gdb_stdlog, 147 fprintf_unfiltered (gdb_stdlog,
147 "Process record: error reading " 148 "Process record: error reading "
148 "memory at addr = 0x%s " 149 "memory at addr = 0x%s "
149 "len = %d.\n", 150 "len = %d.\n",
150 phex_nz (addr, tdep->size_pointer), 151 phex_nz (addr, tdep->size_pointer),
151 tdep->size_msghdr); 152 tdep->size_msghdr);
152 return -1; 153 return -1;
153 } 154 }
154 155
155 /* msg_name msg_namelen */ 156 /* msg_name msg_namelen */
156 addr = extract_unsigned_integer (a, tdep->size_pointer, byte_order); 157 addr = extract_unsigned_integer (a, tdep->size_pointer, byte_order);
157 a += tdep->size_pointer; 158 a += tdep->size_pointer;
158 if (record_arch_list_add_mem ((CORE_ADDR) addr, 159 if (record_full_arch_list_add_mem
159 (int) extract_unsigned_integer (a, 160 ((CORE_ADDR) addr,
160 » » » » tdep->size_int, 161 (int) extract_unsigned_integer (a,
161 » » » » byte_order))) 162 » » » » tdep->size_int,
163 » » » » byte_order)))
162 return -1; 164 return -1;
163 a += tdep->size_int; 165 a += tdep->size_int;
164 166
165 /* msg_iov msg_iovlen */ 167 /* msg_iov msg_iovlen */
166 addr = extract_unsigned_integer (a, tdep->size_pointer, byte_order); 168 addr = extract_unsigned_integer (a, tdep->size_pointer, byte_order);
167 a += tdep->size_pointer; 169 a += tdep->size_pointer;
168 if (addr) 170 if (addr)
169 { 171 {
170 ULONGEST i; 172 ULONGEST i;
171 ULONGEST len = extract_unsigned_integer (a, tdep->size_size_t, 173 ULONGEST len = extract_unsigned_integer (a, tdep->size_size_t,
(...skipping 13 matching lines...) Expand all
185 phex_nz (addr,tdep->size_pointer), 187 phex_nz (addr,tdep->size_pointer),
186 tdep->size_iovec); 188 tdep->size_iovec);
187 return -1; 189 return -1;
188 } 190 }
189 tmpaddr = (CORE_ADDR) extract_unsigned_integer (iov, 191 tmpaddr = (CORE_ADDR) extract_unsigned_integer (iov,
190 tdep->size_pointer, 192 tdep->size_pointer,
191 byte_order); 193 byte_order);
192 tmpint = (int) extract_unsigned_integer (iov + tdep->size_pointer, 194 tmpint = (int) extract_unsigned_integer (iov + tdep->size_pointer,
193 tdep->size_size_t, 195 tdep->size_size_t,
194 byte_order); 196 byte_order);
195 if (record_arch_list_add_mem (tmpaddr, tmpint)) 197 if (record_full_arch_list_add_mem (tmpaddr, tmpint))
196 return -1; 198 return -1;
197 addr += tdep->size_iovec; 199 addr += tdep->size_iovec;
198 } 200 }
199 } 201 }
200 a += tdep->size_size_t; 202 a += tdep->size_size_t;
201 203
202 /* msg_control msg_controllen */ 204 /* msg_control msg_controllen */
203 addr = extract_unsigned_integer (a, tdep->size_pointer, byte_order); 205 addr = extract_unsigned_integer (a, tdep->size_pointer, byte_order);
204 a += tdep->size_pointer; 206 a += tdep->size_pointer;
205 tmpint = (int) extract_unsigned_integer (a, tdep->size_size_t, byte_order); 207 tmpint = (int) extract_unsigned_integer (a, tdep->size_size_t, byte_order);
206 if (record_arch_list_add_mem ((CORE_ADDR) addr, tmpint)) 208 if (record_full_arch_list_add_mem ((CORE_ADDR) addr, tmpint))
207 return -1; 209 return -1;
208 210
209 return 0; 211 return 0;
210 } 212 }
211 213
212 /* When the architecture process record get a Linux syscall 214 /* When the architecture process record get a Linux syscall
213 instruction, it will get a Linux syscall number of this 215 instruction, it will get a Linux syscall number of this
214 architecture and convert it to the Linux syscall number "num" which 216 architecture and convert it to the Linux syscall number "num" which
215 is internal to GDB. Most Linux syscalls across architectures in 217 is internal to GDB. Most Linux syscalls across architectures in
216 Linux would be similar and mostly differ by sizes of types and 218 Linux would be similar and mostly differ by sizes of types and
(...skipping 36 matching lines...) Expand 10 before | Expand all | Expand 10 after
253 255
254 case gdb_sys_fork: 256 case gdb_sys_fork:
255 break; 257 break;
256 258
257 case gdb_sys_read: 259 case gdb_sys_read:
258 { 260 {
259 ULONGEST addr, count; 261 ULONGEST addr, count;
260 262
261 regcache_raw_read_unsigned (regcache, tdep->arg2, &addr); 263 regcache_raw_read_unsigned (regcache, tdep->arg2, &addr);
262 regcache_raw_read_unsigned (regcache, tdep->arg3, &count); 264 regcache_raw_read_unsigned (regcache, tdep->arg3, &count);
263 if (record_arch_list_add_mem ((CORE_ADDR) addr, (int) count)) 265 if (record_full_arch_list_add_mem ((CORE_ADDR) addr, (int) count))
264 return -1; 266 return -1;
265 } 267 }
266 break; 268 break;
267 269
268 case gdb_sys_write: 270 case gdb_sys_write:
269 case gdb_sys_open: 271 case gdb_sys_open:
270 case gdb_sys_close: 272 case gdb_sys_close:
271 case gdb_sys_waitpid: 273 case gdb_sys_waitpid:
272 case gdb_sys_creat: 274 case gdb_sys_creat:
273 case gdb_sys_link: 275 case gdb_sys_link:
274 case gdb_sys_unlink: 276 case gdb_sys_unlink:
275 case gdb_sys_execve: 277 case gdb_sys_execve:
276 case gdb_sys_chdir: 278 case gdb_sys_chdir:
277 case gdb_sys_time: 279 case gdb_sys_time:
278 case gdb_sys_mknod: 280 case gdb_sys_mknod:
279 case gdb_sys_chmod: 281 case gdb_sys_chmod:
280 case gdb_sys_lchown16: 282 case gdb_sys_lchown16:
281 case gdb_sys_ni_syscall17: 283 case gdb_sys_ni_syscall17:
282 break; 284 break;
283 285
284 case gdb_sys_stat: 286 case gdb_sys_stat:
285 case gdb_sys_fstat: 287 case gdb_sys_fstat:
286 case gdb_sys_lstat: 288 case gdb_sys_lstat:
287 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest); 289 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
288 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 290 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
289 tdep->size__old_kernel_stat)) 291 » » » » » tdep->size__old_kernel_stat))
290 return -1; 292 return -1;
291 break; 293 break;
292 294
293 case gdb_sys_lseek: 295 case gdb_sys_lseek:
294 case gdb_sys_getpid: 296 case gdb_sys_getpid:
295 case gdb_sys_mount: 297 case gdb_sys_mount:
296 case gdb_sys_oldumount: 298 case gdb_sys_oldumount:
297 case gdb_sys_setuid16: 299 case gdb_sys_setuid16:
298 case gdb_sys_getuid16: 300 case gdb_sys_getuid16:
299 case gdb_sys_stime: 301 case gdb_sys_stime:
300 break; 302 break;
301 303
302 case gdb_sys_ptrace: 304 case gdb_sys_ptrace:
303 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest); 305 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
304 if (tmpulongest == RECORD_PTRACE_PEEKTEXT 306 if (tmpulongest == RECORD_PTRACE_PEEKTEXT
305 || tmpulongest == RECORD_PTRACE_PEEKDATA 307 || tmpulongest == RECORD_PTRACE_PEEKDATA
306 || tmpulongest == RECORD_PTRACE_PEEKUSR) 308 || tmpulongest == RECORD_PTRACE_PEEKUSR)
307 { 309 {
308 regcache_raw_read_unsigned (regcache, tdep->arg4, 310 regcache_raw_read_unsigned (regcache, tdep->arg4,
309 &tmpulongest); 311 &tmpulongest);
310 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 4)) 312 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest, 4))
311 return -1; 313 return -1;
312 } 314 }
313 break; 315 break;
314 316
315 case gdb_sys_alarm: 317 case gdb_sys_alarm:
316 case gdb_sys_pause: 318 case gdb_sys_pause:
317 case gdb_sys_utime: 319 case gdb_sys_utime:
318 case gdb_sys_ni_syscall31: 320 case gdb_sys_ni_syscall31:
319 case gdb_sys_ni_syscall32: 321 case gdb_sys_ni_syscall32:
320 case gdb_sys_access: 322 case gdb_sys_access:
321 case gdb_sys_nice: 323 case gdb_sys_nice:
322 case gdb_sys_ni_syscall35: 324 case gdb_sys_ni_syscall35:
323 case gdb_sys_sync: 325 case gdb_sys_sync:
324 case gdb_sys_kill: 326 case gdb_sys_kill:
325 case gdb_sys_rename: 327 case gdb_sys_rename:
326 case gdb_sys_mkdir: 328 case gdb_sys_mkdir:
327 case gdb_sys_rmdir: 329 case gdb_sys_rmdir:
328 case gdb_sys_dup: 330 case gdb_sys_dup:
329 case gdb_sys_pipe: 331 case gdb_sys_pipe:
330 break; 332 break;
331 333
332 case gdb_sys_times: 334 case gdb_sys_times:
333 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest); 335 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
334 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_tms)) 336 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
337 » » » » » tdep->size_tms))
335 return -1; 338 return -1;
336 break; 339 break;
337 340
338 case gdb_sys_ni_syscall44: 341 case gdb_sys_ni_syscall44:
339 case gdb_sys_brk: 342 case gdb_sys_brk:
340 case gdb_sys_setgid16: 343 case gdb_sys_setgid16:
341 case gdb_sys_getgid16: 344 case gdb_sys_getgid16:
342 case gdb_sys_signal: 345 case gdb_sys_signal:
343 case gdb_sys_geteuid16: 346 case gdb_sys_geteuid16:
344 case gdb_sys_getegid16: 347 case gdb_sys_getegid16:
(...skipping 51 matching lines...) Expand 10 before | Expand all | Expand 10 after
396 || tmpulongest == tdep->ioctl_TIOCSHAYESESP) 399 || tmpulongest == tdep->ioctl_TIOCSHAYESESP)
397 { 400 {
398 /* Nothing to do. */ 401 /* Nothing to do. */
399 } 402 }
400 else if (tmpulongest == tdep->ioctl_TCGETS 403 else if (tmpulongest == tdep->ioctl_TCGETS
401 || tmpulongest == tdep->ioctl_TCGETA 404 || tmpulongest == tdep->ioctl_TCGETA
402 || tmpulongest == tdep->ioctl_TIOCGLCKTRMIOS) 405 || tmpulongest == tdep->ioctl_TIOCGLCKTRMIOS)
403 { 406 {
404 regcache_raw_read_unsigned (regcache, tdep->arg3, 407 regcache_raw_read_unsigned (regcache, tdep->arg3,
405 &tmpulongest); 408 &tmpulongest);
406 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 409 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
407 tdep->size_termios)) 410 » » » » » tdep->size_termios))
408 return -1; 411 return -1;
409 } 412 }
410 else if (tmpulongest == tdep->ioctl_TIOCGPGRP 413 else if (tmpulongest == tdep->ioctl_TIOCGPGRP
411 || tmpulongest == tdep->ioctl_TIOCGSID) 414 || tmpulongest == tdep->ioctl_TIOCGSID)
412 { 415 {
413 regcache_raw_read_unsigned (regcache, tdep->arg3, 416 regcache_raw_read_unsigned (regcache, tdep->arg3,
414 &tmpulongest); 417 &tmpulongest);
415 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 418 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
416 tdep->size_pid_t)) 419 » » » » » tdep->size_pid_t))
417 return -1; 420 return -1;
418 } 421 }
419 else if (tmpulongest == tdep->ioctl_TIOCOUTQ 422 else if (tmpulongest == tdep->ioctl_TIOCOUTQ
420 || tmpulongest == tdep->ioctl_TIOCMGET 423 || tmpulongest == tdep->ioctl_TIOCMGET
421 || tmpulongest == tdep->ioctl_TIOCGSOFTCAR 424 || tmpulongest == tdep->ioctl_TIOCGSOFTCAR
422 || tmpulongest == tdep->ioctl_FIONREAD 425 || tmpulongest == tdep->ioctl_FIONREAD
423 || tmpulongest == tdep->ioctl_TIOCINQ 426 || tmpulongest == tdep->ioctl_TIOCINQ
424 || tmpulongest == tdep->ioctl_TIOCGETD 427 || tmpulongest == tdep->ioctl_TIOCGETD
425 || tmpulongest == tdep->ioctl_TIOCGPTN 428 || tmpulongest == tdep->ioctl_TIOCGPTN
426 || tmpulongest == tdep->ioctl_TIOCSERGETLSR) 429 || tmpulongest == tdep->ioctl_TIOCSERGETLSR)
427 { 430 {
428 regcache_raw_read_unsigned (regcache, tdep->arg3, 431 regcache_raw_read_unsigned (regcache, tdep->arg3,
429 &tmpulongest); 432 &tmpulongest);
430 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 433 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
431 tdep->size_int)) 434 » » » » » tdep->size_int))
432 return -1; 435 return -1;
433 } 436 }
434 else if (tmpulongest == tdep->ioctl_TIOCGWINSZ) 437 else if (tmpulongest == tdep->ioctl_TIOCGWINSZ)
435 { 438 {
436 regcache_raw_read_unsigned (regcache, tdep->arg3, 439 regcache_raw_read_unsigned (regcache, tdep->arg3,
437 &tmpulongest); 440 &tmpulongest);
438 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 441 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
439 tdep->size_winsize)) 442 » » » » » tdep->size_winsize))
440 return -1; 443 return -1;
441 } 444 }
442 else if (tmpulongest == tdep->ioctl_TIOCLINUX) 445 else if (tmpulongest == tdep->ioctl_TIOCLINUX)
443 { 446 {
444 regcache_raw_read_unsigned (regcache, tdep->arg3, 447 regcache_raw_read_unsigned (regcache, tdep->arg3,
445 &tmpulongest); 448 &tmpulongest);
446 /* This syscall affects a char-size memory. */ 449 /* This syscall affects a char-size memory. */
447 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 1)) 450 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest, 1))
448 return -1; 451 return -1;
449 } 452 }
450 else if (tmpulongest == tdep->ioctl_TIOCGSERIAL) 453 else if (tmpulongest == tdep->ioctl_TIOCGSERIAL)
451 { 454 {
452 regcache_raw_read_unsigned (regcache, tdep->arg3, 455 regcache_raw_read_unsigned (regcache, tdep->arg3,
453 &tmpulongest); 456 &tmpulongest);
454 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 457 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
455 tdep->size_serial_struct)) 458 » » » » » tdep->size_serial_struct))
456 return -1; 459 return -1;
457 } 460 }
458 else if (tmpulongest == tdep->ioctl_TCGETS2) 461 else if (tmpulongest == tdep->ioctl_TCGETS2)
459 { 462 {
460 regcache_raw_read_unsigned (regcache, tdep->arg3, 463 regcache_raw_read_unsigned (regcache, tdep->arg3,
461 &tmpulongest); 464 &tmpulongest);
462 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 465 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
463 tdep->size_termios2)) 466 » » » » » tdep->size_termios2))
464 return -1; 467 return -1;
465 } 468 }
466 else if (tmpulongest == tdep->ioctl_FIOQSIZE) 469 else if (tmpulongest == tdep->ioctl_FIOQSIZE)
467 { 470 {
468 regcache_raw_read_unsigned (regcache, tdep->arg3, 471 regcache_raw_read_unsigned (regcache, tdep->arg3,
469 &tmpulongest); 472 &tmpulongest);
470 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 473 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
471 tdep->size_loff_t)) 474 » » » » » tdep->size_loff_t))
472 return -1; 475 return -1;
473 } 476 }
474 else if (tmpulongest == tdep->ioctl_TIOCGICOUNT) 477 else if (tmpulongest == tdep->ioctl_TIOCGICOUNT)
475 { 478 {
476 regcache_raw_read_unsigned (regcache, tdep->arg3, 479 regcache_raw_read_unsigned (regcache, tdep->arg3,
477 &tmpulongest); 480 &tmpulongest);
478 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 481 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
479 tdep->size_serial_icounter_struct)) 482 » » » » » tdep->size_serial_icounter_struct))
480 return -1; 483 return -1;
481 } 484 }
482 else if (tmpulongest == tdep->ioctl_TIOCGHAYESESP) 485 else if (tmpulongest == tdep->ioctl_TIOCGHAYESESP)
483 { 486 {
484 regcache_raw_read_unsigned (regcache, tdep->arg3, 487 regcache_raw_read_unsigned (regcache, tdep->arg3,
485 &tmpulongest); 488 &tmpulongest);
486 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 489 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
487 tdep->size_hayes_esp_config)) 490 » » » » » tdep->size_hayes_esp_config))
488 return -1; 491 return -1;
489 } 492 }
490 else if (tmpulongest == tdep->ioctl_TIOCSERGSTRUCT) 493 else if (tmpulongest == tdep->ioctl_TIOCSERGSTRUCT)
491 { 494 {
492 printf_unfiltered (_("Process record and replay target doesn't " 495 printf_unfiltered (_("Process record and replay target doesn't "
493 "support ioctl request TIOCSERGSTRUCT\n")); 496 "support ioctl request TIOCSERGSTRUCT\n"));
494 return 1; 497 return 1;
495 } 498 }
496 else 499 else
497 { 500 {
498 printf_unfiltered (_("Process record and replay target doesn't " 501 printf_unfiltered (_("Process record and replay target doesn't "
499 "support ioctl request 0x%s.\n"), 502 "support ioctl request 0x%s.\n"),
500 OUTPUT_REG (tmpulongest, tdep->arg2)); 503 OUTPUT_REG (tmpulongest, tdep->arg2));
501 return 1; 504 return 1;
502 } 505 }
503 break; 506 break;
504 507
505 case gdb_sys_fcntl: 508 case gdb_sys_fcntl:
506 /* XXX */ 509 /* XXX */
507 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest); 510 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
508 sys_fcntl: 511 sys_fcntl:
509 if (tmpulongest == tdep->fcntl_F_GETLK) 512 if (tmpulongest == tdep->fcntl_F_GETLK)
510 { 513 {
511 regcache_raw_read_unsigned (regcache, tdep->arg3, 514 regcache_raw_read_unsigned (regcache, tdep->arg3,
512 &tmpulongest); 515 &tmpulongest);
513 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 516 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
514 tdep->size_flock)) 517 » » » » » tdep->size_flock))
515 return -1; 518 return -1;
516 } 519 }
517 break; 520 break;
518 521
519 case gdb_sys_ni_syscall56: 522 case gdb_sys_ni_syscall56:
520 case gdb_sys_setpgid: 523 case gdb_sys_setpgid:
521 case gdb_sys_ni_syscall58: 524 case gdb_sys_ni_syscall58:
522 break; 525 break;
523 526
524 case gdb_sys_olduname: 527 case gdb_sys_olduname:
525 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest); 528 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
526 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 529 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
527 tdep->size_oldold_utsname)) 530 » » » » » tdep->size_oldold_utsname))
528 return -1; 531 return -1;
529 break; 532 break;
530 533
531 case gdb_sys_umask: 534 case gdb_sys_umask:
532 case gdb_sys_chroot: 535 case gdb_sys_chroot:
533 break; 536 break;
534 537
535 case gdb_sys_ustat: 538 case gdb_sys_ustat:
536 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest); 539 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
537 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 540 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
538 tdep->size_ustat)) 541 » » » » » tdep->size_ustat))
539 return -1; 542 return -1;
540 break; 543 break;
541 544
542 case gdb_sys_dup2: 545 case gdb_sys_dup2:
543 case gdb_sys_getppid: 546 case gdb_sys_getppid:
544 case gdb_sys_getpgrp: 547 case gdb_sys_getpgrp:
545 case gdb_sys_setsid: 548 case gdb_sys_setsid:
546 break; 549 break;
547 550
548 case gdb_sys_sigaction: 551 case gdb_sys_sigaction:
549 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest); 552 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
550 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 553 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
551 tdep->size_old_sigaction)) 554 » » » » » tdep->size_old_sigaction))
552 return -1; 555 return -1;
553 break; 556 break;
554 557
555 case gdb_sys_sgetmask: 558 case gdb_sys_sgetmask:
556 case gdb_sys_ssetmask: 559 case gdb_sys_ssetmask:
557 case gdb_sys_setreuid16: 560 case gdb_sys_setreuid16:
558 case gdb_sys_setregid16: 561 case gdb_sys_setregid16:
559 case gdb_sys_sigsuspend: 562 case gdb_sys_sigsuspend:
560 break; 563 break;
561 564
562 case gdb_sys_sigpending: 565 case gdb_sys_sigpending:
563 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest); 566 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
564 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 567 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
565 tdep->size_old_sigset_t)) 568 » » » » » tdep->size_old_sigset_t))
566 return -1; 569 return -1;
567 break; 570 break;
568 571
569 case gdb_sys_sethostname: 572 case gdb_sys_sethostname:
570 case gdb_sys_setrlimit: 573 case gdb_sys_setrlimit:
571 break; 574 break;
572 575
573 case gdb_sys_old_getrlimit: 576 case gdb_sys_old_getrlimit:
574 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest); 577 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
575 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 578 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
576 tdep->size_rlimit)) 579 » » » » » tdep->size_rlimit))
577 return -1; 580 return -1;
578 break; 581 break;
579 582
580 case gdb_sys_getrusage: 583 case gdb_sys_getrusage:
581 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest); 584 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
582 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 585 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
583 tdep->size_rusage)) 586 » » » » » tdep->size_rusage))
584 return -1; 587 return -1;
585 break; 588 break;
586 589
587 case gdb_sys_gettimeofday: 590 case gdb_sys_gettimeofday:
588 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest); 591 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
589 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 592 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
590 tdep->size_timeval)) 593 » » » » » tdep->size_timeval))
591 return -1; 594 return -1;
592 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest); 595 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
593 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 596 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
594 tdep->size_timezone)) 597 » » » » » tdep->size_timezone))
595 return -1; 598 return -1;
596 break; 599 break;
597 600
598 case gdb_sys_settimeofday: 601 case gdb_sys_settimeofday:
599 break; 602 break;
600 603
601 case gdb_sys_getgroups16: 604 case gdb_sys_getgroups16:
602 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest); 605 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
603 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 606 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
604 tdep->size_old_gid_t)) 607 » » » » » tdep->size_old_gid_t))
605 return -1; 608 return -1;
606 break; 609 break;
607 610
608 case gdb_sys_setgroups16: 611 case gdb_sys_setgroups16:
609 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest); 612 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
610 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 613 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
611 tdep->size_old_gid_t)) 614 » » » » » tdep->size_old_gid_t))
612 return -1; 615 return -1;
613 break; 616 break;
614 617
615 case gdb_old_select: 618 case gdb_old_select:
616 { 619 {
617 struct sel_arg_struct 620 struct sel_arg_struct
618 { 621 {
619 CORE_ADDR n; 622 CORE_ADDR n;
620 CORE_ADDR inp; 623 CORE_ADDR inp;
621 CORE_ADDR outp; 624 CORE_ADDR outp;
622 CORE_ADDR exp; 625 CORE_ADDR exp;
623 CORE_ADDR tvp; 626 CORE_ADDR tvp;
624 } sel; 627 } sel;
625 628
626 regcache_raw_read_unsigned (regcache, tdep->arg1, 629 regcache_raw_read_unsigned (regcache, tdep->arg1,
627 &tmpulongest); 630 &tmpulongest);
628 if (tmpulongest) 631 if (tmpulongest)
629 { 632 {
630 if (target_read_memory (tmpulongest, (gdb_byte *) &sel, 633 if (target_read_memory (tmpulongest, (gdb_byte *) &sel,
631 sizeof(sel))) 634 sizeof(sel)))
632 { 635 {
633 if (record_debug) 636 if (record_debug)
634 fprintf_unfiltered (gdb_stdlog, 637 fprintf_unfiltered (gdb_stdlog,
635 "Process record: error reading memory " 638 "Process record: error reading memory "
636 "at addr = 0x%s len = %lu.\n", 639 "at addr = 0x%s len = %lu.\n",
637 OUTPUT_REG (tmpulongest, tdep->arg1), 640 OUTPUT_REG (tmpulongest, tdep->arg1),
638 (unsigned long) sizeof (sel)); 641 (unsigned long) sizeof (sel));
639 return -1; 642 return -1;
640 } 643 }
641 if (record_arch_list_add_mem (sel.inp, tdep->size_fd_set)) 644 if (record_full_arch_list_add_mem (sel.inp, tdep->size_fd_set))
642 return -1; 645 return -1;
643 if (record_arch_list_add_mem (sel.outp, tdep->size_fd_set)) 646 if (record_full_arch_list_add_mem (sel.outp, tdep->size_fd_set))
644 return -1; 647 return -1;
645 if (record_arch_list_add_mem (sel.exp, tdep->size_fd_set)) 648 if (record_full_arch_list_add_mem (sel.exp, tdep->size_fd_set))
646 return -1; 649 return -1;
647 if (record_arch_list_add_mem (sel.tvp, tdep->size_timeval)) 650 if (record_full_arch_list_add_mem (sel.tvp, tdep->size_timeval))
648 return -1; 651 return -1;
649 } 652 }
650 } 653 }
651 break; 654 break;
652 655
653 case gdb_sys_symlink: 656 case gdb_sys_symlink:
654 break; 657 break;
655 658
656 case gdb_sys_readlink: 659 case gdb_sys_readlink:
657 { 660 {
658 ULONGEST len; 661 ULONGEST len;
659 662
660 regcache_raw_read_unsigned (regcache, tdep->arg2, 663 regcache_raw_read_unsigned (regcache, tdep->arg2,
661 &tmpulongest); 664 &tmpulongest);
662 regcache_raw_read_unsigned (regcache, tdep->arg3, &len); 665 regcache_raw_read_unsigned (regcache, tdep->arg3, &len);
663 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, (int) len)) 666 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest, (int) len))
664 return -1; 667 return -1;
665 } 668 }
666 break; 669 break;
667 670
668 case gdb_sys_uselib: 671 case gdb_sys_uselib:
669 case gdb_sys_swapon: 672 case gdb_sys_swapon:
670 break; 673 break;
671 674
672 case gdb_sys_reboot: 675 case gdb_sys_reboot:
673 { 676 {
674 int q; 677 int q;
675 678
676 target_terminal_ours (); 679 target_terminal_ours ();
677 q = yquery (_("The next instruction is syscall reboot. " 680 q = yquery (_("The next instruction is syscall reboot. "
678 "It will restart the computer. " 681 "It will restart the computer. "
679 "Do you want to stop the program?")); 682 "Do you want to stop the program?"));
680 target_terminal_inferior (); 683 target_terminal_inferior ();
681 if (q) 684 if (q)
682 return 1; 685 return 1;
683 } 686 }
684 break; 687 break;
685 688
686 case gdb_old_readdir: 689 case gdb_old_readdir:
687 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest); 690 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
688 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 691 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
689 tdep->size_dirent)) 692 » » » » » tdep->size_dirent))
690 return -1; 693 return -1;
691 break; 694 break;
692 695
693 case gdb_old_mmap: 696 case gdb_old_mmap:
694 break; 697 break;
695 698
696 case gdb_sys_munmap: 699 case gdb_sys_munmap:
697 { 700 {
698 ULONGEST len; 701 ULONGEST len;
699 702
700 regcache_raw_read_unsigned (regcache, tdep->arg1, 703 regcache_raw_read_unsigned (regcache, tdep->arg1,
701 &tmpulongest); 704 &tmpulongest);
702 regcache_raw_read_unsigned (regcache, tdep->arg2, &len); 705 regcache_raw_read_unsigned (regcache, tdep->arg2, &len);
703 if (record_memory_query) 706 if (record_full_memory_query)
704 { 707 {
705 int q; 708 int q;
706 709
707 target_terminal_ours (); 710 target_terminal_ours ();
708 q = yquery (_("\ 711 q = yquery (_("\
709 The next instruction is syscall munmap.\n\ 712 The next instruction is syscall munmap.\n\
710 It will free the memory addr = 0x%s len = %u.\n\ 713 It will free the memory addr = 0x%s len = %u.\n\
711 It will make record target cannot record some memory change.\n\ 714 It will make record target cannot record some memory change.\n\
712 Do you want to stop the program?"), 715 Do you want to stop the program?"),
713 OUTPUT_REG (tmpulongest, tdep->arg1), (int) len); 716 OUTPUT_REG (tmpulongest, tdep->arg1), (int) len);
714 target_terminal_inferior (); 717 target_terminal_inferior ();
715 if (q) 718 if (q)
716 return 1; 719 return 1;
717 } 720 }
718 } 721 }
719 break; 722 break;
720 723
721 case gdb_sys_truncate: 724 case gdb_sys_truncate:
722 case gdb_sys_ftruncate: 725 case gdb_sys_ftruncate:
723 case gdb_sys_fchmod: 726 case gdb_sys_fchmod:
724 case gdb_sys_fchown16: 727 case gdb_sys_fchown16:
725 case gdb_sys_getpriority: 728 case gdb_sys_getpriority:
726 case gdb_sys_setpriority: 729 case gdb_sys_setpriority:
727 case gdb_sys_ni_syscall98: 730 case gdb_sys_ni_syscall98:
728 break; 731 break;
729 732
730 case gdb_sys_statfs: 733 case gdb_sys_statfs:
731 case gdb_sys_fstatfs: 734 case gdb_sys_fstatfs:
732 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest); 735 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
733 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 736 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
734 tdep->size_statfs)) 737 » » » » » tdep->size_statfs))
735 return -1; 738 return -1;
736 break; 739 break;
737 740
738 case gdb_sys_ioperm: 741 case gdb_sys_ioperm:
739 break; 742 break;
740 743
741 case gdb_sys_socket: 744 case gdb_sys_socket:
742 case gdb_sys_sendto: 745 case gdb_sys_sendto:
743 case gdb_sys_sendmsg: 746 case gdb_sys_sendmsg:
744 case gdb_sys_shutdown: 747 case gdb_sys_shutdown:
(...skipping 26 matching lines...) Expand all
771 return -1; 774 return -1;
772 } 775 }
773 break; 776 break;
774 777
775 case gdb_sys_recv: 778 case gdb_sys_recv:
776 { 779 {
777 ULONGEST size; 780 ULONGEST size;
778 781
779 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest); 782 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
780 regcache_raw_read_unsigned (regcache, tdep->arg3, &size); 783 regcache_raw_read_unsigned (regcache, tdep->arg3, &size);
781 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, (int) size)) 784 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
785 » » » » » (int) size))
782 return -1; 786 return -1;
783 } 787 }
784 break; 788 break;
785 789
786 case gdb_sys_recvmsg: 790 case gdb_sys_recvmsg:
787 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest); 791 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
788 if (record_linux_msghdr (regcache, tdep, tmpulongest)) 792 if (record_linux_msghdr (regcache, tdep, tmpulongest))
789 return -1; 793 return -1;
790 break; 794 break;
791 795
792 case gdb_sys_socketpair: 796 case gdb_sys_socketpair:
793 regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest); 797 regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
794 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_int)) 798 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
799 » » » » » tdep->size_int))
795 return -1; 800 return -1;
796 break; 801 break;
797 802
798 case gdb_sys_getsockopt: 803 case gdb_sys_getsockopt:
799 regcache_raw_read_unsigned (regcache, tdep->arg5, &tmpulongest); 804 regcache_raw_read_unsigned (regcache, tdep->arg5, &tmpulongest);
800 if (tmpulongest) 805 if (tmpulongest)
801 { 806 {
802 ULONGEST optvalp; 807 ULONGEST optvalp;
803 gdb_byte *optlenp = alloca (tdep->size_int); 808 gdb_byte *optlenp = alloca (tdep->size_int);
804 809
805 if (target_read_memory ((CORE_ADDR) tmpulongest, optlenp, 810 if (target_read_memory ((CORE_ADDR) tmpulongest, optlenp,
806 tdep->size_int)) 811 tdep->size_int))
807 { 812 {
808 if (record_debug) 813 if (record_debug)
809 fprintf_unfiltered (gdb_stdlog, 814 fprintf_unfiltered (gdb_stdlog,
810 "Process record: error reading " 815 "Process record: error reading "
811 "memory at addr = 0x%s " 816 "memory at addr = 0x%s "
812 "len = %d.\n", 817 "len = %d.\n",
813 OUTPUT_REG (tmpulongest, tdep->arg5), 818 OUTPUT_REG (tmpulongest, tdep->arg5),
814 tdep->size_int); 819 tdep->size_int);
815 return -1; 820 return -1;
816 } 821 }
817 regcache_raw_read_unsigned (regcache, tdep->arg4, &optvalp); 822 regcache_raw_read_unsigned (regcache, tdep->arg4, &optvalp);
818 tmpint = (int) extract_signed_integer (optlenp, tdep->size_int, 823 tmpint = (int) extract_signed_integer (optlenp, tdep->size_int,
819 byte_order); 824 byte_order);
820 if (record_arch_list_add_mem ((CORE_ADDR) optvalp, tmpint)) 825 if (record_full_arch_list_add_mem ((CORE_ADDR) optvalp, tmpint))
821 return -1; 826 return -1;
822 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 827 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
823 tdep->size_int)) 828 » » » » » tdep->size_int))
824 return -1; 829 return -1;
825 } 830 }
826 break; 831 break;
827 832
828 case gdb_sys_socketcall: 833 case gdb_sys_socketcall:
829 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest); 834 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
830 switch (tmpulongest) 835 switch (tmpulongest)
831 { 836 {
832 case RECORD_SYS_SOCKET: 837 case RECORD_SYS_SOCKET:
833 case RECORD_SYS_BIND: 838 case RECORD_SYS_BIND:
(...skipping 50 matching lines...) Expand 10 before | Expand all | Expand 10 after
884 fprintf_unfiltered (gdb_stdlog, 889 fprintf_unfiltered (gdb_stdlog,
885 "Process record: error reading " 890 "Process record: error reading "
886 "memory at addr = 0x%s len = %d.\n", 891 "memory at addr = 0x%s len = %d.\n",
887 OUTPUT_REG (tmpulongest, tdep->arg2), 892 OUTPUT_REG (tmpulongest, tdep->arg2),
888 tdep->size_ulong); 893 tdep->size_ulong);
889 return -1; 894 return -1;
890 } 895 }
891 tmpaddr 896 tmpaddr
892 = (CORE_ADDR) extract_unsigned_integer (a, tdep->size_ulong, 897 = (CORE_ADDR) extract_unsigned_integer (a, tdep->size_ulong,
893 byte_order); 898 byte_order);
894 if (record_arch_list_add_mem (tmpaddr, tdep->size_int)) 899 if (record_full_arch_list_add_mem (tmpaddr, tdep->size_int))
895 return -1; 900 return -1;
896 } 901 }
897 } 902 }
898 break; 903 break;
899 case RECORD_SYS_SEND: 904 case RECORD_SYS_SEND:
900 case RECORD_SYS_SENDTO: 905 case RECORD_SYS_SENDTO:
901 break; 906 break;
902 case RECORD_SYS_RECVFROM: 907 case RECORD_SYS_RECVFROM:
903 regcache_raw_read_unsigned (regcache, tdep->arg2, 908 regcache_raw_read_unsigned (regcache, tdep->arg2,
904 &tmpulongest); 909 &tmpulongest);
(...skipping 40 matching lines...) Expand 10 before | Expand all | Expand 10 after
945 tdep->size_ulong); 950 tdep->size_ulong);
946 return -1; 951 return -1;
947 } 952 }
948 tmpulongest = extract_unsigned_integer (a, tdep->size_ulong, 953 tmpulongest = extract_unsigned_integer (a, tdep->size_ulong,
949 byte_order); 954 byte_order);
950 if (tmpulongest) 955 if (tmpulongest)
951 { 956 {
952 a += tdep->size_ulong; 957 a += tdep->size_ulong;
953 tmpint = (int) extract_unsigned_integer (a, tdep->size_ulong, 958 tmpint = (int) extract_unsigned_integer (a, tdep->size_ulong,
954 byte_order); 959 byte_order);
955 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 960 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
956 tmpint)) 961 » » » » » » tmpint))
957 return -1; 962 return -1;
958 } 963 }
959 } 964 }
960 break; 965 break;
961 case RECORD_SYS_SHUTDOWN: 966 case RECORD_SYS_SHUTDOWN:
962 case RECORD_SYS_SETSOCKOPT: 967 case RECORD_SYS_SETSOCKOPT:
963 break; 968 break;
964 case RECORD_SYS_GETSOCKOPT: 969 case RECORD_SYS_GETSOCKOPT:
965 { 970 {
966 gdb_byte *a = alloca (tdep->size_ulong * 2); 971 gdb_byte *a = alloca (tdep->size_ulong * 2);
(...skipping 33 matching lines...) Expand 10 before | Expand all | Expand 10 after
1000 tdep->size_int); 1005 tdep->size_int);
1001 return -1; 1006 return -1;
1002 } 1007 }
1003 tmpaddr 1008 tmpaddr
1004 = (CORE_ADDR) extract_unsigned_integer (a, 1009 = (CORE_ADDR) extract_unsigned_integer (a,
1005 tdep->size_ulong, 1010 tdep->size_ulong,
1006 byte_order); 1011 byte_order);
1007 tmpint = (int) extract_unsigned_integer (av, 1012 tmpint = (int) extract_unsigned_integer (av,
1008 tdep->size_int, 1013 tdep->size_int,
1009 byte_order); 1014 byte_order);
1010 if (record_arch_list_add_mem (tmpaddr, tmpint)) 1015 if (record_full_arch_list_add_mem (tmpaddr, tmpint))
1011 return -1; 1016 return -1;
1012 a += tdep->size_ulong; 1017 a += tdep->size_ulong;
1013 tmpaddr 1018 tmpaddr
1014 = (CORE_ADDR) extract_unsigned_integer (a, 1019 = (CORE_ADDR) extract_unsigned_integer (a,
1015 tdep->size_ulong, 1020 tdep->size_ulong,
1016 byte_order); 1021 byte_order);
1017 if (record_arch_list_add_mem (tmpaddr, tdep->size_int)) 1022 if (record_full_arch_list_add_mem (tmpaddr,
1023 » » » » » » tdep->size_int))
1018 return -1; 1024 return -1;
1019 } 1025 }
1020 } 1026 }
1021 } 1027 }
1022 break; 1028 break;
1023 case RECORD_SYS_SENDMSG: 1029 case RECORD_SYS_SENDMSG:
1024 break; 1030 break;
1025 case RECORD_SYS_RECVMSG: 1031 case RECORD_SYS_RECVMSG:
1026 { 1032 {
1027 gdb_byte *a = alloca (tdep->size_ulong); 1033 gdb_byte *a = alloca (tdep->size_ulong);
(...skipping 28 matching lines...) Expand all
1056 return -1; 1062 return -1;
1057 break; 1063 break;
1058 } 1064 }
1059 break; 1065 break;
1060 1066
1061 case gdb_sys_syslog: 1067 case gdb_sys_syslog:
1062 break; 1068 break;
1063 1069
1064 case gdb_sys_setitimer: 1070 case gdb_sys_setitimer:
1065 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest); 1071 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1066 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 1072 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1067 tdep->size_itimerval)) 1073 » » » » » tdep->size_itimerval))
1068 return -1; 1074 return -1;
1069 break; 1075 break;
1070 1076
1071 case gdb_sys_getitimer: 1077 case gdb_sys_getitimer:
1072 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest); 1078 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1073 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 1079 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1074 tdep->size_itimerval)) 1080 » » » » » tdep->size_itimerval))
1075 return -1; 1081 return -1;
1076 break; 1082 break;
1077 1083
1078 case gdb_sys_newstat: 1084 case gdb_sys_newstat:
1079 case gdb_sys_newlstat: 1085 case gdb_sys_newlstat:
1080 case gdb_sys_newfstat: 1086 case gdb_sys_newfstat:
1081 case gdb_sys_newfstatat: 1087 case gdb_sys_newfstatat:
1082 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest); 1088 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1083 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_stat)) 1089 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1090 » » » » » tdep->size_stat))
1084 return -1; 1091 return -1;
1085 break; 1092 break;
1086 1093
1087 case gdb_sys_uname: 1094 case gdb_sys_uname:
1088 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest); 1095 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1089 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 1096 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1090 tdep->size_old_utsname)) 1097 » » » » » tdep->size_old_utsname))
1091 return -1; 1098 return -1;
1092 break; 1099 break;
1093 1100
1094 case gdb_sys_iopl: 1101 case gdb_sys_iopl:
1095 case gdb_sys_vhangup: 1102 case gdb_sys_vhangup:
1096 case gdb_sys_ni_syscall112: 1103 case gdb_sys_ni_syscall112:
1097 case gdb_sys_vm86old: 1104 case gdb_sys_vm86old:
1098 break; 1105 break;
1099 1106
1100 case gdb_sys_wait4: 1107 case gdb_sys_wait4:
1101 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest); 1108 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1102 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 1109 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1103 tdep->size_int)) 1110 » » » » » tdep->size_int))
1104 return -1; 1111 return -1;
1105 regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest); 1112 regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
1106 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 1113 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1107 tdep->size_rusage)) 1114 » » » » » tdep->size_rusage))
1108 return -1; 1115 return -1;
1109 break; 1116 break;
1110 1117
1111 case gdb_sys_swapoff: 1118 case gdb_sys_swapoff:
1112 break; 1119 break;
1113 1120
1114 case gdb_sys_sysinfo: 1121 case gdb_sys_sysinfo:
1115 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest); 1122 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1116 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 1123 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1117 tdep->size_sysinfo)) 1124 » » » » » tdep->size_sysinfo))
1118 return -1; 1125 return -1;
1119 break; 1126 break;
1120 1127
1121 case gdb_sys_shmget: 1128 case gdb_sys_shmget:
1122 case gdb_sys_semget: 1129 case gdb_sys_semget:
1123 case gdb_sys_semop: 1130 case gdb_sys_semop:
1124 case gdb_sys_msgget: 1131 case gdb_sys_msgget:
1125 /* XXX maybe need do some record works with sys_shmdt. */ 1132 /* XXX maybe need do some record works with sys_shmdt. */
1126 case gdb_sys_shmdt: 1133 case gdb_sys_shmdt:
1127 case gdb_sys_msgsnd: 1134 case gdb_sys_msgsnd:
1128 case gdb_sys_semtimedop: 1135 case gdb_sys_semtimedop:
1129 break; 1136 break;
1130 1137
1131 case gdb_sys_shmat: 1138 case gdb_sys_shmat:
1132 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest); 1139 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1133 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 1140 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1134 tdep->size_ulong)) 1141 » » » » » tdep->size_ulong))
1135 return -1; 1142 return -1;
1136 break; 1143 break;
1137 1144
1138 case gdb_sys_shmctl: 1145 case gdb_sys_shmctl:
1139 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest); 1146 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1140 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 1147 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1141 tdep->size_shmid_ds)) 1148 » » » » » tdep->size_shmid_ds))
1142 return -1; 1149 return -1;
1143 break; 1150 break;
1144 1151
1145 /* XXX sys_semctl 525 still not supported. */ 1152 /* XXX sys_semctl 525 still not supported. */
1146 /* sys_semctl */ 1153 /* sys_semctl */
1147 1154
1148 case gdb_sys_msgrcv: 1155 case gdb_sys_msgrcv:
1149 { 1156 {
1150 ULONGEST msgp; 1157 ULONGEST msgp;
1158 LONGEST l;
1151 1159
1152 regcache_raw_read_signed (regcache, tdep->arg3, &tmpulongest); 1160 regcache_raw_read_signed (regcache, tdep->arg3, &l);
1153 regcache_raw_read_unsigned (regcache, tdep->arg2, &msgp); 1161 regcache_raw_read_unsigned (regcache, tdep->arg2, &msgp);
1154 tmpint = (int) tmpulongest + tdep->size_long; 1162 tmpint = l + tdep->size_long;
1155 if (record_arch_list_add_mem ((CORE_ADDR) msgp, tmpint)) 1163 if (record_full_arch_list_add_mem ((CORE_ADDR) msgp, tmpint))
1156 return -1; 1164 return -1;
1157 } 1165 }
1158 break; 1166 break;
1159 1167
1160 case gdb_sys_msgctl: 1168 case gdb_sys_msgctl:
1161 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest); 1169 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1162 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 1170 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1163 tdep->size_msqid_ds)) 1171 » » » » » tdep->size_msqid_ds))
1164 return -1; 1172 return -1;
1165 break; 1173 break;
1166 1174
1167 case gdb_sys_ipc: 1175 case gdb_sys_ipc:
1168 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest); 1176 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1169 tmpulongest &= 0xffff; 1177 tmpulongest &= 0xffff;
1170 switch (tmpulongest) 1178 switch (tmpulongest)
1171 { 1179 {
1172 case RECORD_SEMOP: 1180 case RECORD_SEMOP:
1173 case RECORD_SEMGET: 1181 case RECORD_SEMGET:
1174 case RECORD_SEMTIMEDOP: 1182 case RECORD_SEMTIMEDOP:
1175 case RECORD_MSGSND: 1183 case RECORD_MSGSND:
1176 case RECORD_MSGGET: 1184 case RECORD_MSGGET:
1177 /* XXX maybe need do some record works with RECORD_SHMDT. */ 1185 /* XXX maybe need do some record works with RECORD_SHMDT. */
1178 case RECORD_SHMDT: 1186 case RECORD_SHMDT:
1179 case RECORD_SHMGET: 1187 case RECORD_SHMGET:
1180 break; 1188 break;
1181 case RECORD_MSGRCV: 1189 case RECORD_MSGRCV:
1182 { 1190 {
1183 ULONGEST second; 1191 LONGEST second;
1184 ULONGEST ptr; 1192 ULONGEST ptr;
1185 1193
1186 regcache_raw_read_signed (regcache, tdep->arg3, &second); 1194 regcache_raw_read_signed (regcache, tdep->arg3, &second);
1187 regcache_raw_read_unsigned (regcache, tdep->arg5, &ptr); 1195 regcache_raw_read_unsigned (regcache, tdep->arg5, &ptr);
1188 tmpint = (int) second + tdep->size_long; 1196 tmpint = (int) second + tdep->size_long;
1189 if (record_arch_list_add_mem ((CORE_ADDR) ptr, tmpint)) 1197 if (record_full_arch_list_add_mem ((CORE_ADDR) ptr, tmpint))
1190 return -1; 1198 return -1;
1191 } 1199 }
1192 break; 1200 break;
1193 case RECORD_MSGCTL: 1201 case RECORD_MSGCTL:
1194 regcache_raw_read_unsigned (regcache, tdep->arg5, 1202 regcache_raw_read_unsigned (regcache, tdep->arg5,
1195 &tmpulongest); 1203 &tmpulongest);
1196 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 1204 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1197 tdep->size_msqid_ds)) 1205 » » » » » tdep->size_msqid_ds))
1198 return -1; 1206 return -1;
1199 break; 1207 break;
1200 case RECORD_SHMAT: 1208 case RECORD_SHMAT:
1201 regcache_raw_read_unsigned (regcache, tdep->arg4, 1209 regcache_raw_read_unsigned (regcache, tdep->arg4,
1202 &tmpulongest); 1210 &tmpulongest);
1203 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 1211 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1204 tdep->size_ulong)) 1212 » » » » » tdep->size_ulong))
1205 return -1; 1213 return -1;
1206 break; 1214 break;
1207 case RECORD_SHMCTL: 1215 case RECORD_SHMCTL:
1208 regcache_raw_read_unsigned (regcache, tdep->arg5, 1216 regcache_raw_read_unsigned (regcache, tdep->arg5,
1209 &tmpulongest); 1217 &tmpulongest);
1210 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 1218 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1211 tdep->size_shmid_ds)) 1219 » » » » » tdep->size_shmid_ds))
1212 return -1; 1220 return -1;
1213 break; 1221 break;
1214 default: 1222 default:
1215 /* XXX RECORD_SEMCTL still not supported. */ 1223 /* XXX RECORD_SEMCTL still not supported. */
1216 printf_unfiltered (_("Process record and replay target doesn't " 1224 printf_unfiltered (_("Process record and replay target doesn't "
1217 "support ipc number %s\n"), 1225 "support ipc number %s\n"),
1218 pulongest (tmpulongest)); 1226 pulongest (tmpulongest));
1219 break; 1227 break;
1220 } 1228 }
1221 break; 1229 break;
1222 1230
1223 case gdb_sys_fsync: 1231 case gdb_sys_fsync:
1224 case gdb_sys_sigreturn: 1232 case gdb_sys_sigreturn:
1225 case gdb_sys_clone: 1233 case gdb_sys_clone:
1226 case gdb_sys_setdomainname: 1234 case gdb_sys_setdomainname:
1227 break; 1235 break;
1228 1236
1229 case gdb_sys_newuname: 1237 case gdb_sys_newuname:
1230 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest); 1238 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1231 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 1239 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1232 tdep->size_new_utsname)) 1240 » » » » » tdep->size_new_utsname))
1233 return -1; 1241 return -1;
1234 break; 1242 break;
1235 1243
1236 case gdb_sys_modify_ldt: 1244 case gdb_sys_modify_ldt:
1237 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest); 1245 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1238 if (tmpulongest == 0 || tmpulongest == 2) 1246 if (tmpulongest == 0 || tmpulongest == 2)
1239 { 1247 {
1240 ULONGEST ptr, bytecount; 1248 ULONGEST ptr, bytecount;
1241 1249
1242 regcache_raw_read_unsigned (regcache, tdep->arg2, &ptr); 1250 regcache_raw_read_unsigned (regcache, tdep->arg2, &ptr);
1243 regcache_raw_read_unsigned (regcache, tdep->arg3, &bytecount); 1251 regcache_raw_read_unsigned (regcache, tdep->arg3, &bytecount);
1244 if (record_arch_list_add_mem ((CORE_ADDR) ptr, (int) bytecount)) 1252 if (record_full_arch_list_add_mem ((CORE_ADDR) ptr, (int) bytecount))
1245 return -1; 1253 return -1;
1246 } 1254 }
1247 break; 1255 break;
1248 1256
1249 case gdb_sys_adjtimex: 1257 case gdb_sys_adjtimex:
1250 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest); 1258 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1251 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_timex)) 1259 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1260 » » » » » tdep->size_timex))
1252 return -1; 1261 return -1;
1253 break; 1262 break;
1254 1263
1255 case gdb_sys_mprotect: 1264 case gdb_sys_mprotect:
1256 break; 1265 break;
1257 1266
1258 case gdb_sys_sigprocmask: 1267 case gdb_sys_sigprocmask:
1259 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest); 1268 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1260 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 1269 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1261 tdep->size_old_sigset_t)) 1270 » » » » » tdep->size_old_sigset_t))
1262 return -1; 1271 return -1;
1263 break; 1272 break;
1264 1273
1265 case gdb_sys_ni_syscall127: 1274 case gdb_sys_ni_syscall127:
1266 case gdb_sys_init_module: 1275 case gdb_sys_init_module:
1267 case gdb_sys_delete_module: 1276 case gdb_sys_delete_module:
1268 case gdb_sys_ni_syscall130: 1277 case gdb_sys_ni_syscall130:
1269 break; 1278 break;
1270 1279
1271 case gdb_sys_quotactl: 1280 case gdb_sys_quotactl:
1272 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest); 1281 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1273 switch (tmpulongest) 1282 switch (tmpulongest)
1274 { 1283 {
1275 case RECORD_Q_GETFMT: 1284 case RECORD_Q_GETFMT:
1276 regcache_raw_read_unsigned (regcache, tdep->arg4, 1285 regcache_raw_read_unsigned (regcache, tdep->arg4,
1277 &tmpulongest); 1286 &tmpulongest);
1278 /* __u32 */ 1287 /* __u32 */
1279 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 4)) 1288 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest, 4))
1280 return -1; 1289 return -1;
1281 break; 1290 break;
1282 case RECORD_Q_GETINFO: 1291 case RECORD_Q_GETINFO:
1283 regcache_raw_read_unsigned (regcache, tdep->arg4, 1292 regcache_raw_read_unsigned (regcache, tdep->arg4,
1284 &tmpulongest); 1293 &tmpulongest);
1285 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 1294 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1286 tdep->size_mem_dqinfo)) 1295 » » » » » tdep->size_mem_dqinfo))
1287 return -1; 1296 return -1;
1288 break; 1297 break;
1289 case RECORD_Q_GETQUOTA: 1298 case RECORD_Q_GETQUOTA:
1290 regcache_raw_read_unsigned (regcache, tdep->arg4, 1299 regcache_raw_read_unsigned (regcache, tdep->arg4,
1291 &tmpulongest); 1300 &tmpulongest);
1292 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 1301 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1293 tdep->size_if_dqblk)) 1302 » » » » » tdep->size_if_dqblk))
1294 return -1; 1303 return -1;
1295 break; 1304 break;
1296 case RECORD_Q_XGETQSTAT: 1305 case RECORD_Q_XGETQSTAT:
1297 case RECORD_Q_XGETQUOTA: 1306 case RECORD_Q_XGETQUOTA:
1298 regcache_raw_read_unsigned (regcache, tdep->arg4, 1307 regcache_raw_read_unsigned (regcache, tdep->arg4,
1299 &tmpulongest); 1308 &tmpulongest);
1300 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 1309 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1301 tdep->size_fs_quota_stat)) 1310 » » » » » tdep->size_fs_quota_stat))
1302 return -1; 1311 return -1;
1303 break; 1312 break;
1304 } 1313 }
1305 break; 1314 break;
1306 1315
1307 case gdb_sys_getpgid: 1316 case gdb_sys_getpgid:
1308 case gdb_sys_fchdir: 1317 case gdb_sys_fchdir:
1309 case gdb_sys_bdflush: 1318 case gdb_sys_bdflush:
1310 break; 1319 break;
1311 1320
1312 case gdb_sys_sysfs: 1321 case gdb_sys_sysfs:
1313 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest); 1322 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1314 if (tmpulongest == 2) 1323 if (tmpulongest == 2)
1315 { 1324 {
1316 regcache_raw_read_unsigned (regcache, tdep->arg3, 1325 regcache_raw_read_unsigned (regcache, tdep->arg3,
1317 &tmpulongest); 1326 &tmpulongest);
1318 /*XXX the size of memory is not very clear. */ 1327 /*XXX the size of memory is not very clear. */
1319 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 10)) 1328 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest, 10))
1320 return -1; 1329 return -1;
1321 } 1330 }
1322 break; 1331 break;
1323 1332
1324 case gdb_sys_personality: 1333 case gdb_sys_personality:
1325 case gdb_sys_ni_syscall137: 1334 case gdb_sys_ni_syscall137:
1326 case gdb_sys_setfsuid16: 1335 case gdb_sys_setfsuid16:
1327 case gdb_sys_setfsgid16: 1336 case gdb_sys_setfsgid16:
1328 break; 1337 break;
1329 1338
1330 case gdb_sys_llseek: 1339 case gdb_sys_llseek:
1331 regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest); 1340 regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
1332 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 1341 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1333 tdep->size_loff_t)) 1342 » » » » » tdep->size_loff_t))
1334 return -1; 1343 return -1;
1335 break; 1344 break;
1336 1345
1337 case gdb_sys_getdents: 1346 case gdb_sys_getdents:
1338 { 1347 {
1339 ULONGEST count; 1348 ULONGEST count;
1340 1349
1341 regcache_raw_read_unsigned (regcache, tdep->arg2, 1350 regcache_raw_read_unsigned (regcache, tdep->arg2,
1342 &tmpulongest); 1351 &tmpulongest);
1343 regcache_raw_read_unsigned (regcache, tdep->arg3, &count); 1352 regcache_raw_read_unsigned (regcache, tdep->arg3, &count);
1344 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 1353 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1345 tdep->size_dirent * count)) 1354 » » » » » tdep->size_dirent * count))
1346 return -1; 1355 return -1;
1347 } 1356 }
1348 break; 1357 break;
1349 1358
1350 case gdb_sys_select: 1359 case gdb_sys_select:
1351 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest); 1360 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1352 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 1361 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1353 tdep->size_fd_set)) 1362 » » » » » tdep->size_fd_set))
1354 return -1; 1363 return -1;
1355 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest); 1364 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1356 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 1365 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1357 tdep->size_fd_set)) 1366 » » » » » tdep->size_fd_set))
1358 return -1; 1367 return -1;
1359 regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest); 1368 regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
1360 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 1369 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1361 tdep->size_fd_set)) 1370 » » » » » tdep->size_fd_set))
1362 return -1; 1371 return -1;
1363 regcache_raw_read_unsigned (regcache, tdep->arg5, &tmpulongest); 1372 regcache_raw_read_unsigned (regcache, tdep->arg5, &tmpulongest);
1364 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 1373 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1365 tdep->size_timeval)) 1374 » » » » » tdep->size_timeval))
1366 return -1; 1375 return -1;
1367 break; 1376 break;
1368 1377
1369 case gdb_sys_flock: 1378 case gdb_sys_flock:
1370 case gdb_sys_msync: 1379 case gdb_sys_msync:
1371 break; 1380 break;
1372 1381
1373 case gdb_sys_readv: 1382 case gdb_sys_readv:
1374 { 1383 {
1375 ULONGEST vec, vlen; 1384 ULONGEST vec, vlen;
(...skipping 18 matching lines...) Expand all
1394 return -1; 1403 return -1;
1395 } 1404 }
1396 tmpaddr 1405 tmpaddr
1397 = (CORE_ADDR) extract_unsigned_integer (iov, 1406 = (CORE_ADDR) extract_unsigned_integer (iov,
1398 tdep->size_pointer, 1407 tdep->size_pointer,
1399 byte_order); 1408 byte_order);
1400 tmpint 1409 tmpint
1401 = (int) extract_unsigned_integer (iov + tdep->size_pointer, 1410 = (int) extract_unsigned_integer (iov + tdep->size_pointer,
1402 tdep->size_size_t, 1411 tdep->size_size_t,
1403 byte_order); 1412 byte_order);
1404 if (record_arch_list_add_mem (tmpaddr, tmpint)) 1413 if (record_full_arch_list_add_mem (tmpaddr, tmpint))
1405 return -1; 1414 return -1;
1406 vec += tdep->size_iovec; 1415 vec += tdep->size_iovec;
1407 } 1416 }
1408 } 1417 }
1409 } 1418 }
1410 break; 1419 break;
1411 1420
1412 case gdb_sys_writev: 1421 case gdb_sys_writev:
1413 case gdb_sys_getsid: 1422 case gdb_sys_getsid:
1414 case gdb_sys_fdatasync: 1423 case gdb_sys_fdatasync:
1415 case gdb_sys_sysctl: 1424 case gdb_sys_sysctl:
1416 case gdb_sys_mlock: 1425 case gdb_sys_mlock:
1417 case gdb_sys_munlock: 1426 case gdb_sys_munlock:
1418 case gdb_sys_mlockall: 1427 case gdb_sys_mlockall:
1419 case gdb_sys_munlockall: 1428 case gdb_sys_munlockall:
1420 case gdb_sys_sched_setparam: 1429 case gdb_sys_sched_setparam:
1421 break; 1430 break;
1422 1431
1423 case gdb_sys_sched_getparam: 1432 case gdb_sys_sched_getparam:
1424 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest); 1433 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1425 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_int)) 1434 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1435 » » » » » tdep->size_int))
1426 return -1; 1436 return -1;
1427 break; 1437 break;
1428 1438
1429 case gdb_sys_sched_setscheduler: 1439 case gdb_sys_sched_setscheduler:
1430 case gdb_sys_sched_getscheduler: 1440 case gdb_sys_sched_getscheduler:
1431 case gdb_sys_sched_yield: 1441 case gdb_sys_sched_yield:
1432 case gdb_sys_sched_get_priority_max: 1442 case gdb_sys_sched_get_priority_max:
1433 case gdb_sys_sched_get_priority_min: 1443 case gdb_sys_sched_get_priority_min:
1434 break; 1444 break;
1435 1445
1436 case gdb_sys_sched_rr_get_interval: 1446 case gdb_sys_sched_rr_get_interval:
1437 case gdb_sys_nanosleep: 1447 case gdb_sys_nanosleep:
1438 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest); 1448 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1439 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 1449 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1440 tdep->size_timespec)) 1450 » » » » » tdep->size_timespec))
1441 return -1; 1451 return -1;
1442 break; 1452 break;
1443 1453
1444 case gdb_sys_mremap: 1454 case gdb_sys_mremap:
1445 case gdb_sys_setresuid16: 1455 case gdb_sys_setresuid16:
1446 break; 1456 break;
1447 1457
1448 case gdb_sys_getresuid16: 1458 case gdb_sys_getresuid16:
1449 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest); 1459 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1450 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 1460 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1451 tdep->size_old_uid_t)) 1461 » » » » » tdep->size_old_uid_t))
1452 return -1; 1462 return -1;
1453 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest); 1463 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1454 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 1464 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1455 tdep->size_old_uid_t)) 1465 » » » » » tdep->size_old_uid_t))
1456 return -1; 1466 return -1;
1457 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest); 1467 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1458 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 1468 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1459 tdep->size_old_uid_t)) 1469 » » » » » tdep->size_old_uid_t))
1460 return -1; 1470 return -1;
1461 break; 1471 break;
1462 1472
1463 case gdb_sys_vm86: 1473 case gdb_sys_vm86:
1464 case gdb_sys_ni_syscall167: 1474 case gdb_sys_ni_syscall167:
1465 break; 1475 break;
1466 1476
1467 case gdb_sys_poll: 1477 case gdb_sys_poll:
1468 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest); 1478 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1469 if (tmpulongest) 1479 if (tmpulongest)
1470 { 1480 {
1471 ULONGEST nfds; 1481 ULONGEST nfds;
1472 1482
1473 regcache_raw_read_unsigned (regcache, tdep->arg2, &nfds); 1483 regcache_raw_read_unsigned (regcache, tdep->arg2, &nfds);
1474 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 1484 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1475 tdep->size_pollfd * nfds)) 1485 » » » » » tdep->size_pollfd * nfds))
1476 return -1; 1486 return -1;
1477 } 1487 }
1478 break; 1488 break;
1479 1489
1480 case gdb_sys_nfsservctl: 1490 case gdb_sys_nfsservctl:
1481 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest); 1491 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1482 if (tmpulongest == 7 || tmpulongest == 8) 1492 if (tmpulongest == 7 || tmpulongest == 8)
1483 { 1493 {
1484 int rsize; 1494 int rsize;
1485 1495
1486 if (tmpulongest == 7) 1496 if (tmpulongest == 7)
1487 rsize = tdep->size_NFS_FHSIZE; 1497 rsize = tdep->size_NFS_FHSIZE;
1488 else 1498 else
1489 rsize = tdep->size_knfsd_fh; 1499 rsize = tdep->size_knfsd_fh;
1490 regcache_raw_read_unsigned (regcache, tdep->arg3, 1500 regcache_raw_read_unsigned (regcache, tdep->arg3,
1491 &tmpulongest); 1501 &tmpulongest);
1492 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, rsize)) 1502 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest, rsize))
1493 return -1; 1503 return -1;
1494 } 1504 }
1495 break; 1505 break;
1496 1506
1497 case gdb_sys_setresgid16: 1507 case gdb_sys_setresgid16:
1498 break; 1508 break;
1499 1509
1500 case gdb_sys_getresgid16: 1510 case gdb_sys_getresgid16:
1501 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest); 1511 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1502 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 1512 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1503 tdep->size_old_gid_t)) 1513 » » » » » tdep->size_old_gid_t))
1504 return -1; 1514 return -1;
1505 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest); 1515 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1506 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 1516 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1507 tdep->size_old_gid_t)) 1517 » » » » » tdep->size_old_gid_t))
1508 return -1; 1518 return -1;
1509 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest); 1519 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1510 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 1520 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1511 tdep->size_old_gid_t)) 1521 » » » » » tdep->size_old_gid_t))
1512 return -1; 1522 return -1;
1513 break; 1523 break;
1514 1524
1515 case gdb_sys_prctl: 1525 case gdb_sys_prctl:
1516 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest); 1526 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1517 switch (tmpulongest) 1527 switch (tmpulongest)
1518 { 1528 {
1519 case 2: 1529 case 2:
1520 regcache_raw_read_unsigned (regcache, tdep->arg2, 1530 regcache_raw_read_unsigned (regcache, tdep->arg2,
1521 &tmpulongest); 1531 &tmpulongest);
1522 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 1532 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1523 tdep->size_int)) 1533 » » » » » tdep->size_int))
1524 return -1; 1534 return -1;
1525 break; 1535 break;
1526 case 16: 1536 case 16:
1527 regcache_raw_read_unsigned (regcache, tdep->arg2, 1537 regcache_raw_read_unsigned (regcache, tdep->arg2,
1528 &tmpulongest); 1538 &tmpulongest);
1529 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 1539 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1530 tdep->size_TASK_COMM_LEN)) 1540 » » » » » tdep->size_TASK_COMM_LEN))
1531 return -1; 1541 return -1;
1532 break; 1542 break;
1533 } 1543 }
1534 break; 1544 break;
1535 1545
1536 case gdb_sys_rt_sigreturn: 1546 case gdb_sys_rt_sigreturn:
1537 break; 1547 break;
1538 1548
1539 case gdb_sys_rt_sigaction: 1549 case gdb_sys_rt_sigaction:
1540 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest); 1550 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1541 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 1551 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1542 tdep->size_sigaction)) 1552 » » » » » tdep->size_sigaction))
1543 return -1; 1553 return -1;
1544 break; 1554 break;
1545 1555
1546 case gdb_sys_rt_sigprocmask: 1556 case gdb_sys_rt_sigprocmask:
1547 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest); 1557 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1548 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 1558 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1549 tdep->size_sigset_t)) 1559 » » » » » tdep->size_sigset_t))
1550 return -1; 1560 return -1;
1551 break; 1561 break;
1552 1562
1553 case gdb_sys_rt_sigpending: 1563 case gdb_sys_rt_sigpending:
1554 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest); 1564 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1555 if (tmpulongest) 1565 if (tmpulongest)
1556 { 1566 {
1557 ULONGEST sigsetsize; 1567 ULONGEST sigsetsize;
1558 1568
1559 regcache_raw_read_unsigned (regcache, tdep->arg2,&sigsetsize); 1569 regcache_raw_read_unsigned (regcache, tdep->arg2,&sigsetsize);
1560 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 1570 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1561 (int) sigsetsize)) 1571 » » » » » (int) sigsetsize))
1562 return -1; 1572 return -1;
1563 } 1573 }
1564 break; 1574 break;
1565 1575
1566 case gdb_sys_rt_sigtimedwait: 1576 case gdb_sys_rt_sigtimedwait:
1567 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest); 1577 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1568 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 1578 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1569 tdep->size_siginfo_t)) 1579 » » » » » tdep->size_siginfo_t))
1570 return -1; 1580 return -1;
1571 break; 1581 break;
1572 1582
1573 case gdb_sys_rt_sigqueueinfo: 1583 case gdb_sys_rt_sigqueueinfo:
1574 case gdb_sys_rt_sigsuspend: 1584 case gdb_sys_rt_sigsuspend:
1575 break; 1585 break;
1576 1586
1577 case gdb_sys_pread64: 1587 case gdb_sys_pread64:
1578 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest); 1588 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1579 if (tmpulongest) 1589 if (tmpulongest)
1580 { 1590 {
1581 ULONGEST count; 1591 ULONGEST count;
1582 1592
1583 regcache_raw_read_unsigned (regcache, tdep->arg3,&count); 1593 regcache_raw_read_unsigned (regcache, tdep->arg3,&count);
1584 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, (int) count)) 1594 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1595 » » » » » (int) count))
1585 return -1; 1596 return -1;
1586 } 1597 }
1587 break; 1598 break;
1588 1599
1589 case gdb_sys_pwrite64: 1600 case gdb_sys_pwrite64:
1590 case gdb_sys_chown16: 1601 case gdb_sys_chown16:
1591 break; 1602 break;
1592 1603
1593 case gdb_sys_getcwd: 1604 case gdb_sys_getcwd:
1594 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest); 1605 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1595 if (tmpulongest) 1606 if (tmpulongest)
1596 { 1607 {
1597 ULONGEST size; 1608 ULONGEST size;
1598 1609
1599 regcache_raw_read_unsigned (regcache, tdep->arg2, &size); 1610 regcache_raw_read_unsigned (regcache, tdep->arg2, &size);
1600 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, (int) size)) 1611 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1612 » » » » » (int) size))
1601 return -1; 1613 return -1;
1602 } 1614 }
1603 break; 1615 break;
1604 1616
1605 case gdb_sys_capget: 1617 case gdb_sys_capget:
1606 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest); 1618 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1607 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 1619 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1608 tdep->size_cap_user_data_t)) 1620 » » » » » tdep->size_cap_user_data_t))
1609 return -1; 1621 return -1;
1610 break; 1622 break;
1611 1623
1612 case gdb_sys_capset: 1624 case gdb_sys_capset:
1613 break; 1625 break;
1614 1626
1615 case gdb_sys_sigaltstack: 1627 case gdb_sys_sigaltstack:
1616 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest); 1628 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1617 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 1629 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1618 tdep->size_stack_t)) 1630 » » » » » tdep->size_stack_t))
1619 return -1; 1631 return -1;
1620 break; 1632 break;
1621 1633
1622 case gdb_sys_sendfile: 1634 case gdb_sys_sendfile:
1623 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest); 1635 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1624 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 1636 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1625 tdep->size_off_t)) 1637 » » » » » tdep->size_off_t))
1626 return -1; 1638 return -1;
1627 break; 1639 break;
1628 1640
1629 case gdb_sys_ni_syscall188: 1641 case gdb_sys_ni_syscall188:
1630 case gdb_sys_ni_syscall189: 1642 case gdb_sys_ni_syscall189:
1631 case gdb_sys_vfork: 1643 case gdb_sys_vfork:
1632 break; 1644 break;
1633 1645
1634 case gdb_sys_getrlimit: 1646 case gdb_sys_getrlimit:
1635 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest); 1647 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1636 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 1648 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1637 tdep->size_rlimit)) 1649 » » » » » tdep->size_rlimit))
1638 return -1; 1650 return -1;
1639 break; 1651 break;
1640 1652
1641 case gdb_sys_mmap2: 1653 case gdb_sys_mmap2:
1642 break; 1654 break;
1643 1655
1644 case gdb_sys_truncate64: 1656 case gdb_sys_truncate64:
1645 case gdb_sys_ftruncate64: 1657 case gdb_sys_ftruncate64:
1646 break; 1658 break;
1647 1659
1648 case gdb_sys_stat64: 1660 case gdb_sys_stat64:
1649 case gdb_sys_lstat64: 1661 case gdb_sys_lstat64:
1650 case gdb_sys_fstat64: 1662 case gdb_sys_fstat64:
1651 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest); 1663 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1652 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 1664 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1653 tdep->size_stat64)) 1665 » » » » » tdep->size_stat64))
1654 return -1; 1666 return -1;
1655 break; 1667 break;
1656 1668
1657 case gdb_sys_lchown: 1669 case gdb_sys_lchown:
1658 case gdb_sys_getuid: 1670 case gdb_sys_getuid:
1659 case gdb_sys_getgid: 1671 case gdb_sys_getgid:
1660 case gdb_sys_geteuid: 1672 case gdb_sys_geteuid:
1661 case gdb_sys_getegid: 1673 case gdb_sys_getegid:
1662 case gdb_sys_setreuid: 1674 case gdb_sys_setreuid:
1663 case gdb_sys_setregid: 1675 case gdb_sys_setregid:
1664 break; 1676 break;
1665 1677
1666 case gdb_sys_getgroups: 1678 case gdb_sys_getgroups:
1667 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest); 1679 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1668 if (tmpulongest) 1680 if (tmpulongest)
1669 { 1681 {
1670 ULONGEST gidsetsize; 1682 ULONGEST gidsetsize;
1671 1683
1672 regcache_raw_read_unsigned (regcache, tdep->arg1, 1684 regcache_raw_read_unsigned (regcache, tdep->arg1,
1673 &gidsetsize); 1685 &gidsetsize);
1674 tmpint = tdep->size_gid_t * (int) gidsetsize; 1686 tmpint = tdep->size_gid_t * (int) gidsetsize;
1675 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tmpint)) 1687 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest, tmpint))
1676 return -1; 1688 return -1;
1677 } 1689 }
1678 break; 1690 break;
1679 1691
1680 case gdb_sys_setgroups: 1692 case gdb_sys_setgroups:
1681 case gdb_sys_fchown: 1693 case gdb_sys_fchown:
1682 case gdb_sys_setresuid: 1694 case gdb_sys_setresuid:
1683 break; 1695 break;
1684 1696
1685 case gdb_sys_getresuid: 1697 case gdb_sys_getresuid:
1686 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest); 1698 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1687 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_uid_t)) 1699 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1700 » » » » » tdep->size_uid_t))
1688 return -1; 1701 return -1;
1689 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest); 1702 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1690 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_uid_t)) 1703 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1704 » » » » » tdep->size_uid_t))
1691 return -1; 1705 return -1;
1692 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest); 1706 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1693 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_uid_t)) 1707 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1708 » » » » » tdep->size_uid_t))
1694 return -1; 1709 return -1;
1695 break; 1710 break;
1696 1711
1697 case gdb_sys_setresgid: 1712 case gdb_sys_setresgid:
1698 break; 1713 break;
1699 1714
1700 case gdb_sys_getresgid: 1715 case gdb_sys_getresgid:
1701 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest); 1716 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1702 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_gid_t)) 1717 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1718 » » » » » tdep->size_gid_t))
1703 return -1; 1719 return -1;
1704 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest); 1720 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1705 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_gid_t)) 1721 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1722 » » » » » tdep->size_gid_t))
1706 return -1; 1723 return -1;
1707 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest); 1724 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1708 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_gid_t)) 1725 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1726 » » » » » tdep->size_gid_t))
1709 return -1; 1727 return -1;
1710 break; 1728 break;
1711 1729
1712 case gdb_sys_chown: 1730 case gdb_sys_chown:
1713 case gdb_sys_setuid: 1731 case gdb_sys_setuid:
1714 case gdb_sys_setgid: 1732 case gdb_sys_setgid:
1715 case gdb_sys_setfsuid: 1733 case gdb_sys_setfsuid:
1716 case gdb_sys_setfsgid: 1734 case gdb_sys_setfsgid:
1717 case gdb_sys_pivot_root: 1735 case gdb_sys_pivot_root:
1718 break; 1736 break;
1719 1737
1720 case gdb_sys_mincore: 1738 case gdb_sys_mincore:
1721 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest); 1739 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1722 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 1740 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1723 tdep->size_PAGE_SIZE)) 1741 » » » » » tdep->size_PAGE_SIZE))
1724 return -1; 1742 return -1;
1725 break; 1743 break;
1726 1744
1727 case gdb_sys_madvise: 1745 case gdb_sys_madvise:
1728 break; 1746 break;
1729 1747
1730 case gdb_sys_getdents64: 1748 case gdb_sys_getdents64:
1731 { 1749 {
1732 ULONGEST count; 1750 ULONGEST count;
1733 1751
1734 regcache_raw_read_unsigned (regcache, tdep->arg2, 1752 regcache_raw_read_unsigned (regcache, tdep->arg2,
1735 &tmpulongest); 1753 &tmpulongest);
1736 regcache_raw_read_unsigned (regcache, tdep->arg3, &count); 1754 regcache_raw_read_unsigned (regcache, tdep->arg3, &count);
1737 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 1755 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1738 tdep->size_dirent64 * count)) 1756 » » » » » tdep->size_dirent64 * count))
1739 return -1; 1757 return -1;
1740 } 1758 }
1741 break; 1759 break;
1742 1760
1743 case gdb_sys_fcntl64: 1761 case gdb_sys_fcntl64:
1744 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest); 1762 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1745 if (tmpulongest == tdep->fcntl_F_GETLK64) 1763 if (tmpulongest == tdep->fcntl_F_GETLK64)
1746 { 1764 {
1747 regcache_raw_read_unsigned (regcache, tdep->arg3, 1765 regcache_raw_read_unsigned (regcache, tdep->arg3,
1748 &tmpulongest); 1766 &tmpulongest);
1749 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 1767 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1750 tdep->size_flock64)) 1768 » » » » » tdep->size_flock64))
1751 return -1; 1769 return -1;
1752 } 1770 }
1753 else if (tmpulongest != tdep->fcntl_F_SETLK64 1771 else if (tmpulongest != tdep->fcntl_F_SETLK64
1754 && tmpulongest != tdep->fcntl_F_SETLKW64) 1772 && tmpulongest != tdep->fcntl_F_SETLKW64)
1755 { 1773 {
1756 goto sys_fcntl; 1774 goto sys_fcntl;
1757 } 1775 }
1758 break; 1776 break;
1759 1777
1760 case gdb_sys_ni_syscall222: 1778 case gdb_sys_ni_syscall222:
1761 case gdb_sys_ni_syscall223: 1779 case gdb_sys_ni_syscall223:
1762 case gdb_sys_gettid: 1780 case gdb_sys_gettid:
1763 case gdb_sys_readahead: 1781 case gdb_sys_readahead:
1764 case gdb_sys_setxattr: 1782 case gdb_sys_setxattr:
1765 case gdb_sys_lsetxattr: 1783 case gdb_sys_lsetxattr:
1766 case gdb_sys_fsetxattr: 1784 case gdb_sys_fsetxattr:
1767 break; 1785 break;
1768 1786
1769 case gdb_sys_getxattr: 1787 case gdb_sys_getxattr:
1770 case gdb_sys_lgetxattr: 1788 case gdb_sys_lgetxattr:
1771 case gdb_sys_fgetxattr: 1789 case gdb_sys_fgetxattr:
1772 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest); 1790 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1773 if (tmpulongest) 1791 if (tmpulongest)
1774 { 1792 {
1775 ULONGEST size; 1793 ULONGEST size;
1776 1794
1777 regcache_raw_read_unsigned (regcache, tdep->arg4, &size); 1795 regcache_raw_read_unsigned (regcache, tdep->arg4, &size);
1778 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, (int) size)) 1796 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1797 » » » » » (int) size))
1779 return -1; 1798 return -1;
1780 } 1799 }
1781 break; 1800 break;
1782 1801
1783 case gdb_sys_listxattr: 1802 case gdb_sys_listxattr:
1784 case gdb_sys_llistxattr: 1803 case gdb_sys_llistxattr:
1785 case gdb_sys_flistxattr: 1804 case gdb_sys_flistxattr:
1786 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest); 1805 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1787 if (tmpulongest) 1806 if (tmpulongest)
1788 { 1807 {
1789 ULONGEST size; 1808 ULONGEST size;
1790 1809
1791 regcache_raw_read_unsigned (regcache, tdep->arg3, &size); 1810 regcache_raw_read_unsigned (regcache, tdep->arg3, &size);
1792 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, (int) size)) 1811 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1812 » » » » » (int) size))
1793 return -1; 1813 return -1;
1794 } 1814 }
1795 break; 1815 break;
1796 1816
1797 case gdb_sys_removexattr: 1817 case gdb_sys_removexattr:
1798 case gdb_sys_lremovexattr: 1818 case gdb_sys_lremovexattr:
1799 case gdb_sys_fremovexattr: 1819 case gdb_sys_fremovexattr:
1800 case gdb_sys_tkill: 1820 case gdb_sys_tkill:
1801 break; 1821 break;
1802 1822
1803 case gdb_sys_sendfile64: 1823 case gdb_sys_sendfile64:
1804 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest); 1824 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1805 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 1825 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1806 tdep->size_loff_t)) 1826 » » » » » tdep->size_loff_t))
1807 return -1; 1827 return -1;
1808 break; 1828 break;
1809 1829
1810 case gdb_sys_futex: 1830 case gdb_sys_futex:
1811 case gdb_sys_sched_setaffinity: 1831 case gdb_sys_sched_setaffinity:
1812 break; 1832 break;
1813 1833
1814 case gdb_sys_sched_getaffinity: 1834 case gdb_sys_sched_getaffinity:
1815 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest); 1835 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1816 if (tmpulongest) 1836 if (tmpulongest)
1817 { 1837 {
1818 ULONGEST len; 1838 ULONGEST len;
1819 1839
1820 regcache_raw_read_unsigned (regcache, tdep->arg2, &len); 1840 regcache_raw_read_unsigned (regcache, tdep->arg2, &len);
1821 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, (int) len)) 1841 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1842 » » » » » (int) len))
1822 return -1; 1843 return -1;
1823 } 1844 }
1824 break; 1845 break;
1825 1846
1826 case gdb_sys_set_thread_area: 1847 case gdb_sys_set_thread_area:
1827 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest); 1848 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1828 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_int)) 1849 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1850 » » » » » tdep->size_int))
1829 return -1; 1851 return -1;
1830 break; 1852 break;
1831 1853
1832 case gdb_sys_get_thread_area: 1854 case gdb_sys_get_thread_area:
1833 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest); 1855 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
1834 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 1856 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1835 tdep->size_user_desc)) 1857 » » » » » tdep->size_user_desc))
1836 return -1; 1858 return -1;
1837 break; 1859 break;
1838 1860
1839 case gdb_sys_io_setup: 1861 case gdb_sys_io_setup:
1840 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest); 1862 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1841 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_long)) 1863 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1864 » » » » » tdep->size_long))
1842 return -1; 1865 return -1;
1843 break; 1866 break;
1844 1867
1845 case gdb_sys_io_destroy: 1868 case gdb_sys_io_destroy:
1846 break; 1869 break;
1847 1870
1848 case gdb_sys_io_getevents: 1871 case gdb_sys_io_getevents:
1849 regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest); 1872 regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
1850 if (tmpulongest) 1873 if (tmpulongest)
1851 { 1874 {
1852 ULONGEST nr; 1875 ULONGEST nr;
1853 1876
1854 regcache_raw_read_unsigned (regcache, tdep->arg3, &nr); 1877 regcache_raw_read_unsigned (regcache, tdep->arg3, &nr);
1855 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 1878 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1856 nr * tdep->size_io_event)) 1879 » » » » » nr * tdep->size_io_event))
1857 return -1; 1880 return -1;
1858 } 1881 }
1859 break; 1882 break;
1860 1883
1861 case gdb_sys_io_submit: 1884 case gdb_sys_io_submit:
1862 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest); 1885 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1863 if (tmpulongest) 1886 if (tmpulongest)
1864 { 1887 {
1865 ULONGEST nr, i; 1888 ULONGEST nr, i;
1866 gdb_byte *iocbp; 1889 gdb_byte *iocbp;
(...skipping 10 matching lines...) Expand all
1877 OUTPUT_REG (tmpulongest, tdep->arg2), 1900 OUTPUT_REG (tmpulongest, tdep->arg2),
1878 (int) (nr * tdep->size_pointer)); 1901 (int) (nr * tdep->size_pointer));
1879 return -1; 1902 return -1;
1880 } 1903 }
1881 for (i = 0; i < nr; i++) 1904 for (i = 0; i < nr; i++)
1882 { 1905 {
1883 tmpaddr 1906 tmpaddr
1884 = (CORE_ADDR) extract_unsigned_integer (iocbp, 1907 = (CORE_ADDR) extract_unsigned_integer (iocbp,
1885 tdep->size_pointer, 1908 tdep->size_pointer,
1886 byte_order); 1909 byte_order);
1887 if (record_arch_list_add_mem (tmpaddr, tdep->size_iocb)) 1910 if (record_full_arch_list_add_mem (tmpaddr, tdep->size_iocb))
1888 return -1; 1911 return -1;
1889 iocbp += tdep->size_pointer; 1912 iocbp += tdep->size_pointer;
1890 } 1913 }
1891 } 1914 }
1892 break; 1915 break;
1893 1916
1894 case gdb_sys_io_cancel: 1917 case gdb_sys_io_cancel:
1895 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest); 1918 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1896 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 1919 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1897 tdep->size_io_event)) 1920 » » » » » tdep->size_io_event))
1898 return -1; 1921 return -1;
1899 break; 1922 break;
1900 1923
1901 case gdb_sys_fadvise64: 1924 case gdb_sys_fadvise64:
1902 case gdb_sys_ni_syscall251: 1925 case gdb_sys_ni_syscall251:
1903 break; 1926 break;
1904 1927
1905 case gdb_sys_exit_group: 1928 case gdb_sys_exit_group:
1906 { 1929 {
1907 int q; 1930 int q;
1908 1931
1909 target_terminal_ours (); 1932 target_terminal_ours ();
1910 q = yquery (_("The next instruction is syscall exit_group. " 1933 q = yquery (_("The next instruction is syscall exit_group. "
1911 "It will make the program exit. " 1934 "It will make the program exit. "
1912 "Do you want to stop the program?")); 1935 "Do you want to stop the program?"));
1913 target_terminal_inferior (); 1936 target_terminal_inferior ();
1914 if (q) 1937 if (q)
1915 return 1; 1938 return 1;
1916 } 1939 }
1917 break; 1940 break;
1918 1941
1919 case gdb_sys_lookup_dcookie: 1942 case gdb_sys_lookup_dcookie:
1920 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest); 1943 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1921 if (tmpulongest) 1944 if (tmpulongest)
1922 { 1945 {
1923 ULONGEST len; 1946 ULONGEST len;
1924 1947
1925 regcache_raw_read_unsigned (regcache, tdep->arg3, &len); 1948 regcache_raw_read_unsigned (regcache, tdep->arg3, &len);
1926 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, (int) len)) 1949 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1950 » » » » » (int) len))
1927 return -1; 1951 return -1;
1928 } 1952 }
1929 break; 1953 break;
1930 1954
1931 case gdb_sys_epoll_create: 1955 case gdb_sys_epoll_create:
1932 case gdb_sys_epoll_ctl: 1956 case gdb_sys_epoll_ctl:
1933 break; 1957 break;
1934 1958
1935 case gdb_sys_epoll_wait: 1959 case gdb_sys_epoll_wait:
1936 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest); 1960 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1937 if (tmpulongest) 1961 if (tmpulongest)
1938 { 1962 {
1939 ULONGEST maxevents; 1963 ULONGEST maxevents;
1940 1964
1941 regcache_raw_read_unsigned (regcache, tdep->arg3, &maxevents); 1965 regcache_raw_read_unsigned (regcache, tdep->arg3, &maxevents);
1942 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 1966 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1943 maxevents * tdep->size_epoll_event)) 1967 » » » » » (maxevents
1968 » » » » » * tdep->size_epoll_event)))
1944 return -1; 1969 return -1;
1945 } 1970 }
1946 break; 1971 break;
1947 1972
1948 case gdb_sys_remap_file_pages: 1973 case gdb_sys_remap_file_pages:
1949 case gdb_sys_set_tid_address: 1974 case gdb_sys_set_tid_address:
1950 break; 1975 break;
1951 1976
1952 case gdb_sys_timer_create: 1977 case gdb_sys_timer_create:
1953 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest); 1978 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
1954 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_int)) 1979 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1980 » » » » » tdep->size_int))
1955 return -1; 1981 return -1;
1956 break; 1982 break;
1957 1983
1958 case gdb_sys_timer_settime: 1984 case gdb_sys_timer_settime:
1959 regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest); 1985 regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
1960 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 1986 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1961 tdep->size_itimerspec)) 1987 » » » » » tdep->size_itimerspec))
1962 return -1; 1988 return -1;
1963 break; 1989 break;
1964 1990
1965 case gdb_sys_timer_gettime: 1991 case gdb_sys_timer_gettime:
1966 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest); 1992 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1967 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 1993 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1968 tdep->size_itimerspec)) 1994 » » » » » tdep->size_itimerspec))
1969 return -1; 1995 return -1;
1970 break; 1996 break;
1971 1997
1972 case gdb_sys_timer_getoverrun: 1998 case gdb_sys_timer_getoverrun:
1973 case gdb_sys_timer_delete: 1999 case gdb_sys_timer_delete:
1974 case gdb_sys_clock_settime: 2000 case gdb_sys_clock_settime:
1975 break; 2001 break;
1976 2002
1977 case gdb_sys_clock_gettime: 2003 case gdb_sys_clock_gettime:
1978 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest); 2004 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1979 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 2005 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1980 tdep->size_timespec)) 2006 » » » » » tdep->size_timespec))
1981 return -1; 2007 return -1;
1982 break; 2008 break;
1983 2009
1984 case gdb_sys_clock_getres: 2010 case gdb_sys_clock_getres:
1985 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest); 2011 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
1986 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 2012 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1987 tdep->size_timespec)) 2013 » » » » » tdep->size_timespec))
1988 return -1; 2014 return -1;
1989 break; 2015 break;
1990 2016
1991 case gdb_sys_clock_nanosleep: 2017 case gdb_sys_clock_nanosleep:
1992 regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest); 2018 regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
1993 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 2019 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
1994 tdep->size_timespec)) 2020 » » » » » tdep->size_timespec))
1995 return -1; 2021 return -1;
1996 break; 2022 break;
1997 2023
1998 case gdb_sys_statfs64: 2024 case gdb_sys_statfs64:
1999 case gdb_sys_fstatfs64: 2025 case gdb_sys_fstatfs64:
2000 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest); 2026 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
2001 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 2027 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2002 tdep->size_statfs64)) 2028 » » » » » tdep->size_statfs64))
2003 return -1; 2029 return -1;
2004 break; 2030 break;
2005 2031
2006 case gdb_sys_tgkill: 2032 case gdb_sys_tgkill:
2007 case gdb_sys_utimes: 2033 case gdb_sys_utimes:
2008 case gdb_sys_fadvise64_64: 2034 case gdb_sys_fadvise64_64:
2009 case gdb_sys_ni_syscall273: 2035 case gdb_sys_ni_syscall273:
2010 case gdb_sys_mbind: 2036 case gdb_sys_mbind:
2011 break; 2037 break;
2012 2038
2013 case gdb_sys_get_mempolicy: 2039 case gdb_sys_get_mempolicy:
2014 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest); 2040 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
2015 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_int)) 2041 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2042 » » » » » tdep->size_int))
2016 return -1; 2043 return -1;
2017 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest); 2044 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
2018 if (tmpulongest) 2045 if (tmpulongest)
2019 { 2046 {
2020 ULONGEST maxnode; 2047 ULONGEST maxnode;
2021 2048
2022 regcache_raw_read_unsigned (regcache, tdep->arg3, &maxnode); 2049 regcache_raw_read_unsigned (regcache, tdep->arg3, &maxnode);
2023 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 2050 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2024 maxnode * tdep->size_long)) 2051 » » » » » maxnode * tdep->size_long))
2025 return -1; 2052 return -1;
2026 } 2053 }
2027 break; 2054 break;
2028 2055
2029 case gdb_sys_set_mempolicy: 2056 case gdb_sys_set_mempolicy:
2030 case gdb_sys_mq_open: 2057 case gdb_sys_mq_open:
2031 case gdb_sys_mq_unlink: 2058 case gdb_sys_mq_unlink:
2032 case gdb_sys_mq_timedsend: 2059 case gdb_sys_mq_timedsend:
2033 break; 2060 break;
2034 2061
2035 case gdb_sys_mq_timedreceive: 2062 case gdb_sys_mq_timedreceive:
2036 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest); 2063 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
2037 if (tmpulongest) 2064 if (tmpulongest)
2038 { 2065 {
2039 ULONGEST msg_len; 2066 ULONGEST msg_len;
2040 2067
2041 regcache_raw_read_unsigned (regcache, tdep->arg3, &msg_len); 2068 regcache_raw_read_unsigned (regcache, tdep->arg3, &msg_len);
2042 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 2069 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2043 (int) msg_len)) 2070 » » » » » (int) msg_len))
2044 return -1; 2071 return -1;
2045 } 2072 }
2046 regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest); 2073 regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
2047 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_int)) 2074 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2075 » » » » » tdep->size_int))
2048 return -1; 2076 return -1;
2049 break; 2077 break;
2050 2078
2051 case gdb_sys_mq_notify: 2079 case gdb_sys_mq_notify:
2052 break; 2080 break;
2053 2081
2054 case gdb_sys_mq_getsetattr: 2082 case gdb_sys_mq_getsetattr:
2055 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest); 2083 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
2056 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 2084 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2057 tdep->size_mq_attr)) 2085 » » » » » tdep->size_mq_attr))
2058 return -1; 2086 return -1;
2059 break; 2087 break;
2060 2088
2061 case gdb_sys_kexec_load: 2089 case gdb_sys_kexec_load:
2062 break; 2090 break;
2063 2091
2064 case gdb_sys_waitid: 2092 case gdb_sys_waitid:
2065 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest); 2093 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
2066 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 2094 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2067 tdep->size_siginfo)) 2095 » » » » » tdep->size_siginfo))
2068 return -1; 2096 return -1;
2069 regcache_raw_read_unsigned (regcache, tdep->arg5, &tmpulongest); 2097 regcache_raw_read_unsigned (regcache, tdep->arg5, &tmpulongest);
2070 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 2098 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2071 tdep->size_rusage)) 2099 » » » » » tdep->size_rusage))
2072 return -1; 2100 return -1;
2073 break; 2101 break;
2074 2102
2075 case gdb_sys_ni_syscall285: 2103 case gdb_sys_ni_syscall285:
2076 case gdb_sys_add_key: 2104 case gdb_sys_add_key:
2077 case gdb_sys_request_key: 2105 case gdb_sys_request_key:
2078 break; 2106 break;
2079 2107
2080 case gdb_sys_keyctl: 2108 case gdb_sys_keyctl:
2081 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest); 2109 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
2082 if (tmpulongest == 6 || tmpulongest == 11) 2110 if (tmpulongest == 6 || tmpulongest == 11)
2083 { 2111 {
2084 regcache_raw_read_unsigned (regcache, tdep->arg3, 2112 regcache_raw_read_unsigned (regcache, tdep->arg3,
2085 &tmpulongest); 2113 &tmpulongest);
2086 if (tmpulongest) 2114 if (tmpulongest)
2087 { 2115 {
2088 ULONGEST buflen; 2116 ULONGEST buflen;
2089 2117
2090 regcache_raw_read_unsigned (regcache, tdep->arg4, &buflen); 2118 regcache_raw_read_unsigned (regcache, tdep->arg4, &buflen);
2091 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 2119 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2092 (int) buflen)) 2120 » » » » » » (int) buflen))
2093 return -1; 2121 return -1;
2094 } 2122 }
2095 } 2123 }
2096 break; 2124 break;
2097 2125
2098 case gdb_sys_ioprio_set: 2126 case gdb_sys_ioprio_set:
2099 case gdb_sys_ioprio_get: 2127 case gdb_sys_ioprio_get:
2100 case gdb_sys_inotify_init: 2128 case gdb_sys_inotify_init:
2101 case gdb_sys_inotify_add_watch: 2129 case gdb_sys_inotify_add_watch:
2102 case gdb_sys_inotify_rm_watch: 2130 case gdb_sys_inotify_rm_watch:
2103 case gdb_sys_migrate_pages: 2131 case gdb_sys_migrate_pages:
2104 case gdb_sys_openat: 2132 case gdb_sys_openat:
2105 case gdb_sys_mkdirat: 2133 case gdb_sys_mkdirat:
2106 case gdb_sys_mknodat: 2134 case gdb_sys_mknodat:
2107 case gdb_sys_fchownat: 2135 case gdb_sys_fchownat:
2108 case gdb_sys_futimesat: 2136 case gdb_sys_futimesat:
2109 break; 2137 break;
2110 2138
2111 case gdb_sys_fstatat64: 2139 case gdb_sys_fstatat64:
2112 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest); 2140 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
2113 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 2141 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2114 tdep->size_stat64)) 2142 » » » » » tdep->size_stat64))
2115 return -1; 2143 return -1;
2116 break; 2144 break;
2117 2145
2118 case gdb_sys_unlinkat: 2146 case gdb_sys_unlinkat:
2119 case gdb_sys_renameat: 2147 case gdb_sys_renameat:
2120 case gdb_sys_linkat: 2148 case gdb_sys_linkat:
2121 case gdb_sys_symlinkat: 2149 case gdb_sys_symlinkat:
2122 break; 2150 break;
2123 2151
2124 case gdb_sys_readlinkat: 2152 case gdb_sys_readlinkat:
2125 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest); 2153 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
2126 if (tmpulongest) 2154 if (tmpulongest)
2127 { 2155 {
2128 ULONGEST bufsiz; 2156 ULONGEST bufsiz;
2129 2157
2130 regcache_raw_read_unsigned (regcache, tdep->arg4, &bufsiz); 2158 regcache_raw_read_unsigned (regcache, tdep->arg4, &bufsiz);
2131 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, (int) bufsiz)) 2159 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2160 » » » » » (int) bufsiz))
2132 return -1; 2161 return -1;
2133 } 2162 }
2134 break; 2163 break;
2135 2164
2136 case gdb_sys_fchmodat: 2165 case gdb_sys_fchmodat:
2137 case gdb_sys_faccessat: 2166 case gdb_sys_faccessat:
2138 break; 2167 break;
2139 2168
2140 case gdb_sys_pselect6: 2169 case gdb_sys_pselect6:
2141 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest); 2170 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
2142 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 2171 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2143 tdep->size_fd_set)) 2172 » » » » » tdep->size_fd_set))
2144 return -1; 2173 return -1;
2145 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest); 2174 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
2146 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 2175 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2147 tdep->size_fd_set)) 2176 » » » » » tdep->size_fd_set))
2148 return -1; 2177 return -1;
2149 regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest); 2178 regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
2150 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 2179 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2151 tdep->size_fd_set)) 2180 » » » » » tdep->size_fd_set))
2152 return -1; 2181 return -1;
2153 regcache_raw_read_unsigned (regcache, tdep->arg5, &tmpulongest); 2182 regcache_raw_read_unsigned (regcache, tdep->arg5, &tmpulongest);
2154 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 2183 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2155 tdep->size_timespec)) 2184 » » » » » tdep->size_timespec))
2156 return -1; 2185 return -1;
2157 break; 2186 break;
2158 2187
2159 case gdb_sys_ppoll: 2188 case gdb_sys_ppoll:
2160 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest); 2189 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
2161 if (tmpulongest) 2190 if (tmpulongest)
2162 { 2191 {
2163 ULONGEST nfds; 2192 ULONGEST nfds;
2164 2193
2165 regcache_raw_read_unsigned (regcache, tdep->arg2, &nfds); 2194 regcache_raw_read_unsigned (regcache, tdep->arg2, &nfds);
2166 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 2195 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2167 tdep->size_pollfd * nfds)) 2196 » » » » » tdep->size_pollfd * nfds))
2168 return -1; 2197 return -1;
2169 } 2198 }
2170 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest); 2199 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
2171 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 2200 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2172 tdep->size_timespec)) 2201 » » » » » tdep->size_timespec))
2173 return -1; 2202 return -1;
2174 break; 2203 break;
2175 2204
2176 case gdb_sys_unshare: 2205 case gdb_sys_unshare:
2177 case gdb_sys_set_robust_list: 2206 case gdb_sys_set_robust_list:
2178 break; 2207 break;
2179 2208
2180 case gdb_sys_get_robust_list: 2209 case gdb_sys_get_robust_list:
2181 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest); 2210 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
2182 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_int)) 2211 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2212 » » » » » tdep->size_int))
2183 return -1; 2213 return -1;
2184 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest); 2214 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
2185 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_int)) 2215 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2216 » » » » » tdep->size_int))
2186 return -1; 2217 return -1;
2187 break; 2218 break;
2188 2219
2189 case gdb_sys_splice: 2220 case gdb_sys_splice:
2190 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest); 2221 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
2191 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 2222 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2192 tdep->size_loff_t)) 2223 » » » » » tdep->size_loff_t))
2193 return -1; 2224 return -1;
2194 regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest); 2225 regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
2195 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 2226 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2196 tdep->size_loff_t)) 2227 » » » » » tdep->size_loff_t))
2197 return -1; 2228 return -1;
2198 break; 2229 break;
2199 2230
2200 case gdb_sys_sync_file_range: 2231 case gdb_sys_sync_file_range:
2201 case gdb_sys_tee: 2232 case gdb_sys_tee:
2202 case gdb_sys_vmsplice: 2233 case gdb_sys_vmsplice:
2203 break; 2234 break;
2204 2235
2205 case gdb_sys_move_pages: 2236 case gdb_sys_move_pages:
2206 regcache_raw_read_unsigned (regcache, tdep->arg5, &tmpulongest); 2237 regcache_raw_read_unsigned (regcache, tdep->arg5, &tmpulongest);
2207 if (tmpulongest) 2238 if (tmpulongest)
2208 { 2239 {
2209 ULONGEST nr_pages; 2240 ULONGEST nr_pages;
2210 2241
2211 regcache_raw_read_unsigned (regcache, tdep->arg2, &nr_pages); 2242 regcache_raw_read_unsigned (regcache, tdep->arg2, &nr_pages);
2212 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 2243 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2213 nr_pages * tdep->size_int)) 2244 » » » » » nr_pages * tdep->size_int))
2214 return -1; 2245 return -1;
2215 } 2246 }
2216 break; 2247 break;
2217 2248
2218 case gdb_sys_getcpu: 2249 case gdb_sys_getcpu:
2219 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest); 2250 regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
2220 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_int)) 2251 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2252 » » » » » tdep->size_int))
2221 return -1; 2253 return -1;
2222 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest); 2254 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
2223 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_int)) 2255 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2256 » » » » » tdep->size_int))
2224 return -1; 2257 return -1;
2225 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest); 2258 regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
2226 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 2259 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
2227 tdep->size_ulong * 2)) 2260 » » » » » tdep->size_ulong * 2))
2228 return -1; 2261 return -1;
2229 break; 2262 break;
2230 2263
2231 case gdb_sys_epoll_pwait: 2264 case gdb_sys_epoll_pwait:
2232 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest); 2265 regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
2233 if (tmpulongest) 2266 if (tmpulongest)
2234 { 2267 {
2235 ULONGEST maxevents; 2268 ULONGEST maxevents;
2236 2269
2237 regcache_raw_read_unsigned (regcache, tdep->arg3, &maxevents); 2270 regcache_raw_read_unsigned (regcache, tdep->arg3, &maxevents);
2238 tmpint = (int) maxevents * tdep->size_epoll_event; 2271 tmpint = (int) maxevents * tdep->size_epoll_event;
2239 if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tmpint)) 2272 if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest, tmpint))
2240 return -1; 2273 return -1;
2241 } 2274 }
2242 break; 2275 break;
2243 2276
2244 default: 2277 default:
2245 printf_unfiltered (_("Process record and replay target doesn't " 2278 printf_unfiltered (_("Process record and replay target doesn't "
2246 "support syscall number %d\n"), syscall); 2279 "support syscall number %d\n"), syscall);
2247 return -1; 2280 return -1;
2248 break; 2281 break;
2249 } 2282 }
2250 2283
2251 return 0; 2284 return 0;
2252 } 2285 }
OLDNEW
« no previous file with comments | « gdb/linux-record.h ('k') | gdb/linux-tdep.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698