54#include <sys/ptrace.h>
57#include <sys/pthdebug.h>
59#if !HAVE_DECL_GETTHRDS
60extern int getthrds (pid_t,
struct thrdsinfo64 *,
int, tid_t *,
int);
67#ifndef PTHDB_VERSION_3
68#define pthdb_tid_t tid_t
73#define PD_TID(ptid) (pd_active && ptid.tid () != 0)
77#define PDC_SUCCESS PTHDB_SUCCESS
78#define PDC_FAILURE PTHDB_CALLBACK
93 return gdb::checked_static_cast<aix_thread_info *> (thread->
priv.get ());
108 N_(
"AIX pthread support"),
109 N_(
"AIX pthread support")
121 void resume (ptid_t,
int,
enum gdb_signal)
override;
130 const gdb_byte *writebuf,
131 ULONGEST offset, ULONGEST len,
132 ULONGEST *xfered_len)
override;
168static int pdc_read_data (pthdb_user_t,
void *, pthdb_addr_t,
size_t);
169static int pdc_write_data (pthdb_user_t,
void *, pthdb_addr_t,
size_t);
171 unsigned long long flags,
172 pthdb_context_t *context);
174 unsigned long long flags,
175 pthdb_context_t *context);
176static int pdc_alloc (pthdb_user_t,
size_t,
void **);
177static int pdc_realloc (pthdb_user_t,
void *,
size_t,
void **);
206 case PTHDB_SUCCESS:
return "SUCCESS";
207 case PTHDB_NOSYS:
return "NOSYS";
208 case PTHDB_NOTSUP:
return "NOTSUP";
209 case PTHDB_BAD_VERSION:
return "BAD_VERSION";
210 case PTHDB_BAD_USER:
return "BAD_USER";
211 case PTHDB_BAD_SESSION:
return "BAD_SESSION";
212 case PTHDB_BAD_MODE:
return "BAD_MODE";
213 case PTHDB_BAD_FLAGS:
return "BAD_FLAGS";
214 case PTHDB_BAD_CALLBACK:
return "BAD_CALLBACK";
215 case PTHDB_BAD_POINTER:
return "BAD_POINTER";
216 case PTHDB_BAD_CMD:
return "BAD_CMD";
217 case PTHDB_BAD_PTHREAD:
return "BAD_PTHREAD";
218 case PTHDB_BAD_ATTR:
return "BAD_ATTR";
219 case PTHDB_BAD_MUTEX:
return "BAD_MUTEX";
220 case PTHDB_BAD_MUTEXATTR:
return "BAD_MUTEXATTR";
221 case PTHDB_BAD_COND:
return "BAD_COND";
222 case PTHDB_BAD_CONDATTR:
return "BAD_CONDATTR";
223 case PTHDB_BAD_RWLOCK:
return "BAD_RWLOCK";
224 case PTHDB_BAD_RWLOCKATTR:
return "BAD_RWLOCKATTR";
225 case PTHDB_BAD_KEY:
return "BAD_KEY";
226 case PTHDB_BAD_PTID:
return "BAD_PTID";
227 case PTHDB_BAD_TID:
return "BAD_TID";
228 case PTHDB_CALLBACK:
return "CALLBACK";
229 case PTHDB_CONTEXT:
return "CONTEXT";
230 case PTHDB_HELD:
return "HELD";
231 case PTHDB_NOT_HELD:
return "NOT_HELD";
232 case PTHDB_MEMORY:
return "MEMORY";
233 case PTHDB_NOT_PTHREADED:
return "NOT_PTHREADED";
234 case PTHDB_SYMBOL:
return "SYMBOL";
235 case PTHDB_NOT_AVAIL:
return "NOT_AVAIL";
236 case PTHDB_INTERNAL:
return "INTERNAL";
237 default:
return "UNKNOWN";
248 if (ret == 0 && !errno)
261 if (ret == -1 && errno == EPERM)
265 "ptrace (%d, %d) = %d (errno = %d)\n",
266 req,
id, ret, errno);
267 return ret == -1 ? 0 : 1;
271 error (_(
"aix-thread: ptrace (%d, %d) returned %d (errno = %d %s)"),
272 req,
id, ret, errno, safe_strerror (errno));
281# define ptracex(request, pid, addr, data, buf) \
282 ptrace64 (request, pid, addr, data, buf)
289 return ptrace_check (req,
id, ptracex (req,
id, addr, data, buf));
297# define ptrace(request, pid, addr, data, buf) \
298 ptrace64 (request, pid, addr, data, buf)
299# define addr_ptr long long
301# define addr_ptr int *
309 ptrace (req,
id, addr, data, buf));
322 *ptidp = ptid_t (ptid.pid ());
337 "pdc_symbol_addrs (user_current_pid = %ld, symbols = 0x%lx, count = %d)\n",
338 user_current_pid, (
long) symbols, count);
340 for (i = 0; i < count; i++)
342 name = symbols[i].name;
345 " symbols[%d].name = \"%s\"\n", i,
name);
362 i, hex_string (symbols[i].addr));
378 unsigned long long flags,
379 pthdb_context_t *context)
390 struct ptxsprs sprs64;
391 struct ptsprs sprs32;
395 (
int) tid, hex_string (
flags));
398 if (
flags & PTHDB_FLAG_GPRS)
403 (
unsigned long) gprs64, 0, NULL))
404 memset (gprs64, 0,
sizeof (gprs64));
405 memcpy (context->gpr, gprs64,
sizeof(gprs64));
409 if (!
ptrace32 (PTT_READ_GPRS, tid, (uintptr_t) gprs32, 0, NULL))
410 memset (gprs32, 0,
sizeof (gprs32));
411 memcpy (context->gpr, gprs32,
sizeof(gprs32));
416 if (
flags & PTHDB_FLAG_FPRS)
418 if (!
ptrace32 (PTT_READ_FPRS, tid, (uintptr_t) fprs, 0, NULL))
419 memset (fprs, 0,
sizeof (fprs));
420 memcpy (context->fpr, fprs,
sizeof(fprs));
424 if (
flags & PTHDB_FLAG_SPRS)
429 (
unsigned long) &sprs64, 0, NULL))
430 memset (&sprs64, 0,
sizeof (sprs64));
431 memcpy (&context->msr, &sprs64,
sizeof(sprs64));
435 if (!
ptrace32 (PTT_READ_SPRS, tid, (uintptr_t) &sprs32, 0, NULL))
436 memset (&sprs32, 0,
sizeof (sprs32));
437 memcpy (&context->msr, &sprs32,
sizeof(sprs32));
450 unsigned long long flags,
451 pthdb_context_t *context)
461 (
int) tid, hex_string (
flags));
464 if (
flags & PTHDB_FLAG_GPRS)
468 (
unsigned long) context->gpr, 0, NULL);
470 ptrace32 (PTT_WRITE_GPRS, tid, (uintptr_t) context->gpr, 0, NULL);
474 if (
flags & PTHDB_FLAG_FPRS)
476 ptrace32 (PTT_WRITE_FPRS, tid, (uintptr_t) context->fpr, 0, NULL);
480 if (
flags & PTHDB_FLAG_SPRS)
485 (
unsigned long) &context->msr, 0, NULL);
489 ptrace32 (PTT_WRITE_SPRS, tid, (uintptr_t) &context->msr, 0, NULL);
499 pthdb_addr_t addr,
size_t len)
505 "pdc_read_data (user_current_pid = %ld, buf = 0x%lx, addr = %s, len = %ld)\n",
506 user_current_pid, (
long) buf, hex_string (addr), len);
516 if (user_current_pid != 0)
518 ptid_t (user_current_pid));
533 pthdb_addr_t addr,
size_t len)
539 "pdc_write_data (user_current_pid = %ld, buf = 0x%lx, addr = %s, len = %ld)\n",
540 user_current_pid, (
long) buf, hex_string (addr), len);
555pdc_alloc (pthdb_user_t user_current_pid,
size_t len,
void **bufp)
559 "pdc_alloc (user_current_pid = %ld, len = %ld, bufp = 0x%lx)\n",
560 user_current_pid, len, (
long) bufp);
564 " malloc returned 0x%lx\n", (
long) *bufp);
577pdc_realloc (pthdb_user_t user_current_pid,
void *buf,
size_t len,
void **bufp)
581 "pdc_realloc (user_current_pid = %ld, buf = 0x%lx, len = %ld, bufp = 0x%lx)\n",
582 user_current_pid, (
long) buf, len, (
long) bufp);
586 " realloc returned 0x%lx\n", (
long) *bufp);
598 "pdc_free (user_current_pid = %ld, buf = 0x%lx)\n", user_current_pid,
619 return _(
"sleeping");
625 return _(
"finished");
635pcmp (
const void *p1v,
const void *p2v)
680 if (ptid1.pid () < ptid2.pid ())
682 else if (ptid1.pid () > ptid2.pid ())
684 else if (ptid1.tid () < ptid2.tid ())
686 else if (ptid1.tid () > ptid2.tid ())
688 else if (ptid1.lwp () < ptid2.lwp ())
690 else if (ptid1.lwp () > ptid2.lwp ())
699gcmp (
const void *t1v,
const void *t2v)
713 struct thrdsinfo64 thrinf;
719 sizeof (thrinf), &ktid, 1) != 1)
722 if (thrinf.ti_cursig == SIGTRAP)
723 return thrinf.ti_tid;
747 int pcount, psize, pi, gcount, gi;
750 pthdb_pthread_t pdtid;
758 pbuf = XNEWVEC (
struct pd_thread, psize);
760 for (cmd = PTHDB_LIST_FIRST;; cmd = PTHDB_LIST_NEXT)
763 if (
status != PTHDB_SUCCESS || pdtid == PTHDB_INVALID_PTHREAD)
767 if (
status != PTHDB_SUCCESS || pthid == PTHDB_INVALID_PTID)
774 psize *
sizeof *pbuf);
781 for (pi = 0; pi < pcount; pi++)
784 if (
status != PTHDB_SUCCESS)
785 tid = PTHDB_INVALID_TID;
789 qsort (pbuf, pcount,
sizeof *pbuf,
pcmp);
797 qsort (gbuf, gcount,
sizeof *gbuf,
gcmp);
800 for (pi = gi = 0; pi < pcount || gi < gcount;)
807 else if (gi == gcount)
826 pptid = ptid_t (
pid, 0, pbuf[pi].
pthid);
827 gptid = gbuf[gi]->
ptid;
831 cmp_result =
ptid_cmp (pptid, gptid);
842 else if (cmp_result > 0)
854 thread->
priv.reset (priv);
895 if (
status != PTHDB_SUCCESS)
925 if (
status != PTHDB_SUCCESS)
967 if ((
status != PTHDB_SUCCESS
968 &&
status != PTHDB_NOT_PTHREADED) || !stub_name)
1048 scoped_restore save_inferior_ptid = make_scoped_restore (&
inferior_ptid);
1057 error (_(
"aix-thread resume: unknown pthread %ld"),
1063 if (tid[0] == PTHDB_INVALID_TID)
1064 error (_(
"aix-thread resume: no tid for pthread %ld"),
1070 gdb_signal_to_host (sig), (PTRACE_TYPE_ARG5) tid);
1073 gdb_signal_to_host (sig), (PTRACE_TYPE_ARG5) tid);
1083 target_wait_flags options)
1091 if (ptid.pid () == -1)
1096 gdb_assert (ptid.is_pid ());
1100 &&
status->sig () == GDB_SIGNAL_TRAP)
1126 (
char *) (vals + regno));
1179 uint64_t iar, uint64_t msr, uint32_t cr,
1180 uint64_t lr, uint64_t ctr, uint32_t xer,
1201 uint32_t iar, uint32_t msr, uint32_t cr,
1202 uint32_t lr, uint32_t ctr, uint32_t xer,
1231 pthdb_context_t ctx;
1235 "fetch_regs_user_thread %lx\n", (
long) pdtid);
1237 if (
status != PTHDB_SUCCESS)
1238 error (_(
"aix-thread: fetch_registers: pthdb_pthread_context returned %s"),
1258 ctx.xer, ctx.fpscr);
1261 ctx.xer, ctx.fpscr);
1288 struct ptxsprs sprs64;
1289 struct ptsprs sprs32;
1294 "fetch_regs_kernel_thread tid=%lx regno=%d arch64=%d\n",
1295 (
long) tid, regno,
arch64);
1305 (
unsigned long) gprs64, 0, NULL))
1306 memset (gprs64, 0,
sizeof (gprs64));
1311 if (!
ptrace32 (PTT_READ_GPRS, tid, (uintptr_t) gprs32, 0, NULL))
1312 memset (gprs32, 0,
sizeof (gprs32));
1325 if (!
ptrace32 (PTT_READ_FPRS, tid, (uintptr_t) fprs, 0, NULL))
1326 memset (fprs, 0,
sizeof (fprs));
1337 (
unsigned long) &sprs64, 0, NULL))
1338 memset (&sprs64, 0,
sizeof (sprs64));
1340 sprs64.pt_cr, sprs64.pt_lr, sprs64.pt_ctr,
1341 sprs64.pt_xer, sprs64.pt_fpscr);
1345 if (!
ptrace32 (PTT_READ_SPRS, tid, (uintptr_t) &sprs32, 0, NULL))
1346 memset (&sprs32, 0,
sizeof (sprs32));
1348 sprs32.pt_lr, sprs32.pt_ctr, sprs32.pt_xer,
1374 if (tid == PTHDB_INVALID_TID)
1433 uint64_t *iar, uint64_t *msr, uint32_t *cr,
1434 uint64_t *lr, uint64_t *ctr, uint32_t *xer,
1467 uint32_t *iar, uint32_t *msr, uint32_t *cr,
1468 uint32_t *lr, uint32_t *ctr, uint32_t *xer,
1511 pthdb_context_t ctx;
1517 "store_regs_user_thread %lx\n", (
long) pdtid);
1522 if (
status != PTHDB_SUCCESS)
1523 error (_(
"aix-thread: store_registers: pthdb_pthread_context returned %s"),
1551 &ctx.xer, &ctx.fpscr);
1557 uint32_t tmp_iar, tmp_msr, tmp_cr, tmp_lr, tmp_ctr, tmp_xer,
1561 &tmp_xer, &tmp_fpscr);
1576 ctx.fpscr = tmp_fpscr;
1580 if (
status != PTHDB_SUCCESS)
1581 error (_(
"aix-thread: store_registers: "
1582 "pthdb_pthread_setcontext returned %s"),
1603 struct ptxsprs sprs64;
1604 struct ptsprs sprs32;
1608 "store_regs_kernel_thread tid=%lx regno=%d\n",
1619 ptrace64aix (PTT_READ_GPRS, tid, (
unsigned long) gprs64, 0, NULL);
1621 ptrace64aix (PTT_WRITE_GPRS, tid, (
unsigned long) gprs64, 0, NULL);
1626 ptrace32 (PTT_READ_GPRS, tid, (uintptr_t) gprs32, 0, NULL);
1628 ptrace32 (PTT_WRITE_GPRS, tid, (uintptr_t) gprs32, 0, NULL);
1640 ptrace32 (PTT_READ_FPRS, tid, (uintptr_t) fprs, 0, NULL);
1642 ptrace32 (PTT_WRITE_FPRS, tid, (uintptr_t) fprs, 0, NULL);
1653 (
unsigned long) &sprs64, 0, NULL);
1655 &sprs64.pt_cr, &sprs64.pt_lr, &sprs64.pt_ctr,
1656 &sprs64.pt_xer, &sprs64.pt_fpscr);
1658 (
unsigned long) &sprs64, 0, NULL);
1668 uint32_t tmp_iar, tmp_msr, tmp_cr, tmp_lr, tmp_ctr, tmp_xer,
1671 gdb_assert (
sizeof (sprs32.pt_iar) == 4);
1674 ptrace32 (PTT_READ_SPRS, tid, (uintptr_t) &sprs32, 0, NULL);
1677 &tmp_ctr, &tmp_xer, &tmp_fpscr);
1679 sprs32.pt_iar = tmp_iar;
1680 sprs32.pt_msr = tmp_msr;
1681 sprs32.pt_cr = tmp_cr;
1682 sprs32.pt_lr = tmp_lr;
1683 sprs32.pt_ctr = tmp_ctr;
1684 sprs32.pt_xer = tmp_xer;
1685 sprs32.pt_fpscr = tmp_fpscr;
1692 ptrace32 (PTT_WRITE_SPRS, tid, (uintptr_t) &sprs32, 0, NULL);
1714 if (tid == PTHDB_INVALID_TID)
1725 const char *annex, gdb_byte *readbuf,
1726 const gdb_byte *writebuf,
1727 ULONGEST offset, ULONGEST len,
1728 ULONGEST *xfered_len)
1730 scoped_restore save_inferior_ptid = make_scoped_restore (&
inferior_ptid);
1734 writebuf, offset, len, xfered_len);
1772 return string_printf (_(
"Thread %s"), pulongest (ptid.tid ()));
1782 pthdb_pthread_t pdtid;
1784 pthdb_state_t state;
1785 pthdb_suspendstate_t suspendstate;
1786 pthdb_detachstate_t detachstate;
1788 static char *ret = NULL;
1796 pdtid = priv->
pdtid;
1799 if (tid != PTHDB_INVALID_TID)
1801 buf.
printf (_(
"tid %d"), (
int)tid);
1804 if (
status != PTHDB_SUCCESS)
1810 if (
status == PTHDB_SUCCESS && suspendstate == PSS_SUSPENDED)
1812 buf.
printf (_(
", suspended"));
1816 if (
status == PTHDB_SUCCESS && detachstate == PDS_DETACHED)
1818 buf.
printf (_(
", detached"));
1820 pthdb_pthread_cancelpend (
pd_session, pdtid, &cancelpend);
1821 if (
status == PTHDB_SUCCESS && cancelpend)
1823 buf.
printf (_(
", cancel pending"));
1829 ret = xstrdup (buf.
c_str ());
1857 _(
"Set debugging of AIX thread module."),
1858 _(
"Show debugging of AIX thread module."),
1859 _(
"Enables debugging output (used to debug GDB)."),
static void pd_deactivate(void)
static int giter_accum(struct thread_info *thread, void *bufp)
static const target_info aix_thread_target_info
static void supply_sprs64(struct regcache *regcache, uint64_t iar, uint64_t msr, uint32_t cr, uint64_t lr, uint64_t ctr, uint32_t xer, uint32_t fpscr)
static int pdc_dealloc(pthdb_user_t, void *)
static int giter_count(struct thread_info *thread, void *countp)
static void sync_threadlists(int pid)
static aix_thread_target aix_thread_ops
static ptid_t pd_activate(int pid)
static ptid_t pd_update(int pid)
static void fill_sprs32(const struct regcache *regcache, uint32_t *iar, uint32_t *msr, uint32_t *cr, uint32_t *lr, uint32_t *ctr, uint32_t *xer, uint32_t *fpscr)
static void fill_sprs64(const struct regcache *regcache, uint64_t *iar, uint64_t *msr, uint32_t *cr, uint64_t *lr, uint64_t *ctr, uint32_t *xer, uint32_t *fpscr)
static void fill_fprs(const struct regcache *regcache, double *vals)
static int ptrace64aix(int req, int id, long long addr, int data, int *buf)
static bool debug_aix_thread
static int pdc_symbol_addrs(pthdb_user_t, pthdb_symbol_t *, int)
static int pdc_write_data(pthdb_user_t, void *, pthdb_addr_t, size_t)
static void pd_enable(void)
static const char * pd_status2str(int status)
static void supply_gprs64(struct regcache *regcache, uint64_t *vals)
static void pd_disable(void)
static void fetch_regs_user_thread(struct regcache *regcache, pthdb_pthread_t pdtid)
static void new_objfile(struct objfile *objfile)
static void fetch_regs_kernel_thread(struct regcache *regcache, int regno, pthdb_tid_t tid)
static void fill_gprs64(const struct regcache *regcache, uint64_t *vals)
static int gcmp(const void *t1v, const void *t2v)
static int pdc_read_regs(pthdb_user_t user, pthdb_tid_t tid, unsigned long long flags, pthdb_context_t *context)
static void supply_fprs(struct regcache *regcache, double *vals)
static void supply_sprs32(struct regcache *regcache, uint32_t iar, uint32_t msr, uint32_t cr, uint32_t lr, uint32_t ctr, uint32_t xer, uint32_t fpscr)
static int pdc_alloc(pthdb_user_t, size_t, void **)
static void pid_to_prc(ptid_t *ptidp)
static int ptrace_check(int req, int id, int ret)
static void supply_reg32(struct regcache *regcache, int regno, uint32_t val)
static int pdc_realloc(pthdb_user_t, void *, size_t, void **)
static int ptid_cmp(ptid_t ptid1, ptid_t ptid2)
static int pcmp(const void *p1v, const void *p2v)
static int pdc_read_data(pthdb_user_t, void *, pthdb_addr_t, size_t)
static void store_regs_user_thread(const struct regcache *regcache, pthdb_pthread_t pdtid)
static pthdb_session_t pd_session
static aix_thread_info * get_aix_thread_info(thread_info *thread)
void _initialize_aix_thread()
static pthdb_tid_t get_signaled_thread(int pid)
static void store_regs_kernel_thread(const struct regcache *regcache, int regno, pthdb_tid_t tid)
static pthdb_callbacks_t pd_callbacks
static int ptrace32(int req, int id, addr_ptr addr, int data, int *buf)
static void aix_thread_inferior_created(inferior *inf)
static void fill_gprs32(const struct regcache *regcache, uint32_t *vals)
static char * state2str(pthdb_state_t state)
static int special_register_p(struct gdbarch *gdbarch, int regno)
static int pdc_write_regs(pthdb_user_t user, pthdb_tid_t tid, unsigned long long flags, pthdb_context_t *context)
static int iter_tid(struct thread_info *thread, void *tidp)
static CORE_ADDR pd_brk_addr
int getthrds(pid_t, struct thrdsinfo64 *, int, tid_t *, int)
void * xrealloc(void *ptr, size_t size)
struct gdbarch * target_gdbarch(void)
struct breakpoint * create_thread_event_breakpoint(struct gdbarch *gdbarch, CORE_ADDR address)
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
std::string pid_to_str(ptid_t) override
void fetch_registers(struct regcache *, int) override
const char * extra_thread_info(struct thread_info *) override
void detach(inferior *, int) override
ptid_t wait(ptid_t, struct target_waitstatus *, target_wait_flags) override
void resume(ptid_t, int, enum gdb_signal) override
strata stratum() const override
bool thread_alive(ptid_t ptid) override
const target_info & info() const override
void store_registers(struct regcache *, int) override
ptid_t get_ada_task_ptid(long lwp, ULONGEST thread) override
int unpush_target(struct target_ops *t)
void push_target(struct target_ops *t)
struct process_stratum_target * process_target()
void raw_collect(int regnum, void *buf) const override
void raw_supply(int regnum, const void *buf) override
enum register_status get_register_status(int regnum) const override
void write(const char *buf, long length_buf) override
const char * c_str() const
std::unique_ptr< private_thread_info > priv
void printf(const char *,...) ATTRIBUTE_PRINTF(2
struct cmd_list_element * showdebuglist
struct cmd_list_element * setdebuglist
set_show_commands add_setshow_boolean_cmd(const char *name, enum command_class theclass, bool *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_func_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
#define ptrace(request, pid, addr, data)
int gdbarch_pc_regnum(struct gdbarch *gdbarch)
CORE_ADDR gdbarch_decr_pc_after_break(struct gdbarch *gdbarch)
struct thread_info * add_thread(process_stratum_target *targ, ptid_t ptid)
thread_info * find_thread_ptid(inferior *inf, ptid_t ptid)
void delete_thread(struct thread_info *thread)
void switch_to_thread(struct thread_info *thr)
struct thread_info * add_thread_with_info(process_stratum_target *targ, ptid_t ptid, private_thread_info *)
struct thread_info * iterate_over_threads(thread_callback_func, void *)
bool in_thread_list(process_stratum_target *targ, ptid_t ptid)
mach_port_t kern_return_t mach_port_t mach_msg_type_name_t msgportsPoly mach_port_t kern_return_t pid_t pid mach_port_t kern_return_t mach_port_t task mach_port_t kern_return_t int flags
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t int int rusage_t pid_t pid
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t int status
struct inferior * current_inferior(void)
struct bound_minimal_symbol lookup_minimal_symbol(const char *name, const char *sfile, struct objfile *objf)
observable< struct objfile * > new_objfile
observable< inferior * > inferior_created
int ppc_floating_point_unit_p(struct gdbarch *gdbarch)
CORE_ADDR regcache_read_pc(struct regcache *regcache)
int register_size(struct gdbarch *gdbarch, int regnum)
struct regcache * get_thread_regcache(process_stratum_target *target, ptid_t ptid)
CORE_ADDR value_address() const
struct minimal_symbol * minsym
virtual ptid_t wait(ptid_t, struct target_waitstatus *, target_wait_flags options) TARGET_DEFAULT_FUNC(default_target_wait)
virtual std::string pid_to_str(ptid_t) TARGET_DEFAULT_FUNC(default_pid_to_str)
virtual void fetch_registers(struct regcache *, int) TARGET_DEFAULT_IGNORE()
virtual void detach(inferior *, int) TARGET_DEFAULT_IGNORE()
target_ops * beneath() const
virtual void store_registers(struct regcache *, int) TARGET_DEFAULT_NORETURN(noprocess())
virtual 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) TARGET_DEFAULT_RETURN(TARGET_XFER_E_IO)
virtual void resume(ptid_t, int TARGET_DEBUG_PRINTER(target_debug_print_step), enum gdb_signal) TARGET_DEFAULT_NORETURN(noprocess())
virtual void mourn_inferior() TARGET_DEFAULT_FUNC(default_mourn_inferior)
virtual bool thread_alive(ptid_t ptid) TARGET_DEFAULT_RETURN(false)
int target_write_memory(CORE_ADDR memaddr, const gdb_byte *myaddr, ssize_t len)
int target_read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
void gdb_printf(struct ui_file *stream, const char *format,...)
@ TARGET_WAITKIND_STOPPED