static LONGEST default_xfer_partial (struct target_ops *ops,
enum target_object object,
- const char *annex, void *readbuf,
- const void *writebuf,
+ const char *annex, gdb_byte *readbuf,
+ const gdb_byte *writebuf,
ULONGEST offset, LONGEST len);
/* Transfer LEN bytes between target address MEMADDR and GDB address
partial transfers, try either target_read_memory_partial or
target_write_memory_partial). */
-static int target_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len,
+static int target_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len,
int write);
static void init_dummy_target (void);
static void debug_to_prepare_to_store (void);
-static int deprecated_debug_xfer_memory (CORE_ADDR, char *, int, int,
- struct mem_attrib *,
- struct target_ops *);
-
static void debug_to_files_info (struct target_ops *);
-static int debug_to_insert_breakpoint (CORE_ADDR, bfd_byte *);
+static int debug_to_insert_breakpoint (CORE_ADDR, gdb_byte *);
-static int debug_to_remove_breakpoint (CORE_ADDR, bfd_byte *);
+static int debug_to_remove_breakpoint (CORE_ADDR, gdb_byte *);
static int debug_to_can_use_hw_breakpoint (int, int, int);
-static int debug_to_insert_hw_breakpoint (CORE_ADDR, char *);
+static int debug_to_insert_hw_breakpoint (CORE_ADDR, gdb_byte *);
-static int debug_to_remove_hw_breakpoint (CORE_ADDR, char *);
+static int debug_to_remove_hw_breakpoint (CORE_ADDR, gdb_byte *);
static int debug_to_insert_watchpoint (CORE_ADDR, int, int);
INHERIT (to_remove_fork_catchpoint, t);
INHERIT (to_insert_vfork_catchpoint, t);
INHERIT (to_remove_vfork_catchpoint, t);
- INHERIT (to_follow_fork, t);
+ /* Do not inherit to_follow_fork. */
INHERIT (to_insert_exec_catchpoint, t);
INHERIT (to_remove_exec_catchpoint, t);
INHERIT (to_reported_exec_events_per_exec_call, t);
(void (*) (void))
noprocess);
de_fault (deprecated_xfer_memory,
- (int (*) (CORE_ADDR, char *, int, int, struct mem_attrib *, struct target_ops *))
+ (int (*) (CORE_ADDR, gdb_byte *, int, int, struct mem_attrib *, struct target_ops *))
nomemory);
de_fault (to_files_info,
(void (*) (struct target_ops *))
(int (*) (int, int, int))
return_zero);
de_fault (to_insert_hw_breakpoint,
- (int (*) (CORE_ADDR, char *))
+ (int (*) (CORE_ADDR, gdb_byte *))
return_minus_one);
de_fault (to_remove_hw_breakpoint,
- (int (*) (CORE_ADDR, char *))
+ (int (*) (CORE_ADDR, gdb_byte *))
return_minus_one);
de_fault (to_insert_watchpoint,
(int (*) (CORE_ADDR, int, int))
de_fault (to_remove_vfork_catchpoint,
(int (*) (int))
tcomplain);
- de_fault (to_follow_fork,
- (int (*) (int))
- target_ignore);
de_fault (to_insert_exec_catchpoint,
(void (*) (int))
tcomplain);
target_read_string (CORE_ADDR memaddr, char **string, int len, int *errnop)
{
int tlen, origlen, offset, i;
- char buf[4];
+ gdb_byte buf[4];
int errcode = 0;
char *buffer;
int buffer_allocated;
tlen = MIN (len, 4 - (memaddr & 3));
offset = memaddr & 3;
- errcode = target_read_memory (memaddr & ~3, buf, 4);
+ errcode = target_read_memory (memaddr & ~3, buf, sizeof buf);
if (errcode != 0)
{
/* The transfer request might have crossed the boundary to an
return 0;
offset += xfered;
if (readbuf != NULL)
- readbuf = (bfd_byte *) readbuf + xfered;
+ readbuf = (gdb_byte *) readbuf + xfered;
if (writebuf != NULL)
- writebuf = (bfd_byte *) writebuf + xfered;
+ writebuf = (gdb_byte *) writebuf + xfered;
target = target_stack;
}
else if (xfered < 0)
deal with partial reads should call target_read_memory_partial. */
int
-target_read_memory (CORE_ADDR memaddr, bfd_byte *myaddr, int len)
+target_read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len)
{
if (target_xfer_partial_p ())
return xfer_using_stratum (TARGET_OBJECT_MEMORY, NULL,
}
int
-target_write_memory (CORE_ADDR memaddr, const bfd_byte *myaddr, int len)
+target_write_memory (CORE_ADDR memaddr, const gdb_byte *myaddr, int len)
{
- bfd_byte *bytes = alloca (len);
+ gdb_byte *bytes = alloca (len);
memcpy (bytes, myaddr, len);
if (target_xfer_partial_p ())
return xfer_using_stratum (TARGET_OBJECT_MEMORY, NULL,
Result is -1 on error, or the number of bytes transfered. */
int
-do_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
+do_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len, int write,
struct mem_attrib *attrib)
{
int res;
Result is 0 or errno value. */
static int
-target_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write)
+target_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len, int write)
{
int res;
int reg_len;
{
if (region->attrib.cache)
res = dcache_xfer_memory (target_dcache, memaddr, myaddr,
- reg_len, write);
+ reg_len, write);
else
res = do_xfer_memory (memaddr, myaddr, reg_len, write,
®ion->attrib);
static LONGEST
default_xfer_partial (struct target_ops *ops, enum target_object object,
- const char *annex, void *readbuf,
- const void *writebuf, ULONGEST offset, LONGEST len)
+ const char *annex, gdb_byte *readbuf,
+ const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
{
if (object == TARGET_OBJECT_MEMORY
&& ops->deprecated_xfer_memory != NULL)
LONGEST
target_read_partial (struct target_ops *ops,
enum target_object object,
- const char *annex, void *buf,
+ const char *annex, gdb_byte *buf,
ULONGEST offset, LONGEST len)
{
return target_xfer_partial (ops, object, annex, buf, NULL, offset, len);
LONGEST
target_write_partial (struct target_ops *ops,
enum target_object object,
- const char *annex, const void *buf,
+ const char *annex, const gdb_byte *buf,
ULONGEST offset, LONGEST len)
{
return target_xfer_partial (ops, object, annex, NULL, buf, offset, len);
LONGEST
target_read (struct target_ops *ops,
enum target_object object,
- const char *annex, void *buf,
+ const char *annex, gdb_byte *buf,
ULONGEST offset, LONGEST len)
{
LONGEST xfered = 0;
while (xfered < len)
{
LONGEST xfer = target_read_partial (ops, object, annex,
- (bfd_byte *) buf + xfered,
+ (gdb_byte *) buf + xfered,
offset + xfered, len - xfered);
/* Call an observer, notifying them of the xfer progress? */
if (xfer <= 0)
LONGEST
target_write (struct target_ops *ops,
enum target_object object,
- const char *annex, const void *buf,
+ const char *annex, const gdb_byte *buf,
ULONGEST offset, LONGEST len)
{
LONGEST xfered = 0;
while (xfered < len)
{
LONGEST xfer = target_write_partial (ops, object, annex,
- (bfd_byte *) buf + xfered,
+ (gdb_byte *) buf + xfered,
offset + xfered, len - xfered);
/* Call an observer, notifying them of the xfer progress? */
if (xfer <= 0)
/* Memory transfer methods. */
void
-get_target_memory (struct target_ops *ops, CORE_ADDR addr, void *buf,
+get_target_memory (struct target_ops *ops, CORE_ADDR addr, gdb_byte *buf,
LONGEST len)
{
if (target_read (ops, TARGET_OBJECT_MEMORY, NULL, buf, addr, len)
return saved_async_masked_status;
}
+/* Look through the list of possible targets for a target that can
+ follow forks. */
+
+int
+target_follow_fork (int follow_child)
+{
+ struct target_ops *t;
+
+ for (t = current_target.beneath; t != NULL; t = t->beneath)
+ {
+ if (t->to_follow_fork != NULL)
+ {
+ int retval = t->to_follow_fork (t, follow_child);
+ if (targetdebug)
+ fprintf_unfiltered (gdb_stdlog, "target_follow_fork (%d) = %d\n",
+ follow_child, retval);
+ return retval;
+ }
+ }
+
+ /* Some target returned a fork event, but did not know how to follow it. */
+ internal_error (__FILE__, __LINE__,
+ "could not find a target to follow fork");
+}
+
/* Look through the list of possible targets for a target that can
execute a run or attach command without any other data. This is
used to locate the default process stratum.
normal_pid_to_str (ptid_t ptid)
{
static char buf[32];
- int size;
- size = snprintf (buf, sizeof buf, "process %d", ptid_get_pid (ptid));
- gdb_assert (size < sizeof buf);
+ xsnprintf (buf, sizeof buf, "process %d", ptid_get_pid (ptid));
return buf;
}
}
static int
-deprecated_debug_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len,
+deprecated_debug_xfer_memory (CORE_ADDR memaddr, bfd_byte *myaddr, int len,
int write, struct mem_attrib *attrib,
struct target_ops *target)
{
}
static int
-debug_to_insert_breakpoint (CORE_ADDR addr, bfd_byte *save)
+debug_to_insert_breakpoint (CORE_ADDR addr, gdb_byte *save)
{
int retval;
}
static int
-debug_to_remove_breakpoint (CORE_ADDR addr, bfd_byte *save)
+debug_to_remove_breakpoint (CORE_ADDR addr, gdb_byte *save)
{
int retval;
}
static int
-debug_to_insert_hw_breakpoint (CORE_ADDR addr, char *save)
+debug_to_insert_hw_breakpoint (CORE_ADDR addr, gdb_byte *save)
{
int retval;
}
static int
-debug_to_remove_hw_breakpoint (CORE_ADDR addr, char *save)
+debug_to_remove_hw_breakpoint (CORE_ADDR addr, gdb_byte *save)
{
int retval;
return retval;
}
-static int
-debug_to_follow_fork (int follow_child)
-{
- int retval = debug_target.to_follow_fork (follow_child);
-
- fprintf_unfiltered (gdb_stdlog, "target_follow_fork (%d) = %d\n",
- follow_child, retval);
-
- return retval;
-}
-
static void
debug_to_insert_exec_catchpoint (int pid)
{
current_target.to_remove_fork_catchpoint = debug_to_remove_fork_catchpoint;
current_target.to_insert_vfork_catchpoint = debug_to_insert_vfork_catchpoint;
current_target.to_remove_vfork_catchpoint = debug_to_remove_vfork_catchpoint;
- current_target.to_follow_fork = debug_to_follow_fork;
current_target.to_insert_exec_catchpoint = debug_to_insert_exec_catchpoint;
current_target.to_remove_exec_catchpoint = debug_to_remove_exec_catchpoint;
current_target.to_reported_exec_events_per_exec_call = debug_to_reported_exec_events_per_exec_call;
projects / deliverable / binutils-gdb.git / blobdiff