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 PDC_SUCCESS PTHDB_SUCCESS
74#define PDC_FAILURE PTHDB_CALLBACK
89 return gdb::checked_static_cast<aix_thread_info *> (thread->
priv.get ());
104 N_(
"AIX pthread support"),
105 N_(
"AIX pthread support")
117 void resume (ptid_t,
int,
enum gdb_signal)
override;
126 const gdb_byte *writebuf,
127 ULONGEST offset, ULONGEST len,
128 ULONGEST *xfered_len)
override;
146static int pdc_read_data (pthdb_user_t,
void *, pthdb_addr_t,
size_t);
147static int pdc_write_data (pthdb_user_t,
void *, pthdb_addr_t,
size_t);
149 unsigned long long flags,
150 pthdb_context_t *context);
152 unsigned long long flags,
153 pthdb_context_t *context);
154static int pdc_alloc (pthdb_user_t,
size_t,
void **);
155static int pdc_realloc (pthdb_user_t,
void *,
size_t,
void **);
241 case PTHDB_SUCCESS:
return "SUCCESS";
242 case PTHDB_NOSYS:
return "NOSYS";
243 case PTHDB_NOTSUP:
return "NOTSUP";
244 case PTHDB_BAD_VERSION:
return "BAD_VERSION";
245 case PTHDB_BAD_USER:
return "BAD_USER";
246 case PTHDB_BAD_SESSION:
return "BAD_SESSION";
247 case PTHDB_BAD_MODE:
return "BAD_MODE";
248 case PTHDB_BAD_FLAGS:
return "BAD_FLAGS";
249 case PTHDB_BAD_CALLBACK:
return "BAD_CALLBACK";
250 case PTHDB_BAD_POINTER:
return "BAD_POINTER";
251 case PTHDB_BAD_CMD:
return "BAD_CMD";
252 case PTHDB_BAD_PTHREAD:
return "BAD_PTHREAD";
253 case PTHDB_BAD_ATTR:
return "BAD_ATTR";
254 case PTHDB_BAD_MUTEX:
return "BAD_MUTEX";
255 case PTHDB_BAD_MUTEXATTR:
return "BAD_MUTEXATTR";
256 case PTHDB_BAD_COND:
return "BAD_COND";
257 case PTHDB_BAD_CONDATTR:
return "BAD_CONDATTR";
258 case PTHDB_BAD_RWLOCK:
return "BAD_RWLOCK";
259 case PTHDB_BAD_RWLOCKATTR:
return "BAD_RWLOCKATTR";
260 case PTHDB_BAD_KEY:
return "BAD_KEY";
261 case PTHDB_BAD_PTID:
return "BAD_PTID";
262 case PTHDB_BAD_TID:
return "BAD_TID";
263 case PTHDB_CALLBACK:
return "CALLBACK";
264 case PTHDB_CONTEXT:
return "CONTEXT";
265 case PTHDB_HELD:
return "HELD";
266 case PTHDB_NOT_HELD:
return "NOT_HELD";
267 case PTHDB_MEMORY:
return "MEMORY";
268 case PTHDB_NOT_PTHREADED:
return "NOT_PTHREADED";
269 case PTHDB_SYMBOL:
return "SYMBOL";
270 case PTHDB_NOT_AVAIL:
return "NOT_AVAIL";
271 case PTHDB_INTERNAL:
return "INTERNAL";
272 default:
return "UNKNOWN";
283 if (ret == 0 && !errno)
296 if (ret == -1 && errno == EPERM)
300 "ptrace (%d, %d) = %d (errno = %d)\n",
301 req,
id, ret, errno);
302 return ret == -1 ? 0 : 1;
309 "ptrace (%d, %d) = %d (errno = %d)\n",
310 req,
id, ret, errno);
315 error (_(
"aix-thread: ptrace (%d, %d) returned %d (errno = %d %s)"),
316 req,
id, ret, errno, safe_strerror (errno));
325# define ptracex(request, pid, addr, data, buf) \
326 ptrace64 (request, pid, addr, data, buf)
333 return ptrace_check (req,
id, ptracex (req,
id, addr, data, buf));
341# define ptrace(request, pid, addr, data, buf) \
342 ptrace64 (request, pid, addr, data, buf)
343# define addr_ptr long long
345# define addr_ptr int *
353 ptrace (req,
id, addr, data, buf));
365 if (ptid.tid () != 0)
366 *ptidp = ptid_t (ptid.pid ());
381 "pdc_symbol_addrs (user_current_pid = %ld, symbols = 0x%lx, count = %d)\n",
382 user_current_pid, (
long) symbols, count);
384 for (i = 0; i < count; i++)
386 name = symbols[i].name;
389 " symbols[%d].name = \"%s\"\n", i,
name);
406 i, hex_string (symbols[i].addr));
422 unsigned long long flags,
423 pthdb_context_t *context)
434 struct ptxsprs sprs64;
435 struct ptsprs sprs32;
442 (
int) tid, hex_string (
flags));
445 if (
flags & PTHDB_FLAG_GPRS)
450 (
unsigned long) gprs64, 0, NULL))
451 memset (gprs64, 0,
sizeof (gprs64));
452 memcpy (context->gpr, gprs64,
sizeof(gprs64));
456 if (!
ptrace32 (PTT_READ_GPRS, tid, (uintptr_t) gprs32, 0, NULL))
457 memset (gprs32, 0,
sizeof (gprs32));
458 memcpy (context->gpr, gprs32,
sizeof(gprs32));
463 if (
flags & PTHDB_FLAG_FPRS)
465 if (!
ptrace32 (PTT_READ_FPRS, tid, (uintptr_t) fprs, 0, NULL))
466 memset (fprs, 0,
sizeof (fprs));
467 memcpy (context->fpr, fprs,
sizeof(fprs));
471 if (
flags & PTHDB_FLAG_SPRS)
476 (
unsigned long) &sprs64, 0, NULL))
477 memset (&sprs64, 0,
sizeof (sprs64));
478 memcpy (&context->msr, &sprs64,
sizeof(sprs64));
482 if (!
ptrace32 (PTT_READ_SPRS, tid, (uintptr_t) &sprs32, 0, NULL))
483 memset (&sprs32, 0,
sizeof (sprs32));
484 memcpy (&context->msr, &sprs32,
sizeof(sprs32));
490 if (__power_vmx() && (
flags & PTHDB_FLAG_REGS))
494 if (!
ptrace64aix (PTT_READ_VEC, tid, (
long long) &vmx, 0, 0))
495 memset (&vmx, 0,
sizeof (vmx));
496 memcpy (&context->vmx, &vmx,
sizeof(__vmx_context_t));
500 if (!
ptrace32 (PTT_READ_VEC, tid, (
long long) &vmx, 0, 0))
501 memset (&vmx, 0,
sizeof (vmx));
502 memcpy (&context->vmx, &vmx,
sizeof(__vmx_context_t));
508 if (__power_vsx() && (
flags & PTHDB_FLAG_REGS))
512 if (!
ptrace64aix (PTT_READ_VSX, tid, (
long long) &vsx, 0, 0))
513 memset (&vsx, 0,
sizeof (vsx));
514 memcpy (&context->vsx, &vsx,
sizeof(__vsx_context_t));
518 if (!
ptrace32 (PTT_READ_VSX, tid, (
long long) &vsx, 0, 0))
519 memset (&vsx, 0,
sizeof (vsx));
520 memcpy (&context->vsx, &vsx,
sizeof(__vsx_context_t));
533 unsigned long long flags,
534 pthdb_context_t *context)
548 (
int) tid, hex_string (
flags));
551 if (
flags & PTHDB_FLAG_GPRS)
555 (
unsigned long) context->gpr, 0, NULL);
557 ptrace32 (PTT_WRITE_GPRS, tid, (uintptr_t) context->gpr, 0, NULL);
561 if (
flags & PTHDB_FLAG_FPRS)
563 ptrace32 (PTT_WRITE_FPRS, tid, (uintptr_t) context->fpr, 0, NULL);
567 if (
flags & PTHDB_FLAG_SPRS)
572 (
unsigned long) &context->msr, 0, NULL);
576 ptrace32 (PTT_WRITE_SPRS, tid, (uintptr_t) &context->msr, 0, NULL);
581 if (__power_vmx() && (
flags & PTHDB_FLAG_REGS))
584 ptrace64aix (PTT_WRITE_VEC, tid, (
unsigned long) &context->vmx, 0, 0);
586 ptrace32 (PTT_WRITE_VEC, tid, (uintptr_t) &context->vmx, 0, 0);
590 if (__power_vsx() && (
flags & PTHDB_FLAG_REGS))
593 ptrace64aix (PTT_WRITE_VSX, tid, (
unsigned long) &context->vsx, 0, 0);
595 ptrace32 (PTT_WRITE_VSX, tid, (uintptr_t) &context->vsx, 0, 0);
604 pthdb_addr_t addr,
size_t len)
612 "pdc_read_data (user_current_pid = %ld, buf = 0x%lx, addr = %s, len = %ld)\n",
613 user_current_pid, (
long) buf, hex_string (addr), len);
633 pthdb_addr_t addr,
size_t len)
641 "pdc_write_data (user_current_pid = %ld, buf = 0x%lx, addr = %s, len = %ld)\n",
642 user_current_pid, (
long) buf, hex_string (addr), len);
661pdc_alloc (pthdb_user_t user_current_pid,
size_t len,
void **bufp)
665 "pdc_alloc (user_current_pid = %ld, len = %ld, bufp = 0x%lx)\n",
666 user_current_pid, len, (
long) bufp);
670 " malloc returned 0x%lx\n", (
long) *bufp);
683pdc_realloc (pthdb_user_t user_current_pid,
void *buf,
size_t len,
void **bufp)
687 "pdc_realloc (user_current_pid = %ld, buf = 0x%lx, len = %ld, bufp = 0x%lx)\n",
688 user_current_pid, (
long) buf, len, (
long) bufp);
692 " realloc returned 0x%lx\n", (
long) *bufp);
704 "pdc_free (user_current_pid = %ld, buf = 0x%lx)\n", user_current_pid,
725 return _(
"sleeping");
731 return _(
"finished");
741pcmp (
const void *p1v,
const void *p2v)
753 if (ptid1.pid () < ptid2.pid ())
755 else if (ptid1.pid () > ptid2.pid ())
757 else if (ptid1.tid () < ptid2.tid ())
759 else if (ptid1.tid () > ptid2.tid ())
761 else if (ptid1.lwp () < ptid2.lwp ())
763 else if (ptid1.lwp () > ptid2.lwp ())
772gcmp (
const void *t1v,
const void *t2v)
786 struct thrdsinfo64 thrinf;
792 sizeof (thrinf), &ktid, 1) != 1)
798 if (thrinf.ti_cursig)
799 return thrinf.ti_tid;
823 int pcount, psize, pi, gcount, gi;
826 pthdb_pthread_t pdtid;
838 pbuf = XNEWVEC (
struct pd_thread, psize);
840 for (cmd = PTHDB_LIST_FIRST;; cmd = PTHDB_LIST_NEXT)
842 status = pthdb_pthread (data->pd_session, &pdtid, cmd);
843 if (
status != PTHDB_SUCCESS || pdtid == PTHDB_INVALID_PTHREAD)
846 status = pthdb_pthread_ptid (data->pd_session, pdtid, &pthid);
847 if (
status != PTHDB_SUCCESS || pthid == PTHDB_INVALID_PTID)
854 psize *
sizeof *pbuf);
861 for (pi = 0; pi < pcount; pi++)
863 status = pthdb_pthread_tid (data->pd_session, pbuf[pi].
pdtid, &
tid);
864 if (
status != PTHDB_SUCCESS)
865 tid = PTHDB_INVALID_TID;
869 qsort (pbuf, pcount,
sizeof *pbuf,
pcmp);
881 qsort (gbuf, gcount,
sizeof *gbuf,
gcmp);
885 for (pi = gi = 0; pi < pcount || gi < gcount;)
892 else if (gi == gcount)
909 pptid = ptid_t (
pid, 0, pbuf[pi].
pthid);
910 gptid = gbuf[gi]->
ptid;
914 cmp_result =
ptid_cmp (pptid, gptid);
925 else if (cmp_result > 0)
937 tp->
priv.reset (priv);
952 thread->
priv.reset (priv);
992 if (!data->pd_active)
995 status = pthdb_session_update (data->pd_session);
996 if (
status != PTHDB_SUCCESS)
1007 ptid = ptid_t (
pid);
1009 ptid = thread->
ptid;
1025 status = pthdb_session_init (
pid, data->arch64 ? PEM_64BIT : PEM_32BIT,
1028 if (
status != PTHDB_SUCCESS)
1030 return ptid_t (
pid);
1032 data->pd_active = 1;
1061 status = pthdb_session_pthreaded (
inf->
pid, PTHDB_FLAG_REGS,
1063 if ((
status != PTHDB_SUCCESS
1064 &&
status != PTHDB_NOT_PTHREADED) || !stub_name)
1081 if (
inf->in_initial_library_scan)
1100 if (!data->pd_active)
1102 pthdb_session_destroy (data->pd_session);
1105 data->pd_active = 0;
1152 if (ptid.tid () == 0)
1154 scoped_restore save_inferior_ptid = make_scoped_restore (&
inferior_ptid);
1163 error (_(
"aix-thread resume: unknown pthread %ld"),
1169 if (tid[0] == PTHDB_INVALID_TID)
1170 error (_(
"aix-thread resume: no tid for pthread %ld"),
1176 gdb_signal_to_host (sig), (PTRACE_TYPE_ARG5) tid);
1179 gdb_signal_to_host (sig), (PTRACE_TYPE_ARG5) tid);
1189 target_wait_flags options)
1198 if (ptid.pid () == -1)
1203 gdb_assert (ptid.is_pid ());
1209 &&
status->sig () == GDB_SIGNAL_TRAP)
1234 &(vmx.__vr[regno]));
1250 &(vsx.__vsr_dw1[regno]));
1264 (
char *) (vals + regno));
1317 uint64_t iar, uint64_t msr, uint32_t cr,
1318 uint64_t lr, uint64_t ctr, uint32_t xer,
1339 uint32_t iar, uint32_t msr, uint32_t cr,
1340 uint32_t lr, uint32_t ctr, uint32_t xer,
1369 pthdb_context_t ctx;
1375 "fetch_regs_user_thread %lx\n", (
long) pdtid);
1376 status = pthdb_pthread_context (data->pd_session, pdtid, &ctx);
1377 if (
status != PTHDB_SUCCESS)
1378 error (_(
"aix-thread: fetch_registers: pthdb_pthread_context returned %s"),
1398 ctx.xer, ctx.fpscr);
1401 ctx.xer, ctx.fpscr);
1434 struct ptxsprs sprs64;
1435 struct ptsprs sprs32;
1443 "fetch_regs_kernel_thread tid=%lx regno=%d arch64=%d\n",
1444 (
long) tid, regno, data->arch64);
1454 (
unsigned long) gprs64, 0, NULL))
1455 memset (gprs64, 0,
sizeof (gprs64));
1460 if (!
ptrace32 (PTT_READ_GPRS, tid, (uintptr_t) gprs32, 0, NULL))
1461 memset (gprs32, 0,
sizeof (gprs32));
1471 __vmx_context_t vmx;
1473 ret =
ptrace64aix (PTT_READ_VEC, tid, (
long long) &vmx, 0, 0);
1475 ret =
ptrace32 (PTT_READ_VEC, tid, (uintptr_t) &vmx, 0, 0);
1477 memset(&vmx, 0,
sizeof(__vmx_context_t));
1487 __vsx_context_t vsx;
1490 ret =
ptrace64aix (PTT_READ_VSX, tid, (
long long) &vsx, 0, 0);
1492 ret =
ptrace32 (PTT_READ_VSX, tid, (
long long) &vsx, 0, 0);
1494 memset(&vsx, 0,
sizeof(__vsx_context_t));
1506 if (!
ptrace32 (PTT_READ_FPRS, tid, (uintptr_t) fprs, 0, NULL))
1507 memset (fprs, 0,
sizeof (fprs));
1518 (
unsigned long) &sprs64, 0, NULL))
1519 memset (&sprs64, 0,
sizeof (sprs64));
1521 sprs64.pt_cr, sprs64.pt_lr, sprs64.pt_ctr,
1522 sprs64.pt_xer, sprs64.pt_fpscr);
1526 if (!
ptrace32 (PTT_READ_SPRS, tid, (uintptr_t) &sprs32, 0, NULL))
1527 memset (&sprs32, 0,
sizeof (sprs32));
1529 sprs32.pt_lr, sprs32.pt_ctr, sprs32.pt_xer,
1559 if (tid == PTHDB_INVALID_TID)
1578 &(vmx->__vr[regno]));
1598 &(vsx->__vsr_dw1[0]) + regno);
1653 uint64_t *iar, uint64_t *msr, uint32_t *cr,
1654 uint64_t *lr, uint64_t *ctr, uint32_t *xer,
1687 uint32_t *iar, uint32_t *msr, uint32_t *cr,
1688 uint32_t *lr, uint32_t *ctr, uint32_t *xer,
1731 pthdb_context_t ctx;
1737 __vmx_context_t vmx;
1738 __vsx_context_t vsx;
1742 "store_regs_user_thread %lx\n", (
long) pdtid);
1746 status = pthdb_pthread_context (data->pd_session, pdtid, &ctx);
1747 if (
status != PTHDB_SUCCESS)
1748 error (_(
"aix-thread: store_registers: pthdb_pthread_context returned %s"),
1755 memset(&vmx, 0,
sizeof(__vmx_context_t));
1761 ctx.vmx.__vr[i] = vmx.__vr[i];
1764 ctx.vmx.__vrsave = vmx.__vrsave;
1766 ctx.vmx.__vscr = vmx.__vscr;
1773 memset(&vsx, 0,
sizeof(__vsx_context_t));
1778 &(vsx.__vsr_dw1[i]));
1779 ctx.vsx.__vsr_dw1[i] = vsx.__vsr_dw1[i];
1808 &ctx.xer, &ctx.fpscr);
1814 uint32_t tmp_iar, tmp_msr, tmp_cr, tmp_lr, tmp_ctr, tmp_xer,
1818 &tmp_xer, &tmp_fpscr);
1833 ctx.fpscr = tmp_fpscr;
1836 status = pthdb_pthread_setcontext (data->pd_session, pdtid, &ctx);
1837 if (
status != PTHDB_SUCCESS)
1838 error (_(
"aix-thread: store_registers: "
1839 "pthdb_pthread_setcontext returned %s"),
1860 struct ptxsprs sprs64;
1861 struct ptsprs sprs32;
1869 "store_regs_kernel_thread tid=%lx regno=%d\n",
1880 ptrace64aix (PTT_READ_GPRS, tid, (
unsigned long) gprs64, 0, NULL);
1882 ptrace64aix (PTT_WRITE_GPRS, tid, (
unsigned long) gprs64, 0, NULL);
1887 ptrace32 (PTT_READ_GPRS, tid, (uintptr_t) gprs32, 0, NULL);
1889 ptrace32 (PTT_WRITE_GPRS, tid, (uintptr_t) gprs32, 0, NULL);
1901 ptrace32 (PTT_READ_FPRS, tid, (uintptr_t) fprs, 0, NULL);
1903 ptrace32 (PTT_WRITE_FPRS, tid, (uintptr_t) fprs, 0, NULL);
1914 (
unsigned long) &sprs64, 0, NULL);
1916 &sprs64.pt_cr, &sprs64.pt_lr, &sprs64.pt_ctr,
1917 &sprs64.pt_xer, &sprs64.pt_fpscr);
1919 (
unsigned long) &sprs64, 0, NULL);
1929 uint32_t tmp_iar, tmp_msr, tmp_cr, tmp_lr, tmp_ctr, tmp_xer,
1932 gdb_assert (
sizeof (sprs32.pt_iar) == 4);
1935 ptrace32 (PTT_READ_SPRS, tid, (uintptr_t) &sprs32, 0, NULL);
1938 &tmp_ctr, &tmp_xer, &tmp_fpscr);
1940 sprs32.pt_iar = tmp_iar;
1941 sprs32.pt_msr = tmp_msr;
1942 sprs32.pt_cr = tmp_cr;
1943 sprs32.pt_lr = tmp_lr;
1944 sprs32.pt_ctr = tmp_ctr;
1945 sprs32.pt_xer = tmp_xer;
1946 sprs32.pt_fpscr = tmp_fpscr;
1953 ptrace32 (PTT_WRITE_SPRS, tid, (uintptr_t) &sprs32, 0, NULL);
1960 && regno <= tdep->ppc_vrsave_regnum)))
1962 __vmx_context_t vmx;
1966 ret =
ptrace64aix (PTT_READ_VEC, tid, (
long long) &vmx, 0, 0);
1968 ret =
ptrace32 (PTT_READ_VEC, tid, (
long long) &vmx, 0, 0);
1973 ret =
ptrace64aix (PTT_WRITE_VEC, tid, (
long long) &vmx, 0, 0);
1975 ret =
ptrace32 (PTT_WRITE_VEC, tid, (
long long) &vmx, 0, 0);
1977 perror_with_name (_(
"Unable to store AltiVec register after read"));
1987 __vsx_context_t vsx;
1991 ret =
ptrace64aix (PTT_READ_VSX, tid, (
long long) &vsx, 0, 0);
1993 ret =
ptrace32 (PTT_READ_VSX, tid, (
long long) &vsx, 0, 0);
1998 ret =
ptrace64aix (PTT_WRITE_VSX, tid, (
long long) &vsx, 0, 0);
2000 ret =
ptrace32 (PTT_WRITE_VSX, tid, (
long long) &vsx, 0, 0);
2002 perror_with_name (_(
"Unable to store VSX register after read"));
2025 if (tid == PTHDB_INVALID_TID)
2036 const char *annex, gdb_byte *readbuf,
2037 const gdb_byte *writebuf,
2038 ULONGEST offset, ULONGEST len,
2039 ULONGEST *xfered_len)
2041 scoped_restore save_inferior_ptid = make_scoped_restore (&
inferior_ptid);
2045 writebuf, offset, len, xfered_len);
2064 if (ptid.tid () == 0)
2080 if (ptid.tid () == 0)
2083 return string_printf (_(
"Thread %s"), pulongest (ptid.tid ()));
2093 pthdb_pthread_t pdtid;
2095 pthdb_state_t state;
2096 pthdb_suspendstate_t suspendstate;
2097 pthdb_detachstate_t detachstate;
2099 static char *ret = NULL;
2104 if (thread->
ptid.tid () == 0)
2110 pdtid = priv->
pdtid;
2113 if (tid != PTHDB_INVALID_TID)
2115 buf.
printf (_(
"tid %d"), (
int)tid);
2117 status = pthdb_pthread_state (data->pd_session, pdtid, &state);
2118 if (
status != PTHDB_SUCCESS)
2122 status = pthdb_pthread_suspendstate (data->pd_session, pdtid,
2124 if (
status == PTHDB_SUCCESS && suspendstate == PSS_SUSPENDED)
2126 buf.
printf (_(
", suspended"));
2128 status = pthdb_pthread_detachstate (data->pd_session, pdtid,
2130 if (
status == PTHDB_SUCCESS && detachstate == PDS_DETACHED)
2132 buf.
printf (_(
", detached"));
2134 pthdb_pthread_cancelpend (data->pd_session, pdtid, &cancelpend);
2135 if (
status == PTHDB_SUCCESS && cancelpend)
2137 buf.
printf (_(
", cancel pending"));
2143 ret = xstrdup (buf.
c_str ());
2171 _(
"Set debugging of AIX thread module."),
2172 _(
"Show debugging of AIX thread module."),
2173 _(
"Enables debugging output (used to debug GDB)."),
static void supply_altivec_regs(struct regcache *regcache, __vmx_context_t vmx)
static struct aix_thread_variables * get_thread_data_helper_for_ptid(ptid_t ptid)
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 void sync_threadlists(pid_t pid)
static void pd_enable(inferior *inf)
static aix_thread_target aix_thread_ops
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 const registry< inferior >::key< aix_thread_variables > aix_thread_variables_handle
static void fill_fprs(const struct regcache *regcache, double *vals)
static struct aix_thread_variables * get_aix_thread_variables_data(struct inferior *inf)
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 const char * pd_status2str(int status)
static void supply_gprs64(struct regcache *regcache, uint64_t *vals)
static ptid_t pd_activate(pid_t pid)
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 supply_vsx_regs(struct regcache *regcache, __vsx_context_t vsx)
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 void fill_vsx(const struct regcache *regcache, __vsx_context_t *vsx)
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 void pd_disable(inferior *inf)
static aix_thread_info * get_aix_thread_info(thread_info *thread)
void _initialize_aix_thread()
static struct aix_thread_variables * get_thread_data_helper_for_pid(pid_t pid)
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 ptid_t pd_update(pid_t pid)
static void aix_thread_inferior_created(inferior *inf)
static void fill_gprs32(const struct regcache *regcache, uint32_t *vals)
static void fill_altivec(const struct regcache *regcache, __vmx_context_t *vmx)
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)
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
thread_info * find_thread(ptid_t ptid)
int unpush_target(struct target_ops *t)
void push_target(struct target_ops *t)
struct process_stratum_target * process_target()
thread_info * find_thread(ptid_t ptid)
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
private_thread_info_up 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)
all_matching_threads_range all_threads(process_stratum_target *proc_target=nullptr, ptid_t filter_ptid=minus_one_ptid)
void delete_thread(thread_info *thread)
struct thread_info * iterate_over_threads(thread_callback_func, void *)
void thread_change_ptid(process_stratum_target *targ, ptid_t old_ptid, ptid_t new_ptid)
std::unique_ptr< private_thread_info > private_thread_info_up
struct thread_info * add_thread_with_info(process_stratum_target *targ, ptid_t ptid, private_thread_info_up)
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 * find_inferior_ptid(process_stratum_target *targ, ptid_t ptid)
struct inferior * find_inferior_pid(process_stratum_target *targ, int pid)
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)
pthdb_session_t pd_session
CORE_ADDR value_address() const
struct minimal_symbol * minsym
int ppc_vsr0_upper_regnum
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