/* Low level interface for debugging AIX 4.3+ pthreads.
- Copyright (C) 1999-2018 Free Software Foundation, Inc.
+ Copyright (C) 1999-2020 Free Software Foundation, Inc.
Written by Nick Duffek <nsd@redhat.com>.
This file is part of GDB.
#endif
/* Whether to emit debugging output. */
-static int debug_aix_thread;
+static bool debug_aix_thread;
/* In AIX 5.1, functions use pthdb_tid_t instead of tid_t. */
#ifndef PTHDB_VERSION_3
/* Return whether to treat PID as a debuggable thread id. */
-#define PD_TID(ptid) (pd_active && ptid_get_tid (ptid) != 0)
+#define PD_TID(ptid) (pd_active && ptid.tid () != 0)
/* pthdb_user_t value that we pass to pthdb functions. 0 causes
PTHDB_BAD_USER errors, so use 1. */
/* This module's target-specific operations, active while pd_able is true. */
-static struct target_ops aix_thread_ops;
+static const target_info aix_thread_target_info = {
+ "aix-threads",
+ N_("AIX pthread support"),
+ N_("AIX pthread support")
+};
+
+class aix_thread_target final : public target_ops
+{
+public:
+ const target_info &info () const override
+ { return aix_thread_target_info; }
+
+ strata stratum () const override { return thread_stratum; }
+
+ void detach (inferior *, int) override;
+ void resume (ptid_t, int, enum gdb_signal) override;
+ ptid_t wait (ptid_t, struct target_waitstatus *, int) override;
+
+ void fetch_registers (struct regcache *, int) override;
+ void store_registers (struct regcache *, int) 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;
+
+ void mourn_inferior () override;
+
+ bool thread_alive (ptid_t ptid) override;
+
+ std::string pid_to_str (ptid_t) override;
+
+ const char *extra_thread_info (struct thread_info *) override;
+
+ ptid_t get_ada_task_ptid (long lwp, long thread) override;
+};
+
+static aix_thread_target aix_thread_ops;
/* Address of the function that libpthread will call when libpthdebug
is ready to be initialized. */
ptid = *ptidp;
if (PD_TID (ptid))
- *ptidp = pid_to_ptid (ptid_get_pid (ptid));
+ *ptidp = ptid_t (ptid.pid ());
}
/* pthdb callback: for <i> from 0 to COUNT, set SYMBOLS[<i>].addr to
static int
ptid_cmp (ptid_t ptid1, ptid_t ptid2)
{
- int pid1, pid2;
-
- if (ptid_get_pid (ptid1) < ptid_get_pid (ptid2))
+ if (ptid1.pid () < ptid2.pid ())
return -1;
- else if (ptid_get_pid (ptid1) > ptid_get_pid (ptid2))
+ else if (ptid1.pid () > ptid2.pid ())
return 1;
- else if (ptid_get_tid (ptid1) < ptid_get_tid (ptid2))
+ else if (ptid1.tid () < ptid2.tid ())
return -1;
- else if (ptid_get_tid (ptid1) > ptid_get_tid (ptid2))
+ else if (ptid1.tid () > ptid2.tid ())
return 1;
- else if (ptid_get_lwp (ptid1) < ptid_get_lwp (ptid2))
+ else if (ptid1.lwp () < ptid2.lwp ())
return -1;
- else if (ptid_get_lwp (ptid1) > ptid_get_lwp (ptid2))
+ else if (ptid1.lwp () > ptid2.lwp ())
return 1;
else
return 0;
{
struct thrdsinfo64 thrinf;
tid_t ktid = 0;
- int result = 0;
while (1)
{
- if (getthrds (ptid_get_pid (inferior_ptid), &thrinf,
+ if (getthrds (inferior_ptid.pid (), &thrinf,
sizeof (thrinf), &ktid, 1) != 1)
break;
/* Apply differences between the two arrays to GDB's thread list. */
- infpid = ptid_get_pid (inferior_ptid);
+ infpid = inferior_ptid.pid ();
for (pi = gi = 0; pi < pcount || gi < gcount;)
{
if (pi == pcount)
{
- delete_thread (gbuf[gi]->ptid);
+ delete_thread (gbuf[gi]);
gi++;
}
else if (gi == gcount)
priv->pdtid = pbuf[pi].pdtid;
priv->tid = pbuf[pi].tid;
- thread = add_thread_with_info (ptid_t (infpid, 0, pbuf[pi].pthid), priv);
+ process_stratum_target *proc_target
+ = current_inferior ()->process_target ();
+ thread = add_thread_with_info (proc_target,
+ ptid_t (infpid, 0, pbuf[pi].pthid),
+ priv);
pi++;
}
ptid_t pptid, gptid;
int cmp_result;
- pptid = ptid_build (infpid, 0, pbuf[pi].pthid);
+ pptid = ptid_t (infpid, 0, pbuf[pi].pthid);
gptid = gbuf[gi]->ptid;
pdtid = pbuf[pi].pdtid;
tid = pbuf[pi].tid;
}
else if (cmp_result > 0)
{
- delete_thread (gptid);
+ delete_thread (gbuf[gi]);
gi++;
}
else
{
- thread = add_thread (pptid);
+ process_stratum_target *proc_target
+ = current_inferior ()->process_target ();
+ thread = add_thread (proc_target, pptid);
aix_thread_info *priv = new aix_thread_info;
thread->priv.reset (priv);
/* Detach from the process attached to by aix_thread_attach(). */
-static void
-aix_thread_detach (struct target_ops *ops, inferior *inf, int from_tty)
+void
+aix_thread_target::detach (inferior *inf, int from_tty)
{
- struct target_ops *beneath = find_target_beneath (ops);
+ target_ops *beneath = this->beneath ();
pd_disable ();
- beneath->to_detach (beneath, inf, from_tty);
+ beneath->detach (inf, from_tty);
}
/* Tell the inferior process to continue running thread PID if != -1
and all threads otherwise. */
-static void
-aix_thread_resume (struct target_ops *ops,
- ptid_t ptid, int step, enum gdb_signal sig)
+void
+aix_thread_target::resume (ptid_t ptid, int step, enum gdb_signal sig)
{
struct thread_info *thread;
pthdb_tid_t tid[2];
if (!PD_TID (ptid))
{
scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid);
- struct target_ops *beneath = find_target_beneath (ops);
- inferior_ptid = pid_to_ptid (ptid_get_pid (inferior_ptid));
- beneath->to_resume (beneath, ptid, step, sig);
+ inferior_ptid = ptid_t (inferior_ptid.pid ());
+ beneath ()->resume (ptid, step, sig);
}
else
{
- thread = find_thread_ptid (ptid);
+ thread = find_thread_ptid (current_inferior (), ptid);
if (!thread)
error (_("aix-thread resume: unknown pthread %ld"),
- ptid_get_lwp (ptid));
+ ptid.lwp ());
aix_thread_info *priv = get_aix_thread_info (thread);
tid[0] = priv->tid;
if (tid[0] == PTHDB_INVALID_TID)
error (_("aix-thread resume: no tid for pthread %ld"),
- ptid_get_lwp (ptid));
+ ptid.lwp ());
tid[1] = 0;
if (arch64)
If an error occurs, return -1, else return the pid of the stopped
thread. */
-static ptid_t
-aix_thread_wait (struct target_ops *ops,
- ptid_t ptid, struct target_waitstatus *status, int options)
+ptid_t
+aix_thread_target::wait (ptid_t ptid, struct target_waitstatus *status,
+ int options)
{
- struct target_ops *beneath = find_target_beneath (ops);
-
{
scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid);
pid_to_prc (&ptid);
- inferior_ptid = pid_to_ptid (ptid_get_pid (inferior_ptid));
- ptid = beneath->to_wait (beneath, ptid, status, options);
+ inferior_ptid = ptid_t (inferior_ptid.pid ());
+ ptid = beneath ()->wait (ptid, status, options);
}
- if (ptid_get_pid (ptid) == -1)
- return pid_to_ptid (-1);
+ if (ptid.pid () == -1)
+ return ptid_t (-1);
/* Check whether libpthdebug might be ready to be initialized. */
if (!pd_active && status->kind == TARGET_WAITKIND_STOPPED
&& status->value.sig == GDB_SIGNAL_TRAP)
{
- struct regcache *regcache = get_thread_regcache (ptid);
+ process_stratum_target *proc_target
+ = current_inferior ()->process_target ();
+ struct regcache *regcache = get_thread_regcache (proc_target, ptid);
struct gdbarch *gdbarch = regcache->arch ();
if (regcache_read_pc (regcache)
int regno;
for (regno = 0; regno < ppc_num_gprs; regno++)
- regcache_raw_supply (regcache, tdep->ppc_gp0_regnum + regno,
- (char *) (vals + regno));
+ regcache->raw_supply (tdep->ppc_gp0_regnum + regno,
+ (char *) (vals + regno));
}
/* Record that 32-bit register REGNO contains VAL. */
static void
supply_reg32 (struct regcache *regcache, int regno, uint32_t val)
{
- regcache_raw_supply (regcache, regno, (char *) &val);
+ regcache->raw_supply (regno, (char *) &val);
}
/* Record that the floating-point registers contain VALS. */
for (regno = tdep->ppc_fp0_regnum;
regno < tdep->ppc_fp0_regnum + ppc_num_fprs;
regno++)
- regcache_raw_supply (regcache, regno,
- (char *) (vals + regno - tdep->ppc_fp0_regnum));
+ regcache->raw_supply (regno,
+ (char *) (vals + regno - tdep->ppc_fp0_regnum));
}
/* Predicate to test whether given register number is a "special" register. */
struct gdbarch *gdbarch = regcache->arch ();
struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
- regcache_raw_supply (regcache, gdbarch_pc_regnum (gdbarch),
- (char *) &iar);
- regcache_raw_supply (regcache, tdep->ppc_ps_regnum, (char *) &msr);
- regcache_raw_supply (regcache, tdep->ppc_cr_regnum, (char *) &cr);
- regcache_raw_supply (regcache, tdep->ppc_lr_regnum, (char *) &lr);
- regcache_raw_supply (regcache, tdep->ppc_ctr_regnum, (char *) &ctr);
- regcache_raw_supply (regcache, tdep->ppc_xer_regnum, (char *) &xer);
+ regcache->raw_supply (gdbarch_pc_regnum (gdbarch), (char *) &iar);
+ regcache->raw_supply (tdep->ppc_ps_regnum, (char *) &msr);
+ regcache->raw_supply (tdep->ppc_cr_regnum, (char *) &cr);
+ regcache->raw_supply (tdep->ppc_lr_regnum, (char *) &lr);
+ regcache->raw_supply (tdep->ppc_ctr_regnum, (char *) &ctr);
+ regcache->raw_supply (tdep->ppc_xer_regnum, (char *) &xer);
if (tdep->ppc_fpscr_regnum >= 0)
- regcache_raw_supply (regcache, tdep->ppc_fpscr_regnum,
- (char *) &fpscr);
+ regcache->raw_supply (tdep->ppc_fpscr_regnum, (char *) &fpscr);
}
/* Record that the special registers contain the specified 32-bit
struct gdbarch *gdbarch = regcache->arch ();
struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
- regcache_raw_supply (regcache, gdbarch_pc_regnum (gdbarch),
- (char *) &iar);
- regcache_raw_supply (regcache, tdep->ppc_ps_regnum, (char *) &msr);
- regcache_raw_supply (regcache, tdep->ppc_cr_regnum, (char *) &cr);
- regcache_raw_supply (regcache, tdep->ppc_lr_regnum, (char *) &lr);
- regcache_raw_supply (regcache, tdep->ppc_ctr_regnum, (char *) &ctr);
- regcache_raw_supply (regcache, tdep->ppc_xer_regnum, (char *) &xer);
+ regcache->raw_supply (gdbarch_pc_regnum (gdbarch), (char *) &iar);
+ regcache->raw_supply (tdep->ppc_ps_regnum, (char *) &msr);
+ regcache->raw_supply (tdep->ppc_cr_regnum, (char *) &cr);
+ regcache->raw_supply (tdep->ppc_lr_regnum, (char *) &lr);
+ regcache->raw_supply (tdep->ppc_ctr_regnum, (char *) &ctr);
+ regcache->raw_supply (tdep->ppc_xer_regnum, (char *) &xer);
if (tdep->ppc_fpscr_regnum >= 0)
- regcache_raw_supply (regcache, tdep->ppc_fpscr_regnum,
- (char *) &fpscr);
+ regcache->raw_supply (tdep->ppc_fpscr_regnum, (char *) &fpscr);
}
/* Fetch all registers from pthread PDTID, which doesn't have a kernel
}
else
{
- struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
-
if (!ptrace32 (PTT_READ_SPRS, tid, (uintptr_t) &sprs32, 0, NULL))
memset (&sprs32, 0, sizeof (sprs32));
supply_sprs32 (regcache, sprs32.pt_iar, sprs32.pt_msr, sprs32.pt_cr,
sprs32.pt_fpscr);
if (tdep->ppc_mq_regnum >= 0)
- regcache_raw_supply (regcache, tdep->ppc_mq_regnum,
- (char *) &sprs32.pt_mq);
+ regcache->raw_supply (tdep->ppc_mq_regnum, (char *) &sprs32.pt_mq);
}
}
}
/* Fetch register REGNO if != -1 or all registers otherwise from the
thread/process connected to REGCACHE. */
-static void
-aix_thread_fetch_registers (struct target_ops *ops,
- struct regcache *regcache, int regno)
+void
+aix_thread_target::fetch_registers (struct regcache *regcache, int regno)
{
struct thread_info *thread;
pthdb_tid_t tid;
- struct target_ops *beneath = find_target_beneath (ops);
- if (!PD_TID (regcache_get_ptid (regcache)))
- beneath->to_fetch_registers (beneath, regcache, regno);
+ if (!PD_TID (regcache->ptid ()))
+ beneath ()->fetch_registers (regcache, regno);
else
{
- thread = find_thread_ptid (regcache_get_ptid (regcache));
+ thread = find_thread_ptid (current_inferior (), regcache->ptid ());
aix_thread_info *priv = get_aix_thread_info (thread);
tid = priv->tid;
int regno;
for (regno = 0; regno < ppc_num_gprs; regno++)
- if (REG_VALID == regcache_register_status (regcache,
- tdep->ppc_gp0_regnum + regno))
- regcache_raw_collect (regcache, tdep->ppc_gp0_regnum + regno,
- vals + regno);
+ if (REG_VALID == regcache->get_register_status
+ (tdep->ppc_gp0_regnum + regno))
+ regcache->raw_collect (tdep->ppc_gp0_regnum + regno, vals + regno);
}
static void
int regno;
for (regno = 0; regno < ppc_num_gprs; regno++)
- if (REG_VALID == regcache_register_status (regcache,
- tdep->ppc_gp0_regnum + regno))
- regcache_raw_collect (regcache, tdep->ppc_gp0_regnum + regno,
- vals + regno);
+ if (REG_VALID == regcache->get_register_status
+ (tdep->ppc_gp0_regnum + regno))
+ regcache->raw_collect (tdep->ppc_gp0_regnum + regno, vals + regno);
}
/* Store the floating point registers into a double array. */
for (regno = tdep->ppc_fp0_regnum;
regno < tdep->ppc_fp0_regnum + ppc_num_fprs;
regno++)
- if (REG_VALID == regcache_register_status (regcache, regno))
- regcache_raw_collect (regcache, regno,
- vals + regno - tdep->ppc_fp0_regnum);
+ if (REG_VALID == regcache->get_register_status (regno))
+ regcache->raw_collect (regno, vals + regno - tdep->ppc_fp0_regnum);
}
/* Store the special registers into the specified 64-bit and 32-bit
gdb_assert (sizeof (*iar) == register_size
(gdbarch, gdbarch_pc_regnum (gdbarch)));
- if (REG_VALID == regcache_register_status (regcache,
- gdbarch_pc_regnum (gdbarch)))
- regcache_raw_collect (regcache, gdbarch_pc_regnum (gdbarch), iar);
- if (REG_VALID == regcache_register_status (regcache, tdep->ppc_ps_regnum))
- regcache_raw_collect (regcache, tdep->ppc_ps_regnum, msr);
- if (REG_VALID == regcache_register_status (regcache, tdep->ppc_cr_regnum))
- regcache_raw_collect (regcache, tdep->ppc_cr_regnum, cr);
- if (REG_VALID == regcache_register_status (regcache, tdep->ppc_lr_regnum))
- regcache_raw_collect (regcache, tdep->ppc_lr_regnum, lr);
- if (REG_VALID == regcache_register_status (regcache, tdep->ppc_ctr_regnum))
- regcache_raw_collect (regcache, tdep->ppc_ctr_regnum, ctr);
- if (REG_VALID == regcache_register_status (regcache, tdep->ppc_xer_regnum))
- regcache_raw_collect (regcache, tdep->ppc_xer_regnum, xer);
+ if (REG_VALID == regcache->get_register_status (gdbarch_pc_regnum (gdbarch)))
+ regcache->raw_collect (gdbarch_pc_regnum (gdbarch), iar);
+ if (REG_VALID == regcache->get_register_status (tdep->ppc_ps_regnum))
+ regcache->raw_collect (tdep->ppc_ps_regnum, msr);
+ if (REG_VALID == regcache->get_register_status (tdep->ppc_cr_regnum))
+ regcache->raw_collect (tdep->ppc_cr_regnum, cr);
+ if (REG_VALID == regcache->get_register_status (tdep->ppc_lr_regnum))
+ regcache->raw_collect (tdep->ppc_lr_regnum, lr);
+ if (REG_VALID == regcache->get_register_status (tdep->ppc_ctr_regnum))
+ regcache->raw_collect (tdep->ppc_ctr_regnum, ctr);
+ if (REG_VALID == regcache->get_register_status (tdep->ppc_xer_regnum))
+ regcache->raw_collect (tdep->ppc_xer_regnum, xer);
if (tdep->ppc_fpscr_regnum >= 0
- && REG_VALID == regcache_register_status (regcache,
- tdep->ppc_fpscr_regnum))
- regcache_raw_collect (regcache, tdep->ppc_fpscr_regnum, fpscr);
+ && REG_VALID == regcache->get_register_status (tdep->ppc_fpscr_regnum))
+ regcache->raw_collect (tdep->ppc_fpscr_regnum, fpscr);
}
static void
gdb_assert (sizeof (*iar) == register_size (gdbarch,
gdbarch_pc_regnum (gdbarch)));
- if (REG_VALID == regcache_register_status (regcache,
- gdbarch_pc_regnum (gdbarch)))
- regcache_raw_collect (regcache, gdbarch_pc_regnum (gdbarch), iar);
- if (REG_VALID == regcache_register_status (regcache, tdep->ppc_ps_regnum))
- regcache_raw_collect (regcache, tdep->ppc_ps_regnum, msr);
- if (REG_VALID == regcache_register_status (regcache, tdep->ppc_cr_regnum))
- regcache_raw_collect (regcache, tdep->ppc_cr_regnum, cr);
- if (REG_VALID == regcache_register_status (regcache, tdep->ppc_lr_regnum))
- regcache_raw_collect (regcache, tdep->ppc_lr_regnum, lr);
- if (REG_VALID == regcache_register_status (regcache, tdep->ppc_ctr_regnum))
- regcache_raw_collect (regcache, tdep->ppc_ctr_regnum, ctr);
- if (REG_VALID == regcache_register_status (regcache, tdep->ppc_xer_regnum))
- regcache_raw_collect (regcache, tdep->ppc_xer_regnum, xer);
+ if (REG_VALID == regcache->get_register_status (gdbarch_pc_regnum (gdbarch)))
+ regcache->raw_collect (gdbarch_pc_regnum (gdbarch), iar);
+ if (REG_VALID == regcache->get_register_status (tdep->ppc_ps_regnum))
+ regcache->raw_collect (tdep->ppc_ps_regnum, msr);
+ if (REG_VALID == regcache->get_register_status (tdep->ppc_cr_regnum))
+ regcache->raw_collect (tdep->ppc_cr_regnum, cr);
+ if (REG_VALID == regcache->get_register_status (tdep->ppc_lr_regnum))
+ regcache->raw_collect (tdep->ppc_lr_regnum, lr);
+ if (REG_VALID == regcache->get_register_status (tdep->ppc_ctr_regnum))
+ regcache->raw_collect (tdep->ppc_ctr_regnum, ctr);
+ if (REG_VALID == regcache->get_register_status (tdep->ppc_xer_regnum))
+ regcache->raw_collect (tdep->ppc_xer_regnum, xer);
if (tdep->ppc_fpscr_regnum >= 0
- && REG_VALID == regcache_register_status (regcache, tdep->ppc_fpscr_regnum))
- regcache_raw_collect (regcache, tdep->ppc_fpscr_regnum, fpscr);
+ && REG_VALID == regcache->get_register_status (tdep->ppc_fpscr_regnum))
+ regcache->raw_collect (tdep->ppc_fpscr_regnum, fpscr);
}
/* Store all registers into pthread PDTID, which doesn't have a kernel
pthdb_context_t ctx;
uint32_t int32;
uint64_t int64;
- double dbl;
if (debug_aix_thread)
fprintf_unfiltered (gdb_stdlog,
/* Collect general-purpose register values from the regcache. */
for (i = 0; i < ppc_num_gprs; i++)
- if (REG_VALID == regcache_register_status (regcache,
- tdep->ppc_gp0_regnum + i))
+ if (REG_VALID == regcache->get_register_status (tdep->ppc_gp0_regnum + i))
{
if (arch64)
{
- regcache_raw_collect (regcache, tdep->ppc_gp0_regnum + i,
- (void *) &int64);
+ regcache->raw_collect (tdep->ppc_gp0_regnum + i, (void *) &int64);
ctx.gpr[i] = int64;
}
else
{
- regcache_raw_collect (regcache, tdep->ppc_gp0_regnum + i,
- (void *) &int32);
+ regcache->raw_collect (tdep->ppc_gp0_regnum + i, (void *) &int32);
ctx.gpr[i] = int32;
}
}
fill_sprs32 (regcache, &tmp_iar, &tmp_msr, &tmp_cr, &tmp_lr, &tmp_ctr,
&tmp_xer, &tmp_fpscr);
- if (REG_VALID == regcache_register_status (regcache,
- gdbarch_pc_regnum (gdbarch)))
+ if (REG_VALID == regcache->get_register_status
+ (gdbarch_pc_regnum (gdbarch)))
ctx.iar = tmp_iar;
- if (REG_VALID == regcache_register_status (regcache, tdep->ppc_ps_regnum))
+ if (REG_VALID == regcache->get_register_status (tdep->ppc_ps_regnum))
ctx.msr = tmp_msr;
- if (REG_VALID == regcache_register_status (regcache, tdep->ppc_cr_regnum))
+ if (REG_VALID == regcache->get_register_status (tdep->ppc_cr_regnum))
ctx.cr = tmp_cr;
- if (REG_VALID == regcache_register_status (regcache, tdep->ppc_lr_regnum))
+ if (REG_VALID == regcache->get_register_status (tdep->ppc_lr_regnum))
ctx.lr = tmp_lr;
- if (REG_VALID == regcache_register_status (regcache,
- tdep->ppc_ctr_regnum))
+ if (REG_VALID == regcache->get_register_status (tdep->ppc_ctr_regnum))
ctx.ctr = tmp_ctr;
- if (REG_VALID == regcache_register_status (regcache,
- tdep->ppc_xer_regnum))
+ if (REG_VALID == regcache->get_register_status (tdep->ppc_xer_regnum))
ctx.xer = tmp_xer;
- if (REG_VALID == regcache_register_status (regcache,
- tdep->ppc_xer_regnum))
+ if (REG_VALID == regcache->get_register_status (tdep->ppc_xer_regnum))
ctx.fpscr = tmp_fpscr;
}
double fprs[ppc_num_fprs];
struct ptxsprs sprs64;
struct ptsprs sprs32;
- int i;
if (debug_aix_thread)
fprintf_unfiltered (gdb_stdlog,
sprs32.pt_fpscr = tmp_fpscr;
if (tdep->ppc_mq_regnum >= 0)
- if (REG_VALID == regcache_register_status (regcache,
- tdep->ppc_mq_regnum))
- regcache_raw_collect (regcache, tdep->ppc_mq_regnum,
- &sprs32.pt_mq);
+ if (REG_VALID == regcache->get_register_status
+ (tdep->ppc_mq_regnum))
+ regcache->raw_collect (tdep->ppc_mq_regnum, &sprs32.pt_mq);
ptrace32 (PTT_WRITE_SPRS, tid, (uintptr_t) &sprs32, 0, NULL);
}
/* Store gdb's current view of the register set into the
thread/process connected to REGCACHE. */
-static void
-aix_thread_store_registers (struct target_ops *ops,
- struct regcache *regcache, int regno)
+void
+aix_thread_target::store_registers (struct regcache *regcache, int regno)
{
struct thread_info *thread;
pthdb_tid_t tid;
- struct target_ops *beneath = find_target_beneath (ops);
- if (!PD_TID (regcache_get_ptid (regcache)))
- beneath->to_store_registers (beneath, regcache, regno);
+ if (!PD_TID (regcache->ptid ()))
+ beneath ()->store_registers (regcache, regno);
else
{
- thread = find_thread_ptid (regcache_get_ptid (regcache));
+ thread = find_thread_ptid (current_inferior (), regcache->ptid ());
aix_thread_info *priv = get_aix_thread_info (thread);
tid = priv->tid;
/* Implement the to_xfer_partial target_ops method. */
-static enum target_xfer_status
-aix_thread_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
+aix_thread_target::xfer_partial (enum target_object object,
+ const char *annex, gdb_byte *readbuf,
+ const gdb_byte *writebuf,
+ ULONGEST offset, ULONGEST len,
+ ULONGEST *xfered_len)
{
scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid);
- struct target_ops *beneath = find_target_beneath (ops);
- inferior_ptid = pid_to_ptid (ptid_get_pid (inferior_ptid));
- return beneath->to_xfer_partial (beneath, object, annex, readbuf,
+ inferior_ptid = ptid_t (inferior_ptid.pid ());
+ return beneath ()->xfer_partial (object, annex, readbuf,
writebuf, offset, len, xfered_len);
}
/* Clean up after the inferior exits. */
-static void
-aix_thread_mourn_inferior (struct target_ops *ops)
+void
+aix_thread_target::mourn_inferior ()
{
- struct target_ops *beneath = find_target_beneath (ops);
+ target_ops *beneath = this->beneath ();
pd_deactivate ();
- beneath->to_mourn_inferior (beneath);
+ beneath->mourn_inferior ();
}
/* Return whether thread PID is still valid. */
-static int
-aix_thread_thread_alive (struct target_ops *ops, ptid_t ptid)
+bool
+aix_thread_target::thread_alive (ptid_t ptid)
{
- struct target_ops *beneath = find_target_beneath (ops);
-
if (!PD_TID (ptid))
- return beneath->to_thread_alive (beneath, ptid);
+ return beneath ()->thread_alive (ptid);
/* We update the thread list every time the child stops, so all
valid threads should be in the thread list. */
- return in_thread_list (ptid);
+ process_stratum_target *proc_target
+ = current_inferior ()->process_target ();
+ return in_thread_list (proc_target, ptid);
}
/* Return a printable representation of composite PID for use in
"info threads" output. */
-static const char *
-aix_thread_pid_to_str (struct target_ops *ops, ptid_t ptid)
+std::string
+aix_thread_target::pid_to_str (ptid_t ptid)
{
- static char *ret = NULL;
- struct target_ops *beneath = find_target_beneath (ops);
-
if (!PD_TID (ptid))
- return beneath->to_pid_to_str (beneath, ptid);
-
- /* Free previous return value; a new one will be allocated by
- xstrprintf(). */
- xfree (ret);
+ return beneath ()->pid_to_str (ptid);
- ret = xstrprintf (_("Thread %ld"), ptid_get_tid (ptid));
- return ret;
+ return string_printf (_("Thread %ld"), ptid.tid ());
}
/* Return a printable representation of extra information about
THREAD, for use in "info threads" output. */
-static const char *
-aix_thread_extra_thread_info (struct target_ops *self,
- struct thread_info *thread)
+const char *
+aix_thread_target::extra_thread_info (struct thread_info *thread)
{
int status;
pthdb_pthread_t pdtid;
return ret;
}
-static ptid_t
-aix_thread_get_ada_task_ptid (struct target_ops *self, long lwp, long thread)
+ptid_t
+aix_thread_target::get_ada_task_ptid (long lwp, long thread)
{
- return ptid_build (ptid_get_pid (inferior_ptid), 0, thread);
+ return ptid_t (inferior_ptid.pid (), 0, thread);
}
-/* Initialize target aix_thread_ops. */
-
-static void
-init_aix_thread_ops (void)
-{
- aix_thread_ops.to_shortname = "aix-threads";
- aix_thread_ops.to_longname = _("AIX pthread support");
- aix_thread_ops.to_doc = _("AIX pthread support");
-
- aix_thread_ops.to_detach = aix_thread_detach;
- aix_thread_ops.to_resume = aix_thread_resume;
- aix_thread_ops.to_wait = aix_thread_wait;
- aix_thread_ops.to_fetch_registers = aix_thread_fetch_registers;
- aix_thread_ops.to_store_registers = aix_thread_store_registers;
- aix_thread_ops.to_xfer_partial = aix_thread_xfer_partial;
- aix_thread_ops.to_mourn_inferior = aix_thread_mourn_inferior;
- aix_thread_ops.to_thread_alive = aix_thread_thread_alive;
- aix_thread_ops.to_pid_to_str = aix_thread_pid_to_str;
- aix_thread_ops.to_extra_thread_info = aix_thread_extra_thread_info;
- aix_thread_ops.to_get_ada_task_ptid = aix_thread_get_ada_task_ptid;
- aix_thread_ops.to_stratum = thread_stratum;
- aix_thread_ops.to_magic = OPS_MAGIC;
-}
/* Module startup initialization function, automagically called by
init.c. */
void
_initialize_aix_thread (void)
{
- init_aix_thread_ops ();
- complete_target_initialization (&aix_thread_ops);
-
/* Notice when object files get loaded and unloaded. */
gdb::observers::new_objfile.attach (new_objfile);
projects / deliverable / binutils-gdb.git / blobdiff