1 /* Low level interface for debugging AIX 4.3+ pthreads.
3 Copyright (C) 1999-2018 Free Software Foundation, Inc.
4 Written by Nick Duffek <nsd@redhat.com>.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 /* This module uses the libpthdebug.a library provided by AIX 4.3+ for
23 debugging pthread applications.
25 Some name prefix conventions:
26 pthdb_ provided by libpthdebug.a
27 pdc_ callbacks that this module provides to libpthdebug.a
28 pd_ variables or functions interfacing with libpthdebug.a
30 libpthdebug peculiarities:
32 - pthdb_ptid_pthread() is prototyped in <sys/pthdebug.h>, but
33 it's not documented, and after several calls it stops working
34 and causes other libpthdebug functions to fail.
36 - pthdb_tid_pthread() doesn't always work after
37 pthdb_session_update(), but it does work after cycling through
38 all threads using pthdb_pthread().
43 #include "gdbthread.h"
53 #include <sys/types.h>
54 #include <sys/ptrace.h>
57 #include <sys/pthdebug.h>
59 #if !HAVE_DECL_GETTHRDS
60 extern int getthrds (pid_t, struct thrdsinfo64 *, int, tid_t *, int);
63 /* Whether to emit debugging output. */
64 static int debug_aix_thread;
66 /* In AIX 5.1, functions use pthdb_tid_t instead of tid_t. */
67 #ifndef PTHDB_VERSION_3
68 #define pthdb_tid_t tid_t
71 /* Return whether to treat PID as a debuggable thread id. */
73 #define PD_TID(ptid) (pd_active && ptid_get_tid (ptid) != 0)
75 /* pthdb_user_t value that we pass to pthdb functions. 0 causes
76 PTHDB_BAD_USER errors, so use 1. */
80 /* Success and failure values returned by pthdb callbacks. */
82 #define PDC_SUCCESS PTHDB_SUCCESS
83 #define PDC_FAILURE PTHDB_CALLBACK
85 /* Private data attached to each element in GDB's thread list. */
87 struct aix_thread_info : public private_thread_info
89 pthdb_pthread_t pdtid; /* thread's libpthdebug id */
90 pthdb_tid_t tid; /* kernel thread id */
93 /* Return the aix_thread_info attached to THREAD. */
95 static aix_thread_info *
96 get_aix_thread_info (thread_info *thread)
98 return static_cast<aix_thread_info *> (thread->priv.get ());
101 /* Information about a thread of which libpthdebug is aware. */
104 pthdb_pthread_t pdtid;
109 /* This module's target-specific operations, active while pd_able is true. */
111 static struct target_ops aix_thread_ops;
113 /* Address of the function that libpthread will call when libpthdebug
114 is ready to be initialized. */
116 static CORE_ADDR pd_brk_addr;
118 /* Whether the current application is debuggable by pthdb. */
120 static int pd_able = 0;
122 /* Whether a threaded application is being debugged. */
124 static int pd_active = 0;
126 /* Whether the current architecture is 64-bit.
127 Only valid when pd_able is true. */
131 /* Forward declarations for pthdb callbacks. */
133 static int pdc_symbol_addrs (pthdb_user_t, pthdb_symbol_t *, int);
134 static int pdc_read_data (pthdb_user_t, void *, pthdb_addr_t, size_t);
135 static int pdc_write_data (pthdb_user_t, void *, pthdb_addr_t, size_t);
136 static int pdc_read_regs (pthdb_user_t user, pthdb_tid_t tid,
137 unsigned long long flags,
138 pthdb_context_t *context);
139 static int pdc_write_regs (pthdb_user_t user, pthdb_tid_t tid,
140 unsigned long long flags,
141 pthdb_context_t *context);
142 static int pdc_alloc (pthdb_user_t, size_t, void **);
143 static int pdc_realloc (pthdb_user_t, void *, size_t, void **);
144 static int pdc_dealloc (pthdb_user_t, void *);
146 /* pthdb callbacks. */
148 static pthdb_callbacks_t pd_callbacks = {
160 /* Current pthdb session. */
162 static pthdb_session_t pd_session;
164 /* Return a printable representation of pthdebug function return
168 pd_status2str (int status)
172 case PTHDB_SUCCESS: return "SUCCESS";
173 case PTHDB_NOSYS: return "NOSYS";
174 case PTHDB_NOTSUP: return "NOTSUP";
175 case PTHDB_BAD_VERSION: return "BAD_VERSION";
176 case PTHDB_BAD_USER: return "BAD_USER";
177 case PTHDB_BAD_SESSION: return "BAD_SESSION";
178 case PTHDB_BAD_MODE: return "BAD_MODE";
179 case PTHDB_BAD_FLAGS: return "BAD_FLAGS";
180 case PTHDB_BAD_CALLBACK: return "BAD_CALLBACK";
181 case PTHDB_BAD_POINTER: return "BAD_POINTER";
182 case PTHDB_BAD_CMD: return "BAD_CMD";
183 case PTHDB_BAD_PTHREAD: return "BAD_PTHREAD";
184 case PTHDB_BAD_ATTR: return "BAD_ATTR";
185 case PTHDB_BAD_MUTEX: return "BAD_MUTEX";
186 case PTHDB_BAD_MUTEXATTR: return "BAD_MUTEXATTR";
187 case PTHDB_BAD_COND: return "BAD_COND";
188 case PTHDB_BAD_CONDATTR: return "BAD_CONDATTR";
189 case PTHDB_BAD_RWLOCK: return "BAD_RWLOCK";
190 case PTHDB_BAD_RWLOCKATTR: return "BAD_RWLOCKATTR";
191 case PTHDB_BAD_KEY: return "BAD_KEY";
192 case PTHDB_BAD_PTID: return "BAD_PTID";
193 case PTHDB_BAD_TID: return "BAD_TID";
194 case PTHDB_CALLBACK: return "CALLBACK";
195 case PTHDB_CONTEXT: return "CONTEXT";
196 case PTHDB_HELD: return "HELD";
197 case PTHDB_NOT_HELD: return "NOT_HELD";
198 case PTHDB_MEMORY: return "MEMORY";
199 case PTHDB_NOT_PTHREADED: return "NOT_PTHREADED";
200 case PTHDB_SYMBOL: return "SYMBOL";
201 case PTHDB_NOT_AVAIL: return "NOT_AVAIL";
202 case PTHDB_INTERNAL: return "INTERNAL";
203 default: return "UNKNOWN";
207 /* A call to ptrace(REQ, ID, ...) just returned RET. Check for
208 exceptional conditions and either return nonlocally or else return
209 1 for success and 0 for failure. */
212 ptrace_check (int req, int id, int ret)
214 if (ret == 0 && !errno)
217 /* According to ptrace(2), ptrace may fail with EPERM if "the
218 Identifier parameter corresponds to a kernel thread which is
219 stopped in kernel mode and whose computational state cannot be
220 read or written." This happens quite often with register reads. */
227 if (ret == -1 && errno == EPERM)
229 if (debug_aix_thread)
230 fprintf_unfiltered (gdb_stdlog,
231 "ptrace (%d, %d) = %d (errno = %d)\n",
232 req, id, ret, errno);
233 return ret == -1 ? 0 : 1;
237 error (_("aix-thread: ptrace (%d, %d) returned %d (errno = %d %s)"),
238 req, id, ret, errno, safe_strerror (errno));
239 return 0; /* Not reached. */
242 /* Call ptracex (REQ, ID, ADDR, DATA, BUF) or
243 ptrace64 (REQ, ID, ADDR, DATA, BUF) if HAVE_PTRACE64.
247 # define ptracex(request, pid, addr, data, buf) \
248 ptrace64 (request, pid, addr, data, buf)
252 ptrace64aix (int req, int id, long long addr, int data, int *buf)
255 return ptrace_check (req, id, ptracex (req, id, addr, data, buf));
258 /* Call ptrace (REQ, ID, ADDR, DATA, BUF) or
259 ptrace64 (REQ, ID, ADDR, DATA, BUF) if HAVE_PTRACE64.
263 # define ptrace(request, pid, addr, data, buf) \
264 ptrace64 (request, pid, addr, data, buf)
265 # define addr_ptr long long
267 # define addr_ptr int *
271 ptrace32 (int req, int id, addr_ptr addr, int data, int *buf)
274 return ptrace_check (req, id,
275 ptrace (req, id, addr, data, buf));
278 /* If *PIDP is a composite process/thread id, convert it to a
282 pid_to_prc (ptid_t *ptidp)
288 *ptidp = pid_to_ptid (ptid_get_pid (ptid));
291 /* pthdb callback: for <i> from 0 to COUNT, set SYMBOLS[<i>].addr to
292 the address of SYMBOLS[<i>].name. */
295 pdc_symbol_addrs (pthdb_user_t user, pthdb_symbol_t *symbols, int count)
297 struct bound_minimal_symbol ms;
301 if (debug_aix_thread)
302 fprintf_unfiltered (gdb_stdlog,
303 "pdc_symbol_addrs (user = %ld, symbols = 0x%lx, count = %d)\n",
304 user, (long) symbols, count);
306 for (i = 0; i < count; i++)
308 name = symbols[i].name;
309 if (debug_aix_thread)
310 fprintf_unfiltered (gdb_stdlog,
311 " symbols[%d].name = \"%s\"\n", i, name);
317 ms = lookup_minimal_symbol (name, NULL, NULL);
318 if (ms.minsym == NULL)
320 if (debug_aix_thread)
321 fprintf_unfiltered (gdb_stdlog, " returning PDC_FAILURE\n");
324 symbols[i].addr = BMSYMBOL_VALUE_ADDRESS (ms);
326 if (debug_aix_thread)
327 fprintf_unfiltered (gdb_stdlog, " symbols[%d].addr = %s\n",
328 i, hex_string (symbols[i].addr));
330 if (debug_aix_thread)
331 fprintf_unfiltered (gdb_stdlog, " returning PDC_SUCCESS\n");
335 /* Read registers call back function should be able to read the
336 context information of a debuggee kernel thread from an active
337 process or from a core file. The information should be formatted
338 in context64 form for both 32-bit and 64-bit process.
339 If successful return 0, else non-zero is returned. */
342 pdc_read_regs (pthdb_user_t user,
344 unsigned long long flags,
345 pthdb_context_t *context)
347 /* This function doesn't appear to be used, so we could probably
348 just return 0 here. HOWEVER, if it is not defined, the OS will
349 complain and several thread debug functions will fail. In case
350 this is needed, I have implemented what I think it should do,
351 however this code is untested. */
353 uint64_t gprs64[ppc_num_gprs];
354 uint32_t gprs32[ppc_num_gprs];
355 double fprs[ppc_num_fprs];
356 struct ptxsprs sprs64;
357 struct ptsprs sprs32;
359 if (debug_aix_thread)
360 fprintf_unfiltered (gdb_stdlog, "pdc_read_regs tid=%d flags=%s\n",
361 (int) tid, hex_string (flags));
363 /* General-purpose registers. */
364 if (flags & PTHDB_FLAG_GPRS)
368 if (!ptrace64aix (PTT_READ_GPRS, tid,
369 (unsigned long) gprs64, 0, NULL))
370 memset (gprs64, 0, sizeof (gprs64));
371 memcpy (context->gpr, gprs64, sizeof(gprs64));
375 if (!ptrace32 (PTT_READ_GPRS, tid, (uintptr_t) gprs32, 0, NULL))
376 memset (gprs32, 0, sizeof (gprs32));
377 memcpy (context->gpr, gprs32, sizeof(gprs32));
381 /* Floating-point registers. */
382 if (flags & PTHDB_FLAG_FPRS)
384 if (!ptrace32 (PTT_READ_FPRS, tid, (uintptr_t) fprs, 0, NULL))
385 memset (fprs, 0, sizeof (fprs));
386 memcpy (context->fpr, fprs, sizeof(fprs));
389 /* Special-purpose registers. */
390 if (flags & PTHDB_FLAG_SPRS)
394 if (!ptrace64aix (PTT_READ_SPRS, tid,
395 (unsigned long) &sprs64, 0, NULL))
396 memset (&sprs64, 0, sizeof (sprs64));
397 memcpy (&context->msr, &sprs64, sizeof(sprs64));
401 if (!ptrace32 (PTT_READ_SPRS, tid, (uintptr_t) &sprs32, 0, NULL))
402 memset (&sprs32, 0, sizeof (sprs32));
403 memcpy (&context->msr, &sprs32, sizeof(sprs32));
409 /* Write register function should be able to write requested context
410 information to specified debuggee's kernel thread id.
411 If successful return 0, else non-zero is returned. */
414 pdc_write_regs (pthdb_user_t user,
416 unsigned long long flags,
417 pthdb_context_t *context)
419 /* This function doesn't appear to be used, so we could probably
420 just return 0 here. HOWEVER, if it is not defined, the OS will
421 complain and several thread debug functions will fail. In case
422 this is needed, I have implemented what I think it should do,
423 however this code is untested. */
425 if (debug_aix_thread)
426 fprintf_unfiltered (gdb_stdlog, "pdc_write_regs tid=%d flags=%s\n",
427 (int) tid, hex_string (flags));
429 /* General-purpose registers. */
430 if (flags & PTHDB_FLAG_GPRS)
433 ptrace64aix (PTT_WRITE_GPRS, tid,
434 (unsigned long) context->gpr, 0, NULL);
436 ptrace32 (PTT_WRITE_GPRS, tid, (uintptr_t) context->gpr, 0, NULL);
439 /* Floating-point registers. */
440 if (flags & PTHDB_FLAG_FPRS)
442 ptrace32 (PTT_WRITE_FPRS, tid, (uintptr_t) context->fpr, 0, NULL);
445 /* Special-purpose registers. */
446 if (flags & PTHDB_FLAG_SPRS)
450 ptrace64aix (PTT_WRITE_SPRS, tid,
451 (unsigned long) &context->msr, 0, NULL);
455 ptrace32 (PTT_WRITE_SPRS, tid, (uintptr_t) &context->msr, 0, NULL);
461 /* pthdb callback: read LEN bytes from process ADDR into BUF. */
464 pdc_read_data (pthdb_user_t user, void *buf,
465 pthdb_addr_t addr, size_t len)
469 if (debug_aix_thread)
470 fprintf_unfiltered (gdb_stdlog,
471 "pdc_read_data (user = %ld, buf = 0x%lx, addr = %s, len = %ld)\n",
472 user, (long) buf, hex_string (addr), len);
474 status = target_read_memory (addr, (gdb_byte *) buf, len);
475 ret = status == 0 ? PDC_SUCCESS : PDC_FAILURE;
477 if (debug_aix_thread)
478 fprintf_unfiltered (gdb_stdlog, " status=%d, returning %s\n",
479 status, pd_status2str (ret));
483 /* pthdb callback: write LEN bytes from BUF to process ADDR. */
486 pdc_write_data (pthdb_user_t user, void *buf,
487 pthdb_addr_t addr, size_t len)
491 if (debug_aix_thread)
492 fprintf_unfiltered (gdb_stdlog,
493 "pdc_write_data (user = %ld, buf = 0x%lx, addr = %s, len = %ld)\n",
494 user, (long) buf, hex_string (addr), len);
496 status = target_write_memory (addr, (gdb_byte *) buf, len);
497 ret = status == 0 ? PDC_SUCCESS : PDC_FAILURE;
499 if (debug_aix_thread)
500 fprintf_unfiltered (gdb_stdlog, " status=%d, returning %s\n", status,
501 pd_status2str (ret));
505 /* pthdb callback: allocate a LEN-byte buffer and store a pointer to it
509 pdc_alloc (pthdb_user_t user, size_t len, void **bufp)
511 if (debug_aix_thread)
512 fprintf_unfiltered (gdb_stdlog,
513 "pdc_alloc (user = %ld, len = %ld, bufp = 0x%lx)\n",
514 user, len, (long) bufp);
515 *bufp = xmalloc (len);
516 if (debug_aix_thread)
517 fprintf_unfiltered (gdb_stdlog,
518 " malloc returned 0x%lx\n", (long) *bufp);
520 /* Note: xmalloc() can't return 0; therefore PDC_FAILURE will never
523 return *bufp ? PDC_SUCCESS : PDC_FAILURE;
526 /* pthdb callback: reallocate BUF, which was allocated by the alloc or
527 realloc callback, so that it contains LEN bytes, and store a
528 pointer to the result in BUFP. */
531 pdc_realloc (pthdb_user_t user, void *buf, size_t len, void **bufp)
533 if (debug_aix_thread)
534 fprintf_unfiltered (gdb_stdlog,
535 "pdc_realloc (user = %ld, buf = 0x%lx, len = %ld, bufp = 0x%lx)\n",
536 user, (long) buf, len, (long) bufp);
537 *bufp = xrealloc (buf, len);
538 if (debug_aix_thread)
539 fprintf_unfiltered (gdb_stdlog,
540 " realloc returned 0x%lx\n", (long) *bufp);
541 return *bufp ? PDC_SUCCESS : PDC_FAILURE;
544 /* pthdb callback: free BUF, which was allocated by the alloc or
548 pdc_dealloc (pthdb_user_t user, void *buf)
550 if (debug_aix_thread)
551 fprintf_unfiltered (gdb_stdlog,
552 "pdc_free (user = %ld, buf = 0x%lx)\n", user,
558 /* Return a printable representation of pthread STATE. */
561 state2str (pthdb_state_t state)
566 /* i18n: Like "Thread-Id %d, [state] idle" */
567 return _("idle"); /* being created */
569 /* i18n: Like "Thread-Id %d, [state] running" */
570 return _("running"); /* running */
572 /* i18n: Like "Thread-Id %d, [state] sleeping" */
573 return _("sleeping"); /* awaiting an event */
575 /* i18n: Like "Thread-Id %d, [state] ready" */
576 return _("ready"); /* runnable */
578 /* i18n: Like "Thread-Id %d, [state] finished" */
579 return _("finished"); /* awaiting a join/detach */
581 /* i18n: Like "Thread-Id %d, [state] unknown" */
586 /* qsort() comparison function for sorting pd_thread structs by pthid. */
589 pcmp (const void *p1v, const void *p2v)
591 struct pd_thread *p1 = (struct pd_thread *) p1v;
592 struct pd_thread *p2 = (struct pd_thread *) p2v;
593 return p1->pthid < p2->pthid ? -1 : p1->pthid > p2->pthid;
596 /* iterate_over_threads() callback for counting GDB threads.
598 Do not count the main thread (whose tid is zero). This matches
599 the list of threads provided by the pthreaddebug library, which
600 does not include that main thread either, and thus allows us
601 to compare the two lists. */
604 giter_count (struct thread_info *thread, void *countp)
606 if (PD_TID (thread->ptid))
611 /* iterate_over_threads() callback for accumulating GDB thread pids.
613 Do not include the main thread (whose tid is zero). This matches
614 the list of threads provided by the pthreaddebug library, which
615 does not include that main thread either, and thus allows us
616 to compare the two lists. */
619 giter_accum (struct thread_info *thread, void *bufp)
621 if (PD_TID (thread->ptid))
623 **(struct thread_info ***) bufp = thread;
624 (*(struct thread_info ***) bufp)++;
629 /* ptid comparison function */
632 ptid_cmp (ptid_t ptid1, ptid_t ptid2)
636 if (ptid_get_pid (ptid1) < ptid_get_pid (ptid2))
638 else if (ptid_get_pid (ptid1) > ptid_get_pid (ptid2))
640 else if (ptid_get_tid (ptid1) < ptid_get_tid (ptid2))
642 else if (ptid_get_tid (ptid1) > ptid_get_tid (ptid2))
644 else if (ptid_get_lwp (ptid1) < ptid_get_lwp (ptid2))
646 else if (ptid_get_lwp (ptid1) > ptid_get_lwp (ptid2))
652 /* qsort() comparison function for sorting thread_info structs by pid. */
655 gcmp (const void *t1v, const void *t2v)
657 struct thread_info *t1 = *(struct thread_info **) t1v;
658 struct thread_info *t2 = *(struct thread_info **) t2v;
659 return ptid_cmp (t1->ptid, t2->ptid);
662 /* Search through the list of all kernel threads for the thread
663 that has stopped on a SIGTRAP signal, and return its TID.
664 Return 0 if none found. */
667 get_signaled_thread (void)
669 struct thrdsinfo64 thrinf;
675 if (getthrds (ptid_get_pid (inferior_ptid), &thrinf,
676 sizeof (thrinf), &ktid, 1) != 1)
679 if (thrinf.ti_cursig == SIGTRAP)
680 return thrinf.ti_tid;
683 /* Didn't find any thread stopped on a SIGTRAP signal. */
687 /* Synchronize GDB's thread list with libpthdebug's.
689 There are some benefits of doing this every time the inferior stops:
691 - allows users to run thread-specific commands without needing to
692 run "info threads" first
694 - helps pthdb_tid_pthread() work properly (see "libpthdebug
695 peculiarities" at the top of this module)
697 - simplifies the demands placed on libpthdebug, which seems to
698 have difficulty with certain call patterns */
701 sync_threadlists (void)
703 int cmd, status, infpid;
704 int pcount, psize, pi, gcount, gi;
705 struct pd_thread *pbuf;
706 struct thread_info **gbuf, **g, *thread;
707 pthdb_pthread_t pdtid;
711 /* Accumulate an array of libpthdebug threads sorted by pthread id. */
715 pbuf = XNEWVEC (struct pd_thread, psize);
717 for (cmd = PTHDB_LIST_FIRST;; cmd = PTHDB_LIST_NEXT)
719 status = pthdb_pthread (pd_session, &pdtid, cmd);
720 if (status != PTHDB_SUCCESS || pdtid == PTHDB_INVALID_PTHREAD)
723 status = pthdb_pthread_ptid (pd_session, pdtid, &pthid);
724 if (status != PTHDB_SUCCESS || pthid == PTHDB_INVALID_PTID)
730 pbuf = (struct pd_thread *) xrealloc (pbuf,
731 psize * sizeof *pbuf);
733 pbuf[pcount].pdtid = pdtid;
734 pbuf[pcount].pthid = pthid;
738 for (pi = 0; pi < pcount; pi++)
740 status = pthdb_pthread_tid (pd_session, pbuf[pi].pdtid, &tid);
741 if (status != PTHDB_SUCCESS)
742 tid = PTHDB_INVALID_TID;
746 qsort (pbuf, pcount, sizeof *pbuf, pcmp);
748 /* Accumulate an array of GDB threads sorted by pid. */
751 iterate_over_threads (giter_count, &gcount);
752 g = gbuf = XNEWVEC (struct thread_info *, gcount);
753 iterate_over_threads (giter_accum, &g);
754 qsort (gbuf, gcount, sizeof *gbuf, gcmp);
756 /* Apply differences between the two arrays to GDB's thread list. */
758 infpid = ptid_get_pid (inferior_ptid);
759 for (pi = gi = 0; pi < pcount || gi < gcount;)
763 delete_thread (gbuf[gi]->ptid);
766 else if (gi == gcount)
768 aix_thread_info *priv = new aix_thread_info;
769 priv->pdtid = pbuf[pi].pdtid;
770 priv->tid = pbuf[pi].tid;
772 thread = add_thread_with_info (ptid_t (infpid, 0, pbuf[pi].pthid), priv);
781 pptid = ptid_build (infpid, 0, pbuf[pi].pthid);
782 gptid = gbuf[gi]->ptid;
783 pdtid = pbuf[pi].pdtid;
786 cmp_result = ptid_cmp (pptid, gptid);
790 aix_thread_info *priv = get_aix_thread_info (gbuf[gi]);
797 else if (cmp_result > 0)
799 delete_thread (gptid);
804 thread = add_thread (pptid);
806 aix_thread_info *priv = new aix_thread_info;
807 thread->priv.reset (priv);
819 /* Iterate_over_threads() callback for locating a thread, using
820 the TID of its associated kernel thread. */
823 iter_tid (struct thread_info *thread, void *tidp)
825 const pthdb_tid_t tid = *(pthdb_tid_t *)tidp;
826 aix_thread_info *priv = get_aix_thread_info (thread);
828 return priv->tid == tid;
831 /* Synchronize libpthdebug's state with the inferior and with GDB,
832 generate a composite process/thread <pid> for the current thread,
833 set inferior_ptid to <pid> if SET_INFPID, and return <pid>. */
836 pd_update (int set_infpid)
841 struct thread_info *thread = NULL;
844 return inferior_ptid;
846 status = pthdb_session_update (pd_session);
847 if (status != PTHDB_SUCCESS)
848 return inferior_ptid;
852 /* Define "current thread" as one that just received a trap signal. */
854 tid = get_signaled_thread ();
856 thread = iterate_over_threads (iter_tid, &tid);
858 ptid = inferior_ptid;
863 inferior_ptid = ptid;
868 /* Try to start debugging threads in the current process.
869 If successful and SET_INFPID, set inferior_ptid to reflect the
873 pd_activate (int set_infpid)
877 status = pthdb_session_init (PD_USER, arch64 ? PEM_64BIT : PEM_32BIT,
878 PTHDB_FLAG_REGS, &pd_callbacks,
880 if (status != PTHDB_SUCCESS)
882 return inferior_ptid;
885 return pd_update (set_infpid);
888 /* Undo the effects of pd_activate(). */
895 pthdb_session_destroy (pd_session);
897 pid_to_prc (&inferior_ptid);
901 /* An object file has just been loaded. Check whether the current
902 application is pthreaded, and if so, prepare for thread debugging. */
909 struct bound_minimal_symbol ms;
911 /* Don't initialize twice. */
915 /* Check application word size. */
916 arch64 = register_size (target_gdbarch (), 0) == 8;
918 /* Check whether the application is pthreaded. */
920 status = pthdb_session_pthreaded (PD_USER, PTHDB_FLAG_REGS,
921 &pd_callbacks, &stub_name);
922 if ((status != PTHDB_SUCCESS
923 && status != PTHDB_NOT_PTHREADED) || !stub_name)
926 /* Set a breakpoint on the returned stub function. */
927 ms = lookup_minimal_symbol (stub_name, NULL, NULL);
928 if (ms.minsym == NULL)
930 pd_brk_addr = BMSYMBOL_VALUE_ADDRESS (ms);
931 if (!create_thread_event_breakpoint (target_gdbarch (), pd_brk_addr))
934 /* Prepare for thread debugging. */
935 push_target (&aix_thread_ops);
938 /* If we're debugging a core file or an attached inferior, the
939 pthread library may already have been initialized, so try to
940 activate thread debugging. */
944 /* Undo the effects of pd_enable(). */
954 unpush_target (&aix_thread_ops);
957 /* new_objfile observer callback.
959 If OBJFILE is non-null, check whether a threaded application is
960 being debugged, and if so, prepare for thread debugging.
962 If OBJFILE is null, stop debugging threads. */
965 new_objfile (struct objfile *objfile)
973 /* Attach to process specified by ARGS. */
976 aix_thread_inferior_created (struct target_ops *ops, int from_tty)
981 /* Detach from the process attached to by aix_thread_attach(). */
984 aix_thread_detach (struct target_ops *ops, const char *args, int from_tty)
986 struct target_ops *beneath = find_target_beneath (ops);
989 beneath->to_detach (beneath, args, from_tty);
992 /* Tell the inferior process to continue running thread PID if != -1
993 and all threads otherwise. */
996 aix_thread_resume (struct target_ops *ops,
997 ptid_t ptid, int step, enum gdb_signal sig)
999 struct thread_info *thread;
1004 scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid);
1005 struct target_ops *beneath = find_target_beneath (ops);
1007 inferior_ptid = pid_to_ptid (ptid_get_pid (inferior_ptid));
1008 beneath->to_resume (beneath, ptid, step, sig);
1012 thread = find_thread_ptid (ptid);
1014 error (_("aix-thread resume: unknown pthread %ld"),
1015 ptid_get_lwp (ptid));
1017 aix_thread_info *priv = get_aix_thread_info (thread);
1020 if (tid[0] == PTHDB_INVALID_TID)
1021 error (_("aix-thread resume: no tid for pthread %ld"),
1022 ptid_get_lwp (ptid));
1026 ptrace64aix (PTT_CONTINUE, tid[0], (long long) 1,
1027 gdb_signal_to_host (sig), (PTRACE_TYPE_ARG5) tid);
1029 ptrace32 (PTT_CONTINUE, tid[0], (addr_ptr) 1,
1030 gdb_signal_to_host (sig), (PTRACE_TYPE_ARG5) tid);
1034 /* Wait for thread/process ID if != -1 or for any thread otherwise.
1035 If an error occurs, return -1, else return the pid of the stopped
1039 aix_thread_wait (struct target_ops *ops,
1040 ptid_t ptid, struct target_waitstatus *status, int options)
1042 struct target_ops *beneath = find_target_beneath (ops);
1045 scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid);
1049 inferior_ptid = pid_to_ptid (ptid_get_pid (inferior_ptid));
1050 ptid = beneath->to_wait (beneath, ptid, status, options);
1053 if (ptid_get_pid (ptid) == -1)
1054 return pid_to_ptid (-1);
1056 /* Check whether libpthdebug might be ready to be initialized. */
1057 if (!pd_active && status->kind == TARGET_WAITKIND_STOPPED
1058 && status->value.sig == GDB_SIGNAL_TRAP)
1060 struct regcache *regcache = get_thread_regcache (ptid);
1061 struct gdbarch *gdbarch = regcache->arch ();
1063 if (regcache_read_pc (regcache)
1064 - gdbarch_decr_pc_after_break (gdbarch) == pd_brk_addr)
1065 return pd_activate (0);
1068 return pd_update (0);
1071 /* Record that the 64-bit general-purpose registers contain VALS. */
1074 supply_gprs64 (struct regcache *regcache, uint64_t *vals)
1076 struct gdbarch_tdep *tdep = gdbarch_tdep (regcache->arch ());
1079 for (regno = 0; regno < ppc_num_gprs; regno++)
1080 regcache_raw_supply (regcache, tdep->ppc_gp0_regnum + regno,
1081 (char *) (vals + regno));
1084 /* Record that 32-bit register REGNO contains VAL. */
1087 supply_reg32 (struct regcache *regcache, int regno, uint32_t val)
1089 regcache_raw_supply (regcache, regno, (char *) &val);
1092 /* Record that the floating-point registers contain VALS. */
1095 supply_fprs (struct regcache *regcache, double *vals)
1097 struct gdbarch *gdbarch = regcache->arch ();
1098 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1101 /* This function should never be called on architectures without
1102 floating-point registers. */
1103 gdb_assert (ppc_floating_point_unit_p (gdbarch));
1105 for (regno = tdep->ppc_fp0_regnum;
1106 regno < tdep->ppc_fp0_regnum + ppc_num_fprs;
1108 regcache_raw_supply (regcache, regno,
1109 (char *) (vals + regno - tdep->ppc_fp0_regnum));
1112 /* Predicate to test whether given register number is a "special" register. */
1114 special_register_p (struct gdbarch *gdbarch, int regno)
1116 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1118 return regno == gdbarch_pc_regnum (gdbarch)
1119 || regno == tdep->ppc_ps_regnum
1120 || regno == tdep->ppc_cr_regnum
1121 || regno == tdep->ppc_lr_regnum
1122 || regno == tdep->ppc_ctr_regnum
1123 || regno == tdep->ppc_xer_regnum
1124 || (tdep->ppc_fpscr_regnum >= 0 && regno == tdep->ppc_fpscr_regnum)
1125 || (tdep->ppc_mq_regnum >= 0 && regno == tdep->ppc_mq_regnum);
1129 /* Record that the special registers contain the specified 64-bit and
1133 supply_sprs64 (struct regcache *regcache,
1134 uint64_t iar, uint64_t msr, uint32_t cr,
1135 uint64_t lr, uint64_t ctr, uint32_t xer,
1138 struct gdbarch *gdbarch = regcache->arch ();
1139 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1141 regcache_raw_supply (regcache, gdbarch_pc_regnum (gdbarch),
1143 regcache_raw_supply (regcache, tdep->ppc_ps_regnum, (char *) &msr);
1144 regcache_raw_supply (regcache, tdep->ppc_cr_regnum, (char *) &cr);
1145 regcache_raw_supply (regcache, tdep->ppc_lr_regnum, (char *) &lr);
1146 regcache_raw_supply (regcache, tdep->ppc_ctr_regnum, (char *) &ctr);
1147 regcache_raw_supply (regcache, tdep->ppc_xer_regnum, (char *) &xer);
1148 if (tdep->ppc_fpscr_regnum >= 0)
1149 regcache_raw_supply (regcache, tdep->ppc_fpscr_regnum,
1153 /* Record that the special registers contain the specified 32-bit
1157 supply_sprs32 (struct regcache *regcache,
1158 uint32_t iar, uint32_t msr, uint32_t cr,
1159 uint32_t lr, uint32_t ctr, uint32_t xer,
1162 struct gdbarch *gdbarch = regcache->arch ();
1163 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1165 regcache_raw_supply (regcache, gdbarch_pc_regnum (gdbarch),
1167 regcache_raw_supply (regcache, tdep->ppc_ps_regnum, (char *) &msr);
1168 regcache_raw_supply (regcache, tdep->ppc_cr_regnum, (char *) &cr);
1169 regcache_raw_supply (regcache, tdep->ppc_lr_regnum, (char *) &lr);
1170 regcache_raw_supply (regcache, tdep->ppc_ctr_regnum, (char *) &ctr);
1171 regcache_raw_supply (regcache, tdep->ppc_xer_regnum, (char *) &xer);
1172 if (tdep->ppc_fpscr_regnum >= 0)
1173 regcache_raw_supply (regcache, tdep->ppc_fpscr_regnum,
1177 /* Fetch all registers from pthread PDTID, which doesn't have a kernel
1180 There's no way to query a single register from a non-kernel
1181 pthread, so there's no need for a single-register version of this
1185 fetch_regs_user_thread (struct regcache *regcache, pthdb_pthread_t pdtid)
1187 struct gdbarch *gdbarch = regcache->arch ();
1188 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1190 pthdb_context_t ctx;
1192 if (debug_aix_thread)
1193 fprintf_unfiltered (gdb_stdlog,
1194 "fetch_regs_user_thread %lx\n", (long) pdtid);
1195 status = pthdb_pthread_context (pd_session, pdtid, &ctx);
1196 if (status != PTHDB_SUCCESS)
1197 error (_("aix-thread: fetch_registers: pthdb_pthread_context returned %s"),
1198 pd_status2str (status));
1200 /* General-purpose registers. */
1203 supply_gprs64 (regcache, ctx.gpr);
1205 for (i = 0; i < ppc_num_gprs; i++)
1206 supply_reg32 (regcache, tdep->ppc_gp0_regnum + i, ctx.gpr[i]);
1208 /* Floating-point registers. */
1210 if (ppc_floating_point_unit_p (gdbarch))
1211 supply_fprs (regcache, ctx.fpr);
1213 /* Special registers. */
1216 supply_sprs64 (regcache, ctx.iar, ctx.msr, ctx.cr, ctx.lr, ctx.ctr,
1217 ctx.xer, ctx.fpscr);
1219 supply_sprs32 (regcache, ctx.iar, ctx.msr, ctx.cr, ctx.lr, ctx.ctr,
1220 ctx.xer, ctx.fpscr);
1223 /* Fetch register REGNO if != -1 or all registers otherwise from
1226 AIX provides a way to query all of a kernel thread's GPRs, FPRs, or
1227 SPRs, but there's no way to query individual registers within those
1228 groups. Therefore, if REGNO != -1, this function fetches an entire
1231 Unfortunately, kernel thread register queries often fail with
1232 EPERM, indicating that the thread is in kernel space. This breaks
1233 backtraces of threads other than the current one. To make that
1234 breakage obvious without throwing an error to top level (which is
1235 bad e.g. during "info threads" output), zero registers that can't
1239 fetch_regs_kernel_thread (struct regcache *regcache, int regno,
1242 struct gdbarch *gdbarch = regcache->arch ();
1243 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1244 uint64_t gprs64[ppc_num_gprs];
1245 uint32_t gprs32[ppc_num_gprs];
1246 double fprs[ppc_num_fprs];
1247 struct ptxsprs sprs64;
1248 struct ptsprs sprs32;
1251 if (debug_aix_thread)
1252 fprintf_unfiltered (gdb_stdlog,
1253 "fetch_regs_kernel_thread tid=%lx regno=%d arch64=%d\n",
1254 (long) tid, regno, arch64);
1256 /* General-purpose registers. */
1258 || (tdep->ppc_gp0_regnum <= regno
1259 && regno < tdep->ppc_gp0_regnum + ppc_num_gprs))
1263 if (!ptrace64aix (PTT_READ_GPRS, tid,
1264 (unsigned long) gprs64, 0, NULL))
1265 memset (gprs64, 0, sizeof (gprs64));
1266 supply_gprs64 (regcache, gprs64);
1270 if (!ptrace32 (PTT_READ_GPRS, tid, (uintptr_t) gprs32, 0, NULL))
1271 memset (gprs32, 0, sizeof (gprs32));
1272 for (i = 0; i < ppc_num_gprs; i++)
1273 supply_reg32 (regcache, tdep->ppc_gp0_regnum + i, gprs32[i]);
1277 /* Floating-point registers. */
1279 if (ppc_floating_point_unit_p (gdbarch)
1281 || (regno >= tdep->ppc_fp0_regnum
1282 && regno < tdep->ppc_fp0_regnum + ppc_num_fprs)))
1284 if (!ptrace32 (PTT_READ_FPRS, tid, (uintptr_t) fprs, 0, NULL))
1285 memset (fprs, 0, sizeof (fprs));
1286 supply_fprs (regcache, fprs);
1289 /* Special-purpose registers. */
1291 if (regno == -1 || special_register_p (gdbarch, regno))
1295 if (!ptrace64aix (PTT_READ_SPRS, tid,
1296 (unsigned long) &sprs64, 0, NULL))
1297 memset (&sprs64, 0, sizeof (sprs64));
1298 supply_sprs64 (regcache, sprs64.pt_iar, sprs64.pt_msr,
1299 sprs64.pt_cr, sprs64.pt_lr, sprs64.pt_ctr,
1300 sprs64.pt_xer, sprs64.pt_fpscr);
1304 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1306 if (!ptrace32 (PTT_READ_SPRS, tid, (uintptr_t) &sprs32, 0, NULL))
1307 memset (&sprs32, 0, sizeof (sprs32));
1308 supply_sprs32 (regcache, sprs32.pt_iar, sprs32.pt_msr, sprs32.pt_cr,
1309 sprs32.pt_lr, sprs32.pt_ctr, sprs32.pt_xer,
1312 if (tdep->ppc_mq_regnum >= 0)
1313 regcache_raw_supply (regcache, tdep->ppc_mq_regnum,
1314 (char *) &sprs32.pt_mq);
1319 /* Fetch register REGNO if != -1 or all registers otherwise from the
1320 thread/process connected to REGCACHE. */
1323 aix_thread_fetch_registers (struct target_ops *ops,
1324 struct regcache *regcache, int regno)
1326 struct thread_info *thread;
1328 struct target_ops *beneath = find_target_beneath (ops);
1330 if (!PD_TID (regcache_get_ptid (regcache)))
1331 beneath->to_fetch_registers (beneath, regcache, regno);
1334 thread = find_thread_ptid (regcache_get_ptid (regcache));
1335 aix_thread_info *priv = get_aix_thread_info (thread);
1338 if (tid == PTHDB_INVALID_TID)
1339 fetch_regs_user_thread (regcache, priv->pdtid);
1341 fetch_regs_kernel_thread (regcache, regno, tid);
1345 /* Store the gp registers into an array of uint32_t or uint64_t. */
1348 fill_gprs64 (const struct regcache *regcache, uint64_t *vals)
1350 struct gdbarch_tdep *tdep = gdbarch_tdep (regcache->arch ());
1353 for (regno = 0; regno < ppc_num_gprs; regno++)
1354 if (REG_VALID == regcache_register_status (regcache,
1355 tdep->ppc_gp0_regnum + regno))
1356 regcache_raw_collect (regcache, tdep->ppc_gp0_regnum + regno,
1361 fill_gprs32 (const struct regcache *regcache, uint32_t *vals)
1363 struct gdbarch_tdep *tdep = gdbarch_tdep (regcache->arch ());
1366 for (regno = 0; regno < ppc_num_gprs; regno++)
1367 if (REG_VALID == regcache_register_status (regcache,
1368 tdep->ppc_gp0_regnum + regno))
1369 regcache_raw_collect (regcache, tdep->ppc_gp0_regnum + regno,
1373 /* Store the floating point registers into a double array. */
1375 fill_fprs (const struct regcache *regcache, double *vals)
1377 struct gdbarch *gdbarch = regcache->arch ();
1378 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1381 /* This function should never be called on architectures without
1382 floating-point registers. */
1383 gdb_assert (ppc_floating_point_unit_p (gdbarch));
1385 for (regno = tdep->ppc_fp0_regnum;
1386 regno < tdep->ppc_fp0_regnum + ppc_num_fprs;
1388 if (REG_VALID == regcache_register_status (regcache, regno))
1389 regcache_raw_collect (regcache, regno,
1390 vals + regno - tdep->ppc_fp0_regnum);
1393 /* Store the special registers into the specified 64-bit and 32-bit
1397 fill_sprs64 (const struct regcache *regcache,
1398 uint64_t *iar, uint64_t *msr, uint32_t *cr,
1399 uint64_t *lr, uint64_t *ctr, uint32_t *xer,
1402 struct gdbarch *gdbarch = regcache->arch ();
1403 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1405 /* Verify that the size of the size of the IAR buffer is the
1406 same as the raw size of the PC (in the register cache). If
1407 they're not, then either GDB has been built incorrectly, or
1408 there's some other kind of internal error. To be really safe,
1409 we should check all of the sizes. */
1410 gdb_assert (sizeof (*iar) == register_size
1411 (gdbarch, gdbarch_pc_regnum (gdbarch)));
1413 if (REG_VALID == regcache_register_status (regcache,
1414 gdbarch_pc_regnum (gdbarch)))
1415 regcache_raw_collect (regcache, gdbarch_pc_regnum (gdbarch), iar);
1416 if (REG_VALID == regcache_register_status (regcache, tdep->ppc_ps_regnum))
1417 regcache_raw_collect (regcache, tdep->ppc_ps_regnum, msr);
1418 if (REG_VALID == regcache_register_status (regcache, tdep->ppc_cr_regnum))
1419 regcache_raw_collect (regcache, tdep->ppc_cr_regnum, cr);
1420 if (REG_VALID == regcache_register_status (regcache, tdep->ppc_lr_regnum))
1421 regcache_raw_collect (regcache, tdep->ppc_lr_regnum, lr);
1422 if (REG_VALID == regcache_register_status (regcache, tdep->ppc_ctr_regnum))
1423 regcache_raw_collect (regcache, tdep->ppc_ctr_regnum, ctr);
1424 if (REG_VALID == regcache_register_status (regcache, tdep->ppc_xer_regnum))
1425 regcache_raw_collect (regcache, tdep->ppc_xer_regnum, xer);
1426 if (tdep->ppc_fpscr_regnum >= 0
1427 && REG_VALID == regcache_register_status (regcache,
1428 tdep->ppc_fpscr_regnum))
1429 regcache_raw_collect (regcache, tdep->ppc_fpscr_regnum, fpscr);
1433 fill_sprs32 (const struct regcache *regcache,
1434 uint32_t *iar, uint32_t *msr, uint32_t *cr,
1435 uint32_t *lr, uint32_t *ctr, uint32_t *xer,
1438 struct gdbarch *gdbarch = regcache->arch ();
1439 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1441 /* Verify that the size of the size of the IAR buffer is the
1442 same as the raw size of the PC (in the register cache). If
1443 they're not, then either GDB has been built incorrectly, or
1444 there's some other kind of internal error. To be really safe,
1445 we should check all of the sizes. */
1446 gdb_assert (sizeof (*iar) == register_size (gdbarch,
1447 gdbarch_pc_regnum (gdbarch)));
1449 if (REG_VALID == regcache_register_status (regcache,
1450 gdbarch_pc_regnum (gdbarch)))
1451 regcache_raw_collect (regcache, gdbarch_pc_regnum (gdbarch), iar);
1452 if (REG_VALID == regcache_register_status (regcache, tdep->ppc_ps_regnum))
1453 regcache_raw_collect (regcache, tdep->ppc_ps_regnum, msr);
1454 if (REG_VALID == regcache_register_status (regcache, tdep->ppc_cr_regnum))
1455 regcache_raw_collect (regcache, tdep->ppc_cr_regnum, cr);
1456 if (REG_VALID == regcache_register_status (regcache, tdep->ppc_lr_regnum))
1457 regcache_raw_collect (regcache, tdep->ppc_lr_regnum, lr);
1458 if (REG_VALID == regcache_register_status (regcache, tdep->ppc_ctr_regnum))
1459 regcache_raw_collect (regcache, tdep->ppc_ctr_regnum, ctr);
1460 if (REG_VALID == regcache_register_status (regcache, tdep->ppc_xer_regnum))
1461 regcache_raw_collect (regcache, tdep->ppc_xer_regnum, xer);
1462 if (tdep->ppc_fpscr_regnum >= 0
1463 && REG_VALID == regcache_register_status (regcache, tdep->ppc_fpscr_regnum))
1464 regcache_raw_collect (regcache, tdep->ppc_fpscr_regnum, fpscr);
1467 /* Store all registers into pthread PDTID, which doesn't have a kernel
1470 It's possible to store a single register into a non-kernel pthread,
1471 but I doubt it's worth the effort. */
1474 store_regs_user_thread (const struct regcache *regcache, pthdb_pthread_t pdtid)
1476 struct gdbarch *gdbarch = regcache->arch ();
1477 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1479 pthdb_context_t ctx;
1484 if (debug_aix_thread)
1485 fprintf_unfiltered (gdb_stdlog,
1486 "store_regs_user_thread %lx\n", (long) pdtid);
1488 /* Retrieve the thread's current context for its non-register
1490 status = pthdb_pthread_context (pd_session, pdtid, &ctx);
1491 if (status != PTHDB_SUCCESS)
1492 error (_("aix-thread: store_registers: pthdb_pthread_context returned %s"),
1493 pd_status2str (status));
1495 /* Collect general-purpose register values from the regcache. */
1497 for (i = 0; i < ppc_num_gprs; i++)
1498 if (REG_VALID == regcache_register_status (regcache,
1499 tdep->ppc_gp0_regnum + i))
1503 regcache_raw_collect (regcache, tdep->ppc_gp0_regnum + i,
1509 regcache_raw_collect (regcache, tdep->ppc_gp0_regnum + i,
1515 /* Collect floating-point register values from the regcache. */
1516 if (ppc_floating_point_unit_p (gdbarch))
1517 fill_fprs (regcache, ctx.fpr);
1519 /* Special registers (always kept in ctx as 64 bits). */
1522 fill_sprs64 (regcache, &ctx.iar, &ctx.msr, &ctx.cr, &ctx.lr, &ctx.ctr,
1523 &ctx.xer, &ctx.fpscr);
1527 /* Problem: ctx.iar etc. are 64 bits, but raw_registers are 32.
1528 Solution: use 32-bit temp variables. */
1529 uint32_t tmp_iar, tmp_msr, tmp_cr, tmp_lr, tmp_ctr, tmp_xer,
1532 fill_sprs32 (regcache, &tmp_iar, &tmp_msr, &tmp_cr, &tmp_lr, &tmp_ctr,
1533 &tmp_xer, &tmp_fpscr);
1534 if (REG_VALID == regcache_register_status (regcache,
1535 gdbarch_pc_regnum (gdbarch)))
1537 if (REG_VALID == regcache_register_status (regcache, tdep->ppc_ps_regnum))
1539 if (REG_VALID == regcache_register_status (regcache, tdep->ppc_cr_regnum))
1541 if (REG_VALID == regcache_register_status (regcache, tdep->ppc_lr_regnum))
1543 if (REG_VALID == regcache_register_status (regcache,
1544 tdep->ppc_ctr_regnum))
1546 if (REG_VALID == regcache_register_status (regcache,
1547 tdep->ppc_xer_regnum))
1549 if (REG_VALID == regcache_register_status (regcache,
1550 tdep->ppc_xer_regnum))
1551 ctx.fpscr = tmp_fpscr;
1554 status = pthdb_pthread_setcontext (pd_session, pdtid, &ctx);
1555 if (status != PTHDB_SUCCESS)
1556 error (_("aix-thread: store_registers: "
1557 "pthdb_pthread_setcontext returned %s"),
1558 pd_status2str (status));
1561 /* Store register REGNO if != -1 or all registers otherwise into
1564 AIX provides a way to set all of a kernel thread's GPRs, FPRs, or
1565 SPRs, but there's no way to set individual registers within those
1566 groups. Therefore, if REGNO != -1, this function stores an entire
1570 store_regs_kernel_thread (const struct regcache *regcache, int regno,
1573 struct gdbarch *gdbarch = regcache->arch ();
1574 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1575 uint64_t gprs64[ppc_num_gprs];
1576 uint32_t gprs32[ppc_num_gprs];
1577 double fprs[ppc_num_fprs];
1578 struct ptxsprs sprs64;
1579 struct ptsprs sprs32;
1582 if (debug_aix_thread)
1583 fprintf_unfiltered (gdb_stdlog,
1584 "store_regs_kernel_thread tid=%lx regno=%d\n",
1587 /* General-purpose registers. */
1589 || (tdep->ppc_gp0_regnum <= regno
1590 && regno < tdep->ppc_gp0_regnum + ppc_num_fprs))
1594 /* Pre-fetch: some regs may not be in the cache. */
1595 ptrace64aix (PTT_READ_GPRS, tid, (unsigned long) gprs64, 0, NULL);
1596 fill_gprs64 (regcache, gprs64);
1597 ptrace64aix (PTT_WRITE_GPRS, tid, (unsigned long) gprs64, 0, NULL);
1601 /* Pre-fetch: some regs may not be in the cache. */
1602 ptrace32 (PTT_READ_GPRS, tid, (uintptr_t) gprs32, 0, NULL);
1603 fill_gprs32 (regcache, gprs32);
1604 ptrace32 (PTT_WRITE_GPRS, tid, (uintptr_t) gprs32, 0, NULL);
1608 /* Floating-point registers. */
1610 if (ppc_floating_point_unit_p (gdbarch)
1612 || (regno >= tdep->ppc_fp0_regnum
1613 && regno < tdep->ppc_fp0_regnum + ppc_num_fprs)))
1615 /* Pre-fetch: some regs may not be in the cache. */
1616 ptrace32 (PTT_READ_FPRS, tid, (uintptr_t) fprs, 0, NULL);
1617 fill_fprs (regcache, fprs);
1618 ptrace32 (PTT_WRITE_FPRS, tid, (uintptr_t) fprs, 0, NULL);
1621 /* Special-purpose registers. */
1623 if (regno == -1 || special_register_p (gdbarch, regno))
1627 /* Pre-fetch: some registers won't be in the cache. */
1628 ptrace64aix (PTT_READ_SPRS, tid,
1629 (unsigned long) &sprs64, 0, NULL);
1630 fill_sprs64 (regcache, &sprs64.pt_iar, &sprs64.pt_msr,
1631 &sprs64.pt_cr, &sprs64.pt_lr, &sprs64.pt_ctr,
1632 &sprs64.pt_xer, &sprs64.pt_fpscr);
1633 ptrace64aix (PTT_WRITE_SPRS, tid,
1634 (unsigned long) &sprs64, 0, NULL);
1638 /* The contents of "struct ptspr" were declared as "unsigned
1639 long" up to AIX 5.2, but are "unsigned int" since 5.3.
1640 Use temporaries to work around this problem. Also, add an
1641 assert here to make sure we fail if the system header files
1642 use "unsigned long", and the size of that type is not what
1643 the headers expect. */
1644 uint32_t tmp_iar, tmp_msr, tmp_cr, tmp_lr, tmp_ctr, tmp_xer,
1647 gdb_assert (sizeof (sprs32.pt_iar) == 4);
1649 /* Pre-fetch: some registers won't be in the cache. */
1650 ptrace32 (PTT_READ_SPRS, tid, (uintptr_t) &sprs32, 0, NULL);
1652 fill_sprs32 (regcache, &tmp_iar, &tmp_msr, &tmp_cr, &tmp_lr,
1653 &tmp_ctr, &tmp_xer, &tmp_fpscr);
1655 sprs32.pt_iar = tmp_iar;
1656 sprs32.pt_msr = tmp_msr;
1657 sprs32.pt_cr = tmp_cr;
1658 sprs32.pt_lr = tmp_lr;
1659 sprs32.pt_ctr = tmp_ctr;
1660 sprs32.pt_xer = tmp_xer;
1661 sprs32.pt_fpscr = tmp_fpscr;
1663 if (tdep->ppc_mq_regnum >= 0)
1664 if (REG_VALID == regcache_register_status (regcache,
1665 tdep->ppc_mq_regnum))
1666 regcache_raw_collect (regcache, tdep->ppc_mq_regnum,
1669 ptrace32 (PTT_WRITE_SPRS, tid, (uintptr_t) &sprs32, 0, NULL);
1674 /* Store gdb's current view of the register set into the
1675 thread/process connected to REGCACHE. */
1678 aix_thread_store_registers (struct target_ops *ops,
1679 struct regcache *regcache, int regno)
1681 struct thread_info *thread;
1683 struct target_ops *beneath = find_target_beneath (ops);
1685 if (!PD_TID (regcache_get_ptid (regcache)))
1686 beneath->to_store_registers (beneath, regcache, regno);
1689 thread = find_thread_ptid (regcache_get_ptid (regcache));
1690 aix_thread_info *priv = get_aix_thread_info (thread);
1693 if (tid == PTHDB_INVALID_TID)
1694 store_regs_user_thread (regcache, priv->pdtid);
1696 store_regs_kernel_thread (regcache, regno, tid);
1700 /* Implement the to_xfer_partial target_ops method. */
1702 static enum target_xfer_status
1703 aix_thread_xfer_partial (struct target_ops *ops, enum target_object object,
1704 const char *annex, gdb_byte *readbuf,
1705 const gdb_byte *writebuf,
1706 ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
1708 scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid);
1709 struct target_ops *beneath = find_target_beneath (ops);
1711 inferior_ptid = pid_to_ptid (ptid_get_pid (inferior_ptid));
1712 return beneath->to_xfer_partial (beneath, object, annex, readbuf,
1713 writebuf, offset, len, xfered_len);
1716 /* Clean up after the inferior exits. */
1719 aix_thread_mourn_inferior (struct target_ops *ops)
1721 struct target_ops *beneath = find_target_beneath (ops);
1724 beneath->to_mourn_inferior (beneath);
1727 /* Return whether thread PID is still valid. */
1730 aix_thread_thread_alive (struct target_ops *ops, ptid_t ptid)
1732 struct target_ops *beneath = find_target_beneath (ops);
1735 return beneath->to_thread_alive (beneath, ptid);
1737 /* We update the thread list every time the child stops, so all
1738 valid threads should be in the thread list. */
1739 return in_thread_list (ptid);
1742 /* Return a printable representation of composite PID for use in
1743 "info threads" output. */
1746 aix_thread_pid_to_str (struct target_ops *ops, ptid_t ptid)
1748 static char *ret = NULL;
1749 struct target_ops *beneath = find_target_beneath (ops);
1752 return beneath->to_pid_to_str (beneath, ptid);
1754 /* Free previous return value; a new one will be allocated by
1758 ret = xstrprintf (_("Thread %ld"), ptid_get_tid (ptid));
1762 /* Return a printable representation of extra information about
1763 THREAD, for use in "info threads" output. */
1766 aix_thread_extra_thread_info (struct target_ops *self,
1767 struct thread_info *thread)
1770 pthdb_pthread_t pdtid;
1772 pthdb_state_t state;
1773 pthdb_suspendstate_t suspendstate;
1774 pthdb_detachstate_t detachstate;
1776 static char *ret = NULL;
1778 if (!PD_TID (thread->ptid))
1782 aix_thread_info *priv = get_aix_thread_info (thread);
1784 pdtid = priv->pdtid;
1787 if (tid != PTHDB_INVALID_TID)
1788 /* i18n: Like "thread-identifier %d, [state] running, suspended" */
1789 buf.printf (_("tid %d"), (int)tid);
1791 status = pthdb_pthread_state (pd_session, pdtid, &state);
1792 if (status != PTHDB_SUCCESS)
1794 buf.printf (", %s", state2str (state));
1796 status = pthdb_pthread_suspendstate (pd_session, pdtid,
1798 if (status == PTHDB_SUCCESS && suspendstate == PSS_SUSPENDED)
1799 /* i18n: Like "Thread-Id %d, [state] running, suspended" */
1800 buf.printf (_(", suspended"));
1802 status = pthdb_pthread_detachstate (pd_session, pdtid,
1804 if (status == PTHDB_SUCCESS && detachstate == PDS_DETACHED)
1805 /* i18n: Like "Thread-Id %d, [state] running, detached" */
1806 buf.printf (_(", detached"));
1808 pthdb_pthread_cancelpend (pd_session, pdtid, &cancelpend);
1809 if (status == PTHDB_SUCCESS && cancelpend)
1810 /* i18n: Like "Thread-Id %d, [state] running, cancel pending" */
1811 buf.printf (_(", cancel pending"));
1815 xfree (ret); /* Free old buffer. */
1817 ret = xstrdup (buf.c_str ());
1823 aix_thread_get_ada_task_ptid (struct target_ops *self, long lwp, long thread)
1825 return ptid_build (ptid_get_pid (inferior_ptid), 0, thread);
1828 /* Initialize target aix_thread_ops. */
1831 init_aix_thread_ops (void)
1833 aix_thread_ops.to_shortname = "aix-threads";
1834 aix_thread_ops.to_longname = _("AIX pthread support");
1835 aix_thread_ops.to_doc = _("AIX pthread support");
1837 aix_thread_ops.to_detach = aix_thread_detach;
1838 aix_thread_ops.to_resume = aix_thread_resume;
1839 aix_thread_ops.to_wait = aix_thread_wait;
1840 aix_thread_ops.to_fetch_registers = aix_thread_fetch_registers;
1841 aix_thread_ops.to_store_registers = aix_thread_store_registers;
1842 aix_thread_ops.to_xfer_partial = aix_thread_xfer_partial;
1843 aix_thread_ops.to_mourn_inferior = aix_thread_mourn_inferior;
1844 aix_thread_ops.to_thread_alive = aix_thread_thread_alive;
1845 aix_thread_ops.to_pid_to_str = aix_thread_pid_to_str;
1846 aix_thread_ops.to_extra_thread_info = aix_thread_extra_thread_info;
1847 aix_thread_ops.to_get_ada_task_ptid = aix_thread_get_ada_task_ptid;
1848 aix_thread_ops.to_stratum = thread_stratum;
1849 aix_thread_ops.to_magic = OPS_MAGIC;
1852 /* Module startup initialization function, automagically called by
1856 _initialize_aix_thread (void)
1858 init_aix_thread_ops ();
1859 complete_target_initialization (&aix_thread_ops);
1861 /* Notice when object files get loaded and unloaded. */
1862 observer_attach_new_objfile (new_objfile);
1864 /* Add ourselves to inferior_created event chain.
1865 This is needed to enable the thread target on "attach". */
1866 observer_attach_inferior_created (aix_thread_inferior_created);
1868 add_setshow_boolean_cmd ("aix-thread", class_maintenance, &debug_aix_thread,
1869 _("Set debugging of AIX thread module."),
1870 _("Show debugging of AIX thread module."),
1871 _("Enables debugging output (used to debug GDB)."),
1873 /* FIXME: i18n: Debugging of AIX thread
1874 module is \"%d\". */
1875 &setdebuglist, &showdebuglist);