1 /* Low level interface for debugging AIX 4.3+ pthreads.
3 Copyright (C) 1999-2019 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().
44 /* Standard C includes. */
47 #include <sys/pthdebug.h>
48 #include <sys/ptrace.h>
50 #include <sys/types.h>
52 /* Local non-gdb includes. */
54 #include "gdbthread.h"
57 #include "observable.h"
62 #if !HAVE_DECL_GETTHRDS
63 extern int getthrds (pid_t
, struct thrdsinfo64
*, int, tid_t
*, int);
66 /* Whether to emit debugging output. */
67 static int debug_aix_thread
;
69 /* In AIX 5.1, functions use pthdb_tid_t instead of tid_t. */
70 #ifndef PTHDB_VERSION_3
71 #define pthdb_tid_t tid_t
74 /* Return whether to treat PID as a debuggable thread id. */
76 #define PD_TID(ptid) (pd_active && ptid.tid () != 0)
78 /* pthdb_user_t value that we pass to pthdb functions. 0 causes
79 PTHDB_BAD_USER errors, so use 1. */
83 /* Success and failure values returned by pthdb callbacks. */
85 #define PDC_SUCCESS PTHDB_SUCCESS
86 #define PDC_FAILURE PTHDB_CALLBACK
88 /* Private data attached to each element in GDB's thread list. */
90 struct aix_thread_info
: public private_thread_info
92 pthdb_pthread_t pdtid
; /* thread's libpthdebug id */
93 pthdb_tid_t tid
; /* kernel thread id */
96 /* Return the aix_thread_info attached to THREAD. */
98 static aix_thread_info
*
99 get_aix_thread_info (thread_info
*thread
)
101 return static_cast<aix_thread_info
*> (thread
->priv
.get ());
104 /* Information about a thread of which libpthdebug is aware. */
107 pthdb_pthread_t pdtid
;
112 /* This module's target-specific operations, active while pd_able is true. */
114 static const target_info aix_thread_target_info
= {
116 N_("AIX pthread support"),
117 N_("AIX pthread support")
120 class aix_thread_target final
: public target_ops
123 const target_info
&info () const override
124 { return aix_thread_target_info
; }
126 strata
stratum () const override
{ return thread_stratum
; }
128 void detach (inferior
*, int) override
;
129 void resume (ptid_t
, int, enum gdb_signal
) override
;
130 ptid_t
wait (ptid_t
, struct target_waitstatus
*, int) override
;
132 void fetch_registers (struct regcache
*, int) override
;
133 void store_registers (struct regcache
*, int) override
;
135 enum target_xfer_status
xfer_partial (enum target_object object
,
138 const gdb_byte
*writebuf
,
139 ULONGEST offset
, ULONGEST len
,
140 ULONGEST
*xfered_len
) override
;
142 void mourn_inferior () override
;
144 bool thread_alive (ptid_t ptid
) override
;
146 std::string
pid_to_str (ptid_t
) override
;
148 const char *extra_thread_info (struct thread_info
*) override
;
150 ptid_t
get_ada_task_ptid (long lwp
, long thread
) override
;
153 static aix_thread_target aix_thread_ops
;
155 /* Address of the function that libpthread will call when libpthdebug
156 is ready to be initialized. */
158 static CORE_ADDR pd_brk_addr
;
160 /* Whether the current application is debuggable by pthdb. */
162 static int pd_able
= 0;
164 /* Whether a threaded application is being debugged. */
166 static int pd_active
= 0;
168 /* Whether the current architecture is 64-bit.
169 Only valid when pd_able is true. */
173 /* Forward declarations for pthdb callbacks. */
175 static int pdc_symbol_addrs (pthdb_user_t
, pthdb_symbol_t
*, int);
176 static int pdc_read_data (pthdb_user_t
, void *, pthdb_addr_t
, size_t);
177 static int pdc_write_data (pthdb_user_t
, void *, pthdb_addr_t
, size_t);
178 static int pdc_read_regs (pthdb_user_t user
, pthdb_tid_t tid
,
179 unsigned long long flags
,
180 pthdb_context_t
*context
);
181 static int pdc_write_regs (pthdb_user_t user
, pthdb_tid_t tid
,
182 unsigned long long flags
,
183 pthdb_context_t
*context
);
184 static int pdc_alloc (pthdb_user_t
, size_t, void **);
185 static int pdc_realloc (pthdb_user_t
, void *, size_t, void **);
186 static int pdc_dealloc (pthdb_user_t
, void *);
188 /* pthdb callbacks. */
190 static pthdb_callbacks_t pd_callbacks
= {
202 /* Current pthdb session. */
204 static pthdb_session_t pd_session
;
206 /* Return a printable representation of pthdebug function return
210 pd_status2str (int status
)
214 case PTHDB_SUCCESS
: return "SUCCESS";
215 case PTHDB_NOSYS
: return "NOSYS";
216 case PTHDB_NOTSUP
: return "NOTSUP";
217 case PTHDB_BAD_VERSION
: return "BAD_VERSION";
218 case PTHDB_BAD_USER
: return "BAD_USER";
219 case PTHDB_BAD_SESSION
: return "BAD_SESSION";
220 case PTHDB_BAD_MODE
: return "BAD_MODE";
221 case PTHDB_BAD_FLAGS
: return "BAD_FLAGS";
222 case PTHDB_BAD_CALLBACK
: return "BAD_CALLBACK";
223 case PTHDB_BAD_POINTER
: return "BAD_POINTER";
224 case PTHDB_BAD_CMD
: return "BAD_CMD";
225 case PTHDB_BAD_PTHREAD
: return "BAD_PTHREAD";
226 case PTHDB_BAD_ATTR
: return "BAD_ATTR";
227 case PTHDB_BAD_MUTEX
: return "BAD_MUTEX";
228 case PTHDB_BAD_MUTEXATTR
: return "BAD_MUTEXATTR";
229 case PTHDB_BAD_COND
: return "BAD_COND";
230 case PTHDB_BAD_CONDATTR
: return "BAD_CONDATTR";
231 case PTHDB_BAD_RWLOCK
: return "BAD_RWLOCK";
232 case PTHDB_BAD_RWLOCKATTR
: return "BAD_RWLOCKATTR";
233 case PTHDB_BAD_KEY
: return "BAD_KEY";
234 case PTHDB_BAD_PTID
: return "BAD_PTID";
235 case PTHDB_BAD_TID
: return "BAD_TID";
236 case PTHDB_CALLBACK
: return "CALLBACK";
237 case PTHDB_CONTEXT
: return "CONTEXT";
238 case PTHDB_HELD
: return "HELD";
239 case PTHDB_NOT_HELD
: return "NOT_HELD";
240 case PTHDB_MEMORY
: return "MEMORY";
241 case PTHDB_NOT_PTHREADED
: return "NOT_PTHREADED";
242 case PTHDB_SYMBOL
: return "SYMBOL";
243 case PTHDB_NOT_AVAIL
: return "NOT_AVAIL";
244 case PTHDB_INTERNAL
: return "INTERNAL";
245 default: return "UNKNOWN";
249 /* A call to ptrace(REQ, ID, ...) just returned RET. Check for
250 exceptional conditions and either return nonlocally or else return
251 1 for success and 0 for failure. */
254 ptrace_check (int req
, int id
, int ret
)
256 if (ret
== 0 && !errno
)
259 /* According to ptrace(2), ptrace may fail with EPERM if "the
260 Identifier parameter corresponds to a kernel thread which is
261 stopped in kernel mode and whose computational state cannot be
262 read or written." This happens quite often with register reads. */
269 if (ret
== -1 && errno
== EPERM
)
271 if (debug_aix_thread
)
272 fprintf_unfiltered (gdb_stdlog
,
273 "ptrace (%d, %d) = %d (errno = %d)\n",
274 req
, id
, ret
, errno
);
275 return ret
== -1 ? 0 : 1;
279 error (_("aix-thread: ptrace (%d, %d) returned %d (errno = %d %s)"),
280 req
, id
, ret
, errno
, safe_strerror (errno
));
281 return 0; /* Not reached. */
284 /* Call ptracex (REQ, ID, ADDR, DATA, BUF) or
285 ptrace64 (REQ, ID, ADDR, DATA, BUF) if HAVE_PTRACE64.
289 # define ptracex(request, pid, addr, data, buf) \
290 ptrace64 (request, pid, addr, data, buf)
294 ptrace64aix (int req
, int id
, long long addr
, int data
, int *buf
)
297 return ptrace_check (req
, id
, ptracex (req
, id
, addr
, data
, buf
));
300 /* Call ptrace (REQ, ID, ADDR, DATA, BUF) or
301 ptrace64 (REQ, ID, ADDR, DATA, BUF) if HAVE_PTRACE64.
305 # define ptrace(request, pid, addr, data, buf) \
306 ptrace64 (request, pid, addr, data, buf)
307 # define addr_ptr long long
309 # define addr_ptr int *
313 ptrace32 (int req
, int id
, addr_ptr addr
, int data
, int *buf
)
316 return ptrace_check (req
, id
,
317 ptrace (req
, id
, addr
, data
, buf
));
320 /* If *PIDP is a composite process/thread id, convert it to a
324 pid_to_prc (ptid_t
*ptidp
)
330 *ptidp
= ptid_t (ptid
.pid ());
333 /* pthdb callback: for <i> from 0 to COUNT, set SYMBOLS[<i>].addr to
334 the address of SYMBOLS[<i>].name. */
337 pdc_symbol_addrs (pthdb_user_t user
, pthdb_symbol_t
*symbols
, int count
)
339 struct bound_minimal_symbol ms
;
343 if (debug_aix_thread
)
344 fprintf_unfiltered (gdb_stdlog
,
345 "pdc_symbol_addrs (user = %ld, symbols = 0x%lx, count = %d)\n",
346 user
, (long) symbols
, count
);
348 for (i
= 0; i
< count
; i
++)
350 name
= symbols
[i
].name
;
351 if (debug_aix_thread
)
352 fprintf_unfiltered (gdb_stdlog
,
353 " symbols[%d].name = \"%s\"\n", i
, name
);
359 ms
= lookup_minimal_symbol (name
, NULL
, NULL
);
360 if (ms
.minsym
== NULL
)
362 if (debug_aix_thread
)
363 fprintf_unfiltered (gdb_stdlog
, " returning PDC_FAILURE\n");
366 symbols
[i
].addr
= BMSYMBOL_VALUE_ADDRESS (ms
);
368 if (debug_aix_thread
)
369 fprintf_unfiltered (gdb_stdlog
, " symbols[%d].addr = %s\n",
370 i
, hex_string (symbols
[i
].addr
));
372 if (debug_aix_thread
)
373 fprintf_unfiltered (gdb_stdlog
, " returning PDC_SUCCESS\n");
377 /* Read registers call back function should be able to read the
378 context information of a debuggee kernel thread from an active
379 process or from a core file. The information should be formatted
380 in context64 form for both 32-bit and 64-bit process.
381 If successful return 0, else non-zero is returned. */
384 pdc_read_regs (pthdb_user_t user
,
386 unsigned long long flags
,
387 pthdb_context_t
*context
)
389 /* This function doesn't appear to be used, so we could probably
390 just return 0 here. HOWEVER, if it is not defined, the OS will
391 complain and several thread debug functions will fail. In case
392 this is needed, I have implemented what I think it should do,
393 however this code is untested. */
395 uint64_t gprs64
[ppc_num_gprs
];
396 uint32_t gprs32
[ppc_num_gprs
];
397 double fprs
[ppc_num_fprs
];
398 struct ptxsprs sprs64
;
399 struct ptsprs sprs32
;
401 if (debug_aix_thread
)
402 fprintf_unfiltered (gdb_stdlog
, "pdc_read_regs tid=%d flags=%s\n",
403 (int) tid
, hex_string (flags
));
405 /* General-purpose registers. */
406 if (flags
& PTHDB_FLAG_GPRS
)
410 if (!ptrace64aix (PTT_READ_GPRS
, tid
,
411 (unsigned long) gprs64
, 0, NULL
))
412 memset (gprs64
, 0, sizeof (gprs64
));
413 memcpy (context
->gpr
, gprs64
, sizeof(gprs64
));
417 if (!ptrace32 (PTT_READ_GPRS
, tid
, (uintptr_t) gprs32
, 0, NULL
))
418 memset (gprs32
, 0, sizeof (gprs32
));
419 memcpy (context
->gpr
, gprs32
, sizeof(gprs32
));
423 /* Floating-point registers. */
424 if (flags
& PTHDB_FLAG_FPRS
)
426 if (!ptrace32 (PTT_READ_FPRS
, tid
, (uintptr_t) fprs
, 0, NULL
))
427 memset (fprs
, 0, sizeof (fprs
));
428 memcpy (context
->fpr
, fprs
, sizeof(fprs
));
431 /* Special-purpose registers. */
432 if (flags
& PTHDB_FLAG_SPRS
)
436 if (!ptrace64aix (PTT_READ_SPRS
, tid
,
437 (unsigned long) &sprs64
, 0, NULL
))
438 memset (&sprs64
, 0, sizeof (sprs64
));
439 memcpy (&context
->msr
, &sprs64
, sizeof(sprs64
));
443 if (!ptrace32 (PTT_READ_SPRS
, tid
, (uintptr_t) &sprs32
, 0, NULL
))
444 memset (&sprs32
, 0, sizeof (sprs32
));
445 memcpy (&context
->msr
, &sprs32
, sizeof(sprs32
));
451 /* Write register function should be able to write requested context
452 information to specified debuggee's kernel thread id.
453 If successful return 0, else non-zero is returned. */
456 pdc_write_regs (pthdb_user_t user
,
458 unsigned long long flags
,
459 pthdb_context_t
*context
)
461 /* This function doesn't appear to be used, so we could probably
462 just return 0 here. HOWEVER, if it is not defined, the OS will
463 complain and several thread debug functions will fail. In case
464 this is needed, I have implemented what I think it should do,
465 however this code is untested. */
467 if (debug_aix_thread
)
468 fprintf_unfiltered (gdb_stdlog
, "pdc_write_regs tid=%d flags=%s\n",
469 (int) tid
, hex_string (flags
));
471 /* General-purpose registers. */
472 if (flags
& PTHDB_FLAG_GPRS
)
475 ptrace64aix (PTT_WRITE_GPRS
, tid
,
476 (unsigned long) context
->gpr
, 0, NULL
);
478 ptrace32 (PTT_WRITE_GPRS
, tid
, (uintptr_t) context
->gpr
, 0, NULL
);
481 /* Floating-point registers. */
482 if (flags
& PTHDB_FLAG_FPRS
)
484 ptrace32 (PTT_WRITE_FPRS
, tid
, (uintptr_t) context
->fpr
, 0, NULL
);
487 /* Special-purpose registers. */
488 if (flags
& PTHDB_FLAG_SPRS
)
492 ptrace64aix (PTT_WRITE_SPRS
, tid
,
493 (unsigned long) &context
->msr
, 0, NULL
);
497 ptrace32 (PTT_WRITE_SPRS
, tid
, (uintptr_t) &context
->msr
, 0, NULL
);
503 /* pthdb callback: read LEN bytes from process ADDR into BUF. */
506 pdc_read_data (pthdb_user_t user
, void *buf
,
507 pthdb_addr_t addr
, size_t len
)
511 if (debug_aix_thread
)
512 fprintf_unfiltered (gdb_stdlog
,
513 "pdc_read_data (user = %ld, buf = 0x%lx, addr = %s, len = %ld)\n",
514 user
, (long) buf
, hex_string (addr
), len
);
516 status
= target_read_memory (addr
, (gdb_byte
*) buf
, len
);
517 ret
= status
== 0 ? PDC_SUCCESS
: PDC_FAILURE
;
519 if (debug_aix_thread
)
520 fprintf_unfiltered (gdb_stdlog
, " status=%d, returning %s\n",
521 status
, pd_status2str (ret
));
525 /* pthdb callback: write LEN bytes from BUF to process ADDR. */
528 pdc_write_data (pthdb_user_t user
, void *buf
,
529 pthdb_addr_t addr
, size_t len
)
533 if (debug_aix_thread
)
534 fprintf_unfiltered (gdb_stdlog
,
535 "pdc_write_data (user = %ld, buf = 0x%lx, addr = %s, len = %ld)\n",
536 user
, (long) buf
, hex_string (addr
), len
);
538 status
= target_write_memory (addr
, (gdb_byte
*) buf
, len
);
539 ret
= status
== 0 ? PDC_SUCCESS
: PDC_FAILURE
;
541 if (debug_aix_thread
)
542 fprintf_unfiltered (gdb_stdlog
, " status=%d, returning %s\n", status
,
543 pd_status2str (ret
));
547 /* pthdb callback: allocate a LEN-byte buffer and store a pointer to it
551 pdc_alloc (pthdb_user_t user
, size_t len
, void **bufp
)
553 if (debug_aix_thread
)
554 fprintf_unfiltered (gdb_stdlog
,
555 "pdc_alloc (user = %ld, len = %ld, bufp = 0x%lx)\n",
556 user
, len
, (long) bufp
);
557 *bufp
= xmalloc (len
);
558 if (debug_aix_thread
)
559 fprintf_unfiltered (gdb_stdlog
,
560 " malloc returned 0x%lx\n", (long) *bufp
);
562 /* Note: xmalloc() can't return 0; therefore PDC_FAILURE will never
565 return *bufp
? PDC_SUCCESS
: PDC_FAILURE
;
568 /* pthdb callback: reallocate BUF, which was allocated by the alloc or
569 realloc callback, so that it contains LEN bytes, and store a
570 pointer to the result in BUFP. */
573 pdc_realloc (pthdb_user_t user
, void *buf
, size_t len
, void **bufp
)
575 if (debug_aix_thread
)
576 fprintf_unfiltered (gdb_stdlog
,
577 "pdc_realloc (user = %ld, buf = 0x%lx, len = %ld, bufp = 0x%lx)\n",
578 user
, (long) buf
, len
, (long) bufp
);
579 *bufp
= xrealloc (buf
, len
);
580 if (debug_aix_thread
)
581 fprintf_unfiltered (gdb_stdlog
,
582 " realloc returned 0x%lx\n", (long) *bufp
);
583 return *bufp
? PDC_SUCCESS
: PDC_FAILURE
;
586 /* pthdb callback: free BUF, which was allocated by the alloc or
590 pdc_dealloc (pthdb_user_t user
, void *buf
)
592 if (debug_aix_thread
)
593 fprintf_unfiltered (gdb_stdlog
,
594 "pdc_free (user = %ld, buf = 0x%lx)\n", user
,
600 /* Return a printable representation of pthread STATE. */
603 state2str (pthdb_state_t state
)
608 /* i18n: Like "Thread-Id %d, [state] idle" */
609 return _("idle"); /* being created */
611 /* i18n: Like "Thread-Id %d, [state] running" */
612 return _("running"); /* running */
614 /* i18n: Like "Thread-Id %d, [state] sleeping" */
615 return _("sleeping"); /* awaiting an event */
617 /* i18n: Like "Thread-Id %d, [state] ready" */
618 return _("ready"); /* runnable */
620 /* i18n: Like "Thread-Id %d, [state] finished" */
621 return _("finished"); /* awaiting a join/detach */
623 /* i18n: Like "Thread-Id %d, [state] unknown" */
628 /* qsort() comparison function for sorting pd_thread structs by pthid. */
631 pcmp (const void *p1v
, const void *p2v
)
633 struct pd_thread
*p1
= (struct pd_thread
*) p1v
;
634 struct pd_thread
*p2
= (struct pd_thread
*) p2v
;
635 return p1
->pthid
< p2
->pthid
? -1 : p1
->pthid
> p2
->pthid
;
638 /* iterate_over_threads() callback for counting GDB threads.
640 Do not count the main thread (whose tid is zero). This matches
641 the list of threads provided by the pthreaddebug library, which
642 does not include that main thread either, and thus allows us
643 to compare the two lists. */
646 giter_count (struct thread_info
*thread
, void *countp
)
648 if (PD_TID (thread
->ptid
))
653 /* iterate_over_threads() callback for accumulating GDB thread pids.
655 Do not include the main thread (whose tid is zero). This matches
656 the list of threads provided by the pthreaddebug library, which
657 does not include that main thread either, and thus allows us
658 to compare the two lists. */
661 giter_accum (struct thread_info
*thread
, void *bufp
)
663 if (PD_TID (thread
->ptid
))
665 **(struct thread_info
***) bufp
= thread
;
666 (*(struct thread_info
***) bufp
)++;
671 /* ptid comparison function */
674 ptid_cmp (ptid_t ptid1
, ptid_t ptid2
)
676 if (ptid1
.pid () < ptid2
.pid ())
678 else if (ptid1
.pid () > ptid2
.pid ())
680 else if (ptid1
.tid () < ptid2
.tid ())
682 else if (ptid1
.tid () > ptid2
.tid ())
684 else if (ptid1
.lwp () < ptid2
.lwp ())
686 else if (ptid1
.lwp () > ptid2
.lwp ())
692 /* qsort() comparison function for sorting thread_info structs by pid. */
695 gcmp (const void *t1v
, const void *t2v
)
697 struct thread_info
*t1
= *(struct thread_info
**) t1v
;
698 struct thread_info
*t2
= *(struct thread_info
**) t2v
;
699 return ptid_cmp (t1
->ptid
, t2
->ptid
);
702 /* Search through the list of all kernel threads for the thread
703 that has stopped on a SIGTRAP signal, and return its TID.
704 Return 0 if none found. */
707 get_signaled_thread (void)
709 struct thrdsinfo64 thrinf
;
714 if (getthrds (inferior_ptid
.pid (), &thrinf
,
715 sizeof (thrinf
), &ktid
, 1) != 1)
718 if (thrinf
.ti_cursig
== SIGTRAP
)
719 return thrinf
.ti_tid
;
722 /* Didn't find any thread stopped on a SIGTRAP signal. */
726 /* Synchronize GDB's thread list with libpthdebug's.
728 There are some benefits of doing this every time the inferior stops:
730 - allows users to run thread-specific commands without needing to
731 run "info threads" first
733 - helps pthdb_tid_pthread() work properly (see "libpthdebug
734 peculiarities" at the top of this module)
736 - simplifies the demands placed on libpthdebug, which seems to
737 have difficulty with certain call patterns */
740 sync_threadlists (void)
742 int cmd
, status
, infpid
;
743 int pcount
, psize
, pi
, gcount
, gi
;
744 struct pd_thread
*pbuf
;
745 struct thread_info
**gbuf
, **g
, *thread
;
746 pthdb_pthread_t pdtid
;
750 /* Accumulate an array of libpthdebug threads sorted by pthread id. */
754 pbuf
= XNEWVEC (struct pd_thread
, psize
);
756 for (cmd
= PTHDB_LIST_FIRST
;; cmd
= PTHDB_LIST_NEXT
)
758 status
= pthdb_pthread (pd_session
, &pdtid
, cmd
);
759 if (status
!= PTHDB_SUCCESS
|| pdtid
== PTHDB_INVALID_PTHREAD
)
762 status
= pthdb_pthread_ptid (pd_session
, pdtid
, &pthid
);
763 if (status
!= PTHDB_SUCCESS
|| pthid
== PTHDB_INVALID_PTID
)
769 pbuf
= (struct pd_thread
*) xrealloc (pbuf
,
770 psize
* sizeof *pbuf
);
772 pbuf
[pcount
].pdtid
= pdtid
;
773 pbuf
[pcount
].pthid
= pthid
;
777 for (pi
= 0; pi
< pcount
; pi
++)
779 status
= pthdb_pthread_tid (pd_session
, pbuf
[pi
].pdtid
, &tid
);
780 if (status
!= PTHDB_SUCCESS
)
781 tid
= PTHDB_INVALID_TID
;
785 qsort (pbuf
, pcount
, sizeof *pbuf
, pcmp
);
787 /* Accumulate an array of GDB threads sorted by pid. */
790 iterate_over_threads (giter_count
, &gcount
);
791 g
= gbuf
= XNEWVEC (struct thread_info
*, gcount
);
792 iterate_over_threads (giter_accum
, &g
);
793 qsort (gbuf
, gcount
, sizeof *gbuf
, gcmp
);
795 /* Apply differences between the two arrays to GDB's thread list. */
797 infpid
= inferior_ptid
.pid ();
798 for (pi
= gi
= 0; pi
< pcount
|| gi
< gcount
;)
802 delete_thread (gbuf
[gi
]);
805 else if (gi
== gcount
)
807 aix_thread_info
*priv
= new aix_thread_info
;
808 priv
->pdtid
= pbuf
[pi
].pdtid
;
809 priv
->tid
= pbuf
[pi
].tid
;
811 thread
= add_thread_with_info (ptid_t (infpid
, 0, pbuf
[pi
].pthid
), priv
);
820 pptid
= ptid_t (infpid
, 0, pbuf
[pi
].pthid
);
821 gptid
= gbuf
[gi
]->ptid
;
822 pdtid
= pbuf
[pi
].pdtid
;
825 cmp_result
= ptid_cmp (pptid
, gptid
);
829 aix_thread_info
*priv
= get_aix_thread_info (gbuf
[gi
]);
836 else if (cmp_result
> 0)
838 delete_thread (gbuf
[gi
]);
843 thread
= add_thread (pptid
);
845 aix_thread_info
*priv
= new aix_thread_info
;
846 thread
->priv
.reset (priv
);
858 /* Iterate_over_threads() callback for locating a thread, using
859 the TID of its associated kernel thread. */
862 iter_tid (struct thread_info
*thread
, void *tidp
)
864 const pthdb_tid_t tid
= *(pthdb_tid_t
*)tidp
;
865 aix_thread_info
*priv
= get_aix_thread_info (thread
);
867 return priv
->tid
== tid
;
870 /* Synchronize libpthdebug's state with the inferior and with GDB,
871 generate a composite process/thread <pid> for the current thread,
872 set inferior_ptid to <pid> if SET_INFPID, and return <pid>. */
875 pd_update (int set_infpid
)
880 struct thread_info
*thread
= NULL
;
883 return inferior_ptid
;
885 status
= pthdb_session_update (pd_session
);
886 if (status
!= PTHDB_SUCCESS
)
887 return inferior_ptid
;
891 /* Define "current thread" as one that just received a trap signal. */
893 tid
= get_signaled_thread ();
895 thread
= iterate_over_threads (iter_tid
, &tid
);
897 ptid
= inferior_ptid
;
902 inferior_ptid
= ptid
;
907 /* Try to start debugging threads in the current process.
908 If successful and SET_INFPID, set inferior_ptid to reflect the
912 pd_activate (int set_infpid
)
916 status
= pthdb_session_init (PD_USER
, arch64
? PEM_64BIT
: PEM_32BIT
,
917 PTHDB_FLAG_REGS
, &pd_callbacks
,
919 if (status
!= PTHDB_SUCCESS
)
921 return inferior_ptid
;
924 return pd_update (set_infpid
);
927 /* Undo the effects of pd_activate(). */
934 pthdb_session_destroy (pd_session
);
936 pid_to_prc (&inferior_ptid
);
940 /* An object file has just been loaded. Check whether the current
941 application is pthreaded, and if so, prepare for thread debugging. */
948 struct bound_minimal_symbol ms
;
950 /* Don't initialize twice. */
954 /* Check application word size. */
955 arch64
= register_size (target_gdbarch (), 0) == 8;
957 /* Check whether the application is pthreaded. */
959 status
= pthdb_session_pthreaded (PD_USER
, PTHDB_FLAG_REGS
,
960 &pd_callbacks
, &stub_name
);
961 if ((status
!= PTHDB_SUCCESS
962 && status
!= PTHDB_NOT_PTHREADED
) || !stub_name
)
965 /* Set a breakpoint on the returned stub function. */
966 ms
= lookup_minimal_symbol (stub_name
, NULL
, NULL
);
967 if (ms
.minsym
== NULL
)
969 pd_brk_addr
= BMSYMBOL_VALUE_ADDRESS (ms
);
970 if (!create_thread_event_breakpoint (target_gdbarch (), pd_brk_addr
))
973 /* Prepare for thread debugging. */
974 push_target (&aix_thread_ops
);
977 /* If we're debugging a core file or an attached inferior, the
978 pthread library may already have been initialized, so try to
979 activate thread debugging. */
983 /* Undo the effects of pd_enable(). */
993 unpush_target (&aix_thread_ops
);
996 /* new_objfile observer callback.
998 If OBJFILE is non-null, check whether a threaded application is
999 being debugged, and if so, prepare for thread debugging.
1001 If OBJFILE is null, stop debugging threads. */
1004 new_objfile (struct objfile
*objfile
)
1012 /* Attach to process specified by ARGS. */
1015 aix_thread_inferior_created (struct target_ops
*ops
, int from_tty
)
1020 /* Detach from the process attached to by aix_thread_attach(). */
1023 aix_thread_target::detach (inferior
*inf
, int from_tty
)
1025 target_ops
*beneath
= this->beneath ();
1028 beneath
->detach (inf
, from_tty
);
1031 /* Tell the inferior process to continue running thread PID if != -1
1032 and all threads otherwise. */
1035 aix_thread_target::resume (ptid_t ptid
, int step
, enum gdb_signal sig
)
1037 struct thread_info
*thread
;
1042 scoped_restore save_inferior_ptid
= make_scoped_restore (&inferior_ptid
);
1044 inferior_ptid
= ptid_t (inferior_ptid
.pid ());
1045 beneath ()->resume (ptid
, step
, sig
);
1049 thread
= find_thread_ptid (ptid
);
1051 error (_("aix-thread resume: unknown pthread %ld"),
1054 aix_thread_info
*priv
= get_aix_thread_info (thread
);
1057 if (tid
[0] == PTHDB_INVALID_TID
)
1058 error (_("aix-thread resume: no tid for pthread %ld"),
1063 ptrace64aix (PTT_CONTINUE
, tid
[0], (long long) 1,
1064 gdb_signal_to_host (sig
), (PTRACE_TYPE_ARG5
) tid
);
1066 ptrace32 (PTT_CONTINUE
, tid
[0], (addr_ptr
) 1,
1067 gdb_signal_to_host (sig
), (PTRACE_TYPE_ARG5
) tid
);
1071 /* Wait for thread/process ID if != -1 or for any thread otherwise.
1072 If an error occurs, return -1, else return the pid of the stopped
1076 aix_thread_target::wait (ptid_t ptid
, struct target_waitstatus
*status
,
1080 scoped_restore save_inferior_ptid
= make_scoped_restore (&inferior_ptid
);
1084 inferior_ptid
= ptid_t (inferior_ptid
.pid ());
1085 ptid
= beneath ()->wait (ptid
, status
, options
);
1088 if (ptid
.pid () == -1)
1091 /* Check whether libpthdebug might be ready to be initialized. */
1092 if (!pd_active
&& status
->kind
== TARGET_WAITKIND_STOPPED
1093 && status
->value
.sig
== GDB_SIGNAL_TRAP
)
1095 struct regcache
*regcache
= get_thread_regcache (ptid
);
1096 struct gdbarch
*gdbarch
= regcache
->arch ();
1098 if (regcache_read_pc (regcache
)
1099 - gdbarch_decr_pc_after_break (gdbarch
) == pd_brk_addr
)
1100 return pd_activate (0);
1103 return pd_update (0);
1106 /* Record that the 64-bit general-purpose registers contain VALS. */
1109 supply_gprs64 (struct regcache
*regcache
, uint64_t *vals
)
1111 struct gdbarch_tdep
*tdep
= gdbarch_tdep (regcache
->arch ());
1114 for (regno
= 0; regno
< ppc_num_gprs
; regno
++)
1115 regcache
->raw_supply (tdep
->ppc_gp0_regnum
+ regno
,
1116 (char *) (vals
+ regno
));
1119 /* Record that 32-bit register REGNO contains VAL. */
1122 supply_reg32 (struct regcache
*regcache
, int regno
, uint32_t val
)
1124 regcache
->raw_supply (regno
, (char *) &val
);
1127 /* Record that the floating-point registers contain VALS. */
1130 supply_fprs (struct regcache
*regcache
, double *vals
)
1132 struct gdbarch
*gdbarch
= regcache
->arch ();
1133 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1136 /* This function should never be called on architectures without
1137 floating-point registers. */
1138 gdb_assert (ppc_floating_point_unit_p (gdbarch
));
1140 for (regno
= tdep
->ppc_fp0_regnum
;
1141 regno
< tdep
->ppc_fp0_regnum
+ ppc_num_fprs
;
1143 regcache
->raw_supply (regno
,
1144 (char *) (vals
+ regno
- tdep
->ppc_fp0_regnum
));
1147 /* Predicate to test whether given register number is a "special" register. */
1149 special_register_p (struct gdbarch
*gdbarch
, int regno
)
1151 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1153 return regno
== gdbarch_pc_regnum (gdbarch
)
1154 || regno
== tdep
->ppc_ps_regnum
1155 || regno
== tdep
->ppc_cr_regnum
1156 || regno
== tdep
->ppc_lr_regnum
1157 || regno
== tdep
->ppc_ctr_regnum
1158 || regno
== tdep
->ppc_xer_regnum
1159 || (tdep
->ppc_fpscr_regnum
>= 0 && regno
== tdep
->ppc_fpscr_regnum
)
1160 || (tdep
->ppc_mq_regnum
>= 0 && regno
== tdep
->ppc_mq_regnum
);
1164 /* Record that the special registers contain the specified 64-bit and
1168 supply_sprs64 (struct regcache
*regcache
,
1169 uint64_t iar
, uint64_t msr
, uint32_t cr
,
1170 uint64_t lr
, uint64_t ctr
, uint32_t xer
,
1173 struct gdbarch
*gdbarch
= regcache
->arch ();
1174 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1176 regcache
->raw_supply (gdbarch_pc_regnum (gdbarch
), (char *) &iar
);
1177 regcache
->raw_supply (tdep
->ppc_ps_regnum
, (char *) &msr
);
1178 regcache
->raw_supply (tdep
->ppc_cr_regnum
, (char *) &cr
);
1179 regcache
->raw_supply (tdep
->ppc_lr_regnum
, (char *) &lr
);
1180 regcache
->raw_supply (tdep
->ppc_ctr_regnum
, (char *) &ctr
);
1181 regcache
->raw_supply (tdep
->ppc_xer_regnum
, (char *) &xer
);
1182 if (tdep
->ppc_fpscr_regnum
>= 0)
1183 regcache
->raw_supply (tdep
->ppc_fpscr_regnum
, (char *) &fpscr
);
1186 /* Record that the special registers contain the specified 32-bit
1190 supply_sprs32 (struct regcache
*regcache
,
1191 uint32_t iar
, uint32_t msr
, uint32_t cr
,
1192 uint32_t lr
, uint32_t ctr
, uint32_t xer
,
1195 struct gdbarch
*gdbarch
= regcache
->arch ();
1196 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1198 regcache
->raw_supply (gdbarch_pc_regnum (gdbarch
), (char *) &iar
);
1199 regcache
->raw_supply (tdep
->ppc_ps_regnum
, (char *) &msr
);
1200 regcache
->raw_supply (tdep
->ppc_cr_regnum
, (char *) &cr
);
1201 regcache
->raw_supply (tdep
->ppc_lr_regnum
, (char *) &lr
);
1202 regcache
->raw_supply (tdep
->ppc_ctr_regnum
, (char *) &ctr
);
1203 regcache
->raw_supply (tdep
->ppc_xer_regnum
, (char *) &xer
);
1204 if (tdep
->ppc_fpscr_regnum
>= 0)
1205 regcache
->raw_supply (tdep
->ppc_fpscr_regnum
, (char *) &fpscr
);
1208 /* Fetch all registers from pthread PDTID, which doesn't have a kernel
1211 There's no way to query a single register from a non-kernel
1212 pthread, so there's no need for a single-register version of this
1216 fetch_regs_user_thread (struct regcache
*regcache
, pthdb_pthread_t pdtid
)
1218 struct gdbarch
*gdbarch
= regcache
->arch ();
1219 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1221 pthdb_context_t ctx
;
1223 if (debug_aix_thread
)
1224 fprintf_unfiltered (gdb_stdlog
,
1225 "fetch_regs_user_thread %lx\n", (long) pdtid
);
1226 status
= pthdb_pthread_context (pd_session
, pdtid
, &ctx
);
1227 if (status
!= PTHDB_SUCCESS
)
1228 error (_("aix-thread: fetch_registers: pthdb_pthread_context returned %s"),
1229 pd_status2str (status
));
1231 /* General-purpose registers. */
1234 supply_gprs64 (regcache
, ctx
.gpr
);
1236 for (i
= 0; i
< ppc_num_gprs
; i
++)
1237 supply_reg32 (regcache
, tdep
->ppc_gp0_regnum
+ i
, ctx
.gpr
[i
]);
1239 /* Floating-point registers. */
1241 if (ppc_floating_point_unit_p (gdbarch
))
1242 supply_fprs (regcache
, ctx
.fpr
);
1244 /* Special registers. */
1247 supply_sprs64 (regcache
, ctx
.iar
, ctx
.msr
, ctx
.cr
, ctx
.lr
, ctx
.ctr
,
1248 ctx
.xer
, ctx
.fpscr
);
1250 supply_sprs32 (regcache
, ctx
.iar
, ctx
.msr
, ctx
.cr
, ctx
.lr
, ctx
.ctr
,
1251 ctx
.xer
, ctx
.fpscr
);
1254 /* Fetch register REGNO if != -1 or all registers otherwise from
1257 AIX provides a way to query all of a kernel thread's GPRs, FPRs, or
1258 SPRs, but there's no way to query individual registers within those
1259 groups. Therefore, if REGNO != -1, this function fetches an entire
1262 Unfortunately, kernel thread register queries often fail with
1263 EPERM, indicating that the thread is in kernel space. This breaks
1264 backtraces of threads other than the current one. To make that
1265 breakage obvious without throwing an error to top level (which is
1266 bad e.g. during "info threads" output), zero registers that can't
1270 fetch_regs_kernel_thread (struct regcache
*regcache
, int regno
,
1273 struct gdbarch
*gdbarch
= regcache
->arch ();
1274 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1275 uint64_t gprs64
[ppc_num_gprs
];
1276 uint32_t gprs32
[ppc_num_gprs
];
1277 double fprs
[ppc_num_fprs
];
1278 struct ptxsprs sprs64
;
1279 struct ptsprs sprs32
;
1282 if (debug_aix_thread
)
1283 fprintf_unfiltered (gdb_stdlog
,
1284 "fetch_regs_kernel_thread tid=%lx regno=%d arch64=%d\n",
1285 (long) tid
, regno
, arch64
);
1287 /* General-purpose registers. */
1289 || (tdep
->ppc_gp0_regnum
<= regno
1290 && regno
< tdep
->ppc_gp0_regnum
+ ppc_num_gprs
))
1294 if (!ptrace64aix (PTT_READ_GPRS
, tid
,
1295 (unsigned long) gprs64
, 0, NULL
))
1296 memset (gprs64
, 0, sizeof (gprs64
));
1297 supply_gprs64 (regcache
, gprs64
);
1301 if (!ptrace32 (PTT_READ_GPRS
, tid
, (uintptr_t) gprs32
, 0, NULL
))
1302 memset (gprs32
, 0, sizeof (gprs32
));
1303 for (i
= 0; i
< ppc_num_gprs
; i
++)
1304 supply_reg32 (regcache
, tdep
->ppc_gp0_regnum
+ i
, gprs32
[i
]);
1308 /* Floating-point registers. */
1310 if (ppc_floating_point_unit_p (gdbarch
)
1312 || (regno
>= tdep
->ppc_fp0_regnum
1313 && regno
< tdep
->ppc_fp0_regnum
+ ppc_num_fprs
)))
1315 if (!ptrace32 (PTT_READ_FPRS
, tid
, (uintptr_t) fprs
, 0, NULL
))
1316 memset (fprs
, 0, sizeof (fprs
));
1317 supply_fprs (regcache
, fprs
);
1320 /* Special-purpose registers. */
1322 if (regno
== -1 || special_register_p (gdbarch
, regno
))
1326 if (!ptrace64aix (PTT_READ_SPRS
, tid
,
1327 (unsigned long) &sprs64
, 0, NULL
))
1328 memset (&sprs64
, 0, sizeof (sprs64
));
1329 supply_sprs64 (regcache
, sprs64
.pt_iar
, sprs64
.pt_msr
,
1330 sprs64
.pt_cr
, sprs64
.pt_lr
, sprs64
.pt_ctr
,
1331 sprs64
.pt_xer
, sprs64
.pt_fpscr
);
1335 if (!ptrace32 (PTT_READ_SPRS
, tid
, (uintptr_t) &sprs32
, 0, NULL
))
1336 memset (&sprs32
, 0, sizeof (sprs32
));
1337 supply_sprs32 (regcache
, sprs32
.pt_iar
, sprs32
.pt_msr
, sprs32
.pt_cr
,
1338 sprs32
.pt_lr
, sprs32
.pt_ctr
, sprs32
.pt_xer
,
1341 if (tdep
->ppc_mq_regnum
>= 0)
1342 regcache
->raw_supply (tdep
->ppc_mq_regnum
, (char *) &sprs32
.pt_mq
);
1347 /* Fetch register REGNO if != -1 or all registers otherwise from the
1348 thread/process connected to REGCACHE. */
1351 aix_thread_target::fetch_registers (struct regcache
*regcache
, int regno
)
1353 struct thread_info
*thread
;
1356 if (!PD_TID (regcache
->ptid ()))
1357 beneath ()->fetch_registers (regcache
, regno
);
1360 thread
= find_thread_ptid (regcache
->ptid ());
1361 aix_thread_info
*priv
= get_aix_thread_info (thread
);
1364 if (tid
== PTHDB_INVALID_TID
)
1365 fetch_regs_user_thread (regcache
, priv
->pdtid
);
1367 fetch_regs_kernel_thread (regcache
, regno
, tid
);
1371 /* Store the gp registers into an array of uint32_t or uint64_t. */
1374 fill_gprs64 (const struct regcache
*regcache
, uint64_t *vals
)
1376 struct gdbarch_tdep
*tdep
= gdbarch_tdep (regcache
->arch ());
1379 for (regno
= 0; regno
< ppc_num_gprs
; regno
++)
1380 if (REG_VALID
== regcache
->get_register_status
1381 (tdep
->ppc_gp0_regnum
+ regno
))
1382 regcache
->raw_collect (tdep
->ppc_gp0_regnum
+ regno
, vals
+ regno
);
1386 fill_gprs32 (const struct regcache
*regcache
, uint32_t *vals
)
1388 struct gdbarch_tdep
*tdep
= gdbarch_tdep (regcache
->arch ());
1391 for (regno
= 0; regno
< ppc_num_gprs
; regno
++)
1392 if (REG_VALID
== regcache
->get_register_status
1393 (tdep
->ppc_gp0_regnum
+ regno
))
1394 regcache
->raw_collect (tdep
->ppc_gp0_regnum
+ regno
, vals
+ regno
);
1397 /* Store the floating point registers into a double array. */
1399 fill_fprs (const struct regcache
*regcache
, double *vals
)
1401 struct gdbarch
*gdbarch
= regcache
->arch ();
1402 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1405 /* This function should never be called on architectures without
1406 floating-point registers. */
1407 gdb_assert (ppc_floating_point_unit_p (gdbarch
));
1409 for (regno
= tdep
->ppc_fp0_regnum
;
1410 regno
< tdep
->ppc_fp0_regnum
+ ppc_num_fprs
;
1412 if (REG_VALID
== regcache
->get_register_status (regno
))
1413 regcache
->raw_collect (regno
, vals
+ regno
- tdep
->ppc_fp0_regnum
);
1416 /* Store the special registers into the specified 64-bit and 32-bit
1420 fill_sprs64 (const struct regcache
*regcache
,
1421 uint64_t *iar
, uint64_t *msr
, uint32_t *cr
,
1422 uint64_t *lr
, uint64_t *ctr
, uint32_t *xer
,
1425 struct gdbarch
*gdbarch
= regcache
->arch ();
1426 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1428 /* Verify that the size of the size of the IAR buffer is the
1429 same as the raw size of the PC (in the register cache). If
1430 they're not, then either GDB has been built incorrectly, or
1431 there's some other kind of internal error. To be really safe,
1432 we should check all of the sizes. */
1433 gdb_assert (sizeof (*iar
) == register_size
1434 (gdbarch
, gdbarch_pc_regnum (gdbarch
)));
1436 if (REG_VALID
== regcache
->get_register_status (gdbarch_pc_regnum (gdbarch
)))
1437 regcache
->raw_collect (gdbarch_pc_regnum (gdbarch
), iar
);
1438 if (REG_VALID
== regcache
->get_register_status (tdep
->ppc_ps_regnum
))
1439 regcache
->raw_collect (tdep
->ppc_ps_regnum
, msr
);
1440 if (REG_VALID
== regcache
->get_register_status (tdep
->ppc_cr_regnum
))
1441 regcache
->raw_collect (tdep
->ppc_cr_regnum
, cr
);
1442 if (REG_VALID
== regcache
->get_register_status (tdep
->ppc_lr_regnum
))
1443 regcache
->raw_collect (tdep
->ppc_lr_regnum
, lr
);
1444 if (REG_VALID
== regcache
->get_register_status (tdep
->ppc_ctr_regnum
))
1445 regcache
->raw_collect (tdep
->ppc_ctr_regnum
, ctr
);
1446 if (REG_VALID
== regcache
->get_register_status (tdep
->ppc_xer_regnum
))
1447 regcache
->raw_collect (tdep
->ppc_xer_regnum
, xer
);
1448 if (tdep
->ppc_fpscr_regnum
>= 0
1449 && REG_VALID
== regcache
->get_register_status (tdep
->ppc_fpscr_regnum
))
1450 regcache
->raw_collect (tdep
->ppc_fpscr_regnum
, fpscr
);
1454 fill_sprs32 (const struct regcache
*regcache
,
1455 uint32_t *iar
, uint32_t *msr
, uint32_t *cr
,
1456 uint32_t *lr
, uint32_t *ctr
, uint32_t *xer
,
1459 struct gdbarch
*gdbarch
= regcache
->arch ();
1460 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1462 /* Verify that the size of the size of the IAR buffer is the
1463 same as the raw size of the PC (in the register cache). If
1464 they're not, then either GDB has been built incorrectly, or
1465 there's some other kind of internal error. To be really safe,
1466 we should check all of the sizes. */
1467 gdb_assert (sizeof (*iar
) == register_size (gdbarch
,
1468 gdbarch_pc_regnum (gdbarch
)));
1470 if (REG_VALID
== regcache
->get_register_status (gdbarch_pc_regnum (gdbarch
)))
1471 regcache
->raw_collect (gdbarch_pc_regnum (gdbarch
), iar
);
1472 if (REG_VALID
== regcache
->get_register_status (tdep
->ppc_ps_regnum
))
1473 regcache
->raw_collect (tdep
->ppc_ps_regnum
, msr
);
1474 if (REG_VALID
== regcache
->get_register_status (tdep
->ppc_cr_regnum
))
1475 regcache
->raw_collect (tdep
->ppc_cr_regnum
, cr
);
1476 if (REG_VALID
== regcache
->get_register_status (tdep
->ppc_lr_regnum
))
1477 regcache
->raw_collect (tdep
->ppc_lr_regnum
, lr
);
1478 if (REG_VALID
== regcache
->get_register_status (tdep
->ppc_ctr_regnum
))
1479 regcache
->raw_collect (tdep
->ppc_ctr_regnum
, ctr
);
1480 if (REG_VALID
== regcache
->get_register_status (tdep
->ppc_xer_regnum
))
1481 regcache
->raw_collect (tdep
->ppc_xer_regnum
, xer
);
1482 if (tdep
->ppc_fpscr_regnum
>= 0
1483 && REG_VALID
== regcache
->get_register_status (tdep
->ppc_fpscr_regnum
))
1484 regcache
->raw_collect (tdep
->ppc_fpscr_regnum
, fpscr
);
1487 /* Store all registers into pthread PDTID, which doesn't have a kernel
1490 It's possible to store a single register into a non-kernel pthread,
1491 but I doubt it's worth the effort. */
1494 store_regs_user_thread (const struct regcache
*regcache
, pthdb_pthread_t pdtid
)
1496 struct gdbarch
*gdbarch
= regcache
->arch ();
1497 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1499 pthdb_context_t ctx
;
1503 if (debug_aix_thread
)
1504 fprintf_unfiltered (gdb_stdlog
,
1505 "store_regs_user_thread %lx\n", (long) pdtid
);
1507 /* Retrieve the thread's current context for its non-register
1509 status
= pthdb_pthread_context (pd_session
, pdtid
, &ctx
);
1510 if (status
!= PTHDB_SUCCESS
)
1511 error (_("aix-thread: store_registers: pthdb_pthread_context returned %s"),
1512 pd_status2str (status
));
1514 /* Collect general-purpose register values from the regcache. */
1516 for (i
= 0; i
< ppc_num_gprs
; i
++)
1517 if (REG_VALID
== regcache
->get_register_status (tdep
->ppc_gp0_regnum
+ i
))
1521 regcache
->raw_collect (tdep
->ppc_gp0_regnum
+ i
, (void *) &int64
);
1526 regcache
->raw_collect (tdep
->ppc_gp0_regnum
+ i
, (void *) &int32
);
1531 /* Collect floating-point register values from the regcache. */
1532 if (ppc_floating_point_unit_p (gdbarch
))
1533 fill_fprs (regcache
, ctx
.fpr
);
1535 /* Special registers (always kept in ctx as 64 bits). */
1538 fill_sprs64 (regcache
, &ctx
.iar
, &ctx
.msr
, &ctx
.cr
, &ctx
.lr
, &ctx
.ctr
,
1539 &ctx
.xer
, &ctx
.fpscr
);
1543 /* Problem: ctx.iar etc. are 64 bits, but raw_registers are 32.
1544 Solution: use 32-bit temp variables. */
1545 uint32_t tmp_iar
, tmp_msr
, tmp_cr
, tmp_lr
, tmp_ctr
, tmp_xer
,
1548 fill_sprs32 (regcache
, &tmp_iar
, &tmp_msr
, &tmp_cr
, &tmp_lr
, &tmp_ctr
,
1549 &tmp_xer
, &tmp_fpscr
);
1550 if (REG_VALID
== regcache
->get_register_status
1551 (gdbarch_pc_regnum (gdbarch
)))
1553 if (REG_VALID
== regcache
->get_register_status (tdep
->ppc_ps_regnum
))
1555 if (REG_VALID
== regcache
->get_register_status (tdep
->ppc_cr_regnum
))
1557 if (REG_VALID
== regcache
->get_register_status (tdep
->ppc_lr_regnum
))
1559 if (REG_VALID
== regcache
->get_register_status (tdep
->ppc_ctr_regnum
))
1561 if (REG_VALID
== regcache
->get_register_status (tdep
->ppc_xer_regnum
))
1563 if (REG_VALID
== regcache
->get_register_status (tdep
->ppc_xer_regnum
))
1564 ctx
.fpscr
= tmp_fpscr
;
1567 status
= pthdb_pthread_setcontext (pd_session
, pdtid
, &ctx
);
1568 if (status
!= PTHDB_SUCCESS
)
1569 error (_("aix-thread: store_registers: "
1570 "pthdb_pthread_setcontext returned %s"),
1571 pd_status2str (status
));
1574 /* Store register REGNO if != -1 or all registers otherwise into
1577 AIX provides a way to set all of a kernel thread's GPRs, FPRs, or
1578 SPRs, but there's no way to set individual registers within those
1579 groups. Therefore, if REGNO != -1, this function stores an entire
1583 store_regs_kernel_thread (const struct regcache
*regcache
, int regno
,
1586 struct gdbarch
*gdbarch
= regcache
->arch ();
1587 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1588 uint64_t gprs64
[ppc_num_gprs
];
1589 uint32_t gprs32
[ppc_num_gprs
];
1590 double fprs
[ppc_num_fprs
];
1591 struct ptxsprs sprs64
;
1592 struct ptsprs sprs32
;
1594 if (debug_aix_thread
)
1595 fprintf_unfiltered (gdb_stdlog
,
1596 "store_regs_kernel_thread tid=%lx regno=%d\n",
1599 /* General-purpose registers. */
1601 || (tdep
->ppc_gp0_regnum
<= regno
1602 && regno
< tdep
->ppc_gp0_regnum
+ ppc_num_fprs
))
1606 /* Pre-fetch: some regs may not be in the cache. */
1607 ptrace64aix (PTT_READ_GPRS
, tid
, (unsigned long) gprs64
, 0, NULL
);
1608 fill_gprs64 (regcache
, gprs64
);
1609 ptrace64aix (PTT_WRITE_GPRS
, tid
, (unsigned long) gprs64
, 0, NULL
);
1613 /* Pre-fetch: some regs may not be in the cache. */
1614 ptrace32 (PTT_READ_GPRS
, tid
, (uintptr_t) gprs32
, 0, NULL
);
1615 fill_gprs32 (regcache
, gprs32
);
1616 ptrace32 (PTT_WRITE_GPRS
, tid
, (uintptr_t) gprs32
, 0, NULL
);
1620 /* Floating-point registers. */
1622 if (ppc_floating_point_unit_p (gdbarch
)
1624 || (regno
>= tdep
->ppc_fp0_regnum
1625 && regno
< tdep
->ppc_fp0_regnum
+ ppc_num_fprs
)))
1627 /* Pre-fetch: some regs may not be in the cache. */
1628 ptrace32 (PTT_READ_FPRS
, tid
, (uintptr_t) fprs
, 0, NULL
);
1629 fill_fprs (regcache
, fprs
);
1630 ptrace32 (PTT_WRITE_FPRS
, tid
, (uintptr_t) fprs
, 0, NULL
);
1633 /* Special-purpose registers. */
1635 if (regno
== -1 || special_register_p (gdbarch
, regno
))
1639 /* Pre-fetch: some registers won't be in the cache. */
1640 ptrace64aix (PTT_READ_SPRS
, tid
,
1641 (unsigned long) &sprs64
, 0, NULL
);
1642 fill_sprs64 (regcache
, &sprs64
.pt_iar
, &sprs64
.pt_msr
,
1643 &sprs64
.pt_cr
, &sprs64
.pt_lr
, &sprs64
.pt_ctr
,
1644 &sprs64
.pt_xer
, &sprs64
.pt_fpscr
);
1645 ptrace64aix (PTT_WRITE_SPRS
, tid
,
1646 (unsigned long) &sprs64
, 0, NULL
);
1650 /* The contents of "struct ptspr" were declared as "unsigned
1651 long" up to AIX 5.2, but are "unsigned int" since 5.3.
1652 Use temporaries to work around this problem. Also, add an
1653 assert here to make sure we fail if the system header files
1654 use "unsigned long", and the size of that type is not what
1655 the headers expect. */
1656 uint32_t tmp_iar
, tmp_msr
, tmp_cr
, tmp_lr
, tmp_ctr
, tmp_xer
,
1659 gdb_assert (sizeof (sprs32
.pt_iar
) == 4);
1661 /* Pre-fetch: some registers won't be in the cache. */
1662 ptrace32 (PTT_READ_SPRS
, tid
, (uintptr_t) &sprs32
, 0, NULL
);
1664 fill_sprs32 (regcache
, &tmp_iar
, &tmp_msr
, &tmp_cr
, &tmp_lr
,
1665 &tmp_ctr
, &tmp_xer
, &tmp_fpscr
);
1667 sprs32
.pt_iar
= tmp_iar
;
1668 sprs32
.pt_msr
= tmp_msr
;
1669 sprs32
.pt_cr
= tmp_cr
;
1670 sprs32
.pt_lr
= tmp_lr
;
1671 sprs32
.pt_ctr
= tmp_ctr
;
1672 sprs32
.pt_xer
= tmp_xer
;
1673 sprs32
.pt_fpscr
= tmp_fpscr
;
1675 if (tdep
->ppc_mq_regnum
>= 0)
1676 if (REG_VALID
== regcache
->get_register_status
1677 (tdep
->ppc_mq_regnum
))
1678 regcache
->raw_collect (tdep
->ppc_mq_regnum
, &sprs32
.pt_mq
);
1680 ptrace32 (PTT_WRITE_SPRS
, tid
, (uintptr_t) &sprs32
, 0, NULL
);
1685 /* Store gdb's current view of the register set into the
1686 thread/process connected to REGCACHE. */
1689 aix_thread_target::store_registers (struct regcache
*regcache
, int regno
)
1691 struct thread_info
*thread
;
1694 if (!PD_TID (regcache
->ptid ()))
1695 beneath ()->store_registers (regcache
, regno
);
1698 thread
= find_thread_ptid (regcache
->ptid ());
1699 aix_thread_info
*priv
= get_aix_thread_info (thread
);
1702 if (tid
== PTHDB_INVALID_TID
)
1703 store_regs_user_thread (regcache
, priv
->pdtid
);
1705 store_regs_kernel_thread (regcache
, regno
, tid
);
1709 /* Implement the to_xfer_partial target_ops method. */
1711 enum target_xfer_status
1712 aix_thread_target::xfer_partial (enum target_object object
,
1713 const char *annex
, gdb_byte
*readbuf
,
1714 const gdb_byte
*writebuf
,
1715 ULONGEST offset
, ULONGEST len
,
1716 ULONGEST
*xfered_len
)
1718 scoped_restore save_inferior_ptid
= make_scoped_restore (&inferior_ptid
);
1720 inferior_ptid
= ptid_t (inferior_ptid
.pid ());
1721 return beneath ()->xfer_partial (object
, annex
, readbuf
,
1722 writebuf
, offset
, len
, xfered_len
);
1725 /* Clean up after the inferior exits. */
1728 aix_thread_target::mourn_inferior ()
1730 target_ops
*beneath
= this->beneath ();
1733 beneath
->mourn_inferior ();
1736 /* Return whether thread PID is still valid. */
1739 aix_thread_target::thread_alive (ptid_t ptid
)
1742 return beneath ()->thread_alive (ptid
);
1744 /* We update the thread list every time the child stops, so all
1745 valid threads should be in the thread list. */
1746 return in_thread_list (ptid
);
1749 /* Return a printable representation of composite PID for use in
1750 "info threads" output. */
1753 aix_thread_target::pid_to_str (ptid_t ptid
)
1756 return beneath ()->pid_to_str (ptid
);
1758 return string_printf (_("Thread %ld"), ptid
.tid ());
1761 /* Return a printable representation of extra information about
1762 THREAD, for use in "info threads" output. */
1765 aix_thread_target::extra_thread_info (struct thread_info
*thread
)
1768 pthdb_pthread_t pdtid
;
1770 pthdb_state_t state
;
1771 pthdb_suspendstate_t suspendstate
;
1772 pthdb_detachstate_t detachstate
;
1774 static char *ret
= NULL
;
1776 if (!PD_TID (thread
->ptid
))
1780 aix_thread_info
*priv
= get_aix_thread_info (thread
);
1782 pdtid
= priv
->pdtid
;
1785 if (tid
!= PTHDB_INVALID_TID
)
1786 /* i18n: Like "thread-identifier %d, [state] running, suspended" */
1787 buf
.printf (_("tid %d"), (int)tid
);
1789 status
= pthdb_pthread_state (pd_session
, pdtid
, &state
);
1790 if (status
!= PTHDB_SUCCESS
)
1792 buf
.printf (", %s", state2str (state
));
1794 status
= pthdb_pthread_suspendstate (pd_session
, pdtid
,
1796 if (status
== PTHDB_SUCCESS
&& suspendstate
== PSS_SUSPENDED
)
1797 /* i18n: Like "Thread-Id %d, [state] running, suspended" */
1798 buf
.printf (_(", suspended"));
1800 status
= pthdb_pthread_detachstate (pd_session
, pdtid
,
1802 if (status
== PTHDB_SUCCESS
&& detachstate
== PDS_DETACHED
)
1803 /* i18n: Like "Thread-Id %d, [state] running, detached" */
1804 buf
.printf (_(", detached"));
1806 pthdb_pthread_cancelpend (pd_session
, pdtid
, &cancelpend
);
1807 if (status
== PTHDB_SUCCESS
&& cancelpend
)
1808 /* i18n: Like "Thread-Id %d, [state] running, cancel pending" */
1809 buf
.printf (_(", cancel pending"));
1813 xfree (ret
); /* Free old buffer. */
1815 ret
= xstrdup (buf
.c_str ());
1821 aix_thread_target::get_ada_task_ptid (long lwp
, long thread
)
1823 return ptid_t (inferior_ptid
.pid (), 0, thread
);
1827 /* Module startup initialization function, automagically called by
1831 _initialize_aix_thread (void)
1833 /* Notice when object files get loaded and unloaded. */
1834 gdb::observers::new_objfile
.attach (new_objfile
);
1836 /* Add ourselves to inferior_created event chain.
1837 This is needed to enable the thread target on "attach". */
1838 gdb::observers::inferior_created
.attach (aix_thread_inferior_created
);
1840 add_setshow_boolean_cmd ("aix-thread", class_maintenance
, &debug_aix_thread
,
1841 _("Set debugging of AIX thread module."),
1842 _("Show debugging of AIX thread module."),
1843 _("Enables debugging output (used to debug GDB)."),
1845 /* FIXME: i18n: Debugging of AIX thread
1846 module is \"%d\". */
1847 &setdebuglist
, &showdebuglist
);