1 /* Low level interface for debugging AIX 4.3+ pthreads.
3 Copyright (C) 1999-2014 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 "gdb_assert.h"
44 #include "gdbthread.h"
55 #include <sys/types.h>
56 #include <sys/ptrace.h>
59 #include <sys/pthdebug.h>
61 #if !HAVE_DECL_GETTHRDS
62 extern int getthrds (pid_t
, struct thrdsinfo64
*, int, tid_t
*, int);
65 /* Whether to emit debugging output. */
66 static int debug_aix_thread
;
68 /* In AIX 5.1, functions use pthdb_tid_t instead of tid_t. */
69 #ifndef PTHDB_VERSION_3
70 #define pthdb_tid_t tid_t
73 /* Return whether to treat PID as a debuggable thread id. */
75 #define PD_TID(ptid) (pd_active && ptid_get_tid (ptid) != 0)
77 /* pthdb_user_t value that we pass to pthdb functions. 0 causes
78 PTHDB_BAD_USER errors, so use 1. */
82 /* Success and failure values returned by pthdb callbacks. */
84 #define PDC_SUCCESS PTHDB_SUCCESS
85 #define PDC_FAILURE PTHDB_CALLBACK
87 /* Private data attached to each element in GDB's thread list. */
89 struct private_thread_info
{
90 pthdb_pthread_t pdtid
; /* thread's libpthdebug id */
91 pthdb_tid_t tid
; /* kernel thread id */
94 /* Information about a thread of which libpthdebug is aware. */
97 pthdb_pthread_t pdtid
;
102 /* This module's target-specific operations, active while pd_able is true. */
104 static struct target_ops aix_thread_ops
;
106 /* Address of the function that libpthread will call when libpthdebug
107 is ready to be initialized. */
109 static CORE_ADDR pd_brk_addr
;
111 /* Whether the current application is debuggable by pthdb. */
113 static int pd_able
= 0;
115 /* Whether a threaded application is being debugged. */
117 static int pd_active
= 0;
119 /* Whether the current architecture is 64-bit.
120 Only valid when pd_able is true. */
124 /* Forward declarations for pthdb callbacks. */
126 static int pdc_symbol_addrs (pthdb_user_t
, pthdb_symbol_t
*, int);
127 static int pdc_read_data (pthdb_user_t
, void *, pthdb_addr_t
, size_t);
128 static int pdc_write_data (pthdb_user_t
, void *, pthdb_addr_t
, size_t);
129 static int pdc_read_regs (pthdb_user_t user
, pthdb_tid_t tid
,
130 unsigned long long flags
,
131 pthdb_context_t
*context
);
132 static int pdc_write_regs (pthdb_user_t user
, pthdb_tid_t tid
,
133 unsigned long long flags
,
134 pthdb_context_t
*context
);
135 static int pdc_alloc (pthdb_user_t
, size_t, void **);
136 static int pdc_realloc (pthdb_user_t
, void *, size_t, void **);
137 static int pdc_dealloc (pthdb_user_t
, void *);
139 /* pthdb callbacks. */
141 static pthdb_callbacks_t pd_callbacks
= {
153 /* Current pthdb session. */
155 static pthdb_session_t pd_session
;
157 /* Return a printable representation of pthdebug function return
161 pd_status2str (int status
)
165 case PTHDB_SUCCESS
: return "SUCCESS";
166 case PTHDB_NOSYS
: return "NOSYS";
167 case PTHDB_NOTSUP
: return "NOTSUP";
168 case PTHDB_BAD_VERSION
: return "BAD_VERSION";
169 case PTHDB_BAD_USER
: return "BAD_USER";
170 case PTHDB_BAD_SESSION
: return "BAD_SESSION";
171 case PTHDB_BAD_MODE
: return "BAD_MODE";
172 case PTHDB_BAD_FLAGS
: return "BAD_FLAGS";
173 case PTHDB_BAD_CALLBACK
: return "BAD_CALLBACK";
174 case PTHDB_BAD_POINTER
: return "BAD_POINTER";
175 case PTHDB_BAD_CMD
: return "BAD_CMD";
176 case PTHDB_BAD_PTHREAD
: return "BAD_PTHREAD";
177 case PTHDB_BAD_ATTR
: return "BAD_ATTR";
178 case PTHDB_BAD_MUTEX
: return "BAD_MUTEX";
179 case PTHDB_BAD_MUTEXATTR
: return "BAD_MUTEXATTR";
180 case PTHDB_BAD_COND
: return "BAD_COND";
181 case PTHDB_BAD_CONDATTR
: return "BAD_CONDATTR";
182 case PTHDB_BAD_RWLOCK
: return "BAD_RWLOCK";
183 case PTHDB_BAD_RWLOCKATTR
: return "BAD_RWLOCKATTR";
184 case PTHDB_BAD_KEY
: return "BAD_KEY";
185 case PTHDB_BAD_PTID
: return "BAD_PTID";
186 case PTHDB_BAD_TID
: return "BAD_TID";
187 case PTHDB_CALLBACK
: return "CALLBACK";
188 case PTHDB_CONTEXT
: return "CONTEXT";
189 case PTHDB_HELD
: return "HELD";
190 case PTHDB_NOT_HELD
: return "NOT_HELD";
191 case PTHDB_MEMORY
: return "MEMORY";
192 case PTHDB_NOT_PTHREADED
: return "NOT_PTHREADED";
193 case PTHDB_SYMBOL
: return "SYMBOL";
194 case PTHDB_NOT_AVAIL
: return "NOT_AVAIL";
195 case PTHDB_INTERNAL
: return "INTERNAL";
196 default: return "UNKNOWN";
200 /* A call to ptrace(REQ, ID, ...) just returned RET. Check for
201 exceptional conditions and either return nonlocally or else return
202 1 for success and 0 for failure. */
205 ptrace_check (int req
, int id
, int ret
)
207 if (ret
== 0 && !errno
)
210 /* According to ptrace(2), ptrace may fail with EPERM if "the
211 Identifier parameter corresponds to a kernel thread which is
212 stopped in kernel mode and whose computational state cannot be
213 read or written." This happens quite often with register reads. */
220 if (ret
== -1 && errno
== EPERM
)
222 if (debug_aix_thread
)
223 fprintf_unfiltered (gdb_stdlog
,
224 "ptrace (%d, %d) = %d (errno = %d)\n",
225 req
, id
, ret
, errno
);
226 return ret
== -1 ? 0 : 1;
230 error (_("aix-thread: ptrace (%d, %d) returned %d (errno = %d %s)"),
231 req
, id
, ret
, errno
, safe_strerror (errno
));
232 return 0; /* Not reached. */
235 /* Call ptracex (REQ, ID, ADDR, DATA, BUF) or
236 ptrace64 (REQ, ID, ADDR, DATA, BUF) if HAVE_PTRACE64.
240 # define ptracex(request, pid, addr, data, buf) \
241 ptrace64 (request, pid, addr, data, buf)
245 ptrace64aix (int req
, int id
, long long addr
, int data
, int *buf
)
248 return ptrace_check (req
, id
, ptracex (req
, id
, addr
, data
, buf
));
251 /* Call ptrace (REQ, ID, ADDR, DATA, BUF) or
252 ptrace64 (REQ, ID, ADDR, DATA, BUF) if HAVE_PTRACE64.
256 # define ptrace(request, pid, addr, data, buf) \
257 ptrace64 (request, pid, addr, data, buf)
258 # define addr_ptr long long
260 # define addr_ptr int *
264 ptrace32 (int req
, int id
, addr_ptr addr
, int data
, int *buf
)
267 return ptrace_check (req
, id
,
268 ptrace (req
, id
, addr
, data
, buf
));
271 /* If *PIDP is a composite process/thread id, convert it to a
275 pid_to_prc (ptid_t
*ptidp
)
281 *ptidp
= pid_to_ptid (ptid_get_pid (ptid
));
284 /* pthdb callback: for <i> from 0 to COUNT, set SYMBOLS[<i>].addr to
285 the address of SYMBOLS[<i>].name. */
288 pdc_symbol_addrs (pthdb_user_t user
, pthdb_symbol_t
*symbols
, int count
)
290 struct bound_minimal_symbol ms
;
294 if (debug_aix_thread
)
295 fprintf_unfiltered (gdb_stdlog
,
296 "pdc_symbol_addrs (user = %ld, symbols = 0x%lx, count = %d)\n",
297 user
, (long) symbols
, count
);
299 for (i
= 0; i
< count
; i
++)
301 name
= symbols
[i
].name
;
302 if (debug_aix_thread
)
303 fprintf_unfiltered (gdb_stdlog
,
304 " symbols[%d].name = \"%s\"\n", i
, name
);
310 ms
= lookup_minimal_symbol (name
, NULL
, NULL
);
311 if (ms
.minsym
== NULL
)
313 if (debug_aix_thread
)
314 fprintf_unfiltered (gdb_stdlog
, " returning PDC_FAILURE\n");
317 symbols
[i
].addr
= BMSYMBOL_VALUE_ADDRESS (ms
);
319 if (debug_aix_thread
)
320 fprintf_unfiltered (gdb_stdlog
, " symbols[%d].addr = %s\n",
321 i
, hex_string (symbols
[i
].addr
));
323 if (debug_aix_thread
)
324 fprintf_unfiltered (gdb_stdlog
, " returning PDC_SUCCESS\n");
328 /* Read registers call back function should be able to read the
329 context information of a debuggee kernel thread from an active
330 process or from a core file. The information should be formatted
331 in context64 form for both 32-bit and 64-bit process.
332 If successful return 0, else non-zero is returned. */
335 pdc_read_regs (pthdb_user_t user
,
337 unsigned long long flags
,
338 pthdb_context_t
*context
)
340 /* This function doesn't appear to be used, so we could probably
341 just return 0 here. HOWEVER, if it is not defined, the OS will
342 complain and several thread debug functions will fail. In case
343 this is needed, I have implemented what I think it should do,
344 however this code is untested. */
346 uint64_t gprs64
[ppc_num_gprs
];
347 uint32_t gprs32
[ppc_num_gprs
];
348 double fprs
[ppc_num_fprs
];
349 struct ptxsprs sprs64
;
350 struct ptsprs sprs32
;
352 if (debug_aix_thread
)
353 fprintf_unfiltered (gdb_stdlog
, "pdc_read_regs tid=%d flags=%s\n",
354 (int) tid
, hex_string (flags
));
356 /* General-purpose registers. */
357 if (flags
& PTHDB_FLAG_GPRS
)
361 if (!ptrace64aix (PTT_READ_GPRS
, tid
,
362 (unsigned long) gprs64
, 0, NULL
))
363 memset (gprs64
, 0, sizeof (gprs64
));
364 memcpy (context
->gpr
, gprs64
, sizeof(gprs64
));
368 if (!ptrace32 (PTT_READ_GPRS
, tid
, (uintptr_t) gprs32
, 0, NULL
))
369 memset (gprs32
, 0, sizeof (gprs32
));
370 memcpy (context
->gpr
, gprs32
, sizeof(gprs32
));
374 /* Floating-point registers. */
375 if (flags
& PTHDB_FLAG_FPRS
)
377 if (!ptrace32 (PTT_READ_FPRS
, tid
, (uintptr_t) fprs
, 0, NULL
))
378 memset (fprs
, 0, sizeof (fprs
));
379 memcpy (context
->fpr
, fprs
, sizeof(fprs
));
382 /* Special-purpose registers. */
383 if (flags
& PTHDB_FLAG_SPRS
)
387 if (!ptrace64aix (PTT_READ_SPRS
, tid
,
388 (unsigned long) &sprs64
, 0, NULL
))
389 memset (&sprs64
, 0, sizeof (sprs64
));
390 memcpy (&context
->msr
, &sprs64
, sizeof(sprs64
));
394 if (!ptrace32 (PTT_READ_SPRS
, tid
, (uintptr_t) &sprs32
, 0, NULL
))
395 memset (&sprs32
, 0, sizeof (sprs32
));
396 memcpy (&context
->msr
, &sprs32
, sizeof(sprs32
));
402 /* Write register function should be able to write requested context
403 information to specified debuggee's kernel thread id.
404 If successful return 0, else non-zero is returned. */
407 pdc_write_regs (pthdb_user_t user
,
409 unsigned long long flags
,
410 pthdb_context_t
*context
)
412 /* This function doesn't appear to be used, so we could probably
413 just return 0 here. HOWEVER, if it is not defined, the OS will
414 complain and several thread debug functions will fail. In case
415 this is needed, I have implemented what I think it should do,
416 however this code is untested. */
418 if (debug_aix_thread
)
419 fprintf_unfiltered (gdb_stdlog
, "pdc_write_regs tid=%d flags=%s\n",
420 (int) tid
, hex_string (flags
));
422 /* General-purpose registers. */
423 if (flags
& PTHDB_FLAG_GPRS
)
426 ptrace64aix (PTT_WRITE_GPRS
, tid
,
427 (unsigned long) context
->gpr
, 0, NULL
);
429 ptrace32 (PTT_WRITE_GPRS
, tid
, (uintptr_t) context
->gpr
, 0, NULL
);
432 /* Floating-point registers. */
433 if (flags
& PTHDB_FLAG_FPRS
)
435 ptrace32 (PTT_WRITE_FPRS
, tid
, (uintptr_t) context
->fpr
, 0, NULL
);
438 /* Special-purpose registers. */
439 if (flags
& PTHDB_FLAG_SPRS
)
443 ptrace64aix (PTT_WRITE_SPRS
, tid
,
444 (unsigned long) &context
->msr
, 0, NULL
);
448 ptrace32 (PTT_WRITE_SPRS
, tid
, (uintptr_t) &context
->msr
, 0, NULL
);
454 /* pthdb callback: read LEN bytes from process ADDR into BUF. */
457 pdc_read_data (pthdb_user_t user
, void *buf
,
458 pthdb_addr_t addr
, size_t len
)
462 if (debug_aix_thread
)
463 fprintf_unfiltered (gdb_stdlog
,
464 "pdc_read_data (user = %ld, buf = 0x%lx, addr = %s, len = %ld)\n",
465 user
, (long) buf
, hex_string (addr
), len
);
467 status
= target_read_memory (addr
, buf
, len
);
468 ret
= status
== 0 ? PDC_SUCCESS
: PDC_FAILURE
;
470 if (debug_aix_thread
)
471 fprintf_unfiltered (gdb_stdlog
, " status=%d, returning %s\n",
472 status
, pd_status2str (ret
));
476 /* pthdb callback: write LEN bytes from BUF to process ADDR. */
479 pdc_write_data (pthdb_user_t user
, void *buf
,
480 pthdb_addr_t addr
, size_t len
)
484 if (debug_aix_thread
)
485 fprintf_unfiltered (gdb_stdlog
,
486 "pdc_write_data (user = %ld, buf = 0x%lx, addr = %s, len = %ld)\n",
487 user
, (long) buf
, hex_string (addr
), len
);
489 status
= target_write_memory (addr
, buf
, len
);
490 ret
= status
== 0 ? PDC_SUCCESS
: PDC_FAILURE
;
492 if (debug_aix_thread
)
493 fprintf_unfiltered (gdb_stdlog
, " status=%d, returning %s\n", status
,
494 pd_status2str (ret
));
498 /* pthdb callback: allocate a LEN-byte buffer and store a pointer to it
502 pdc_alloc (pthdb_user_t user
, size_t len
, void **bufp
)
504 if (debug_aix_thread
)
505 fprintf_unfiltered (gdb_stdlog
,
506 "pdc_alloc (user = %ld, len = %ld, bufp = 0x%lx)\n",
507 user
, len
, (long) bufp
);
508 *bufp
= xmalloc (len
);
509 if (debug_aix_thread
)
510 fprintf_unfiltered (gdb_stdlog
,
511 " malloc returned 0x%lx\n", (long) *bufp
);
513 /* Note: xmalloc() can't return 0; therefore PDC_FAILURE will never
516 return *bufp
? PDC_SUCCESS
: PDC_FAILURE
;
519 /* pthdb callback: reallocate BUF, which was allocated by the alloc or
520 realloc callback, so that it contains LEN bytes, and store a
521 pointer to the result in BUFP. */
524 pdc_realloc (pthdb_user_t user
, void *buf
, size_t len
, void **bufp
)
526 if (debug_aix_thread
)
527 fprintf_unfiltered (gdb_stdlog
,
528 "pdc_realloc (user = %ld, buf = 0x%lx, len = %ld, bufp = 0x%lx)\n",
529 user
, (long) buf
, len
, (long) bufp
);
530 *bufp
= xrealloc (buf
, len
);
531 if (debug_aix_thread
)
532 fprintf_unfiltered (gdb_stdlog
,
533 " realloc returned 0x%lx\n", (long) *bufp
);
534 return *bufp
? PDC_SUCCESS
: PDC_FAILURE
;
537 /* pthdb callback: free BUF, which was allocated by the alloc or
541 pdc_dealloc (pthdb_user_t user
, void *buf
)
543 if (debug_aix_thread
)
544 fprintf_unfiltered (gdb_stdlog
,
545 "pdc_free (user = %ld, buf = 0x%lx)\n", user
,
551 /* Return a printable representation of pthread STATE. */
554 state2str (pthdb_state_t state
)
559 /* i18n: Like "Thread-Id %d, [state] idle" */
560 return _("idle"); /* being created */
562 /* i18n: Like "Thread-Id %d, [state] running" */
563 return _("running"); /* running */
565 /* i18n: Like "Thread-Id %d, [state] sleeping" */
566 return _("sleeping"); /* awaiting an event */
568 /* i18n: Like "Thread-Id %d, [state] ready" */
569 return _("ready"); /* runnable */
571 /* i18n: Like "Thread-Id %d, [state] finished" */
572 return _("finished"); /* awaiting a join/detach */
574 /* i18n: Like "Thread-Id %d, [state] unknown" */
579 /* qsort() comparison function for sorting pd_thread structs by pthid. */
582 pcmp (const void *p1v
, const void *p2v
)
584 struct pd_thread
*p1
= (struct pd_thread
*) p1v
;
585 struct pd_thread
*p2
= (struct pd_thread
*) p2v
;
586 return p1
->pthid
< p2
->pthid
? -1 : p1
->pthid
> p2
->pthid
;
589 /* iterate_over_threads() callback for counting GDB threads.
591 Do not count the main thread (whose tid is zero). This matches
592 the list of threads provided by the pthreaddebug library, which
593 does not include that main thread either, and thus allows us
594 to compare the two lists. */
597 giter_count (struct thread_info
*thread
, void *countp
)
599 if (PD_TID (thread
->ptid
))
604 /* iterate_over_threads() callback for accumulating GDB thread pids.
606 Do not include the main thread (whose tid is zero). This matches
607 the list of threads provided by the pthreaddebug library, which
608 does not include that main thread either, and thus allows us
609 to compare the two lists. */
612 giter_accum (struct thread_info
*thread
, void *bufp
)
614 if (PD_TID (thread
->ptid
))
616 **(struct thread_info
***) bufp
= thread
;
617 (*(struct thread_info
***) bufp
)++;
622 /* ptid comparison function */
625 ptid_cmp (ptid_t ptid1
, ptid_t ptid2
)
629 if (ptid_get_pid (ptid1
) < ptid_get_pid (ptid2
))
631 else if (ptid_get_pid (ptid1
) > ptid_get_pid (ptid2
))
633 else if (ptid_get_tid (ptid1
) < ptid_get_tid (ptid2
))
635 else if (ptid_get_tid (ptid1
) > ptid_get_tid (ptid2
))
637 else if (ptid_get_lwp (ptid1
) < ptid_get_lwp (ptid2
))
639 else if (ptid_get_lwp (ptid1
) > ptid_get_lwp (ptid2
))
645 /* qsort() comparison function for sorting thread_info structs by pid. */
648 gcmp (const void *t1v
, const void *t2v
)
650 struct thread_info
*t1
= *(struct thread_info
**) t1v
;
651 struct thread_info
*t2
= *(struct thread_info
**) t2v
;
652 return ptid_cmp (t1
->ptid
, t2
->ptid
);
655 /* Search through the list of all kernel threads for the thread
656 that has stopped on a SIGTRAP signal, and return its TID.
657 Return 0 if none found. */
660 get_signaled_thread (void)
662 struct thrdsinfo64 thrinf
;
668 if (getthrds (ptid_get_pid (inferior_ptid
), &thrinf
,
669 sizeof (thrinf
), &ktid
, 1) != 1)
672 if (thrinf
.ti_cursig
== SIGTRAP
)
673 return thrinf
.ti_tid
;
676 /* Didn't find any thread stopped on a SIGTRAP signal. */
680 /* Synchronize GDB's thread list with libpthdebug's.
682 There are some benefits of doing this every time the inferior stops:
684 - allows users to run thread-specific commands without needing to
685 run "info threads" first
687 - helps pthdb_tid_pthread() work properly (see "libpthdebug
688 peculiarities" at the top of this module)
690 - simplifies the demands placed on libpthdebug, which seems to
691 have difficulty with certain call patterns */
694 sync_threadlists (void)
696 int cmd
, status
, infpid
;
697 int pcount
, psize
, pi
, gcount
, gi
;
698 struct pd_thread
*pbuf
;
699 struct thread_info
**gbuf
, **g
, *thread
;
700 pthdb_pthread_t pdtid
;
704 /* Accumulate an array of libpthdebug threads sorted by pthread id. */
708 pbuf
= (struct pd_thread
*) xmalloc (psize
* sizeof *pbuf
);
710 for (cmd
= PTHDB_LIST_FIRST
;; cmd
= PTHDB_LIST_NEXT
)
712 status
= pthdb_pthread (pd_session
, &pdtid
, cmd
);
713 if (status
!= PTHDB_SUCCESS
|| pdtid
== PTHDB_INVALID_PTHREAD
)
716 status
= pthdb_pthread_ptid (pd_session
, pdtid
, &pthid
);
717 if (status
!= PTHDB_SUCCESS
|| pthid
== PTHDB_INVALID_PTID
)
723 pbuf
= (struct pd_thread
*) xrealloc (pbuf
,
724 psize
* sizeof *pbuf
);
726 pbuf
[pcount
].pdtid
= pdtid
;
727 pbuf
[pcount
].pthid
= pthid
;
731 for (pi
= 0; pi
< pcount
; pi
++)
733 status
= pthdb_pthread_tid (pd_session
, pbuf
[pi
].pdtid
, &tid
);
734 if (status
!= PTHDB_SUCCESS
)
735 tid
= PTHDB_INVALID_TID
;
739 qsort (pbuf
, pcount
, sizeof *pbuf
, pcmp
);
741 /* Accumulate an array of GDB threads sorted by pid. */
744 iterate_over_threads (giter_count
, &gcount
);
745 g
= gbuf
= (struct thread_info
**) xmalloc (gcount
* sizeof *gbuf
);
746 iterate_over_threads (giter_accum
, &g
);
747 qsort (gbuf
, gcount
, sizeof *gbuf
, gcmp
);
749 /* Apply differences between the two arrays to GDB's thread list. */
751 infpid
= ptid_get_pid (inferior_ptid
);
752 for (pi
= gi
= 0; pi
< pcount
|| gi
< gcount
;)
756 delete_thread (gbuf
[gi
]->ptid
);
759 else if (gi
== gcount
)
761 thread
= add_thread (ptid_build (infpid
, 0, pbuf
[pi
].pthid
));
762 thread
->private = xmalloc (sizeof (struct private_thread_info
));
763 thread
->private->pdtid
= pbuf
[pi
].pdtid
;
764 thread
->private->tid
= pbuf
[pi
].tid
;
772 pptid
= ptid_build (infpid
, 0, pbuf
[pi
].pthid
);
773 gptid
= gbuf
[gi
]->ptid
;
774 pdtid
= pbuf
[pi
].pdtid
;
777 cmp_result
= ptid_cmp (pptid
, gptid
);
781 gbuf
[gi
]->private->pdtid
= pdtid
;
782 gbuf
[gi
]->private->tid
= tid
;
786 else if (cmp_result
> 0)
788 delete_thread (gptid
);
793 thread
= add_thread (pptid
);
794 thread
->private = xmalloc (sizeof (struct private_thread_info
));
795 thread
->private->pdtid
= pdtid
;
796 thread
->private->tid
= tid
;
806 /* Iterate_over_threads() callback for locating a thread, using
807 the TID of its associated kernel thread. */
810 iter_tid (struct thread_info
*thread
, void *tidp
)
812 const pthdb_tid_t tid
= *(pthdb_tid_t
*)tidp
;
814 return (thread
->private->tid
== tid
);
817 /* Synchronize libpthdebug's state with the inferior and with GDB,
818 generate a composite process/thread <pid> for the current thread,
819 set inferior_ptid to <pid> if SET_INFPID, and return <pid>. */
822 pd_update (int set_infpid
)
827 struct thread_info
*thread
= NULL
;
830 return inferior_ptid
;
832 status
= pthdb_session_update (pd_session
);
833 if (status
!= PTHDB_SUCCESS
)
834 return inferior_ptid
;
838 /* Define "current thread" as one that just received a trap signal. */
840 tid
= get_signaled_thread ();
842 thread
= iterate_over_threads (iter_tid
, &tid
);
844 ptid
= inferior_ptid
;
849 inferior_ptid
= ptid
;
854 /* Try to start debugging threads in the current process.
855 If successful and SET_INFPID, set inferior_ptid to reflect the
859 pd_activate (int set_infpid
)
863 status
= pthdb_session_init (PD_USER
, arch64
? PEM_64BIT
: PEM_32BIT
,
864 PTHDB_FLAG_REGS
, &pd_callbacks
,
866 if (status
!= PTHDB_SUCCESS
)
868 return inferior_ptid
;
871 return pd_update (set_infpid
);
874 /* Undo the effects of pd_activate(). */
881 pthdb_session_destroy (pd_session
);
883 pid_to_prc (&inferior_ptid
);
887 /* An object file has just been loaded. Check whether the current
888 application is pthreaded, and if so, prepare for thread debugging. */
895 struct bound_minimal_symbol ms
;
897 /* Don't initialize twice. */
901 /* Check application word size. */
902 arch64
= register_size (target_gdbarch (), 0) == 8;
904 /* Check whether the application is pthreaded. */
906 status
= pthdb_session_pthreaded (PD_USER
, PTHDB_FLAG_REGS
,
907 &pd_callbacks
, &stub_name
);
908 if ((status
!= PTHDB_SUCCESS
909 && status
!= PTHDB_NOT_PTHREADED
) || !stub_name
)
912 /* Set a breakpoint on the returned stub function. */
913 ms
= lookup_minimal_symbol (stub_name
, NULL
, NULL
);
914 if (ms
.minsym
== NULL
)
916 pd_brk_addr
= BMSYMBOL_VALUE_ADDRESS (ms
);
917 if (!create_thread_event_breakpoint (target_gdbarch (), pd_brk_addr
))
920 /* Prepare for thread debugging. */
921 push_target (&aix_thread_ops
);
924 /* If we're debugging a core file or an attached inferior, the
925 pthread library may already have been initialized, so try to
926 activate thread debugging. */
930 /* Undo the effects of pd_enable(). */
940 unpush_target (&aix_thread_ops
);
943 /* new_objfile observer callback.
945 If OBJFILE is non-null, check whether a threaded application is
946 being debugged, and if so, prepare for thread debugging.
948 If OBJFILE is null, stop debugging threads. */
951 new_objfile (struct objfile
*objfile
)
959 /* Attach to process specified by ARGS. */
962 aix_thread_attach (struct target_ops
*ops
, char *args
, int from_tty
)
964 struct target_ops
*beneath
= find_target_beneath (ops
);
966 beneath
->to_attach (beneath
, args
, from_tty
);
970 /* Detach from the process attached to by aix_thread_attach(). */
973 aix_thread_detach (struct target_ops
*ops
, const char *args
, int from_tty
)
975 struct target_ops
*beneath
= find_target_beneath (ops
);
978 beneath
->to_detach (beneath
, args
, from_tty
);
981 /* Tell the inferior process to continue running thread PID if != -1
982 and all threads otherwise. */
985 aix_thread_resume (struct target_ops
*ops
,
986 ptid_t ptid
, int step
, enum gdb_signal sig
)
988 struct thread_info
*thread
;
993 struct cleanup
*cleanup
= save_inferior_ptid ();
994 struct target_ops
*beneath
= find_target_beneath (ops
);
996 inferior_ptid
= pid_to_ptid (ptid_get_pid (inferior_ptid
));
997 beneath
->to_resume (beneath
, ptid
, step
, sig
);
998 do_cleanups (cleanup
);
1002 thread
= find_thread_ptid (ptid
);
1004 error (_("aix-thread resume: unknown pthread %ld"),
1005 ptid_get_lwp (ptid
));
1007 tid
[0] = thread
->private->tid
;
1008 if (tid
[0] == PTHDB_INVALID_TID
)
1009 error (_("aix-thread resume: no tid for pthread %ld"),
1010 ptid_get_lwp (ptid
));
1014 ptrace64aix (PTT_CONTINUE
, tid
[0], (long long) 1,
1015 gdb_signal_to_host (sig
), (void *) tid
);
1017 ptrace32 (PTT_CONTINUE
, tid
[0], (addr_ptr
) 1,
1018 gdb_signal_to_host (sig
), (void *) tid
);
1022 /* Wait for thread/process ID if != -1 or for any thread otherwise.
1023 If an error occurs, return -1, else return the pid of the stopped
1027 aix_thread_wait (struct target_ops
*ops
,
1028 ptid_t ptid
, struct target_waitstatus
*status
, int options
)
1030 struct cleanup
*cleanup
= save_inferior_ptid ();
1031 struct target_ops
*beneath
= find_target_beneath (ops
);
1035 inferior_ptid
= pid_to_ptid (ptid_get_pid (inferior_ptid
));
1036 ptid
= beneath
->to_wait (beneath
, ptid
, status
, options
);
1037 do_cleanups (cleanup
);
1039 if (ptid_get_pid (ptid
) == -1)
1040 return pid_to_ptid (-1);
1042 /* Check whether libpthdebug might be ready to be initialized. */
1043 if (!pd_active
&& status
->kind
== TARGET_WAITKIND_STOPPED
1044 && status
->value
.sig
== GDB_SIGNAL_TRAP
)
1046 struct regcache
*regcache
= get_thread_regcache (ptid
);
1047 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1049 if (regcache_read_pc (regcache
)
1050 - target_decr_pc_after_break (gdbarch
) == pd_brk_addr
)
1051 return pd_activate (0);
1054 return pd_update (0);
1057 /* Record that the 64-bit general-purpose registers contain VALS. */
1060 supply_gprs64 (struct regcache
*regcache
, uint64_t *vals
)
1062 struct gdbarch_tdep
*tdep
= gdbarch_tdep (get_regcache_arch (regcache
));
1065 for (regno
= 0; regno
< ppc_num_gprs
; regno
++)
1066 regcache_raw_supply (regcache
, tdep
->ppc_gp0_regnum
+ regno
,
1067 (char *) (vals
+ regno
));
1070 /* Record that 32-bit register REGNO contains VAL. */
1073 supply_reg32 (struct regcache
*regcache
, int regno
, uint32_t val
)
1075 regcache_raw_supply (regcache
, regno
, (char *) &val
);
1078 /* Record that the floating-point registers contain VALS. */
1081 supply_fprs (struct regcache
*regcache
, double *vals
)
1083 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1084 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1087 /* This function should never be called on architectures without
1088 floating-point registers. */
1089 gdb_assert (ppc_floating_point_unit_p (gdbarch
));
1091 for (regno
= tdep
->ppc_fp0_regnum
;
1092 regno
< tdep
->ppc_fp0_regnum
+ ppc_num_fprs
;
1094 regcache_raw_supply (regcache
, regno
,
1095 (char *) (vals
+ regno
- tdep
->ppc_fp0_regnum
));
1098 /* Predicate to test whether given register number is a "special" register. */
1100 special_register_p (struct gdbarch
*gdbarch
, int regno
)
1102 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1104 return regno
== gdbarch_pc_regnum (gdbarch
)
1105 || regno
== tdep
->ppc_ps_regnum
1106 || regno
== tdep
->ppc_cr_regnum
1107 || regno
== tdep
->ppc_lr_regnum
1108 || regno
== tdep
->ppc_ctr_regnum
1109 || regno
== tdep
->ppc_xer_regnum
1110 || (tdep
->ppc_fpscr_regnum
>= 0 && regno
== tdep
->ppc_fpscr_regnum
)
1111 || (tdep
->ppc_mq_regnum
>= 0 && regno
== tdep
->ppc_mq_regnum
);
1115 /* Record that the special registers contain the specified 64-bit and
1119 supply_sprs64 (struct regcache
*regcache
,
1120 uint64_t iar
, uint64_t msr
, uint32_t cr
,
1121 uint64_t lr
, uint64_t ctr
, uint32_t xer
,
1124 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1125 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1127 regcache_raw_supply (regcache
, gdbarch_pc_regnum (gdbarch
),
1129 regcache_raw_supply (regcache
, tdep
->ppc_ps_regnum
, (char *) &msr
);
1130 regcache_raw_supply (regcache
, tdep
->ppc_cr_regnum
, (char *) &cr
);
1131 regcache_raw_supply (regcache
, tdep
->ppc_lr_regnum
, (char *) &lr
);
1132 regcache_raw_supply (regcache
, tdep
->ppc_ctr_regnum
, (char *) &ctr
);
1133 regcache_raw_supply (regcache
, tdep
->ppc_xer_regnum
, (char *) &xer
);
1134 if (tdep
->ppc_fpscr_regnum
>= 0)
1135 regcache_raw_supply (regcache
, tdep
->ppc_fpscr_regnum
,
1139 /* Record that the special registers contain the specified 32-bit
1143 supply_sprs32 (struct regcache
*regcache
,
1144 uint32_t iar
, uint32_t msr
, uint32_t cr
,
1145 uint32_t lr
, uint32_t ctr
, uint32_t xer
,
1148 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1149 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1151 regcache_raw_supply (regcache
, gdbarch_pc_regnum (gdbarch
),
1153 regcache_raw_supply (regcache
, tdep
->ppc_ps_regnum
, (char *) &msr
);
1154 regcache_raw_supply (regcache
, tdep
->ppc_cr_regnum
, (char *) &cr
);
1155 regcache_raw_supply (regcache
, tdep
->ppc_lr_regnum
, (char *) &lr
);
1156 regcache_raw_supply (regcache
, tdep
->ppc_ctr_regnum
, (char *) &ctr
);
1157 regcache_raw_supply (regcache
, tdep
->ppc_xer_regnum
, (char *) &xer
);
1158 if (tdep
->ppc_fpscr_regnum
>= 0)
1159 regcache_raw_supply (regcache
, tdep
->ppc_fpscr_regnum
,
1163 /* Fetch all registers from pthread PDTID, which doesn't have a kernel
1166 There's no way to query a single register from a non-kernel
1167 pthread, so there's no need for a single-register version of this
1171 fetch_regs_user_thread (struct regcache
*regcache
, pthdb_pthread_t pdtid
)
1173 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1174 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1176 pthdb_context_t ctx
;
1178 if (debug_aix_thread
)
1179 fprintf_unfiltered (gdb_stdlog
,
1180 "fetch_regs_user_thread %lx\n", (long) pdtid
);
1181 status
= pthdb_pthread_context (pd_session
, pdtid
, &ctx
);
1182 if (status
!= PTHDB_SUCCESS
)
1183 error (_("aix-thread: fetch_registers: pthdb_pthread_context returned %s"),
1184 pd_status2str (status
));
1186 /* General-purpose registers. */
1189 supply_gprs64 (regcache
, ctx
.gpr
);
1191 for (i
= 0; i
< ppc_num_gprs
; i
++)
1192 supply_reg32 (regcache
, tdep
->ppc_gp0_regnum
+ i
, ctx
.gpr
[i
]);
1194 /* Floating-point registers. */
1196 if (ppc_floating_point_unit_p (gdbarch
))
1197 supply_fprs (regcache
, ctx
.fpr
);
1199 /* Special registers. */
1202 supply_sprs64 (regcache
, ctx
.iar
, ctx
.msr
, ctx
.cr
, ctx
.lr
, ctx
.ctr
,
1203 ctx
.xer
, ctx
.fpscr
);
1205 supply_sprs32 (regcache
, ctx
.iar
, ctx
.msr
, ctx
.cr
, ctx
.lr
, ctx
.ctr
,
1206 ctx
.xer
, ctx
.fpscr
);
1209 /* Fetch register REGNO if != -1 or all registers otherwise from
1212 AIX provides a way to query all of a kernel thread's GPRs, FPRs, or
1213 SPRs, but there's no way to query individual registers within those
1214 groups. Therefore, if REGNO != -1, this function fetches an entire
1217 Unfortunately, kernel thread register queries often fail with
1218 EPERM, indicating that the thread is in kernel space. This breaks
1219 backtraces of threads other than the current one. To make that
1220 breakage obvious without throwing an error to top level (which is
1221 bad e.g. during "info threads" output), zero registers that can't
1225 fetch_regs_kernel_thread (struct regcache
*regcache
, int regno
,
1228 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1229 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1230 uint64_t gprs64
[ppc_num_gprs
];
1231 uint32_t gprs32
[ppc_num_gprs
];
1232 double fprs
[ppc_num_fprs
];
1233 struct ptxsprs sprs64
;
1234 struct ptsprs sprs32
;
1237 if (debug_aix_thread
)
1238 fprintf_unfiltered (gdb_stdlog
,
1239 "fetch_regs_kernel_thread tid=%lx regno=%d arch64=%d\n",
1240 (long) tid
, regno
, arch64
);
1242 /* General-purpose registers. */
1244 || (tdep
->ppc_gp0_regnum
<= regno
1245 && regno
< tdep
->ppc_gp0_regnum
+ ppc_num_gprs
))
1249 if (!ptrace64aix (PTT_READ_GPRS
, tid
,
1250 (unsigned long) gprs64
, 0, NULL
))
1251 memset (gprs64
, 0, sizeof (gprs64
));
1252 supply_gprs64 (regcache
, gprs64
);
1256 if (!ptrace32 (PTT_READ_GPRS
, tid
, (uintptr_t) gprs32
, 0, NULL
))
1257 memset (gprs32
, 0, sizeof (gprs32
));
1258 for (i
= 0; i
< ppc_num_gprs
; i
++)
1259 supply_reg32 (regcache
, tdep
->ppc_gp0_regnum
+ i
, gprs32
[i
]);
1263 /* Floating-point registers. */
1265 if (ppc_floating_point_unit_p (gdbarch
)
1267 || (regno
>= tdep
->ppc_fp0_regnum
1268 && regno
< tdep
->ppc_fp0_regnum
+ ppc_num_fprs
)))
1270 if (!ptrace32 (PTT_READ_FPRS
, tid
, (uintptr_t) fprs
, 0, NULL
))
1271 memset (fprs
, 0, sizeof (fprs
));
1272 supply_fprs (regcache
, fprs
);
1275 /* Special-purpose registers. */
1277 if (regno
== -1 || special_register_p (gdbarch
, regno
))
1281 if (!ptrace64aix (PTT_READ_SPRS
, tid
,
1282 (unsigned long) &sprs64
, 0, NULL
))
1283 memset (&sprs64
, 0, sizeof (sprs64
));
1284 supply_sprs64 (regcache
, sprs64
.pt_iar
, sprs64
.pt_msr
,
1285 sprs64
.pt_cr
, sprs64
.pt_lr
, sprs64
.pt_ctr
,
1286 sprs64
.pt_xer
, sprs64
.pt_fpscr
);
1290 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1292 if (!ptrace32 (PTT_READ_SPRS
, tid
, (uintptr_t) &sprs32
, 0, NULL
))
1293 memset (&sprs32
, 0, sizeof (sprs32
));
1294 supply_sprs32 (regcache
, sprs32
.pt_iar
, sprs32
.pt_msr
, sprs32
.pt_cr
,
1295 sprs32
.pt_lr
, sprs32
.pt_ctr
, sprs32
.pt_xer
,
1298 if (tdep
->ppc_mq_regnum
>= 0)
1299 regcache_raw_supply (regcache
, tdep
->ppc_mq_regnum
,
1300 (char *) &sprs32
.pt_mq
);
1305 /* Fetch register REGNO if != -1 or all registers otherwise in the
1306 thread/process specified by inferior_ptid. */
1309 aix_thread_fetch_registers (struct target_ops
*ops
,
1310 struct regcache
*regcache
, int regno
)
1312 struct thread_info
*thread
;
1314 struct target_ops
*beneath
= find_target_beneath (ops
);
1316 if (!PD_TID (inferior_ptid
))
1317 beneath
->to_fetch_registers (beneath
, regcache
, regno
);
1320 thread
= find_thread_ptid (inferior_ptid
);
1321 tid
= thread
->private->tid
;
1323 if (tid
== PTHDB_INVALID_TID
)
1324 fetch_regs_user_thread (regcache
, thread
->private->pdtid
);
1326 fetch_regs_kernel_thread (regcache
, regno
, tid
);
1330 /* Store the gp registers into an array of uint32_t or uint64_t. */
1333 fill_gprs64 (const struct regcache
*regcache
, uint64_t *vals
)
1335 struct gdbarch_tdep
*tdep
= gdbarch_tdep (get_regcache_arch (regcache
));
1338 for (regno
= 0; regno
< ppc_num_gprs
; regno
++)
1339 if (REG_VALID
== regcache_register_status (regcache
,
1340 tdep
->ppc_gp0_regnum
+ regno
))
1341 regcache_raw_collect (regcache
, tdep
->ppc_gp0_regnum
+ regno
,
1346 fill_gprs32 (const struct regcache
*regcache
, uint32_t *vals
)
1348 struct gdbarch_tdep
*tdep
= gdbarch_tdep (get_regcache_arch (regcache
));
1351 for (regno
= 0; regno
< ppc_num_gprs
; regno
++)
1352 if (REG_VALID
== regcache_register_status (regcache
,
1353 tdep
->ppc_gp0_regnum
+ regno
))
1354 regcache_raw_collect (regcache
, tdep
->ppc_gp0_regnum
+ regno
,
1358 /* Store the floating point registers into a double array. */
1360 fill_fprs (const struct regcache
*regcache
, double *vals
)
1362 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1363 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1366 /* This function should never be called on architectures without
1367 floating-point registers. */
1368 gdb_assert (ppc_floating_point_unit_p (gdbarch
));
1370 for (regno
= tdep
->ppc_fp0_regnum
;
1371 regno
< tdep
->ppc_fp0_regnum
+ ppc_num_fprs
;
1373 if (REG_VALID
== regcache_register_status (regcache
, regno
))
1374 regcache_raw_collect (regcache
, regno
,
1375 vals
+ regno
- tdep
->ppc_fp0_regnum
);
1378 /* Store the special registers into the specified 64-bit and 32-bit
1382 fill_sprs64 (const struct regcache
*regcache
,
1383 uint64_t *iar
, uint64_t *msr
, uint32_t *cr
,
1384 uint64_t *lr
, uint64_t *ctr
, uint32_t *xer
,
1387 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1388 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1390 /* Verify that the size of the size of the IAR buffer is the
1391 same as the raw size of the PC (in the register cache). If
1392 they're not, then either GDB has been built incorrectly, or
1393 there's some other kind of internal error. To be really safe,
1394 we should check all of the sizes. */
1395 gdb_assert (sizeof (*iar
) == register_size
1396 (gdbarch
, gdbarch_pc_regnum (gdbarch
)));
1398 if (REG_VALID
== regcache_register_status (regcache
,
1399 gdbarch_pc_regnum (gdbarch
)))
1400 regcache_raw_collect (regcache
, gdbarch_pc_regnum (gdbarch
), iar
);
1401 if (REG_VALID
== regcache_register_status (regcache
, tdep
->ppc_ps_regnum
))
1402 regcache_raw_collect (regcache
, tdep
->ppc_ps_regnum
, msr
);
1403 if (REG_VALID
== regcache_register_status (regcache
, tdep
->ppc_cr_regnum
))
1404 regcache_raw_collect (regcache
, tdep
->ppc_cr_regnum
, cr
);
1405 if (REG_VALID
== regcache_register_status (regcache
, tdep
->ppc_lr_regnum
))
1406 regcache_raw_collect (regcache
, tdep
->ppc_lr_regnum
, lr
);
1407 if (REG_VALID
== regcache_register_status (regcache
, tdep
->ppc_ctr_regnum
))
1408 regcache_raw_collect (regcache
, tdep
->ppc_ctr_regnum
, ctr
);
1409 if (REG_VALID
== regcache_register_status (regcache
, tdep
->ppc_xer_regnum
))
1410 regcache_raw_collect (regcache
, tdep
->ppc_xer_regnum
, xer
);
1411 if (tdep
->ppc_fpscr_regnum
>= 0
1412 && REG_VALID
== regcache_register_status (regcache
,
1413 tdep
->ppc_fpscr_regnum
))
1414 regcache_raw_collect (regcache
, tdep
->ppc_fpscr_regnum
, fpscr
);
1418 fill_sprs32 (const struct regcache
*regcache
,
1419 uint32_t *iar
, uint32_t *msr
, uint32_t *cr
,
1420 uint32_t *lr
, uint32_t *ctr
, uint32_t *xer
,
1423 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1424 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1426 /* Verify that the size of the size of the IAR buffer is the
1427 same as the raw size of the PC (in the register cache). If
1428 they're not, then either GDB has been built incorrectly, or
1429 there's some other kind of internal error. To be really safe,
1430 we should check all of the sizes. */
1431 gdb_assert (sizeof (*iar
) == register_size (gdbarch
,
1432 gdbarch_pc_regnum (gdbarch
)));
1434 if (REG_VALID
== regcache_register_status (regcache
,
1435 gdbarch_pc_regnum (gdbarch
)))
1436 regcache_raw_collect (regcache
, gdbarch_pc_regnum (gdbarch
), iar
);
1437 if (REG_VALID
== regcache_register_status (regcache
, tdep
->ppc_ps_regnum
))
1438 regcache_raw_collect (regcache
, tdep
->ppc_ps_regnum
, msr
);
1439 if (REG_VALID
== regcache_register_status (regcache
, tdep
->ppc_cr_regnum
))
1440 regcache_raw_collect (regcache
, tdep
->ppc_cr_regnum
, cr
);
1441 if (REG_VALID
== regcache_register_status (regcache
, tdep
->ppc_lr_regnum
))
1442 regcache_raw_collect (regcache
, tdep
->ppc_lr_regnum
, lr
);
1443 if (REG_VALID
== regcache_register_status (regcache
, tdep
->ppc_ctr_regnum
))
1444 regcache_raw_collect (regcache
, tdep
->ppc_ctr_regnum
, ctr
);
1445 if (REG_VALID
== regcache_register_status (regcache
, tdep
->ppc_xer_regnum
))
1446 regcache_raw_collect (regcache
, tdep
->ppc_xer_regnum
, xer
);
1447 if (tdep
->ppc_fpscr_regnum
>= 0
1448 && REG_VALID
== regcache_register_status (regcache
, tdep
->ppc_fpscr_regnum
))
1449 regcache_raw_collect (regcache
, tdep
->ppc_fpscr_regnum
, fpscr
);
1452 /* Store all registers into pthread PDTID, which doesn't have a kernel
1455 It's possible to store a single register into a non-kernel pthread,
1456 but I doubt it's worth the effort. */
1459 store_regs_user_thread (const struct regcache
*regcache
, pthdb_pthread_t pdtid
)
1461 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1462 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1464 pthdb_context_t ctx
;
1469 if (debug_aix_thread
)
1470 fprintf_unfiltered (gdb_stdlog
,
1471 "store_regs_user_thread %lx\n", (long) pdtid
);
1473 /* Retrieve the thread's current context for its non-register
1475 status
= pthdb_pthread_context (pd_session
, pdtid
, &ctx
);
1476 if (status
!= PTHDB_SUCCESS
)
1477 error (_("aix-thread: store_registers: pthdb_pthread_context returned %s"),
1478 pd_status2str (status
));
1480 /* Collect general-purpose register values from the regcache. */
1482 for (i
= 0; i
< ppc_num_gprs
; i
++)
1483 if (REG_VALID
== regcache_register_status (regcache
,
1484 tdep
->ppc_gp0_regnum
+ i
))
1488 regcache_raw_collect (regcache
, tdep
->ppc_gp0_regnum
+ i
,
1494 regcache_raw_collect (regcache
, tdep
->ppc_gp0_regnum
+ i
,
1500 /* Collect floating-point register values from the regcache. */
1501 if (ppc_floating_point_unit_p (gdbarch
))
1502 fill_fprs (regcache
, ctx
.fpr
);
1504 /* Special registers (always kept in ctx as 64 bits). */
1507 fill_sprs64 (regcache
, &ctx
.iar
, &ctx
.msr
, &ctx
.cr
, &ctx
.lr
, &ctx
.ctr
,
1508 &ctx
.xer
, &ctx
.fpscr
);
1512 /* Problem: ctx.iar etc. are 64 bits, but raw_registers are 32.
1513 Solution: use 32-bit temp variables. */
1514 uint32_t tmp_iar
, tmp_msr
, tmp_cr
, tmp_lr
, tmp_ctr
, tmp_xer
,
1517 fill_sprs32 (regcache
, &tmp_iar
, &tmp_msr
, &tmp_cr
, &tmp_lr
, &tmp_ctr
,
1518 &tmp_xer
, &tmp_fpscr
);
1519 if (REG_VALID
== regcache_register_status (regcache
,
1520 gdbarch_pc_regnum (gdbarch
)))
1522 if (REG_VALID
== regcache_register_status (regcache
, tdep
->ppc_ps_regnum
))
1524 if (REG_VALID
== regcache_register_status (regcache
, tdep
->ppc_cr_regnum
))
1526 if (REG_VALID
== regcache_register_status (regcache
, tdep
->ppc_lr_regnum
))
1528 if (REG_VALID
== regcache_register_status (regcache
,
1529 tdep
->ppc_ctr_regnum
))
1531 if (REG_VALID
== regcache_register_status (regcache
,
1532 tdep
->ppc_xer_regnum
))
1534 if (REG_VALID
== regcache_register_status (regcache
,
1535 tdep
->ppc_xer_regnum
))
1536 ctx
.fpscr
= tmp_fpscr
;
1539 status
= pthdb_pthread_setcontext (pd_session
, pdtid
, &ctx
);
1540 if (status
!= PTHDB_SUCCESS
)
1541 error (_("aix-thread: store_registers: "
1542 "pthdb_pthread_setcontext returned %s"),
1543 pd_status2str (status
));
1546 /* Store register REGNO if != -1 or all registers otherwise into
1549 AIX provides a way to set all of a kernel thread's GPRs, FPRs, or
1550 SPRs, but there's no way to set individual registers within those
1551 groups. Therefore, if REGNO != -1, this function stores an entire
1555 store_regs_kernel_thread (const struct regcache
*regcache
, int regno
,
1558 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1559 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1560 uint64_t gprs64
[ppc_num_gprs
];
1561 uint32_t gprs32
[ppc_num_gprs
];
1562 double fprs
[ppc_num_fprs
];
1563 struct ptxsprs sprs64
;
1564 struct ptsprs sprs32
;
1567 if (debug_aix_thread
)
1568 fprintf_unfiltered (gdb_stdlog
,
1569 "store_regs_kernel_thread tid=%lx regno=%d\n",
1572 /* General-purpose registers. */
1574 || (tdep
->ppc_gp0_regnum
<= regno
1575 && regno
< tdep
->ppc_gp0_regnum
+ ppc_num_fprs
))
1579 /* Pre-fetch: some regs may not be in the cache. */
1580 ptrace64aix (PTT_READ_GPRS
, tid
, (unsigned long) gprs64
, 0, NULL
);
1581 fill_gprs64 (regcache
, gprs64
);
1582 ptrace64aix (PTT_WRITE_GPRS
, tid
, (unsigned long) gprs64
, 0, NULL
);
1586 /* Pre-fetch: some regs may not be in the cache. */
1587 ptrace32 (PTT_READ_GPRS
, tid
, (uintptr_t) gprs32
, 0, NULL
);
1588 fill_gprs32 (regcache
, gprs32
);
1589 ptrace32 (PTT_WRITE_GPRS
, tid
, (uintptr_t) gprs32
, 0, NULL
);
1593 /* Floating-point registers. */
1595 if (ppc_floating_point_unit_p (gdbarch
)
1597 || (regno
>= tdep
->ppc_fp0_regnum
1598 && regno
< tdep
->ppc_fp0_regnum
+ ppc_num_fprs
)))
1600 /* Pre-fetch: some regs may not be in the cache. */
1601 ptrace32 (PTT_READ_FPRS
, tid
, (uintptr_t) fprs
, 0, NULL
);
1602 fill_fprs (regcache
, fprs
);
1603 ptrace32 (PTT_WRITE_FPRS
, tid
, (uintptr_t) fprs
, 0, NULL
);
1606 /* Special-purpose registers. */
1608 if (regno
== -1 || special_register_p (gdbarch
, regno
))
1612 /* Pre-fetch: some registers won't be in the cache. */
1613 ptrace64aix (PTT_READ_SPRS
, tid
,
1614 (unsigned long) &sprs64
, 0, NULL
);
1615 fill_sprs64 (regcache
, &sprs64
.pt_iar
, &sprs64
.pt_msr
,
1616 &sprs64
.pt_cr
, &sprs64
.pt_lr
, &sprs64
.pt_ctr
,
1617 &sprs64
.pt_xer
, &sprs64
.pt_fpscr
);
1618 ptrace64aix (PTT_WRITE_SPRS
, tid
,
1619 (unsigned long) &sprs64
, 0, NULL
);
1623 /* The contents of "struct ptspr" were declared as "unsigned
1624 long" up to AIX 5.2, but are "unsigned int" since 5.3.
1625 Use temporaries to work around this problem. Also, add an
1626 assert here to make sure we fail if the system header files
1627 use "unsigned long", and the size of that type is not what
1628 the headers expect. */
1629 uint32_t tmp_iar
, tmp_msr
, tmp_cr
, tmp_lr
, tmp_ctr
, tmp_xer
,
1632 gdb_assert (sizeof (sprs32
.pt_iar
) == 4);
1634 /* Pre-fetch: some registers won't be in the cache. */
1635 ptrace32 (PTT_READ_SPRS
, tid
, (uintptr_t) &sprs32
, 0, NULL
);
1637 fill_sprs32 (regcache
, &tmp_iar
, &tmp_msr
, &tmp_cr
, &tmp_lr
,
1638 &tmp_ctr
, &tmp_xer
, &tmp_fpscr
);
1640 sprs32
.pt_iar
= tmp_iar
;
1641 sprs32
.pt_msr
= tmp_msr
;
1642 sprs32
.pt_cr
= tmp_cr
;
1643 sprs32
.pt_lr
= tmp_lr
;
1644 sprs32
.pt_ctr
= tmp_ctr
;
1645 sprs32
.pt_xer
= tmp_xer
;
1646 sprs32
.pt_fpscr
= tmp_fpscr
;
1648 if (tdep
->ppc_mq_regnum
>= 0)
1649 if (REG_VALID
== regcache_register_status (regcache
,
1650 tdep
->ppc_mq_regnum
))
1651 regcache_raw_collect (regcache
, tdep
->ppc_mq_regnum
,
1654 ptrace32 (PTT_WRITE_SPRS
, tid
, (uintptr_t) &sprs32
, 0, NULL
);
1659 /* Store gdb's current view of the register set into the
1660 thread/process specified by inferior_ptid. */
1663 aix_thread_store_registers (struct target_ops
*ops
,
1664 struct regcache
*regcache
, int regno
)
1666 struct thread_info
*thread
;
1668 struct target_ops
*beneath
= find_target_beneath (ops
);
1670 if (!PD_TID (inferior_ptid
))
1671 beneath
->to_store_registers (beneath
, regcache
, regno
);
1674 thread
= find_thread_ptid (inferior_ptid
);
1675 tid
= thread
->private->tid
;
1677 if (tid
== PTHDB_INVALID_TID
)
1678 store_regs_user_thread (regcache
, thread
->private->pdtid
);
1680 store_regs_kernel_thread (regcache
, regno
, tid
);
1684 /* Implement the to_xfer_partial target_ops method. */
1686 static enum target_xfer_status
1687 aix_thread_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1688 const char *annex
, gdb_byte
*readbuf
,
1689 const gdb_byte
*writebuf
,
1690 ULONGEST offset
, ULONGEST len
, ULONGEST
*xfered_len
)
1692 struct cleanup
*old_chain
= save_inferior_ptid ();
1693 enum target_xfer_status xfer
;
1694 struct target_ops
*beneath
= find_target_beneath (ops
);
1696 inferior_ptid
= pid_to_ptid (ptid_get_pid (inferior_ptid
));
1697 xfer
= beneath
->to_xfer_partial (beneath
, object
, annex
, readbuf
,
1698 writebuf
, offset
, len
, xfered_len
);
1700 do_cleanups (old_chain
);
1704 /* Clean up after the inferior exits. */
1707 aix_thread_mourn_inferior (struct target_ops
*ops
)
1709 struct target_ops
*beneath
= find_target_beneath (ops
);
1712 beneath
->to_mourn_inferior (beneath
);
1715 /* Return whether thread PID is still valid. */
1718 aix_thread_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
1720 struct target_ops
*beneath
= find_target_beneath (ops
);
1723 return beneath
->to_thread_alive (beneath
, ptid
);
1725 /* We update the thread list every time the child stops, so all
1726 valid threads should be in the thread list. */
1727 return in_thread_list (ptid
);
1730 /* Return a printable representation of composite PID for use in
1731 "info threads" output. */
1734 aix_thread_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
1736 static char *ret
= NULL
;
1737 struct target_ops
*beneath
= find_target_beneath (ops
);
1740 return beneath
->to_pid_to_str (beneath
, ptid
);
1742 /* Free previous return value; a new one will be allocated by
1746 ret
= xstrprintf (_("Thread %ld"), ptid_get_tid (ptid
));
1750 /* Return a printable representation of extra information about
1751 THREAD, for use in "info threads" output. */
1754 aix_thread_extra_thread_info (struct target_ops
*self
,
1755 struct thread_info
*thread
)
1757 struct ui_file
*buf
;
1759 pthdb_pthread_t pdtid
;
1761 pthdb_state_t state
;
1762 pthdb_suspendstate_t suspendstate
;
1763 pthdb_detachstate_t detachstate
;
1765 static char *ret
= NULL
;
1767 if (!PD_TID (thread
->ptid
))
1770 buf
= mem_fileopen ();
1772 pdtid
= thread
->private->pdtid
;
1773 tid
= thread
->private->tid
;
1775 if (tid
!= PTHDB_INVALID_TID
)
1776 /* i18n: Like "thread-identifier %d, [state] running, suspended" */
1777 fprintf_unfiltered (buf
, _("tid %d"), (int)tid
);
1779 status
= pthdb_pthread_state (pd_session
, pdtid
, &state
);
1780 if (status
!= PTHDB_SUCCESS
)
1782 fprintf_unfiltered (buf
, ", %s", state2str (state
));
1784 status
= pthdb_pthread_suspendstate (pd_session
, pdtid
,
1786 if (status
== PTHDB_SUCCESS
&& suspendstate
== PSS_SUSPENDED
)
1787 /* i18n: Like "Thread-Id %d, [state] running, suspended" */
1788 fprintf_unfiltered (buf
, _(", suspended"));
1790 status
= pthdb_pthread_detachstate (pd_session
, pdtid
,
1792 if (status
== PTHDB_SUCCESS
&& detachstate
== PDS_DETACHED
)
1793 /* i18n: Like "Thread-Id %d, [state] running, detached" */
1794 fprintf_unfiltered (buf
, _(", detached"));
1796 pthdb_pthread_cancelpend (pd_session
, pdtid
, &cancelpend
);
1797 if (status
== PTHDB_SUCCESS
&& cancelpend
)
1798 /* i18n: Like "Thread-Id %d, [state] running, cancel pending" */
1799 fprintf_unfiltered (buf
, _(", cancel pending"));
1801 ui_file_write (buf
, "", 1);
1803 xfree (ret
); /* Free old buffer. */
1805 ret
= ui_file_xstrdup (buf
, NULL
);
1806 ui_file_delete (buf
);
1812 aix_thread_get_ada_task_ptid (struct target_ops
*self
, long lwp
, long thread
)
1814 return ptid_build (ptid_get_pid (inferior_ptid
), 0, thread
);
1817 /* Initialize target aix_thread_ops. */
1820 init_aix_thread_ops (void)
1822 aix_thread_ops
.to_shortname
= "aix-threads";
1823 aix_thread_ops
.to_longname
= _("AIX pthread support");
1824 aix_thread_ops
.to_doc
= _("AIX pthread support");
1826 aix_thread_ops
.to_attach
= aix_thread_attach
;
1827 aix_thread_ops
.to_detach
= aix_thread_detach
;
1828 aix_thread_ops
.to_resume
= aix_thread_resume
;
1829 aix_thread_ops
.to_wait
= aix_thread_wait
;
1830 aix_thread_ops
.to_fetch_registers
= aix_thread_fetch_registers
;
1831 aix_thread_ops
.to_store_registers
= aix_thread_store_registers
;
1832 aix_thread_ops
.to_xfer_partial
= aix_thread_xfer_partial
;
1833 /* No need for aix_thread_ops.to_create_inferior, because we activate thread
1834 debugging when the inferior reaches pd_brk_addr. */
1835 aix_thread_ops
.to_mourn_inferior
= aix_thread_mourn_inferior
;
1836 aix_thread_ops
.to_thread_alive
= aix_thread_thread_alive
;
1837 aix_thread_ops
.to_pid_to_str
= aix_thread_pid_to_str
;
1838 aix_thread_ops
.to_extra_thread_info
= aix_thread_extra_thread_info
;
1839 aix_thread_ops
.to_get_ada_task_ptid
= aix_thread_get_ada_task_ptid
;
1840 aix_thread_ops
.to_stratum
= thread_stratum
;
1841 aix_thread_ops
.to_magic
= OPS_MAGIC
;
1844 /* Module startup initialization function, automagically called by
1847 void _initialize_aix_thread (void);
1850 _initialize_aix_thread (void)
1852 init_aix_thread_ops ();
1853 complete_target_initialization (&aix_thread_ops
);
1855 /* Notice when object files get loaded and unloaded. */
1856 observer_attach_new_objfile (new_objfile
);
1858 add_setshow_boolean_cmd ("aix-thread", class_maintenance
, &debug_aix_thread
,
1859 _("Set debugging of AIX thread module."),
1860 _("Show debugging of AIX thread module."),
1861 _("Enables debugging output (used to debug GDB)."),
1863 /* FIXME: i18n: Debugging of AIX thread
1864 module is \"%d\". */
1865 &setdebuglist
, &showdebuglist
);