1 /* Low-level child interface to ptrace.
3 Copyright (C) 1988-2018 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
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/>. */
27 #include "nat/gdb_ptrace.h"
31 #include "inf-ptrace.h"
32 #include "inf-child.h"
33 #include "gdbthread.h"
34 #include "nat/fork-inferior.h"
39 /* A unique_ptr helper to unpush a target. */
41 struct target_unpusher
43 void operator() (struct target_ops
*ops
) const
49 /* A unique_ptr that unpushes a target on destruction. */
51 typedef std::unique_ptr
<struct target_ops
, target_unpusher
> target_unpush_up
;
55 #ifdef PT_GET_PROCESS_STATE
57 /* Target hook for follow_fork. On entry and at return inferior_ptid is
58 the ptid of the followed inferior. */
61 inf_ptrace_follow_fork (struct target_ops
*ops
, int follow_child
,
66 struct thread_info
*tp
= inferior_thread ();
67 pid_t child_pid
= ptid_get_pid (tp
->pending_follow
.value
.related_pid
);
69 /* Breakpoints have already been detached from the child by
72 if (ptrace (PT_DETACH
, child_pid
, (PTRACE_TYPE_ARG3
)1, 0) == -1)
73 perror_with_name (("ptrace"));
80 inf_ptrace_insert_fork_catchpoint (struct target_ops
*self
, int pid
)
86 inf_ptrace_remove_fork_catchpoint (struct target_ops
*self
, int pid
)
91 #endif /* PT_GET_PROCESS_STATE */
94 /* Prepare to be traced. */
99 /* "Trace me, Dr. Memory!" */
100 if (ptrace (PT_TRACE_ME
, 0, (PTRACE_TYPE_ARG3
) 0, 0) < 0)
101 trace_start_error_with_name ("ptrace");
104 /* Start a new inferior Unix child process. EXEC_FILE is the file to
105 run, ALLARGS is a string containing the arguments to the program.
106 ENV is the environment vector to pass. If FROM_TTY is non-zero, be
110 inf_ptrace_create_inferior (struct target_ops
*ops
,
111 const char *exec_file
, const std::string
&allargs
,
112 char **env
, int from_tty
)
117 /* Do not change either targets above or the same target if already present.
118 The reason is the target stack is shared across multiple inferiors. */
119 int ops_already_pushed
= target_is_pushed (ops
);
121 target_unpush_up unpusher
;
122 if (! ops_already_pushed
)
124 /* Clear possible core file with its process_stratum. */
126 unpusher
.reset (ops
);
129 pid
= fork_inferior (exec_file
, allargs
, env
, inf_ptrace_me
, NULL
,
132 ptid
= pid_to_ptid (pid
);
133 /* We have something that executes now. We'll be running through
134 the shell at this point (if startup-with-shell is true), but the
135 pid shouldn't change. */
136 add_thread_silent (ptid
);
140 gdb_startup_inferior (pid
, START_INFERIOR_TRAPS_EXPECTED
);
142 /* On some targets, there must be some explicit actions taken after
143 the inferior has been started up. */
144 target_post_startup_inferior (ptid
);
147 #ifdef PT_GET_PROCESS_STATE
150 inf_ptrace_post_startup_inferior (struct target_ops
*self
, ptid_t pid
)
154 /* Set the initial event mask. */
155 memset (&pe
, 0, sizeof pe
);
156 pe
.pe_set_event
|= PTRACE_FORK
;
157 if (ptrace (PT_SET_EVENT_MASK
, ptid_get_pid (pid
),
158 (PTRACE_TYPE_ARG3
)&pe
, sizeof pe
) == -1)
159 perror_with_name (("ptrace"));
164 /* Clean up a rotting corpse of an inferior after it died. */
167 inf_ptrace_mourn_inferior (struct target_ops
*ops
)
171 /* Wait just one more time to collect the inferior's exit status.
172 Do not check whether this succeeds though, since we may be
173 dealing with a process that we attached to. Such a process will
174 only report its exit status to its original parent. */
175 waitpid (ptid_get_pid (inferior_ptid
), &status
, 0);
177 inf_child_mourn_inferior (ops
);
180 /* Attach to the process specified by ARGS. If FROM_TTY is non-zero,
181 be chatty about it. */
184 inf_ptrace_attach (struct target_ops
*ops
, const char *args
, int from_tty
)
188 struct inferior
*inf
;
190 /* Do not change either targets above or the same target if already present.
191 The reason is the target stack is shared across multiple inferiors. */
192 int ops_already_pushed
= target_is_pushed (ops
);
194 pid
= parse_pid_to_attach (args
);
196 if (pid
== getpid ()) /* Trying to masturbate? */
197 error (_("I refuse to debug myself!"));
199 target_unpush_up unpusher
;
200 if (! ops_already_pushed
)
202 /* target_pid_to_str already uses the target. Also clear possible core
203 file with its process_stratum. */
205 unpusher
.reset (ops
);
210 exec_file
= get_exec_file (0);
213 printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file
,
214 target_pid_to_str (pid_to_ptid (pid
)));
216 printf_unfiltered (_("Attaching to %s\n"),
217 target_pid_to_str (pid_to_ptid (pid
)));
219 gdb_flush (gdb_stdout
);
224 ptrace (PT_ATTACH
, pid
, (PTRACE_TYPE_ARG3
)0, 0);
226 perror_with_name (("ptrace"));
228 error (_("This system does not support attaching to a process"));
231 inf
= current_inferior ();
232 inferior_appeared (inf
, pid
);
233 inf
->attach_flag
= 1;
234 inferior_ptid
= pid_to_ptid (pid
);
236 /* Always add a main thread. If some target extends the ptrace
237 target, it should decorate the ptid later with more info. */
238 add_thread_silent (inferior_ptid
);
243 #ifdef PT_GET_PROCESS_STATE
246 inf_ptrace_post_attach (struct target_ops
*self
, int pid
)
250 /* Set the initial event mask. */
251 memset (&pe
, 0, sizeof pe
);
252 pe
.pe_set_event
|= PTRACE_FORK
;
253 if (ptrace (PT_SET_EVENT_MASK
, pid
,
254 (PTRACE_TYPE_ARG3
)&pe
, sizeof pe
) == -1)
255 perror_with_name (("ptrace"));
260 /* Detach from the inferior. If FROM_TTY is non-zero, be chatty about it. */
263 inf_ptrace_detach (struct target_ops
*ops
, inferior
*inf
, int from_tty
)
265 pid_t pid
= ptid_get_pid (inferior_ptid
);
267 target_announce_detach (from_tty
);
270 /* We'd better not have left any breakpoints in the program or it'll
271 die when it hits one. Also note that this may only work if we
272 previously attached to the inferior. It *might* work if we
273 started the process ourselves. */
275 ptrace (PT_DETACH
, pid
, (PTRACE_TYPE_ARG3
)1, 0);
277 perror_with_name (("ptrace"));
279 error (_("This system does not support detaching from a process"));
282 inf_ptrace_detach_success (ops
, inf
);
285 /* See inf-ptrace.h. */
288 inf_ptrace_detach_success (struct target_ops
*ops
, inferior
*inf
)
290 inferior_ptid
= null_ptid
;
291 detach_inferior (inf
);
293 inf_child_maybe_unpush_target (ops
);
296 /* Kill the inferior. */
299 inf_ptrace_kill (struct target_ops
*ops
)
301 pid_t pid
= ptid_get_pid (inferior_ptid
);
307 ptrace (PT_KILL
, pid
, (PTRACE_TYPE_ARG3
)0, 0);
308 waitpid (pid
, &status
, 0);
310 target_mourn_inferior (inferior_ptid
);
313 /* Return which PID to pass to ptrace in order to observe/control the
314 tracee identified by PTID. */
317 get_ptrace_pid (ptid_t ptid
)
321 /* If we have an LWPID to work with, use it. Otherwise, we're
322 dealing with a non-threaded program/target. */
323 pid
= ptid_get_lwp (ptid
);
325 pid
= ptid_get_pid (ptid
);
329 /* Resume execution of thread PTID, or all threads if PTID is -1. If
330 STEP is nonzero, single-step it. If SIGNAL is nonzero, give it
334 inf_ptrace_resume (struct target_ops
*ops
,
335 ptid_t ptid
, int step
, enum gdb_signal signal
)
340 if (ptid_equal (minus_one_ptid
, ptid
))
341 /* Resume all threads. Traditionally ptrace() only supports
342 single-threaded processes, so simply resume the inferior. */
343 pid
= ptid_get_pid (inferior_ptid
);
345 pid
= get_ptrace_pid (ptid
);
347 if (catch_syscall_enabled () > 0)
348 request
= PT_SYSCALL
;
350 request
= PT_CONTINUE
;
354 /* If this system does not support PT_STEP, a higher level
355 function will have called single_step() to transmute the step
356 request into a continue request (by setting breakpoints on
357 all possible successor instructions), so we don't have to
358 worry about that here. */
362 /* An address of (PTRACE_TYPE_ARG3)1 tells ptrace to continue from
363 where it was. If GDB wanted it to start some other way, we have
364 already written a new program counter value to the child. */
366 ptrace (request
, pid
, (PTRACE_TYPE_ARG3
)1, gdb_signal_to_host (signal
));
368 perror_with_name (("ptrace"));
371 /* Wait for the child specified by PTID to do something. Return the
372 process ID of the child, or MINUS_ONE_PTID in case of error; store
373 the status in *OURSTATUS. */
376 inf_ptrace_wait (struct target_ops
*ops
,
377 ptid_t ptid
, struct target_waitstatus
*ourstatus
, int options
)
380 int status
, save_errno
;
388 pid
= waitpid (ptid_get_pid (ptid
), &status
, 0);
391 while (pid
== -1 && errno
== EINTR
);
393 clear_sigint_trap ();
397 fprintf_unfiltered (gdb_stderr
,
398 _("Child process unexpectedly missing: %s.\n"),
399 safe_strerror (save_errno
));
401 /* Claim it exited with unknown signal. */
402 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
403 ourstatus
->value
.sig
= GDB_SIGNAL_UNKNOWN
;
404 return inferior_ptid
;
407 /* Ignore terminated detached child processes. */
408 if (!WIFSTOPPED (status
) && pid
!= ptid_get_pid (inferior_ptid
))
413 #ifdef PT_GET_PROCESS_STATE
414 if (WIFSTOPPED (status
))
419 if (ptrace (PT_GET_PROCESS_STATE
, pid
,
420 (PTRACE_TYPE_ARG3
)&pe
, sizeof pe
) == -1)
421 perror_with_name (("ptrace"));
423 switch (pe
.pe_report_event
)
426 ourstatus
->kind
= TARGET_WAITKIND_FORKED
;
427 ourstatus
->value
.related_pid
= pid_to_ptid (pe
.pe_other_pid
);
429 /* Make sure the other end of the fork is stopped too. */
430 fpid
= waitpid (pe
.pe_other_pid
, &status
, 0);
432 perror_with_name (("waitpid"));
434 if (ptrace (PT_GET_PROCESS_STATE
, fpid
,
435 (PTRACE_TYPE_ARG3
)&pe
, sizeof pe
) == -1)
436 perror_with_name (("ptrace"));
438 gdb_assert (pe
.pe_report_event
== PTRACE_FORK
);
439 gdb_assert (pe
.pe_other_pid
== pid
);
440 if (fpid
== ptid_get_pid (inferior_ptid
))
442 ourstatus
->value
.related_pid
= pid_to_ptid (pe
.pe_other_pid
);
443 return pid_to_ptid (fpid
);
446 return pid_to_ptid (pid
);
451 store_waitstatus (ourstatus
, status
);
452 return pid_to_ptid (pid
);
455 /* Transfer data via ptrace into process PID's memory from WRITEBUF, or
456 from process PID's memory into READBUF. Start at target address ADDR
457 and transfer up to LEN bytes. Exactly one of READBUF and WRITEBUF must
458 be non-null. Return the number of transferred bytes. */
461 inf_ptrace_peek_poke (pid_t pid
, gdb_byte
*readbuf
,
462 const gdb_byte
*writebuf
,
463 ULONGEST addr
, ULONGEST len
)
468 /* We transfer aligned words. Thus align ADDR down to a word
469 boundary and determine how many bytes to skip at the
471 ULONGEST skip
= addr
& (sizeof (PTRACE_TYPE_RET
) - 1);
476 n
+= chunk
, addr
+= sizeof (PTRACE_TYPE_RET
), skip
= 0)
478 /* Restrict to a chunk that fits in the current word. */
479 chunk
= std::min (sizeof (PTRACE_TYPE_RET
) - skip
, len
- n
);
481 /* Use a union for type punning. */
484 PTRACE_TYPE_RET word
;
485 gdb_byte byte
[sizeof (PTRACE_TYPE_RET
)];
488 /* Read the word, also when doing a partial word write. */
489 if (readbuf
!= NULL
|| chunk
< sizeof (PTRACE_TYPE_RET
))
492 buf
.word
= ptrace (PT_READ_I
, pid
,
493 (PTRACE_TYPE_ARG3
)(uintptr_t) addr
, 0);
497 memcpy (readbuf
+ n
, buf
.byte
+ skip
, chunk
);
499 if (writebuf
!= NULL
)
501 memcpy (buf
.byte
+ skip
, writebuf
+ n
, chunk
);
503 ptrace (PT_WRITE_D
, pid
, (PTRACE_TYPE_ARG3
)(uintptr_t) addr
,
507 /* Using the appropriate one (I or D) is necessary for
508 Gould NP1, at least. */
510 ptrace (PT_WRITE_I
, pid
, (PTRACE_TYPE_ARG3
)(uintptr_t) addr
,
521 /* Implement the to_xfer_partial target_ops method. */
523 static enum target_xfer_status
524 inf_ptrace_xfer_partial (struct target_ops
*ops
, enum target_object object
,
525 const char *annex
, gdb_byte
*readbuf
,
526 const gdb_byte
*writebuf
,
527 ULONGEST offset
, ULONGEST len
, ULONGEST
*xfered_len
)
529 pid_t pid
= get_ptrace_pid (inferior_ptid
);
533 case TARGET_OBJECT_MEMORY
:
535 /* OpenBSD 3.1, NetBSD 1.6 and FreeBSD 5.0 have a new PT_IO
536 request that promises to be much more efficient in reading
537 and writing data in the traced process's address space. */
539 struct ptrace_io_desc piod
;
541 /* NOTE: We assume that there are no distinct address spaces
542 for instruction and data. However, on OpenBSD 3.9 and
543 later, PIOD_WRITE_D doesn't allow changing memory that's
544 mapped read-only. Since most code segments will be
545 read-only, using PIOD_WRITE_D will prevent us from
546 inserting breakpoints, so we use PIOD_WRITE_I instead. */
547 piod
.piod_op
= writebuf
? PIOD_WRITE_I
: PIOD_READ_D
;
548 piod
.piod_addr
= writebuf
? (void *) writebuf
: readbuf
;
549 piod
.piod_offs
= (void *) (long) offset
;
553 if (ptrace (PT_IO
, pid
, (caddr_t
)&piod
, 0) == 0)
555 /* Return the actual number of bytes read or written. */
556 *xfered_len
= piod
.piod_len
;
557 return (piod
.piod_len
== 0) ? TARGET_XFER_EOF
: TARGET_XFER_OK
;
559 /* If the PT_IO request is somehow not supported, fallback on
560 using PT_WRITE_D/PT_READ_D. Otherwise we will return zero
561 to indicate failure. */
563 return TARGET_XFER_EOF
;
566 *xfered_len
= inf_ptrace_peek_poke (pid
, readbuf
, writebuf
,
568 return *xfered_len
!= 0 ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
570 case TARGET_OBJECT_UNWIND_TABLE
:
571 return TARGET_XFER_E_IO
;
573 case TARGET_OBJECT_AUXV
:
574 #if defined (PT_IO) && defined (PIOD_READ_AUXV)
575 /* OpenBSD 4.5 has a new PIOD_READ_AUXV operation for the PT_IO
576 request that allows us to read the auxilliary vector. Other
577 BSD's may follow if they feel the need to support PIE. */
579 struct ptrace_io_desc piod
;
582 return TARGET_XFER_E_IO
;
583 piod
.piod_op
= PIOD_READ_AUXV
;
584 piod
.piod_addr
= readbuf
;
585 piod
.piod_offs
= (void *) (long) offset
;
589 if (ptrace (PT_IO
, pid
, (caddr_t
)&piod
, 0) == 0)
591 /* Return the actual number of bytes read or written. */
592 *xfered_len
= piod
.piod_len
;
593 return (piod
.piod_len
== 0) ? TARGET_XFER_EOF
: TARGET_XFER_OK
;
597 return TARGET_XFER_E_IO
;
599 case TARGET_OBJECT_WCOOKIE
:
600 return TARGET_XFER_E_IO
;
603 return TARGET_XFER_E_IO
;
607 /* Return non-zero if the thread specified by PTID is alive. */
610 inf_ptrace_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
612 /* ??? Is kill the right way to do this? */
613 return (kill (ptid_get_pid (ptid
), 0) != -1);
616 /* Print status information about what we're accessing. */
619 inf_ptrace_files_info (struct target_ops
*ignore
)
621 struct inferior
*inf
= current_inferior ();
623 printf_filtered (_("\tUsing the running image of %s %s.\n"),
624 inf
->attach_flag
? "attached" : "child",
625 target_pid_to_str (inferior_ptid
));
629 inf_ptrace_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
631 return normal_pid_to_str (ptid
);
634 #if defined (PT_IO) && defined (PIOD_READ_AUXV)
636 /* Read one auxv entry from *READPTR, not reading locations >= ENDPTR.
637 Return 0 if *READPTR is already at the end of the buffer.
638 Return -1 if there is insufficient buffer for a whole entry.
639 Return 1 if an entry was read into *TYPEP and *VALP. */
642 inf_ptrace_auxv_parse (struct target_ops
*ops
, gdb_byte
**readptr
,
643 gdb_byte
*endptr
, CORE_ADDR
*typep
, CORE_ADDR
*valp
)
645 struct type
*int_type
= builtin_type (target_gdbarch ())->builtin_int
;
646 struct type
*ptr_type
= builtin_type (target_gdbarch ())->builtin_data_ptr
;
647 const int sizeof_auxv_type
= TYPE_LENGTH (int_type
);
648 const int sizeof_auxv_val
= TYPE_LENGTH (ptr_type
);
649 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
650 gdb_byte
*ptr
= *readptr
;
655 if (endptr
- ptr
< 2 * sizeof_auxv_val
)
658 *typep
= extract_unsigned_integer (ptr
, sizeof_auxv_type
, byte_order
);
659 ptr
+= sizeof_auxv_val
; /* Alignment. */
660 *valp
= extract_unsigned_integer (ptr
, sizeof_auxv_val
, byte_order
);
661 ptr
+= sizeof_auxv_val
;
669 /* Create a prototype ptrace target. The client can override it with
673 inf_ptrace_target (void)
675 struct target_ops
*t
= inf_child_target ();
677 t
->to_attach
= inf_ptrace_attach
;
678 t
->to_detach
= inf_ptrace_detach
;
679 t
->to_resume
= inf_ptrace_resume
;
680 t
->to_wait
= inf_ptrace_wait
;
681 t
->to_files_info
= inf_ptrace_files_info
;
682 t
->to_kill
= inf_ptrace_kill
;
683 t
->to_create_inferior
= inf_ptrace_create_inferior
;
684 #ifdef PT_GET_PROCESS_STATE
685 t
->to_follow_fork
= inf_ptrace_follow_fork
;
686 t
->to_insert_fork_catchpoint
= inf_ptrace_insert_fork_catchpoint
;
687 t
->to_remove_fork_catchpoint
= inf_ptrace_remove_fork_catchpoint
;
688 t
->to_post_startup_inferior
= inf_ptrace_post_startup_inferior
;
689 t
->to_post_attach
= inf_ptrace_post_attach
;
691 t
->to_mourn_inferior
= inf_ptrace_mourn_inferior
;
692 t
->to_thread_alive
= inf_ptrace_thread_alive
;
693 t
->to_pid_to_str
= inf_ptrace_pid_to_str
;
694 t
->to_xfer_partial
= inf_ptrace_xfer_partial
;
695 #if defined (PT_IO) && defined (PIOD_READ_AUXV)
696 t
->to_auxv_parse
= inf_ptrace_auxv_parse
;
703 /* Pointer to a function that returns the offset within the user area
704 where a particular register is stored. */
705 static CORE_ADDR (*inf_ptrace_register_u_offset
)(struct gdbarch
*, int, int);
707 /* Fetch register REGNUM from the inferior. */
710 inf_ptrace_fetch_register (struct regcache
*regcache
, int regnum
)
712 struct gdbarch
*gdbarch
= regcache
->arch ();
715 PTRACE_TYPE_RET
*buf
;
719 /* This isn't really an address, but ptrace thinks of it as one. */
720 addr
= inf_ptrace_register_u_offset (gdbarch
, regnum
, 0);
721 if (addr
== (CORE_ADDR
)-1
722 || gdbarch_cannot_fetch_register (gdbarch
, regnum
))
724 regcache_raw_supply (regcache
, regnum
, NULL
);
728 pid
= get_ptrace_pid (regcache_get_ptid (regcache
));
730 size
= register_size (gdbarch
, regnum
);
731 gdb_assert ((size
% sizeof (PTRACE_TYPE_RET
)) == 0);
732 buf
= (PTRACE_TYPE_RET
*) alloca (size
);
734 /* Read the register contents from the inferior a chunk at a time. */
735 for (i
= 0; i
< size
/ sizeof (PTRACE_TYPE_RET
); i
++)
738 buf
[i
] = ptrace (PT_READ_U
, pid
, (PTRACE_TYPE_ARG3
)(uintptr_t)addr
, 0);
740 error (_("Couldn't read register %s (#%d): %s."),
741 gdbarch_register_name (gdbarch
, regnum
),
742 regnum
, safe_strerror (errno
));
744 addr
+= sizeof (PTRACE_TYPE_RET
);
746 regcache_raw_supply (regcache
, regnum
, buf
);
749 /* Fetch register REGNUM from the inferior. If REGNUM is -1, do this
750 for all registers. */
753 inf_ptrace_fetch_registers (struct target_ops
*ops
,
754 struct regcache
*regcache
, int regnum
)
758 regnum
< gdbarch_num_regs (regcache
->arch ());
760 inf_ptrace_fetch_register (regcache
, regnum
);
762 inf_ptrace_fetch_register (regcache
, regnum
);
765 /* Store register REGNUM into the inferior. */
768 inf_ptrace_store_register (const struct regcache
*regcache
, int regnum
)
770 struct gdbarch
*gdbarch
= regcache
->arch ();
773 PTRACE_TYPE_RET
*buf
;
777 /* This isn't really an address, but ptrace thinks of it as one. */
778 addr
= inf_ptrace_register_u_offset (gdbarch
, regnum
, 1);
779 if (addr
== (CORE_ADDR
)-1
780 || gdbarch_cannot_store_register (gdbarch
, regnum
))
783 pid
= get_ptrace_pid (regcache_get_ptid (regcache
));
785 size
= register_size (gdbarch
, regnum
);
786 gdb_assert ((size
% sizeof (PTRACE_TYPE_RET
)) == 0);
787 buf
= (PTRACE_TYPE_RET
*) alloca (size
);
789 /* Write the register contents into the inferior a chunk at a time. */
790 regcache_raw_collect (regcache
, regnum
, buf
);
791 for (i
= 0; i
< size
/ sizeof (PTRACE_TYPE_RET
); i
++)
794 ptrace (PT_WRITE_U
, pid
, (PTRACE_TYPE_ARG3
)(uintptr_t)addr
, buf
[i
]);
796 error (_("Couldn't write register %s (#%d): %s."),
797 gdbarch_register_name (gdbarch
, regnum
),
798 regnum
, safe_strerror (errno
));
800 addr
+= sizeof (PTRACE_TYPE_RET
);
804 /* Store register REGNUM back into the inferior. If REGNUM is -1, do
805 this for all registers. */
808 inf_ptrace_store_registers (struct target_ops
*ops
,
809 struct regcache
*regcache
, int regnum
)
813 regnum
< gdbarch_num_regs (regcache
->arch ());
815 inf_ptrace_store_register (regcache
, regnum
);
817 inf_ptrace_store_register (regcache
, regnum
);
820 /* Create a "traditional" ptrace target. REGISTER_U_OFFSET should be
821 a function returning the offset within the user area where a
822 particular register is stored. */
825 inf_ptrace_trad_target (CORE_ADDR (*register_u_offset
)
826 (struct gdbarch
*, int, int))
828 struct target_ops
*t
= inf_ptrace_target();
830 gdb_assert (register_u_offset
);
831 inf_ptrace_register_u_offset
= register_u_offset
;
832 t
->to_fetch_registers
= inf_ptrace_fetch_registers
;
833 t
->to_store_registers
= inf_ptrace_store_registers
;