OpenE2K
/
binutils-gdb
12
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

2002-07-17 Michael Snyder <msnyder@redhat.com> 

* aix-thread.c: Shorten some long lines.
	Bring comments into line with code spec.
This commit is contained in:
Michael Snyder 2002-07-18 19:26:14 +00:00
parent 488f131ba0
commit 0fe7bf7bb4
2 changed files with 267 additions and 214 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
gdb/ChangeLog
View File

@ -1,3 +1,8 @@
2002-07-17 Michael Snyder <msnyder@redhat.com>
* aix-thread.c: Shorten some long lines.
Bring comments into line with code spec.
2002-07-18 Joel Brobecker <brobecker@gnat.com> 2002-07-18 Joel Brobecker <brobecker@gnat.com>
* infrun.c: Re-indent using gdb_indent.sh. * infrun.c: Re-indent using gdb_indent.sh.

340
gdb/aix-thread.c
View File

@ -31,13 +31,13 @@
libpthdebug peculiarities: libpthdebug peculiarities:
- pthdb_ptid_pthread() is prototyped in <sys/pthdebug.h>, but it's not - pthdb_ptid_pthread() is prototyped in <sys/pthdebug.h>, but
documented, and after several calls it stops working and causes other it's not documented, and after several calls it stops working
libpthdebug functions to fail. and causes other libpthdebug functions to fail.
- pthdb_tid_pthread() doesn't always work after pthdb_session_update(), - pthdb_tid_pthread() doesn't always work after
but it does work after cycling through all threads using pthdb_session_update(), but it does work after cycling through
pthdb_pthread(). all threads using pthdb_pthread().
*/ */
@ -66,7 +66,7 @@
/* Whether to emit debugging output. */ /* Whether to emit debugging output. */
static int debug_aix_thread; static int debug_aix_thread;
/* in AIX 5.1, functions use pthdb_tid_t instead of tid_t */ /* In AIX 5.1, functions use pthdb_tid_t instead of tid_t. */
#ifndef PTHDB_VERSION_3 #ifndef PTHDB_VERSION_3
#define pthdb_tid_t tid_t #define pthdb_tid_t tid_t
#endif #endif
@ -110,14 +110,14 @@ struct pd_thread {
static struct target_ops ops; static struct target_ops ops;
/* Copy of the target over which ops is pushed. This is /* Copy of the target over which ops is pushed.
more convenient than a pointer to child_ops or core_ops, because This is more convenient than a pointer to child_ops or core_ops,
they lack current_target's default callbacks. */ because they lack current_target's default callbacks. */
static struct target_ops base_ops; static struct target_ops base_ops;
/* Address of the function that libpthread will call when libpthdebug is /* Address of the function that libpthread will call when libpthdebug
ready to be initialized. */ is ready to be initialized. */
static CORE_ADDR pd_brk_addr; static CORE_ADDR pd_brk_addr;
@ -129,8 +129,8 @@ static int pd_able = 0;
static int pd_active = 0; static int pd_active = 0;
/* Whether the current architecture is 64-bit. Only valid when pd_able is /* Whether the current architecture is 64-bit.
true. */ Only valid when pd_able is true. */
static int arch64; static int arch64;
@ -144,9 +144,11 @@ static int pdc_symbol_addrs (pthdb_user_t, pthdb_symbol_t *, int);
static int pdc_read_data (pthdb_user_t, void *, pthdb_addr_t, size_t); static int pdc_read_data (pthdb_user_t, void *, pthdb_addr_t, size_t);
static int pdc_write_data (pthdb_user_t, void *, pthdb_addr_t, size_t); static int pdc_write_data (pthdb_user_t, void *, pthdb_addr_t, size_t);
static int pdc_read_regs (pthdb_user_t user, pthdb_tid_t tid, static int pdc_read_regs (pthdb_user_t user, pthdb_tid_t tid,
unsigned long long flags, pthdb_context_t *context); unsigned long long flags,
pthdb_context_t *context);
static int pdc_write_regs (pthdb_user_t user, pthdb_tid_t tid, static int pdc_write_regs (pthdb_user_t user, pthdb_tid_t tid,
unsigned long long flags, pthdb_context_t *context); unsigned long long flags,
pthdb_context_t *context);
static int pdc_alloc (pthdb_user_t, size_t, void **); static int pdc_alloc (pthdb_user_t, size_t, void **);
static int pdc_realloc (pthdb_user_t, void *, size_t, void **); static int pdc_realloc (pthdb_user_t, void *, size_t, void **);
static int pdc_dealloc (pthdb_user_t, void *); static int pdc_dealloc (pthdb_user_t, void *);
@ -169,7 +171,8 @@ static pthdb_callbacks_t pd_callbacks = {
static pthdb_session_t pd_session; static pthdb_session_t pd_session;
/* Return a printable representation of pthdebug function return STATUS. */ /* Return a printable representation of pthdebug function return
STATUS. */
static char * static char *
pd_status2str (int status) pd_status2str (int status)
@ -211,9 +214,9 @@ pd_status2str (int status)
} }
} }
/* A call to ptrace(REQ, ID, ...) just returned RET. Check for exceptional /* A call to ptrace(REQ, ID, ...) just returned RET. Check for
conditions and either return nonlocally or else return 1 for success and 0 exceptional conditions and either return nonlocally or else return
for failure. */ 1 for success and 0 for failure. */
static int static int
ptrace_check (int req, int id, int ret) ptrace_check (int req, int id, int ret)
@ -221,10 +224,10 @@ ptrace_check (int req, int id, int ret)
if (ret == 0 && !errno) if (ret == 0 && !errno)
return 1; return 1;
/* According to ptrace(2), ptrace may fail with EPERM if "the Identifier /* According to ptrace(2), ptrace may fail with EPERM if "the
parameter corresponds to a kernel thread which is stopped in kernel mode Identifier parameter corresponds to a kernel thread which is
and whose computational state cannot be read or written." This happens stopped in kernel mode and whose computational state cannot be
quite often with register reads. */ read or written." This happens quite often with register reads. */
switch (req) switch (req)
{ {
@ -234,7 +237,8 @@ ptrace_check (int req, int id, int ret)
if (ret == -1 && errno == EPERM) if (ret == -1 && errno == EPERM)
{ {
if (debug_aix_thread) if (debug_aix_thread)
fprintf_unfiltered (gdb_stdlog, "ptrace (%d, %d) = %d (errno = %d)", fprintf_unfiltered (gdb_stdlog,
"ptrace (%d, %d) = %d (errno = %d)",
req, id, ret, errno); req, id, ret, errno);
return ret == -1 ? 0 : 1; return ret == -1 ? 0 : 1;
} }
@ -242,10 +246,10 @@ ptrace_check (int req, int id, int ret)
} }
error ("aix-thread: ptrace (%d, %d) returned %d (errno = %d %s)", error ("aix-thread: ptrace (%d, %d) returned %d (errno = %d %s)",
req, id, ret, errno, safe_strerror (errno)); req, id, ret, errno, safe_strerror (errno));
return 0; /* not reached. */ return 0; /* Not reached. */
} }
/* Call ptracex(REQ, ID, ADDR, DATA, BUF). Return success. */ /* Call ptracex (REQ, ID, ADDR, DATA, BUF). Return success. */
static int static int
ptrace64aix (int req, int id, long long addr, int data, int *buf) ptrace64aix (int req, int id, long long addr, int data, int *buf)
@ -254,16 +258,18 @@ ptrace64aix (int req, int id, long long addr, int data, int *buf)
return ptrace_check (req, id, ptracex (req, id, addr, data, buf)); return ptrace_check (req, id, ptracex (req, id, addr, data, buf));
} }
/* Call ptrace(REQ, ID, ADDR, DATA, BUF). Return success. */ /* Call ptrace (REQ, ID, ADDR, DATA, BUF). Return success. */
static int static int
ptrace32 (int req, int id, int *addr, int data, int *buf) ptrace32 (int req, int id, int *addr, int data, int *buf)
{ {
errno = 0; errno = 0;
return ptrace_check (req, id, ptrace (req, id, (int *)addr, data, buf)); return ptrace_check (req, id,
ptrace (req, id, (int *)addr, data, buf));
} }
/* If *PIDP is a composite process/thread id, convert it to a process id. */ /* If *PIDP is a composite process/thread id, convert it to a
process id. */
static void static void
pid_to_prc (ptid_t *ptidp) pid_to_prc (ptid_t *ptidp)
@ -275,8 +281,8 @@ pid_to_prc (ptid_t *ptidp)
*ptidp = pid_to_ptid (PIDGET (ptid)); *ptidp = pid_to_ptid (PIDGET (ptid));
} }
/* pthdb callback: for <i> from 0 to COUNT, set SYMBOLS[<i>].addr to the /* pthdb callback: for <i> from 0 to COUNT, set SYMBOLS[<i>].addr to
address of SYMBOLS[<i>].name. */ the address of SYMBOLS[<i>].name. */
static int static int
pdc_symbol_addrs (pthdb_user_t user, pthdb_symbol_t *symbols, int count) pdc_symbol_addrs (pthdb_user_t user, pthdb_symbol_t *symbols, int count)
@ -294,7 +300,8 @@ pdc_symbol_addrs (pthdb_user_t user, pthdb_symbol_t *symbols, int count)
{ {
name = symbols[i].name; name = symbols[i].name;
if (debug_aix_thread) if (debug_aix_thread)
fprintf_unfiltered (gdb_stdlog, " symbols[%d].name = \"%s\"", i, name); fprintf_unfiltered (gdb_stdlog,
" symbols[%d].name = \"%s\"", i, name);
if (!*name) if (!*name)
symbols[i].addr = 0; symbols[i].addr = 0;
@ -317,22 +324,24 @@ pdc_symbol_addrs (pthdb_user_t user, pthdb_symbol_t *symbols, int count)
return PDC_SUCCESS; return PDC_SUCCESS;
} }
/* Read registers call back function should be able to read the context */ /* Read registers call back function should be able to read the
/* information of a debuggee kernel thread from an active process or from */ context information of a debuggee kernel thread from an active
/* a core file. The information should be formatted in context64 form for */ process or from a core file. The information should be formatted
/* both 32-bit and 64-bit process. If successful return 0, else non-zero */ in context64 form for both 32-bit and 64-bit process.
/* is returned. */ If successful return 0, else non-zero is returned. */
static int static int
pdc_read_regs (pthdb_user_t user, pdc_read_regs (pthdb_user_t user,
pthdb_tid_t tid, pthdb_tid_t tid,
unsigned long long flags, unsigned long long flags,
pthdb_context_t *context) pthdb_context_t *context)
{ {
/* this function doesn't appear to be used, so we could probably just */ /* This function doesn't appear to be used, so we could probably
/* return 0 here. HOWEVER, if it is not defined, the OS will complain */ just return 0 here. HOWEVER, if it is not defined, the OS will
/* and several thread debug functions will fail. In case this is needed, */ complain and several thread debug functions will fail. In case
/* I have implemented what I think it should do, however this code is */ this is needed, I have implemented what I think it should do,
/* untested. */ however this code is untested. */
uint64_t gprs64[32]; uint64_t gprs64[32];
uint32_t gprs32[32]; uint32_t gprs32[32];
double fprs[32]; double fprs[32];
@ -348,7 +357,8 @@ pdc_read_regs (pthdb_user_t user,
{ {
if (arch64) if (arch64)
{ {
if (!ptrace64aix (PTT_READ_GPRS, tid, (unsigned long) gprs64, 0, NULL)) if (!ptrace64aix (PTT_READ_GPRS, tid,
(unsigned long) gprs64, 0, NULL))
memset (gprs64, 0, sizeof (gprs64)); memset (gprs64, 0, sizeof (gprs64));
memcpy (context->gpr, gprs64, sizeof(gprs64)); memcpy (context->gpr, gprs64, sizeof(gprs64));
} }
@ -373,7 +383,8 @@ pdc_read_regs (pthdb_user_t user,
{ {
if (arch64) if (arch64)
{ {
if (!ptrace64aix (PTT_READ_SPRS, tid, (unsigned long) &sprs64, 0, NULL)) if (!ptrace64aix (PTT_READ_SPRS, tid,
(unsigned long) &sprs64, 0, NULL))
memset (&sprs64, 0, sizeof (sprs64)); memset (&sprs64, 0, sizeof (sprs64));
memcpy (&context->msr, &sprs64, sizeof(sprs64)); memcpy (&context->msr, &sprs64, sizeof(sprs64));
} }
@ -387,20 +398,21 @@ pdc_read_regs (pthdb_user_t user,
return 0; return 0;
} }
/* Write register function should be able to write requested context */ /* Write register function should be able to write requested context
/* information to specified debuggee's kernel thread id. If successful */ information to specified debuggee's kernel thread id.
/* return 0, else non-zero is returned. */ If successful return 0, else non-zero is returned. */
static int static int
pdc_write_regs (pthdb_user_t user, pdc_write_regs (pthdb_user_t user,
pthdb_tid_t tid, pthdb_tid_t tid,
unsigned long long flags, unsigned long long flags,
pthdb_context_t *context) pthdb_context_t *context)
{ {
/* this function doesn't appear to be used, so we could probably just */ /* This function doesn't appear to be used, so we could probably
/* return 0 here. HOWEVER, if it is not defined, the OS will complain */ just return 0 here. HOWEVER, if it is not defined, the OS will
/* and several thread debug functions will fail. In case this is needed, */ complain and several thread debug functions will fail. In case
/* I have implemented what I think it should do, however this code is */ this is needed, I have implemented what I think it should do,
/* untested. */ however this code is untested. */
if (debug_aix_thread) if (debug_aix_thread)
fprintf_unfiltered (gdb_stdlog, "pdc_write_regs tid=%d flags=%llx\n", fprintf_unfiltered (gdb_stdlog, "pdc_write_regs tid=%d flags=%llx\n",
@ -410,7 +422,8 @@ pdc_write_regs (pthdb_user_t user,
if (flags & PTHDB_FLAG_GPRS) if (flags & PTHDB_FLAG_GPRS)
{ {
if (arch64) if (arch64)
ptrace64aix (PTT_WRITE_GPRS, tid, (unsigned long)context->gpr, 0, NULL); ptrace64aix (PTT_WRITE_GPRS, tid,
(unsigned long)context->gpr, 0, NULL);
else else
ptrace32 (PTT_WRITE_GPRS, tid, (int *)context->gpr, 0, NULL); ptrace32 (PTT_WRITE_GPRS, tid, (int *)context->gpr, 0, NULL);
} }
@ -426,7 +439,8 @@ pdc_write_regs (pthdb_user_t user,
{ {
if (arch64) if (arch64)
{ {
ptrace64aix (PTT_WRITE_SPRS, tid, (unsigned long) &context->msr, 0, NULL); ptrace64aix (PTT_WRITE_SPRS, tid,
(unsigned long) &context->msr, 0, NULL);
} }
else else
{ {
@ -439,7 +453,8 @@ pdc_write_regs (pthdb_user_t user,
/* pthdb callback: read LEN bytes from process ADDR into BUF. */ /* pthdb callback: read LEN bytes from process ADDR into BUF. */
static int static int
pdc_read_data (pthdb_user_t user, void *buf, pthdb_addr_t addr, size_t len) pdc_read_data (pthdb_user_t user, void *buf,
pthdb_addr_t addr, size_t len)
{ {
int status, ret; int status, ret;
@ -452,15 +467,16 @@ pdc_read_data (pthdb_user_t user, void *buf, pthdb_addr_t addr, size_t len)
ret = status == 0 ? PDC_SUCCESS : PDC_FAILURE; ret = status == 0 ? PDC_SUCCESS : PDC_FAILURE;
if (debug_aix_thread) if (debug_aix_thread)
fprintf_unfiltered (gdb_stdlog, " status=%d, returning %s", status, fprintf_unfiltered (gdb_stdlog, " status=%d, returning %s",
pd_status2str (ret)); status, pd_status2str (ret));
return ret; return ret;
} }
/* pthdb callback: write LEN bytes from BUF to process ADDR. */ /* pthdb callback: write LEN bytes from BUF to process ADDR. */
static int static int
pdc_write_data (pthdb_user_t user, void *buf, pthdb_addr_t addr, size_t len) pdc_write_data (pthdb_user_t user, void *buf,
pthdb_addr_t addr, size_t len)
{ {
int status, ret; int status, ret;
@ -478,8 +494,8 @@ pdc_write_data (pthdb_user_t user, void *buf, pthdb_addr_t addr, size_t len)
return ret; return ret;
} }
/* pthdb callback: allocate a LEN-byte buffer and store a pointer to it in /* pthdb callback: allocate a LEN-byte buffer and store a pointer to it
BUFP. */ in BUFP. */
static int static int
pdc_alloc (pthdb_user_t user, size_t len, void **bufp) pdc_alloc (pthdb_user_t user, size_t len, void **bufp)
@ -490,15 +506,18 @@ pdc_alloc (pthdb_user_t user, size_t len, void **bufp)
user, len, (long) bufp); user, len, (long) bufp);
*bufp = xmalloc (len); *bufp = xmalloc (len);
if (debug_aix_thread) if (debug_aix_thread)
fprintf_unfiltered (gdb_stdlog, " malloc returned 0x%lx", (long) *bufp); fprintf_unfiltered (gdb_stdlog,
/* Note: xmalloc() can't return 0; therefore PDC_FAILURE will never be " malloc returned 0x%lx", (long) *bufp);
returned. */
/* Note: xmalloc() can't return 0; therefore PDC_FAILURE will never
be returned. */
return *bufp ? PDC_SUCCESS : PDC_FAILURE; return *bufp ? PDC_SUCCESS : PDC_FAILURE;
} }
/* pthdb callback: reallocate BUF, which was allocated by the alloc or realloc /* pthdb callback: reallocate BUF, which was allocated by the alloc or
callback, so that it contains LEN bytes, and store a pointer to the result realloc callback, so that it contains LEN bytes, and store a
in BUFP. */ pointer to the result in BUFP. */
static int static int
pdc_realloc (pthdb_user_t user, void *buf, size_t len, void **bufp) pdc_realloc (pthdb_user_t user, void *buf, size_t len, void **bufp)
@ -509,18 +528,20 @@ pdc_realloc (pthdb_user_t user, void *buf, size_t len, void **bufp)
user, (long) buf, len, (long) bufp); user, (long) buf, len, (long) bufp);
*bufp = xrealloc (buf, len); *bufp = xrealloc (buf, len);
if (debug_aix_thread) if (debug_aix_thread)
fprintf_unfiltered (gdb_stdlog, " realloc returned 0x%lx", (long) *bufp); fprintf_unfiltered (gdb_stdlog,
" realloc returned 0x%lx", (long) *bufp);
return *bufp ? PDC_SUCCESS : PDC_FAILURE; return *bufp ? PDC_SUCCESS : PDC_FAILURE;
} }
/* pthdb callback: free BUF, which was allocated by the alloc or realloc /* pthdb callback: free BUF, which was allocated by the alloc or
callback. */ realloc callback. */
static int static int
pdc_dealloc (pthdb_user_t user, void *buf) pdc_dealloc (pthdb_user_t user, void *buf)
{ {
if (debug_aix_thread) if (debug_aix_thread)
fprintf_unfiltered (gdb_stdlog, "pdc_free (user = %ld, buf = 0x%lx)", user, fprintf_unfiltered (gdb_stdlog,
"pdc_free (user = %ld, buf = 0x%lx)", user,
(long) buf); (long) buf);
xfree (buf); xfree (buf);
return PDC_SUCCESS; return PDC_SUCCESS;
@ -572,6 +593,7 @@ giter_accum (struct thread_info *thread, void *bufp)
} }
/* ptid comparison function */ /* ptid comparison function */
static int static int
ptid_cmp (ptid_t ptid1, ptid_t ptid2) ptid_cmp (ptid_t ptid1, ptid_t ptid2)
{ {
@ -607,14 +629,14 @@ gcmp (const void *t1v, const void *t2v)
There are some benefits of doing this every time the inferior stops: There are some benefits of doing this every time the inferior stops:
- allows users to run thread-specific commands without needing to run - allows users to run thread-specific commands without needing to
"info threads" first run "info threads" first
- helps pthdb_tid_pthread() work properly (see "libpthdebug - helps pthdb_tid_pthread() work properly (see "libpthdebug
peculiarities" at the top of this module) peculiarities" at the top of this module)
- simplifies the demands placed on libpthdebug, which seems to have - simplifies the demands placed on libpthdebug, which seems to
difficulty with certain call patterns */ have difficulty with certain call patterns */
static void static void
sync_threadlists (void) sync_threadlists (void)
@ -646,7 +668,8 @@ sync_threadlists (void)
if (pcount == psize) if (pcount == psize)
{ {
psize *= 2; psize *= 2;
pbuf = (struct pd_thread *) xrealloc (pbuf, psize * sizeof *pbuf); pbuf = (struct pd_thread *) xrealloc (pbuf,
psize * sizeof *pbuf);
} }
pbuf[pcount].pdtid = pdtid; pbuf[pcount].pdtid = pdtid;
pbuf[pcount].pthid = pthid; pbuf[pcount].pthid = pthid;
@ -728,8 +751,8 @@ sync_threadlists (void)
xfree (gbuf); xfree (gbuf);
} }
/* iterate_over_threads() callback for locating a thread whose kernel thread /* Iterate_over_threads() callback for locating a thread whose kernel
just received a trap signal. */ thread just received a trap signal. */
static int static int
iter_trap (struct thread_info *thread, void *unused) iter_trap (struct thread_info *thread, void *unused)
@ -738,21 +761,23 @@ iter_trap (struct thread_info *thread, void *unused)
pthdb_tid_t tid; pthdb_tid_t tid;
/* getthrds(3) isn't prototyped in any AIX 4.3.3 #include file. */ /* getthrds(3) isn't prototyped in any AIX 4.3.3 #include file. */
extern int getthrds (pid_t, struct thrdsinfo64 *, int, pthdb_tid_t *, int); extern int getthrds (pid_t, struct thrdsinfo64 *,
int, pthdb_tid_t *, int);
tid = thread->private->tid; tid = thread->private->tid;
if (tid == PTHDB_INVALID_TID) if (tid == PTHDB_INVALID_TID)
return 0; return 0;
if (getthrds (PIDGET (inferior_ptid), &thrinf, sizeof (thrinf), &tid, 1) != 1) if (getthrds (PIDGET (inferior_ptid), &thrinf,
sizeof (thrinf), &tid, 1) != 1)
return 0; return 0;
return thrinf.ti_cursig == SIGTRAP; return thrinf.ti_cursig == SIGTRAP;
} }
/* Synchronize libpthdebug's state with the inferior and with GDB, generate a /* Synchronize libpthdebug's state with the inferior and with GDB,
composite process/thread <pid> for the current thread, set inferior_ptid to generate a composite process/thread <pid> for the current thread,
<pid> if SET_INFPID, and return <pid>. */ set inferior_ptid to <pid> if SET_INFPID, and return <pid>. */
static ptid_t static ptid_t
pd_update (int set_infpid) pd_update (int set_infpid)
@ -784,8 +809,9 @@ pd_update (int set_infpid)
return ptid; return ptid;
} }
/* Try to start debugging threads in the current process. If successful and /* Try to start debugging threads in the current process.
SET_INFPID, set inferior_ptid to reflect the current thread. */ If successful and SET_INFPID, set inferior_ptid to reflect the
current thread. */
static ptid_t static ptid_t
pd_activate (int set_infpid) pd_activate (int set_infpid)
@ -793,7 +819,8 @@ pd_activate (int set_infpid)
int status; int status;
status = pthdb_session_init (PD_USER, arch64 ? PEM_64BIT : PEM_32BIT, status = pthdb_session_init (PD_USER, arch64 ? PEM_64BIT : PEM_32BIT,
PTHDB_FLAG_REGS, &pd_callbacks, &pd_session); PTHDB_FLAG_REGS, &pd_callbacks,
&pd_session);
if (status != PTHDB_SUCCESS) if (status != PTHDB_SUCCESS)
{ {
return inferior_ptid; return inferior_ptid;
@ -815,8 +842,8 @@ pd_deactivate (void)
pd_active = 0; pd_active = 0;
} }
/* An object file has just been loaded. Check whether the current application /* An object file has just been loaded. Check whether the current
is pthreaded, and if so, prepare for thread debugging. */ application is pthreaded, and if so, prepare for thread debugging. */
static void static void
pd_enable (void) pd_enable (void)
@ -834,9 +861,10 @@ pd_enable (void)
/* Check whether the application is pthreaded. */ /* Check whether the application is pthreaded. */
stub_name = NULL; stub_name = NULL;
status = pthdb_session_pthreaded (PD_USER, PTHDB_FLAG_REGS, &pd_callbacks, status = pthdb_session_pthreaded (PD_USER, PTHDB_FLAG_REGS,
&stub_name); &pd_callbacks, &stub_name);
if ((status != PTHDB_SUCCESS && status != PTHDB_NOT_PTHREADED) || !stub_name) if ((status != PTHDB_SUCCESS &&
status != PTHDB_NOT_PTHREADED) || !stub_name)
return; return;
/* Set a breakpoint on the returned stub function. */ /* Set a breakpoint on the returned stub function. */
@ -851,9 +879,9 @@ pd_enable (void)
push_target (&ops); push_target (&ops);
pd_able = 1; pd_able = 1;
/* If we're debugging a core file or an attached inferior, the pthread /* If we're debugging a core file or an attached inferior, the
library may already have been initialized, so try to activate thread pthread library may already have been initialized, so try to
debugging. */ activate thread debugging. */
pd_activate (1); pd_activate (1);
} }
@ -872,8 +900,8 @@ pd_disable (void)
/* target_new_objfile_hook callback. /* target_new_objfile_hook callback.
If OBJFILE is non-null, check whether a threaded application is being If OBJFILE is non-null, check whether a threaded application is
debugged, and if so, prepare for thread debugging. being debugged, and if so, prepare for thread debugging.
If OBJFILE is null, stop debugging threads. */ If OBJFILE is null, stop debugging threads. */
@ -927,23 +955,27 @@ ops_resume (ptid_t ptid, int step, enum target_signal sig)
{ {
thread = find_thread_pid (ptid); thread = find_thread_pid (ptid);
if (!thread) if (!thread)
error ("aix-thread resume: unknown pthread %ld", TIDGET (ptid)); error ("aix-thread resume: unknown pthread %ld",
TIDGET (ptid));
tid[0] = thread->private->tid; tid[0] = thread->private->tid;
if (tid[0] == PTHDB_INVALID_TID) if (tid[0] == PTHDB_INVALID_TID)
error ("aix-thread resume: no tid for pthread %ld", TIDGET (ptid)); error ("aix-thread resume: no tid for pthread %ld",
TIDGET (ptid));
tid[1] = 0; tid[1] = 0;
if (arch64) if (arch64)
ptrace64aix (PTT_CONTINUE, tid[0], 1, target_signal_to_host (sig), (int *)tid); ptrace64aix (PTT_CONTINUE, tid[0], 1,
target_signal_to_host (sig), (int *)tid);
else else
ptrace32 (PTT_CONTINUE, tid[0], (int *) 1, ptrace32 (PTT_CONTINUE, tid[0], (int *) 1,
target_signal_to_host (sig), (int *)tid); target_signal_to_host (sig), (int *)tid);
} }
} }
/* Wait for thread/process ID if != -1 or for any thread otherwise. If an /* Wait for thread/process ID if != -1 or for any thread otherwise.
error occurs, return -1, else return the pid of the stopped thread. */ If an error occurs, return -1, else return the pid of the stopped
thread. */
static ptid_t static ptid_t
ops_wait (ptid_t ptid, struct target_waitstatus *status) ops_wait (ptid_t ptid, struct target_waitstatus *status)
@ -998,8 +1030,8 @@ supply_fprs (double *vals)
supply_register (regno + FP0_REGNUM, (char *) (vals + regno)); supply_register (regno + FP0_REGNUM, (char *) (vals + regno));
} }
/* Record that the special registers contain the specified 64-bit and 32-bit /* Record that the special registers contain the specified 64-bit and
values. */ 32-bit values. */
static void static void
supply_sprs64 (uint64_t iar, uint64_t msr, uint32_t cr, supply_sprs64 (uint64_t iar, uint64_t msr, uint32_t cr,
@ -1014,7 +1046,8 @@ supply_sprs64 (uint64_t iar, uint64_t msr, uint32_t cr,
supply_register (regno + 5, (char *) &xer); supply_register (regno + 5, (char *) &xer);
} }
/* Record that the special registers contain the specified 32-bit values. */ /* Record that the special registers contain the specified 32-bit
values. */
static void static void
supply_sprs32 (uint32_t iar, uint32_t msr, uint32_t cr, supply_sprs32 (uint32_t iar, uint32_t msr, uint32_t cr,
@ -1032,8 +1065,9 @@ supply_sprs32 (uint32_t iar, uint32_t msr, uint32_t cr,
/* Fetch all registers from pthread PDTID, which doesn't have a kernel /* Fetch all registers from pthread PDTID, which doesn't have a kernel
thread. thread.
There's no way to query a single register from a non-kernel pthread, There's no way to query a single register from a non-kernel
so there's no need for a single-register version of this function. */ pthread, so there's no need for a single-register version of this
function. */
static void static void
fetch_regs_lib (pthdb_pthread_t pdtid) fetch_regs_lib (pthdb_pthread_t pdtid)
@ -1068,18 +1102,20 @@ fetch_regs_lib (pthdb_pthread_t pdtid)
supply_sprs32 (ctx.iar, ctx.msr, ctx.cr, ctx.lr, ctx.ctr, ctx.xer); supply_sprs32 (ctx.iar, ctx.msr, ctx.cr, ctx.lr, ctx.ctr, ctx.xer);
} }
/* Fetch register REGNO if != -1 or all registers otherwise from kernel thread /* Fetch register REGNO if != -1 or all registers otherwise from
TID. kernel thread TID.
AIX provides a way to query all of a kernel thread's GPRs, FPRs, or SPRs, AIX provides a way to query all of a kernel thread's GPRs, FPRs, or
but there's no way to query individual registers within those groups. SPRs, but there's no way to query individual registers within those
Therefore, if REGNO != -1, this function fetches an entire group. groups. Therefore, if REGNO != -1, this function fetches an entire
group.
Unfortunately, kernel thread register queries often fail with EPERM, Unfortunately, kernel thread register queries often fail with
indicating that the thread is in kernel space. This breaks backtraces of EPERM, indicating that the thread is in kernel space. This breaks
threads other than the current one. To make that breakage obvious without backtraces of threads other than the current one. To make that
throwing an error to top level (which is bad e.g. during "info threads" breakage obvious without throwing an error to top level (which is
output), zero registers that can't be retrieved. */ bad e.g. during "info threads" output), zero registers that can't
be retrieved. */
static void static void
fetch_regs_kern (int regno, pthdb_tid_t tid) fetch_regs_kern (int regno, pthdb_tid_t tid)
@ -1101,7 +1137,8 @@ fetch_regs_kern (int regno, pthdb_tid_t tid)
{ {
if (arch64) if (arch64)
{ {
if (!ptrace64aix (PTT_READ_GPRS, tid, (unsigned long) gprs64, 0, NULL)) if (!ptrace64aix (PTT_READ_GPRS, tid,
(unsigned long) gprs64, 0, NULL))
memset (gprs64, 0, sizeof (gprs64)); memset (gprs64, 0, sizeof (gprs64));
supply_gprs64 (gprs64); supply_gprs64 (gprs64);
} }
@ -1125,11 +1162,13 @@ fetch_regs_kern (int regno, pthdb_tid_t tid)
/* Special-purpose registers. */ /* Special-purpose registers. */
if (regno == -1 || (regno > FPLAST_REGNUM && regno <= LAST_UISA_SP_REGNUM)) if (regno == -1 ||
(regno > FPLAST_REGNUM && regno <= LAST_UISA_SP_REGNUM))
{ {
if (arch64) if (arch64)
{ {
if (!ptrace64aix (PTT_READ_SPRS, tid, (unsigned long) &sprs64, 0, NULL)) if (!ptrace64aix (PTT_READ_SPRS, tid,
(unsigned long) &sprs64, 0, NULL))
memset (&sprs64, 0, sizeof (sprs64)); memset (&sprs64, 0, sizeof (sprs64));
supply_sprs64 (sprs64.pt_iar, sprs64.pt_msr, sprs64.pt_cr, supply_sprs64 (sprs64.pt_iar, sprs64.pt_msr, sprs64.pt_cr,
sprs64.pt_lr, sprs64.pt_ctr, sprs64.pt_xer); sprs64.pt_lr, sprs64.pt_ctr, sprs64.pt_xer);
@ -1189,8 +1228,8 @@ fill_sprs64 (uint64_t *iar, uint64_t *msr, uint32_t *cr,
/* Store all registers into pthread PDTID, which doesn't have a kernel /* Store all registers into pthread PDTID, which doesn't have a kernel
thread. thread.
It's possible to store a single register into a non-kernel pthread, but I It's possible to store a single register into a non-kernel pthread,
doubt it's worth the effort. */ but I doubt it's worth the effort. */
static void static void
store_regs_lib (pthdb_pthread_t pdtid) store_regs_lib (pthdb_pthread_t pdtid)
@ -1199,9 +1238,11 @@ store_regs_lib (pthdb_pthread_t pdtid)
pthdb_context_t ctx; pthdb_context_t ctx;
if (debug_aix_thread) if (debug_aix_thread)
fprintf_unfiltered (gdb_stdlog, "store_regs_lib %lx\n", (long)pdtid); fprintf_unfiltered (gdb_stdlog,
"store_regs_lib %lx\n", (long)pdtid);
/* Retrieve the thread's current context for its non-register values. */ /* Retrieve the thread's current context for its non-register
values. */
status = pthdb_pthread_context (pd_session, pdtid, &ctx); status = pthdb_pthread_context (pd_session, pdtid, &ctx);
if (status != PTHDB_SUCCESS) if (status != PTHDB_SUCCESS)
error ("aix-thread: store_registers: pthdb_pthread_context returned %s", error ("aix-thread: store_registers: pthdb_pthread_context returned %s",
@ -1227,12 +1268,13 @@ store_regs_lib (pthdb_pthread_t pdtid)
pd_status2str (status)); pd_status2str (status));
} }
/* Store register REGNO if != -1 or all registers otherwise into kernel /* Store register REGNO if != -1 or all registers otherwise into
thread TID. kernel thread TID.
AIX provides a way to set all of a kernel thread's GPRs, FPRs, or SPRs, but AIX provides a way to set all of a kernel thread's GPRs, FPRs, or
there's no way to set individual registers within those groups. Therefore, SPRs, but there's no way to set individual registers within those
if REGNO != -1, this function stores an entire group. */ groups. Therefore, if REGNO != -1, this function stores an entire
group. */
static void static void
store_regs_kern (int regno, pthdb_tid_t tid) store_regs_kern (int regno, pthdb_tid_t tid)
@ -1265,14 +1307,17 @@ store_regs_kern (int regno, pthdb_tid_t tid)
/* Special-purpose registers. */ /* Special-purpose registers. */
if (regno == -1 || (regno > FPLAST_REGNUM && regno <= LAST_UISA_SP_REGNUM)) if (regno == -1 ||
(regno > FPLAST_REGNUM && regno <= LAST_UISA_SP_REGNUM))
{ {
if (arch64) if (arch64)
{ {
ptrace64aix (PTT_READ_SPRS, tid, (unsigned long) &sprs64, 0, NULL); ptrace64aix (PTT_READ_SPRS, tid,
(unsigned long) &sprs64, 0, NULL);
fill_sprs64 (&sprs64.pt_iar, &sprs64.pt_msr, &sprs64.pt_cr, fill_sprs64 (&sprs64.pt_iar, &sprs64.pt_msr, &sprs64.pt_cr,
&sprs64.pt_lr, &sprs64.pt_ctr, &sprs64.pt_xer); &sprs64.pt_lr, &sprs64.pt_ctr, &sprs64.pt_xer);
ptrace64aix (PTT_WRITE_SPRS, tid, (unsigned long) &sprs64, 0, NULL); ptrace64aix (PTT_WRITE_SPRS, tid,
(unsigned long) &sprs64, 0, NULL);
} }
else else
{ {
@ -1294,8 +1339,8 @@ store_regs_kern (int regno, pthdb_tid_t tid)
} }
} }
/* Store gdb's current view of the register set into the thread/process /* Store gdb's current view of the register set into the
specified by inferior_ptid. */ thread/process specified by inferior_ptid. */
static void static void
ops_store_registers (int regno) ops_store_registers (int regno)
@ -1328,8 +1373,8 @@ ops_prepare_to_store (void)
read_register_bytes (0, NULL, REGISTER_BYTES); read_register_bytes (0, NULL, REGISTER_BYTES);
} }
/* Transfer LEN bytes of memory from GDB address MYADDR to target address /* Transfer LEN bytes of memory from GDB address MYADDR to target
MEMADDR if WRITE and vice versa otherwise. */ address MEMADDR if WRITE and vice versa otherwise. */
static int static int
ops_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write, ops_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
@ -1340,7 +1385,8 @@ ops_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
struct cleanup *cleanup = save_inferior_ptid (); struct cleanup *cleanup = save_inferior_ptid ();
inferior_ptid = pid_to_ptid (PIDGET (inferior_ptid)); inferior_ptid = pid_to_ptid (PIDGET (inferior_ptid));
n = base_ops.to_xfer_memory (memaddr, myaddr, len, write, attrib, &base_ops); n = base_ops.to_xfer_memory (memaddr, myaddr, len,
write, attrib, &base_ops);
do_cleanups (cleanup); do_cleanups (cleanup);
return n; return n;
@ -1375,13 +1421,13 @@ ops_thread_alive (ptid_t ptid)
if (!PD_TID (ptid)) if (!PD_TID (ptid))
return base_ops.to_thread_alive (ptid); return base_ops.to_thread_alive (ptid);
/* We update the thread list every time the child stops, so all valid /* We update the thread list every time the child stops, so all
threads should be in the thread list. */ valid threads should be in the thread list. */
return in_thread_list (ptid); return in_thread_list (ptid);
} }
/* Return a printable representation of composite PID for use in "info /* Return a printable representation of composite PID for use in
threads" output. */ "info threads" output. */
static char * static char *
ops_pid_to_str (ptid_t ptid) ops_pid_to_str (ptid_t ptid)
@ -1399,8 +1445,8 @@ ops_pid_to_str (ptid_t ptid)
return ret; return ret;
} }
/* Return a printable representation of extra information about THREAD, for /* Return a printable representation of extra information about
use in "info threads" output. */ THREAD, for use in "info threads" output. */
static char * static char *
ops_extra_thread_info (struct thread_info *thread) ops_extra_thread_info (struct thread_info *thread)
@ -1432,11 +1478,13 @@ ops_extra_thread_info (struct thread_info *thread)
state = PST_NOTSUP; state = PST_NOTSUP;
fprintf_unfiltered (buf, ", %s", state2str (state)); fprintf_unfiltered (buf, ", %s", state2str (state));
status = pthdb_pthread_suspendstate (pd_session, pdtid, &suspendstate); status = pthdb_pthread_suspendstate (pd_session, pdtid,
&suspendstate);
if (status == PTHDB_SUCCESS && suspendstate == PSS_SUSPENDED) if (status == PTHDB_SUCCESS && suspendstate == PSS_SUSPENDED)
fprintf_unfiltered (buf, ", suspended"); fprintf_unfiltered (buf, ", suspended");
status = pthdb_pthread_detachstate (pd_session, pdtid, &detachstate); status = pthdb_pthread_detachstate (pd_session, pdtid,
&detachstate);
if (status == PTHDB_SUCCESS && detachstate == PDS_DETACHED) if (status == PTHDB_SUCCESS && detachstate == PDS_DETACHED)
fprintf_unfiltered (buf, ", detached"); fprintf_unfiltered (buf, ", detached");
@ -1471,8 +1519,8 @@ init_ops (void)
ops.to_store_registers = ops_store_registers; ops.to_store_registers = ops_store_registers;
ops.to_prepare_to_store = ops_prepare_to_store; ops.to_prepare_to_store = ops_prepare_to_store;
ops.to_xfer_memory = ops_xfer_memory; ops.to_xfer_memory = ops_xfer_memory;
/* No need for ops.to_create_inferior, because we activate thread debugging /* No need for ops.to_create_inferior, because we activate thread
when the inferior reaches pd_brk_addr. */ debugging when the inferior reaches pd_brk_addr. */
ops.to_kill = ops_kill; ops.to_kill = ops_kill;
ops.to_mourn_inferior = ops_mourn_inferior; ops.to_mourn_inferior = ops_mourn_inferior;
ops.to_thread_alive = ops_thread_alive; ops.to_thread_alive = ops_thread_alive;