/* SPU native-dependent code for GDB, the GNU debugger.
- Copyright (C) 2006-2017 Free Software Foundation, Inc.
+ Copyright (C) 2006-2019 Free Software Foundation, Inc.
Contributed by Ulrich Weigand <uweigand@de.ibm.com>.
#include "inf-ptrace.h"
#include "regcache.h"
#include "symfile.h"
-#include "gdb_wait.h"
+#include "common/gdb_wait.h"
#include "gdbthread.h"
#include "gdb_bfd.h"
#define INSTR_SC 0x44000002
#define NR_spu_run 0x0116
+class spu_linux_nat_target final : public inf_ptrace_target
+{
+public:
+ void fetch_registers (struct regcache *regcache, int regnum) override;
+ void store_registers (struct regcache *regcache, int regnum) override;
+
+ void post_attach (int) override;
+ void post_startup_inferior (ptid_t) override;
+
+ ptid_t wait (ptid_t, struct target_waitstatus *, int options) override;
+
+ enum target_xfer_status xfer_partial (enum target_object object,
+ const char *annex,
+ gdb_byte *readbuf,
+ const gdb_byte *writebuf,
+ ULONGEST offset, ULONGEST len,
+ ULONGEST *xfered_len) override;
+
+ int can_use_hw_breakpoint (enum bptype, int, int) override;
+};
+
+static spu_linux_nat_target the_spu_linux_nat_target;
/* Fetch PPU register REGNO. */
static ULONGEST
{
PTRACE_TYPE_RET res;
- int tid = ptid_get_lwp (inferior_ptid);
+ int tid = inferior_ptid.lwp ();
if (tid == 0)
- tid = ptid_get_pid (inferior_ptid);
+ tid = inferior_ptid.pid ();
#ifndef __powerpc64__
/* If running as a 32-bit process on a 64-bit system, we attempt
/ sizeof (PTRACE_TYPE_RET));
PTRACE_TYPE_RET *buffer;
- int tid = ptid_get_lwp (inferior_ptid);
+ int tid = inferior_ptid.lwp ();
if (tid == 0)
- tid = ptid_get_pid (inferior_ptid);
+ tid = inferior_ptid.pid ();
buffer = (PTRACE_TYPE_RET *) alloca (count * sizeof (PTRACE_TYPE_RET));
for (i = 0; i < count; i++, addr += sizeof (PTRACE_TYPE_RET))
/ sizeof (PTRACE_TYPE_RET));
PTRACE_TYPE_RET *buffer;
- int tid = ptid_get_lwp (inferior_ptid);
+ int tid = inferior_ptid.lwp ();
if (tid == 0)
- tid = ptid_get_pid (inferior_ptid);
+ tid = inferior_ptid.pid ();
buffer = (PTRACE_TYPE_RET *) alloca (count * sizeof (PTRACE_TYPE_RET));
char buf[128];
int fd = 0;
int ret = -1;
- int pid = ptid_get_pid (inferior_ptid);
+ int pid = inferior_ptid.pid ();
if (!annex)
return TARGET_XFER_EOF;
/* Override the post_startup_inferior routine to continue running
the inferior until the first spu_run system call. */
-static void
-spu_child_post_startup_inferior (struct target_ops *self, ptid_t ptid)
+void
+spu_linux_nat_target::post_startup_inferior (ptid_t ptid)
{
int fd;
ULONGEST addr;
- int tid = ptid_get_lwp (ptid);
+ int tid = ptid.lwp ();
if (tid == 0)
- tid = ptid_get_pid (ptid);
+ tid = ptid.pid ();
while (!parse_spufs_run (&fd, &addr))
{
/* Override the post_attach routine to try load the SPE executable
file image from its copy inside the target process. */
-static void
-spu_child_post_attach (struct target_ops *self, int pid)
+void
+spu_linux_nat_target::post_attach (int pid)
{
int fd;
ULONGEST addr;
/* Wait for child PTID to do something. Return id of the child,
minus_one_ptid in case of error; store status into *OURSTATUS. */
-static ptid_t
-spu_child_wait (struct target_ops *ops,
- ptid_t ptid, struct target_waitstatus *ourstatus, int options)
+ptid_t
+spu_linux_nat_target::wait (ptid_t ptid, struct target_waitstatus *ourstatus,
+ int options)
{
int save_errno;
int status;
set_sigint_trap (); /* Causes SIGINT to be passed on to the
attached process. */
- pid = waitpid (ptid_get_pid (ptid), &status, 0);
+ pid = waitpid (ptid.pid (), &status, 0);
if (pid == -1 && errno == ECHILD)
/* Try again with __WCLONE to check cloned processes. */
- pid = waitpid (ptid_get_pid (ptid), &status, __WCLONE);
+ pid = waitpid (ptid.pid (), &status, __WCLONE);
save_errno = errno;
/* Make sure we don't report an event for the exit of the
original program, if we've detached from it. */
if (pid != -1 && !WIFSTOPPED (status)
- && pid != ptid_get_pid (inferior_ptid))
+ && pid != inferior_ptid.pid ())
{
pid = -1;
save_errno = EINTR;
}
store_waitstatus (ourstatus, status);
- return pid_to_ptid (pid);
+ return ptid_t (pid);
}
/* Override the fetch_inferior_register routine. */
-static void
-spu_fetch_inferior_registers (struct target_ops *ops,
- struct regcache *regcache, int regno)
+void
+spu_linux_nat_target::fetch_registers (struct regcache *regcache, int regno)
{
int fd;
ULONGEST addr;
/* Since we use functions that rely on inferior_ptid, we need to set and
restore it. */
scoped_restore save_ptid
- = make_scoped_restore (&inferior_ptid, regcache_get_ptid (regcache));
+ = make_scoped_restore (&inferior_ptid, regcache->ptid ());
/* We must be stopped on a spu_run system call. */
if (!parse_spufs_run (&fd, &addr))
/* The ID register holds the spufs file handle. */
if (regno == -1 || regno == SPU_ID_REGNUM)
{
- struct gdbarch *gdbarch = get_regcache_arch (regcache);
+ struct gdbarch *gdbarch = regcache->arch ();
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
gdb_byte buf[4];
store_unsigned_integer (buf, 4, byte_order, fd);
- regcache_raw_supply (regcache, SPU_ID_REGNUM, buf);
+ regcache->raw_supply (SPU_ID_REGNUM, buf);
}
/* The NPC register is found at ADDR. */
{
gdb_byte buf[4];
if (fetch_ppc_memory (addr, buf, 4) == 0)
- regcache_raw_supply (regcache, SPU_PC_REGNUM, buf);
+ regcache->raw_supply (SPU_PC_REGNUM, buf);
}
/* The GPRs are found in the "regs" spufs file. */
== TARGET_XFER_OK)
&& len == sizeof buf)
for (i = 0; i < SPU_NUM_GPRS; i++)
- regcache_raw_supply (regcache, i, buf + i*16);
+ regcache->raw_supply (i, buf + i*16);
}
}
/* Override the store_inferior_register routine. */
-static void
-spu_store_inferior_registers (struct target_ops *ops,
- struct regcache *regcache, int regno)
+void
+spu_linux_nat_target::store_registers (struct regcache *regcache, int regno)
{
int fd;
ULONGEST addr;
/* Since we use functions that rely on inferior_ptid, we need to set and
restore it. */
scoped_restore save_ptid
- = make_scoped_restore (&inferior_ptid, regcache_get_ptid (regcache));
+ = make_scoped_restore (&inferior_ptid, regcache->ptid ());
/* We must be stopped on a spu_run system call. */
if (!parse_spufs_run (&fd, &addr))
if (regno == -1 || regno == SPU_PC_REGNUM)
{
gdb_byte buf[4];
- regcache_raw_collect (regcache, SPU_PC_REGNUM, buf);
+ regcache->raw_collect (SPU_PC_REGNUM, buf);
store_ppc_memory (addr, buf, 4);
}
ULONGEST len;
for (i = 0; i < SPU_NUM_GPRS; i++)
- regcache_raw_collect (regcache, i, buf + i*16);
+ regcache->raw_collect (i, buf + i*16);
xsnprintf (annex, sizeof annex, "%d/regs", fd);
spu_proc_xfer_spu (annex, NULL, buf, 0, sizeof buf, &len);
}
/* Override the to_xfer_partial routine. */
-static enum target_xfer_status
-spu_xfer_partial (struct target_ops *ops,
- enum target_object object, const char *annex,
- gdb_byte *readbuf, const gdb_byte *writebuf,
- ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
+enum target_xfer_status
+spu_linux_nat_target::xfer_partial (enum target_object object, const char *annex,
+ gdb_byte *readbuf, const gdb_byte *writebuf,
+ ULONGEST offset, ULONGEST len,
+ ULONGEST *xfered_len)
{
if (object == TARGET_OBJECT_SPU)
return spu_proc_xfer_spu (annex, readbuf, writebuf, offset, len,
}
/* Override the to_can_use_hw_breakpoint routine. */
-static int
-spu_can_use_hw_breakpoint (struct target_ops *self,
- enum bptype type, int cnt, int othertype)
+int
+spu_linux_nat_target::can_use_hw_breakpoint (enum bptype type,
+ int cnt, int othertype)
{
return 0;
}
void
_initialize_spu_nat (void)
{
- /* Generic ptrace methods. */
- struct target_ops *t;
- t = inf_ptrace_target ();
-
- /* Add SPU methods. */
- t->to_post_attach = spu_child_post_attach;
- t->to_post_startup_inferior = spu_child_post_startup_inferior;
- t->to_wait = spu_child_wait;
- t->to_fetch_registers = spu_fetch_inferior_registers;
- t->to_store_registers = spu_store_inferior_registers;
- t->to_xfer_partial = spu_xfer_partial;
- t->to_can_use_hw_breakpoint = spu_can_use_hw_breakpoint;
-
- /* Register SPU target. */
- add_target (t);
+ add_inf_child_target (&the_spu_linux_nat_target);
}