X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Faix-thread.c;h=b9b25d5e3cb637f7a79cd8bf1f00f2cc49672a52;hb=5b6d1e4fa4fc6827c7b3f0e99ff120dfa14d65d2;hp=ea6422043da9a4b66dafa83a2744e0b2b0df6f1a;hpb=61baf725eca99af2569262d10aca03dcde2698f6;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/aix-thread.c b/gdb/aix-thread.c index ea6422043d..b9b25d5e3c 100644 --- a/gdb/aix-thread.c +++ b/gdb/aix-thread.c @@ -1,6 +1,6 @@ /* Low level interface for debugging AIX 4.3+ pthreads. - Copyright (C) 1999-2017 Free Software Foundation, Inc. + Copyright (C) 1999-2020 Free Software Foundation, Inc. Written by Nick Duffek . This file is part of GDB. @@ -46,7 +46,7 @@ #include "regcache.h" #include "gdbcmd.h" #include "ppc-tdep.h" -#include "observer.h" +#include "observable.h" #include "objfiles.h" #include @@ -61,7 +61,7 @@ extern int getthrds (pid_t, struct thrdsinfo64 *, int, tid_t *, int); #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 @@ -70,7 +70,7 @@ static int debug_aix_thread; /* 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. */ @@ -84,11 +84,20 @@ static int debug_aix_thread; /* Private data attached to each element in GDB's thread list. */ -struct private_thread_info { +struct aix_thread_info : public private_thread_info +{ pthdb_pthread_t pdtid; /* thread's libpthdebug id */ pthdb_tid_t tid; /* kernel thread id */ }; +/* Return the aix_thread_info attached to THREAD. */ + +static aix_thread_info * +get_aix_thread_info (thread_info *thread) +{ + return static_cast (thread->priv.get ()); +} + /* Information about a thread of which libpthdebug is aware. */ struct pd_thread { @@ -99,7 +108,46 @@ struct pd_thread { /* 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. */ @@ -155,7 +203,7 @@ static pthdb_session_t pd_session; /* Return a printable representation of pthdebug function return STATUS. */ -static char * +static const char * pd_status2str (int status) { switch (status) @@ -276,7 +324,7 @@ pid_to_prc (ptid_t *ptidp) ptid = *ptidp; if (PD_TID (ptid)) - *ptidp = pid_to_ptid (ptid_get_pid (ptid)); + *ptidp = ptid_t (ptid.pid ()); } /* pthdb callback: for from 0 to COUNT, set SYMBOLS[].addr to @@ -622,19 +670,17 @@ giter_accum (struct thread_info *thread, void *bufp) 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; @@ -659,11 +705,10 @@ get_signaled_thread (void) { 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; @@ -746,20 +791,26 @@ sync_threadlists (void) /* 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) { - thread = add_thread (ptid_build (infpid, 0, pbuf[pi].pthid)); - thread->priv = XNEW (struct private_thread_info); - thread->priv->pdtid = pbuf[pi].pdtid; - thread->priv->tid = pbuf[pi].tid; + aix_thread_info *priv = new aix_thread_info; + priv->pdtid = pbuf[pi].pdtid; + priv->tid = pbuf[pi].tid; + + 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++; } else @@ -767,7 +818,7 @@ sync_threadlists (void) 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; @@ -776,22 +827,28 @@ sync_threadlists (void) if (cmp_result == 0) { - gbuf[gi]->priv->pdtid = pdtid; - gbuf[gi]->priv->tid = tid; + aix_thread_info *priv = get_aix_thread_info (gbuf[gi]); + + priv->pdtid = pdtid; + priv->tid = tid; pi++; gi++; } else if (cmp_result > 0) { - delete_thread (gptid); + delete_thread (gbuf[gi]); gi++; } else { - thread = add_thread (pptid); - thread->priv = XNEW (struct private_thread_info); - thread->priv->pdtid = pdtid; - thread->priv->tid = tid; + 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); + priv->pdtid = pdtid; + priv->tid = tid; pi++; } } @@ -808,8 +865,9 @@ static int iter_tid (struct thread_info *thread, void *tidp) { const pthdb_tid_t tid = *(pthdb_tid_t *)tidp; + aix_thread_info *priv = get_aix_thread_info (thread); - return (thread->priv->tid == tid); + return priv->tid == tid; } /* Synchronize libpthdebug's state with the inferior and with GDB, @@ -964,45 +1022,44 @@ aix_thread_inferior_created (struct target_ops *ops, int from_tty) /* Detach from the process attached to by aix_thread_attach(). */ -static void -aix_thread_detach (struct target_ops *ops, const char *args, 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, args, 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)) { - struct cleanup *cleanup = save_inferior_ptid (); - struct target_ops *beneath = find_target_beneath (ops); + scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid); - inferior_ptid = pid_to_ptid (ptid_get_pid (inferior_ptid)); - beneath->to_resume (beneath, ptid, step, sig); - do_cleanups (cleanup); + 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 ()); - tid[0] = thread->priv->tid; + 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) @@ -1018,28 +1075,30 @@ aix_thread_resume (struct target_ops *ops, 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 cleanup *cleanup = save_inferior_ptid (); - struct target_ops *beneath = find_target_beneath (ops); + { + scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid); - pid_to_prc (&ptid); + pid_to_prc (&ptid); - inferior_ptid = pid_to_ptid (ptid_get_pid (inferior_ptid)); - ptid = beneath->to_wait (beneath, ptid, status, options); - do_cleanups (cleanup); + 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); - struct gdbarch *gdbarch = get_regcache_arch (regcache); + 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) - gdbarch_decr_pc_after_break (gdbarch) == pd_brk_addr) @@ -1054,12 +1113,12 @@ aix_thread_wait (struct target_ops *ops, static void supply_gprs64 (struct regcache *regcache, uint64_t *vals) { - struct gdbarch_tdep *tdep = gdbarch_tdep (get_regcache_arch (regcache)); + struct gdbarch_tdep *tdep = gdbarch_tdep (regcache->arch ()); 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. */ @@ -1067,7 +1126,7 @@ supply_gprs64 (struct regcache *regcache, uint64_t *vals) 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. */ @@ -1075,7 +1134,7 @@ supply_reg32 (struct regcache *regcache, int regno, uint32_t val) static void supply_fprs (struct regcache *regcache, double *vals) { - struct gdbarch *gdbarch = get_regcache_arch (regcache); + struct gdbarch *gdbarch = regcache->arch (); struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); int regno; @@ -1086,8 +1145,8 @@ supply_fprs (struct regcache *regcache, double *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. */ @@ -1116,19 +1175,17 @@ supply_sprs64 (struct regcache *regcache, uint64_t lr, uint64_t ctr, uint32_t xer, uint32_t fpscr) { - struct gdbarch *gdbarch = get_regcache_arch (regcache); + 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 @@ -1140,19 +1197,17 @@ supply_sprs32 (struct regcache *regcache, uint32_t lr, uint32_t ctr, uint32_t xer, uint32_t fpscr) { - struct gdbarch *gdbarch = get_regcache_arch (regcache); + 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 @@ -1165,7 +1220,7 @@ supply_sprs32 (struct regcache *regcache, static void fetch_regs_user_thread (struct regcache *regcache, pthdb_pthread_t pdtid) { - struct gdbarch *gdbarch = get_regcache_arch (regcache); + struct gdbarch *gdbarch = regcache->arch (); struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); int status, i; pthdb_context_t ctx; @@ -1220,7 +1275,7 @@ static void fetch_regs_kernel_thread (struct regcache *regcache, int regno, pthdb_tid_t tid) { - struct gdbarch *gdbarch = get_regcache_arch (regcache); + struct gdbarch *gdbarch = regcache->arch (); struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); uint64_t gprs64[ppc_num_gprs]; uint32_t gprs32[ppc_num_gprs]; @@ -1282,8 +1337,6 @@ fetch_regs_kernel_thread (struct regcache *regcache, int regno, } 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, @@ -1291,32 +1344,30 @@ fetch_regs_kernel_thread (struct regcache *regcache, int regno, 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 in the - thread/process specified by inferior_ptid. */ +/* 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 (inferior_ptid)) - beneath->to_fetch_registers (beneath, regcache, regno); + if (!PD_TID (regcache->ptid ())) + beneath ()->fetch_registers (regcache, regno); else { - thread = find_thread_ptid (inferior_ptid); - tid = thread->priv->tid; + thread = find_thread_ptid (current_inferior (), regcache->ptid ()); + aix_thread_info *priv = get_aix_thread_info (thread); + tid = priv->tid; if (tid == PTHDB_INVALID_TID) - fetch_regs_user_thread (regcache, thread->priv->pdtid); + fetch_regs_user_thread (regcache, priv->pdtid); else fetch_regs_kernel_thread (regcache, regno, tid); } @@ -1327,34 +1378,32 @@ aix_thread_fetch_registers (struct target_ops *ops, static void fill_gprs64 (const struct regcache *regcache, uint64_t *vals) { - struct gdbarch_tdep *tdep = gdbarch_tdep (get_regcache_arch (regcache)); + struct gdbarch_tdep *tdep = gdbarch_tdep (regcache->arch ()); 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 fill_gprs32 (const struct regcache *regcache, uint32_t *vals) { - struct gdbarch_tdep *tdep = gdbarch_tdep (get_regcache_arch (regcache)); + struct gdbarch_tdep *tdep = gdbarch_tdep (regcache->arch ()); 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. */ static void fill_fprs (const struct regcache *regcache, double *vals) { - struct gdbarch *gdbarch = get_regcache_arch (regcache); + struct gdbarch *gdbarch = regcache->arch (); struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); int regno; @@ -1365,9 +1414,8 @@ fill_fprs (const struct regcache *regcache, double *vals) 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 @@ -1379,7 +1427,7 @@ fill_sprs64 (const struct regcache *regcache, uint64_t *lr, uint64_t *ctr, uint32_t *xer, uint32_t *fpscr) { - struct gdbarch *gdbarch = get_regcache_arch (regcache); + struct gdbarch *gdbarch = regcache->arch (); struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); /* Verify that the size of the size of the IAR buffer is the @@ -1390,23 +1438,21 @@ fill_sprs64 (const struct regcache *regcache, 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 @@ -1415,7 +1461,7 @@ fill_sprs32 (const struct regcache *regcache, uint32_t *lr, uint32_t *ctr, uint32_t *xer, uint32_t *fpscr) { - struct gdbarch *gdbarch = get_regcache_arch (regcache); + struct gdbarch *gdbarch = regcache->arch (); struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); /* Verify that the size of the size of the IAR buffer is the @@ -1426,22 +1472,21 @@ fill_sprs32 (const struct regcache *regcache, 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 @@ -1453,13 +1498,12 @@ fill_sprs32 (const struct regcache *regcache, static void store_regs_user_thread (const struct regcache *regcache, pthdb_pthread_t pdtid) { - struct gdbarch *gdbarch = get_regcache_arch (regcache); + struct gdbarch *gdbarch = regcache->arch (); struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); int status, i; pthdb_context_t ctx; uint32_t int32; uint64_t int64; - double dbl; if (debug_aix_thread) fprintf_unfiltered (gdb_stdlog, @@ -1475,19 +1519,16 @@ store_regs_user_thread (const struct regcache *regcache, pthdb_pthread_t pdtid) /* 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; } } @@ -1511,23 +1552,20 @@ store_regs_user_thread (const struct regcache *regcache, pthdb_pthread_t pdtid) 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; } @@ -1550,14 +1588,13 @@ static void store_regs_kernel_thread (const struct regcache *regcache, int regno, pthdb_tid_t tid) { - struct gdbarch *gdbarch = get_regcache_arch (regcache); + struct gdbarch *gdbarch = regcache->arch (); struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); uint64_t gprs64[ppc_num_gprs]; uint32_t gprs32[ppc_num_gprs]; double fprs[ppc_num_fprs]; struct ptxsprs sprs64; struct ptsprs sprs32; - int i; if (debug_aix_thread) fprintf_unfiltered (gdb_stdlog, @@ -1641,10 +1678,9 @@ store_regs_kernel_thread (const struct regcache *regcache, int regno, 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); } @@ -1652,25 +1688,24 @@ store_regs_kernel_thread (const struct regcache *regcache, int regno, } /* Store gdb's current view of the register set into the - thread/process specified by inferior_ptid. */ + 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 (inferior_ptid)) - beneath->to_store_registers (beneath, regcache, regno); + if (!PD_TID (regcache->ptid ())) + beneath ()->store_registers (regcache, regno); else { - thread = find_thread_ptid (inferior_ptid); - tid = thread->priv->tid; + thread = find_thread_ptid (current_inferior (), regcache->ptid ()); + aix_thread_info *priv = get_aix_thread_info (thread); + tid = priv->tid; if (tid == PTHDB_INVALID_TID) - store_regs_user_thread (regcache, thread->priv->pdtid); + store_regs_user_thread (regcache, priv->pdtid); else store_regs_kernel_thread (regcache, regno, tid); } @@ -1678,78 +1713,64 @@ aix_thread_store_registers (struct target_ops *ops, /* 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) { - struct cleanup *old_chain = save_inferior_ptid (); - enum target_xfer_status xfer; - struct target_ops *beneath = find_target_beneath (ops); + scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid); - inferior_ptid = pid_to_ptid (ptid_get_pid (inferior_ptid)); - xfer = 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); - - do_cleanups (old_chain); - return xfer; } /* 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 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); + return beneath ()->pid_to_str (ptid); - /* Free previous return value; a new one will be allocated by - xstrprintf(). */ - xfree (ret); - - 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 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) { - struct ui_file *buf; int status; pthdb_pthread_t pdtid; pthdb_tid_t tid; @@ -1762,94 +1783,66 @@ aix_thread_extra_thread_info (struct target_ops *self, if (!PD_TID (thread->ptid)) return NULL; - buf = mem_fileopen (); + string_file buf; + aix_thread_info *priv = get_aix_thread_info (thread); - pdtid = thread->priv->pdtid; - tid = thread->priv->tid; + pdtid = priv->pdtid; + tid = priv->tid; if (tid != PTHDB_INVALID_TID) /* i18n: Like "thread-identifier %d, [state] running, suspended" */ - fprintf_unfiltered (buf, _("tid %d"), (int)tid); + buf.printf (_("tid %d"), (int)tid); status = pthdb_pthread_state (pd_session, pdtid, &state); if (status != PTHDB_SUCCESS) state = PST_NOTSUP; - fprintf_unfiltered (buf, ", %s", state2str (state)); + buf.printf (", %s", state2str (state)); status = pthdb_pthread_suspendstate (pd_session, pdtid, &suspendstate); if (status == PTHDB_SUCCESS && suspendstate == PSS_SUSPENDED) /* i18n: Like "Thread-Id %d, [state] running, suspended" */ - fprintf_unfiltered (buf, _(", suspended")); + buf.printf (_(", suspended")); status = pthdb_pthread_detachstate (pd_session, pdtid, &detachstate); if (status == PTHDB_SUCCESS && detachstate == PDS_DETACHED) /* i18n: Like "Thread-Id %d, [state] running, detached" */ - fprintf_unfiltered (buf, _(", detached")); + buf.printf (_(", detached")); pthdb_pthread_cancelpend (pd_session, pdtid, &cancelpend); if (status == PTHDB_SUCCESS && cancelpend) /* i18n: Like "Thread-Id %d, [state] running, cancel pending" */ - fprintf_unfiltered (buf, _(", cancel pending")); + buf.printf (_(", cancel pending")); - ui_file_write (buf, "", 1); + buf.write ("", 1); xfree (ret); /* Free old buffer. */ - ret = ui_file_xstrdup (buf, NULL); - ui_file_delete (buf); + ret = xstrdup (buf.c_str ()); 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); - void _initialize_aix_thread (void) { - init_aix_thread_ops (); - complete_target_initialization (&aix_thread_ops); - /* Notice when object files get loaded and unloaded. */ - observer_attach_new_objfile (new_objfile); + gdb::observers::new_objfile.attach (new_objfile); /* Add ourselves to inferior_created event chain. This is needed to enable the thread target on "attach". */ - observer_attach_inferior_created (aix_thread_inferior_created); + gdb::observers::inferior_created.attach (aix_thread_inferior_created); add_setshow_boolean_cmd ("aix-thread", class_maintenance, &debug_aix_thread, _("Set debugging of AIX thread module."),