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"
54 #include <sys/types.h>
55 #include <sys/ptrace.h>
58 #include <sys/pthdebug.h>
60 #if !HAVE_DECL_GETTHRDS
61 extern int getthrds (pid_t
, struct thrdsinfo64
*, int, tid_t
*, int);
64 /* Whether to emit debugging output. */
65 static int debug_aix_thread
;
67 /* In AIX 5.1, functions use pthdb_tid_t instead of tid_t. */
68 #ifndef PTHDB_VERSION_3
69 #define pthdb_tid_t tid_t
72 /* Return whether to treat PID as a debuggable thread id. */
74 #define PD_TID(ptid) (pd_active && ptid_get_tid (ptid) != 0)
76 /* pthdb_user_t value that we pass to pthdb functions. 0 causes
77 PTHDB_BAD_USER errors, so use 1. */
81 /* Success and failure values returned by pthdb callbacks. */
83 #define PDC_SUCCESS PTHDB_SUCCESS
84 #define PDC_FAILURE PTHDB_CALLBACK
86 /* Private data attached to each element in GDB's thread list. */
88 struct private_thread_info
{
89 pthdb_pthread_t pdtid
; /* thread's libpthdebug id */
90 pthdb_tid_t tid
; /* kernel thread id */
93 /* Information about a thread of which libpthdebug is aware. */
96 pthdb_pthread_t pdtid
;
101 /* This module's target-specific operations, active while pd_able is true. */
103 static struct target_ops aix_thread_ops
;
105 /* Address of the function that libpthread will call when libpthdebug
106 is ready to be initialized. */
108 static CORE_ADDR pd_brk_addr
;
110 /* Whether the current application is debuggable by pthdb. */
112 static int pd_able
= 0;
114 /* Whether a threaded application is being debugged. */
116 static int pd_active
= 0;
118 /* Whether the current architecture is 64-bit.
119 Only valid when pd_able is true. */
123 /* Forward declarations for pthdb callbacks. */
125 static int pdc_symbol_addrs (pthdb_user_t
, pthdb_symbol_t
*, int);
126 static int pdc_read_data (pthdb_user_t
, void *, pthdb_addr_t
, size_t);
127 static int pdc_write_data (pthdb_user_t
, void *, pthdb_addr_t
, size_t);
128 static int pdc_read_regs (pthdb_user_t user
, pthdb_tid_t tid
,
129 unsigned long long flags
,
130 pthdb_context_t
*context
);
131 static int pdc_write_regs (pthdb_user_t user
, pthdb_tid_t tid
,
132 unsigned long long flags
,
133 pthdb_context_t
*context
);
134 static int pdc_alloc (pthdb_user_t
, size_t, void **);
135 static int pdc_realloc (pthdb_user_t
, void *, size_t, void **);
136 static int pdc_dealloc (pthdb_user_t
, void *);
138 /* pthdb callbacks. */
140 static pthdb_callbacks_t pd_callbacks
= {
152 /* Current pthdb session. */
154 static pthdb_session_t pd_session
;
156 /* Return a printable representation of pthdebug function return
160 pd_status2str (int status
)
164 case PTHDB_SUCCESS
: return "SUCCESS";
165 case PTHDB_NOSYS
: return "NOSYS";
166 case PTHDB_NOTSUP
: return "NOTSUP";
167 case PTHDB_BAD_VERSION
: return "BAD_VERSION";
168 case PTHDB_BAD_USER
: return "BAD_USER";
169 case PTHDB_BAD_SESSION
: return "BAD_SESSION";
170 case PTHDB_BAD_MODE
: return "BAD_MODE";
171 case PTHDB_BAD_FLAGS
: return "BAD_FLAGS";
172 case PTHDB_BAD_CALLBACK
: return "BAD_CALLBACK";
173 case PTHDB_BAD_POINTER
: return "BAD_POINTER";
174 case PTHDB_BAD_CMD
: return "BAD_CMD";
175 case PTHDB_BAD_PTHREAD
: return "BAD_PTHREAD";
176 case PTHDB_BAD_ATTR
: return "BAD_ATTR";
177 case PTHDB_BAD_MUTEX
: return "BAD_MUTEX";
178 case PTHDB_BAD_MUTEXATTR
: return "BAD_MUTEXATTR";
179 case PTHDB_BAD_COND
: return "BAD_COND";
180 case PTHDB_BAD_CONDATTR
: return "BAD_CONDATTR";
181 case PTHDB_BAD_RWLOCK
: return "BAD_RWLOCK";
182 case PTHDB_BAD_RWLOCKATTR
: return "BAD_RWLOCKATTR";
183 case PTHDB_BAD_KEY
: return "BAD_KEY";
184 case PTHDB_BAD_PTID
: return "BAD_PTID";
185 case PTHDB_BAD_TID
: return "BAD_TID";
186 case PTHDB_CALLBACK
: return "CALLBACK";
187 case PTHDB_CONTEXT
: return "CONTEXT";
188 case PTHDB_HELD
: return "HELD";
189 case PTHDB_NOT_HELD
: return "NOT_HELD";
190 case PTHDB_MEMORY
: return "MEMORY";
191 case PTHDB_NOT_PTHREADED
: return "NOT_PTHREADED";
192 case PTHDB_SYMBOL
: return "SYMBOL";
193 case PTHDB_NOT_AVAIL
: return "NOT_AVAIL";
194 case PTHDB_INTERNAL
: return "INTERNAL";
195 default: return "UNKNOWN";
199 /* A call to ptrace(REQ, ID, ...) just returned RET. Check for
200 exceptional conditions and either return nonlocally or else return
201 1 for success and 0 for failure. */
204 ptrace_check (int req
, int id
, int ret
)
206 if (ret
== 0 && !errno
)
209 /* According to ptrace(2), ptrace may fail with EPERM if "the
210 Identifier parameter corresponds to a kernel thread which is
211 stopped in kernel mode and whose computational state cannot be
212 read or written." This happens quite often with register reads. */
219 if (ret
== -1 && errno
== EPERM
)
221 if (debug_aix_thread
)
222 fprintf_unfiltered (gdb_stdlog
,
223 "ptrace (%d, %d) = %d (errno = %d)\n",
224 req
, id
, ret
, errno
);
225 return ret
== -1 ? 0 : 1;
229 error (_("aix-thread: ptrace (%d, %d) returned %d (errno = %d %s)"),
230 req
, id
, ret
, errno
, safe_strerror (errno
));
231 return 0; /* Not reached. */
234 /* Call ptracex (REQ, ID, ADDR, DATA, BUF) or
235 ptrace64 (REQ, ID, ADDR, DATA, BUF) if HAVE_PTRACE64.
239 # define ptracex(request, pid, addr, data, buf) \
240 ptrace64 (request, pid, addr, data, buf)
244 ptrace64aix (int req
, int id
, long long addr
, int data
, int *buf
)
247 return ptrace_check (req
, id
, ptracex (req
, id
, addr
, data
, buf
));
250 /* Call ptrace (REQ, ID, ADDR, DATA, BUF) or
251 ptrace64 (REQ, ID, ADDR, DATA, BUF) if HAVE_PTRACE64.
255 # define ptrace(request, pid, addr, data, buf) \
256 ptrace64 (request, pid, addr, data, buf)
257 # define addr_ptr long long
259 # define addr_ptr int *
263 ptrace32 (int req
, int id
, addr_ptr addr
, int data
, int *buf
)
266 return ptrace_check (req
, id
,
267 ptrace (req
, id
, addr
, data
, buf
));
270 /* If *PIDP is a composite process/thread id, convert it to a
274 pid_to_prc (ptid_t
*ptidp
)
280 *ptidp
= pid_to_ptid (ptid_get_pid (ptid
));
283 /* pthdb callback: for <i> from 0 to COUNT, set SYMBOLS[<i>].addr to
284 the address of SYMBOLS[<i>].name. */
287 pdc_symbol_addrs (pthdb_user_t user
, pthdb_symbol_t
*symbols
, int count
)
289 struct minimal_symbol
*ms
;
293 if (debug_aix_thread
)
294 fprintf_unfiltered (gdb_stdlog
,
295 "pdc_symbol_addrs (user = %ld, symbols = 0x%lx, count = %d)\n",
296 user
, (long) symbols
, count
);
298 for (i
= 0; i
< count
; i
++)
300 name
= symbols
[i
].name
;
301 if (debug_aix_thread
)
302 fprintf_unfiltered (gdb_stdlog
,
303 " symbols[%d].name = \"%s\"\n", i
, name
);
309 if (!(ms
= lookup_minimal_symbol (name
, NULL
, NULL
)))
311 if (debug_aix_thread
)
312 fprintf_unfiltered (gdb_stdlog
, " returning PDC_FAILURE\n");
315 symbols
[i
].addr
= SYMBOL_VALUE_ADDRESS (ms
);
317 if (debug_aix_thread
)
318 fprintf_unfiltered (gdb_stdlog
, " symbols[%d].addr = %s\n",
319 i
, hex_string (symbols
[i
].addr
));
321 if (debug_aix_thread
)
322 fprintf_unfiltered (gdb_stdlog
, " returning PDC_SUCCESS\n");
326 /* Read registers call back function should be able to read the
327 context information of a debuggee kernel thread from an active
328 process or from a core file. The information should be formatted
329 in context64 form for both 32-bit and 64-bit process.
330 If successful return 0, else non-zero is returned. */
333 pdc_read_regs (pthdb_user_t user
,
335 unsigned long long flags
,
336 pthdb_context_t
*context
)
338 /* This function doesn't appear to be used, so we could probably
339 just return 0 here. HOWEVER, if it is not defined, the OS will
340 complain and several thread debug functions will fail. In case
341 this is needed, I have implemented what I think it should do,
342 however this code is untested. */
344 uint64_t gprs64
[ppc_num_gprs
];
345 uint32_t gprs32
[ppc_num_gprs
];
346 double fprs
[ppc_num_fprs
];
347 struct ptxsprs sprs64
;
348 struct ptsprs sprs32
;
350 if (debug_aix_thread
)
351 fprintf_unfiltered (gdb_stdlog
, "pdc_read_regs tid=%d flags=%s\n",
352 (int) tid
, hex_string (flags
));
354 /* General-purpose registers. */
355 if (flags
& PTHDB_FLAG_GPRS
)
359 if (!ptrace64aix (PTT_READ_GPRS
, tid
,
360 (unsigned long) gprs64
, 0, NULL
))
361 memset (gprs64
, 0, sizeof (gprs64
));
362 memcpy (context
->gpr
, gprs64
, sizeof(gprs64
));
366 if (!ptrace32 (PTT_READ_GPRS
, tid
, (uintptr_t) gprs32
, 0, NULL
))
367 memset (gprs32
, 0, sizeof (gprs32
));
368 memcpy (context
->gpr
, gprs32
, sizeof(gprs32
));
372 /* Floating-point registers. */
373 if (flags
& PTHDB_FLAG_FPRS
)
375 if (!ptrace32 (PTT_READ_FPRS
, tid
, (uintptr_t) fprs
, 0, NULL
))
376 memset (fprs
, 0, sizeof (fprs
));
377 memcpy (context
->fpr
, fprs
, sizeof(fprs
));
380 /* Special-purpose registers. */
381 if (flags
& PTHDB_FLAG_SPRS
)
385 if (!ptrace64aix (PTT_READ_SPRS
, tid
,
386 (unsigned long) &sprs64
, 0, NULL
))
387 memset (&sprs64
, 0, sizeof (sprs64
));
388 memcpy (&context
->msr
, &sprs64
, sizeof(sprs64
));
392 if (!ptrace32 (PTT_READ_SPRS
, tid
, (uintptr_t) &sprs32
, 0, NULL
))
393 memset (&sprs32
, 0, sizeof (sprs32
));
394 memcpy (&context
->msr
, &sprs32
, sizeof(sprs32
));
400 /* Write register function should be able to write requested context
401 information to specified debuggee's kernel thread id.
402 If successful return 0, else non-zero is returned. */
405 pdc_write_regs (pthdb_user_t user
,
407 unsigned long long flags
,
408 pthdb_context_t
*context
)
410 /* This function doesn't appear to be used, so we could probably
411 just return 0 here. HOWEVER, if it is not defined, the OS will
412 complain and several thread debug functions will fail. In case
413 this is needed, I have implemented what I think it should do,
414 however this code is untested. */
416 if (debug_aix_thread
)
417 fprintf_unfiltered (gdb_stdlog
, "pdc_write_regs tid=%d flags=%s\n",
418 (int) tid
, hex_string (flags
));
420 /* General-purpose registers. */
421 if (flags
& PTHDB_FLAG_GPRS
)
424 ptrace64aix (PTT_WRITE_GPRS
, tid
,
425 (unsigned long) context
->gpr
, 0, NULL
);
427 ptrace32 (PTT_WRITE_GPRS
, tid
, (uintptr_t) context
->gpr
, 0, NULL
);
430 /* Floating-point registers. */
431 if (flags
& PTHDB_FLAG_FPRS
)
433 ptrace32 (PTT_WRITE_FPRS
, tid
, (uintptr_t) context
->fpr
, 0, NULL
);
436 /* Special-purpose registers. */
437 if (flags
& PTHDB_FLAG_SPRS
)
441 ptrace64aix (PTT_WRITE_SPRS
, tid
,
442 (unsigned long) &context
->msr
, 0, NULL
);
446 ptrace32 (PTT_WRITE_SPRS
, tid
, (uintptr_t) &context
->msr
, 0, NULL
);
452 /* pthdb callback: read LEN bytes from process ADDR into BUF. */
455 pdc_read_data (pthdb_user_t user
, void *buf
,
456 pthdb_addr_t addr
, size_t len
)
460 if (debug_aix_thread
)
461 fprintf_unfiltered (gdb_stdlog
,
462 "pdc_read_data (user = %ld, buf = 0x%lx, addr = %s, len = %ld)\n",
463 user
, (long) buf
, hex_string (addr
), len
);
465 status
= target_read_memory (addr
, buf
, len
);
466 ret
= status
== 0 ? PDC_SUCCESS
: PDC_FAILURE
;
468 if (debug_aix_thread
)
469 fprintf_unfiltered (gdb_stdlog
, " status=%d, returning %s\n",
470 status
, pd_status2str (ret
));
474 /* pthdb callback: write LEN bytes from BUF to process ADDR. */
477 pdc_write_data (pthdb_user_t user
, void *buf
,
478 pthdb_addr_t addr
, size_t len
)
482 if (debug_aix_thread
)
483 fprintf_unfiltered (gdb_stdlog
,
484 "pdc_write_data (user = %ld, buf = 0x%lx, addr = %s, len = %ld)\n",
485 user
, (long) buf
, hex_string (addr
), len
);
487 status
= target_write_memory (addr
, buf
, len
);
488 ret
= status
== 0 ? PDC_SUCCESS
: PDC_FAILURE
;
490 if (debug_aix_thread
)
491 fprintf_unfiltered (gdb_stdlog
, " status=%d, returning %s\n", status
,
492 pd_status2str (ret
));
496 /* pthdb callback: allocate a LEN-byte buffer and store a pointer to it
500 pdc_alloc (pthdb_user_t user
, size_t len
, void **bufp
)
502 if (debug_aix_thread
)
503 fprintf_unfiltered (gdb_stdlog
,
504 "pdc_alloc (user = %ld, len = %ld, bufp = 0x%lx)\n",
505 user
, len
, (long) bufp
);
506 *bufp
= xmalloc (len
);
507 if (debug_aix_thread
)
508 fprintf_unfiltered (gdb_stdlog
,
509 " malloc returned 0x%lx\n", (long) *bufp
);
511 /* Note: xmalloc() can't return 0; therefore PDC_FAILURE will never
514 return *bufp
? PDC_SUCCESS
: PDC_FAILURE
;
517 /* pthdb callback: reallocate BUF, which was allocated by the alloc or
518 realloc callback, so that it contains LEN bytes, and store a
519 pointer to the result in BUFP. */
522 pdc_realloc (pthdb_user_t user
, void *buf
, size_t len
, void **bufp
)
524 if (debug_aix_thread
)
525 fprintf_unfiltered (gdb_stdlog
,
526 "pdc_realloc (user = %ld, buf = 0x%lx, len = %ld, bufp = 0x%lx)\n",
527 user
, (long) buf
, len
, (long) bufp
);
528 *bufp
= xrealloc (buf
, len
);
529 if (debug_aix_thread
)
530 fprintf_unfiltered (gdb_stdlog
,
531 " realloc returned 0x%lx\n", (long) *bufp
);
532 return *bufp
? PDC_SUCCESS
: PDC_FAILURE
;
535 /* pthdb callback: free BUF, which was allocated by the alloc or
539 pdc_dealloc (pthdb_user_t user
, void *buf
)
541 if (debug_aix_thread
)
542 fprintf_unfiltered (gdb_stdlog
,
543 "pdc_free (user = %ld, buf = 0x%lx)\n", user
,
549 /* Return a printable representation of pthread STATE. */
552 state2str (pthdb_state_t state
)
557 /* i18n: Like "Thread-Id %d, [state] idle" */
558 return _("idle"); /* being created */
560 /* i18n: Like "Thread-Id %d, [state] running" */
561 return _("running"); /* running */
563 /* i18n: Like "Thread-Id %d, [state] sleeping" */
564 return _("sleeping"); /* awaiting an event */
566 /* i18n: Like "Thread-Id %d, [state] ready" */
567 return _("ready"); /* runnable */
569 /* i18n: Like "Thread-Id %d, [state] finished" */
570 return _("finished"); /* awaiting a join/detach */
572 /* i18n: Like "Thread-Id %d, [state] unknown" */
577 /* qsort() comparison function for sorting pd_thread structs by pthid. */
580 pcmp (const void *p1v
, const void *p2v
)
582 struct pd_thread
*p1
= (struct pd_thread
*) p1v
;
583 struct pd_thread
*p2
= (struct pd_thread
*) p2v
;
584 return p1
->pthid
< p2
->pthid
? -1 : p1
->pthid
> p2
->pthid
;
587 /* iterate_over_threads() callback for counting GDB threads.
589 Do not count the main thread (whose tid is zero). This matches
590 the list of threads provided by the pthreaddebug library, which
591 does not include that main thread either, and thus allows us
592 to compare the two lists. */
595 giter_count (struct thread_info
*thread
, void *countp
)
597 if (PD_TID (thread
->ptid
))
602 /* iterate_over_threads() callback for accumulating GDB thread pids.
604 Do not include the main thread (whose tid is zero). This matches
605 the list of threads provided by the pthreaddebug library, which
606 does not include that main thread either, and thus allows us
607 to compare the two lists. */
610 giter_accum (struct thread_info
*thread
, void *bufp
)
612 if (PD_TID (thread
->ptid
))
614 **(struct thread_info
***) bufp
= thread
;
615 (*(struct thread_info
***) bufp
)++;
620 /* ptid comparison function */
623 ptid_cmp (ptid_t ptid1
, ptid_t ptid2
)
627 if (ptid_get_pid (ptid1
) < ptid_get_pid (ptid2
))
629 else if (ptid_get_pid (ptid1
) > ptid_get_pid (ptid2
))
631 else if (ptid_get_tid (ptid1
) < ptid_get_tid (ptid2
))
633 else if (ptid_get_tid (ptid1
) > ptid_get_tid (ptid2
))
635 else if (ptid_get_lwp (ptid1
) < ptid_get_lwp (ptid2
))
637 else if (ptid_get_lwp (ptid1
) > ptid_get_lwp (ptid2
))
643 /* qsort() comparison function for sorting thread_info structs by pid. */
646 gcmp (const void *t1v
, const void *t2v
)
648 struct thread_info
*t1
= *(struct thread_info
**) t1v
;
649 struct thread_info
*t2
= *(struct thread_info
**) t2v
;
650 return ptid_cmp (t1
->ptid
, t2
->ptid
);
653 /* Search through the list of all kernel threads for the thread
654 that has stopped on a SIGTRAP signal, and return its TID.
655 Return 0 if none found. */
658 get_signaled_thread (void)
660 struct thrdsinfo64 thrinf
;
666 if (getthrds (ptid_get_pid (inferior_ptid
), &thrinf
,
667 sizeof (thrinf
), &ktid
, 1) != 1)
670 if (thrinf
.ti_cursig
== SIGTRAP
)
671 return thrinf
.ti_tid
;
674 /* Didn't find any thread stopped on a SIGTRAP signal. */
678 /* Synchronize GDB's thread list with libpthdebug's.
680 There are some benefits of doing this every time the inferior stops:
682 - allows users to run thread-specific commands without needing to
683 run "info threads" first
685 - helps pthdb_tid_pthread() work properly (see "libpthdebug
686 peculiarities" at the top of this module)
688 - simplifies the demands placed on libpthdebug, which seems to
689 have difficulty with certain call patterns */
692 sync_threadlists (void)
694 int cmd
, status
, infpid
;
695 int pcount
, psize
, pi
, gcount
, gi
;
696 struct pd_thread
*pbuf
;
697 struct thread_info
**gbuf
, **g
, *thread
;
698 pthdb_pthread_t pdtid
;
702 /* Accumulate an array of libpthdebug threads sorted by pthread id. */
706 pbuf
= (struct pd_thread
*) xmalloc (psize
* sizeof *pbuf
);
708 for (cmd
= PTHDB_LIST_FIRST
;; cmd
= PTHDB_LIST_NEXT
)
710 status
= pthdb_pthread (pd_session
, &pdtid
, cmd
);
711 if (status
!= PTHDB_SUCCESS
|| pdtid
== PTHDB_INVALID_PTHREAD
)
714 status
= pthdb_pthread_ptid (pd_session
, pdtid
, &pthid
);
715 if (status
!= PTHDB_SUCCESS
|| pthid
== PTHDB_INVALID_PTID
)
721 pbuf
= (struct pd_thread
*) xrealloc (pbuf
,
722 psize
* sizeof *pbuf
);
724 pbuf
[pcount
].pdtid
= pdtid
;
725 pbuf
[pcount
].pthid
= pthid
;
729 for (pi
= 0; pi
< pcount
; pi
++)
731 status
= pthdb_pthread_tid (pd_session
, pbuf
[pi
].pdtid
, &tid
);
732 if (status
!= PTHDB_SUCCESS
)
733 tid
= PTHDB_INVALID_TID
;
737 qsort (pbuf
, pcount
, sizeof *pbuf
, pcmp
);
739 /* Accumulate an array of GDB threads sorted by pid. */
742 iterate_over_threads (giter_count
, &gcount
);
743 g
= gbuf
= (struct thread_info
**) xmalloc (gcount
* sizeof *gbuf
);
744 iterate_over_threads (giter_accum
, &g
);
745 qsort (gbuf
, gcount
, sizeof *gbuf
, gcmp
);
747 /* Apply differences between the two arrays to GDB's thread list. */
749 infpid
= ptid_get_pid (inferior_ptid
);
750 for (pi
= gi
= 0; pi
< pcount
|| gi
< gcount
;)
754 delete_thread (gbuf
[gi
]->ptid
);
757 else if (gi
== gcount
)
759 thread
= add_thread (ptid_build (infpid
, 0, pbuf
[pi
].pthid
));
760 thread
->private = xmalloc (sizeof (struct private_thread_info
));
761 thread
->private->pdtid
= pbuf
[pi
].pdtid
;
762 thread
->private->tid
= pbuf
[pi
].tid
;
770 pptid
= ptid_build (infpid
, 0, pbuf
[pi
].pthid
);
771 gptid
= gbuf
[gi
]->ptid
;
772 pdtid
= pbuf
[pi
].pdtid
;
775 cmp_result
= ptid_cmp (pptid
, gptid
);
779 gbuf
[gi
]->private->pdtid
= pdtid
;
780 gbuf
[gi
]->private->tid
= tid
;
784 else if (cmp_result
> 0)
786 delete_thread (gptid
);
791 thread
= add_thread (pptid
);
792 thread
->private = xmalloc (sizeof (struct private_thread_info
));
793 thread
->private->pdtid
= pdtid
;
794 thread
->private->tid
= tid
;
804 /* Iterate_over_threads() callback for locating a thread, using
805 the TID of its associated kernel thread. */
808 iter_tid (struct thread_info
*thread
, void *tidp
)
810 const pthdb_tid_t tid
= *(pthdb_tid_t
*)tidp
;
812 return (thread
->private->tid
== tid
);
815 /* Synchronize libpthdebug's state with the inferior and with GDB,
816 generate a composite process/thread <pid> for the current thread,
817 set inferior_ptid to <pid> if SET_INFPID, and return <pid>. */
820 pd_update (int set_infpid
)
825 struct thread_info
*thread
= NULL
;
828 return inferior_ptid
;
830 status
= pthdb_session_update (pd_session
);
831 if (status
!= PTHDB_SUCCESS
)
832 return inferior_ptid
;
836 /* Define "current thread" as one that just received a trap signal. */
838 tid
= get_signaled_thread ();
840 thread
= iterate_over_threads (iter_tid
, &tid
);
842 ptid
= inferior_ptid
;
847 inferior_ptid
= ptid
;
852 /* Try to start debugging threads in the current process.
853 If successful and SET_INFPID, set inferior_ptid to reflect the
857 pd_activate (int set_infpid
)
861 status
= pthdb_session_init (PD_USER
, arch64
? PEM_64BIT
: PEM_32BIT
,
862 PTHDB_FLAG_REGS
, &pd_callbacks
,
864 if (status
!= PTHDB_SUCCESS
)
866 return inferior_ptid
;
869 return pd_update (set_infpid
);
872 /* Undo the effects of pd_activate(). */
879 pthdb_session_destroy (pd_session
);
881 pid_to_prc (&inferior_ptid
);
885 /* An object file has just been loaded. Check whether the current
886 application is pthreaded, and if so, prepare for thread debugging. */
893 struct minimal_symbol
*ms
;
895 /* Don't initialize twice. */
899 /* Check application word size. */
900 arch64
= register_size (target_gdbarch (), 0) == 8;
902 /* Check whether the application is pthreaded. */
904 status
= pthdb_session_pthreaded (PD_USER
, PTHDB_FLAG_REGS
,
905 &pd_callbacks
, &stub_name
);
906 if ((status
!= PTHDB_SUCCESS
907 && status
!= PTHDB_NOT_PTHREADED
) || !stub_name
)
910 /* Set a breakpoint on the returned stub function. */
911 if (!(ms
= lookup_minimal_symbol (stub_name
, NULL
, NULL
)))
913 pd_brk_addr
= SYMBOL_VALUE_ADDRESS (ms
);
914 if (!create_thread_event_breakpoint (target_gdbarch (), pd_brk_addr
))
917 /* Prepare for thread debugging. */
918 push_target (&aix_thread_ops
);
921 /* If we're debugging a core file or an attached inferior, the
922 pthread library may already have been initialized, so try to
923 activate thread debugging. */
927 /* Undo the effects of pd_enable(). */
937 unpush_target (&aix_thread_ops
);
940 /* new_objfile observer callback.
942 If OBJFILE is non-null, check whether a threaded application is
943 being debugged, and if so, prepare for thread debugging.
945 If OBJFILE is null, stop debugging threads. */
948 new_objfile (struct objfile
*objfile
)
956 /* Attach to process specified by ARGS. */
959 aix_thread_attach (struct target_ops
*ops
, char *args
, int from_tty
)
961 struct target_ops
*beneath
= find_target_beneath (ops
);
963 beneath
->to_attach (beneath
, args
, from_tty
);
967 /* Detach from the process attached to by aix_thread_attach(). */
970 aix_thread_detach (struct target_ops
*ops
, const char *args
, int from_tty
)
972 struct target_ops
*beneath
= find_target_beneath (ops
);
975 beneath
->to_detach (beneath
, args
, from_tty
);
978 /* Tell the inferior process to continue running thread PID if != -1
979 and all threads otherwise. */
982 aix_thread_resume (struct target_ops
*ops
,
983 ptid_t ptid
, int step
, enum gdb_signal sig
)
985 struct thread_info
*thread
;
990 struct cleanup
*cleanup
= save_inferior_ptid ();
991 struct target_ops
*beneath
= find_target_beneath (ops
);
993 inferior_ptid
= pid_to_ptid (ptid_get_pid (inferior_ptid
));
994 beneath
->to_resume (beneath
, ptid
, step
, sig
);
995 do_cleanups (cleanup
);
999 thread
= find_thread_ptid (ptid
);
1001 error (_("aix-thread resume: unknown pthread %ld"),
1002 ptid_get_lwp (ptid
));
1004 tid
[0] = thread
->private->tid
;
1005 if (tid
[0] == PTHDB_INVALID_TID
)
1006 error (_("aix-thread resume: no tid for pthread %ld"),
1007 ptid_get_lwp (ptid
));
1011 ptrace64aix (PTT_CONTINUE
, tid
[0], (long long) 1,
1012 gdb_signal_to_host (sig
), (void *) tid
);
1014 ptrace32 (PTT_CONTINUE
, tid
[0], (addr_ptr
) 1,
1015 gdb_signal_to_host (sig
), (void *) tid
);
1019 /* Wait for thread/process ID if != -1 or for any thread otherwise.
1020 If an error occurs, return -1, else return the pid of the stopped
1024 aix_thread_wait (struct target_ops
*ops
,
1025 ptid_t ptid
, struct target_waitstatus
*status
, int options
)
1027 struct cleanup
*cleanup
= save_inferior_ptid ();
1028 struct target_ops
*beneath
= find_target_beneath (ops
);
1032 inferior_ptid
= pid_to_ptid (ptid_get_pid (inferior_ptid
));
1033 ptid
= beneath
->to_wait (beneath
, ptid
, status
, options
);
1034 do_cleanups (cleanup
);
1036 if (ptid_get_pid (ptid
) == -1)
1037 return pid_to_ptid (-1);
1039 /* Check whether libpthdebug might be ready to be initialized. */
1040 if (!pd_active
&& status
->kind
== TARGET_WAITKIND_STOPPED
1041 && status
->value
.sig
== GDB_SIGNAL_TRAP
)
1043 struct regcache
*regcache
= get_thread_regcache (ptid
);
1044 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1046 if (regcache_read_pc (regcache
)
1047 - gdbarch_decr_pc_after_break (gdbarch
) == pd_brk_addr
)
1048 return pd_activate (0);
1051 return pd_update (0);
1054 /* Record that the 64-bit general-purpose registers contain VALS. */
1057 supply_gprs64 (struct regcache
*regcache
, uint64_t *vals
)
1059 struct gdbarch_tdep
*tdep
= gdbarch_tdep (get_regcache_arch (regcache
));
1062 for (regno
= 0; regno
< ppc_num_gprs
; regno
++)
1063 regcache_raw_supply (regcache
, tdep
->ppc_gp0_regnum
+ regno
,
1064 (char *) (vals
+ regno
));
1067 /* Record that 32-bit register REGNO contains VAL. */
1070 supply_reg32 (struct regcache
*regcache
, int regno
, uint32_t val
)
1072 regcache_raw_supply (regcache
, regno
, (char *) &val
);
1075 /* Record that the floating-point registers contain VALS. */
1078 supply_fprs (struct regcache
*regcache
, double *vals
)
1080 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1081 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1084 /* This function should never be called on architectures without
1085 floating-point registers. */
1086 gdb_assert (ppc_floating_point_unit_p (gdbarch
));
1088 for (regno
= tdep
->ppc_fp0_regnum
;
1089 regno
< tdep
->ppc_fp0_regnum
+ ppc_num_fprs
;
1091 regcache_raw_supply (regcache
, regno
,
1092 (char *) (vals
+ regno
- tdep
->ppc_fp0_regnum
));
1095 /* Predicate to test whether given register number is a "special" register. */
1097 special_register_p (struct gdbarch
*gdbarch
, int regno
)
1099 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1101 return regno
== gdbarch_pc_regnum (gdbarch
)
1102 || regno
== tdep
->ppc_ps_regnum
1103 || regno
== tdep
->ppc_cr_regnum
1104 || regno
== tdep
->ppc_lr_regnum
1105 || regno
== tdep
->ppc_ctr_regnum
1106 || regno
== tdep
->ppc_xer_regnum
1107 || (tdep
->ppc_fpscr_regnum
>= 0 && regno
== tdep
->ppc_fpscr_regnum
)
1108 || (tdep
->ppc_mq_regnum
>= 0 && regno
== tdep
->ppc_mq_regnum
);
1112 /* Record that the special registers contain the specified 64-bit and
1116 supply_sprs64 (struct regcache
*regcache
,
1117 uint64_t iar
, uint64_t msr
, uint32_t cr
,
1118 uint64_t lr
, uint64_t ctr
, uint32_t xer
,
1121 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1122 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1124 regcache_raw_supply (regcache
, gdbarch_pc_regnum (gdbarch
),
1126 regcache_raw_supply (regcache
, tdep
->ppc_ps_regnum
, (char *) &msr
);
1127 regcache_raw_supply (regcache
, tdep
->ppc_cr_regnum
, (char *) &cr
);
1128 regcache_raw_supply (regcache
, tdep
->ppc_lr_regnum
, (char *) &lr
);
1129 regcache_raw_supply (regcache
, tdep
->ppc_ctr_regnum
, (char *) &ctr
);
1130 regcache_raw_supply (regcache
, tdep
->ppc_xer_regnum
, (char *) &xer
);
1131 if (tdep
->ppc_fpscr_regnum
>= 0)
1132 regcache_raw_supply (regcache
, tdep
->ppc_fpscr_regnum
,
1136 /* Record that the special registers contain the specified 32-bit
1140 supply_sprs32 (struct regcache
*regcache
,
1141 uint32_t iar
, uint32_t msr
, uint32_t cr
,
1142 uint32_t lr
, uint32_t ctr
, uint32_t xer
,
1145 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1146 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1148 regcache_raw_supply (regcache
, gdbarch_pc_regnum (gdbarch
),
1150 regcache_raw_supply (regcache
, tdep
->ppc_ps_regnum
, (char *) &msr
);
1151 regcache_raw_supply (regcache
, tdep
->ppc_cr_regnum
, (char *) &cr
);
1152 regcache_raw_supply (regcache
, tdep
->ppc_lr_regnum
, (char *) &lr
);
1153 regcache_raw_supply (regcache
, tdep
->ppc_ctr_regnum
, (char *) &ctr
);
1154 regcache_raw_supply (regcache
, tdep
->ppc_xer_regnum
, (char *) &xer
);
1155 if (tdep
->ppc_fpscr_regnum
>= 0)
1156 regcache_raw_supply (regcache
, tdep
->ppc_fpscr_regnum
,
1160 /* Fetch all registers from pthread PDTID, which doesn't have a kernel
1163 There's no way to query a single register from a non-kernel
1164 pthread, so there's no need for a single-register version of this
1168 fetch_regs_user_thread (struct regcache
*regcache
, pthdb_pthread_t pdtid
)
1170 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1171 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1173 pthdb_context_t ctx
;
1175 if (debug_aix_thread
)
1176 fprintf_unfiltered (gdb_stdlog
,
1177 "fetch_regs_user_thread %lx\n", (long) pdtid
);
1178 status
= pthdb_pthread_context (pd_session
, pdtid
, &ctx
);
1179 if (status
!= PTHDB_SUCCESS
)
1180 error (_("aix-thread: fetch_registers: pthdb_pthread_context returned %s"),
1181 pd_status2str (status
));
1183 /* General-purpose registers. */
1186 supply_gprs64 (regcache
, ctx
.gpr
);
1188 for (i
= 0; i
< ppc_num_gprs
; i
++)
1189 supply_reg32 (regcache
, tdep
->ppc_gp0_regnum
+ i
, ctx
.gpr
[i
]);
1191 /* Floating-point registers. */
1193 if (ppc_floating_point_unit_p (gdbarch
))
1194 supply_fprs (regcache
, ctx
.fpr
);
1196 /* Special registers. */
1199 supply_sprs64 (regcache
, ctx
.iar
, ctx
.msr
, ctx
.cr
, ctx
.lr
, ctx
.ctr
,
1200 ctx
.xer
, ctx
.fpscr
);
1202 supply_sprs32 (regcache
, ctx
.iar
, ctx
.msr
, ctx
.cr
, ctx
.lr
, ctx
.ctr
,
1203 ctx
.xer
, ctx
.fpscr
);
1206 /* Fetch register REGNO if != -1 or all registers otherwise from
1209 AIX provides a way to query all of a kernel thread's GPRs, FPRs, or
1210 SPRs, but there's no way to query individual registers within those
1211 groups. Therefore, if REGNO != -1, this function fetches an entire
1214 Unfortunately, kernel thread register queries often fail with
1215 EPERM, indicating that the thread is in kernel space. This breaks
1216 backtraces of threads other than the current one. To make that
1217 breakage obvious without throwing an error to top level (which is
1218 bad e.g. during "info threads" output), zero registers that can't
1222 fetch_regs_kernel_thread (struct regcache
*regcache
, int regno
,
1225 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1226 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1227 uint64_t gprs64
[ppc_num_gprs
];
1228 uint32_t gprs32
[ppc_num_gprs
];
1229 double fprs
[ppc_num_fprs
];
1230 struct ptxsprs sprs64
;
1231 struct ptsprs sprs32
;
1234 if (debug_aix_thread
)
1235 fprintf_unfiltered (gdb_stdlog
,
1236 "fetch_regs_kernel_thread tid=%lx regno=%d arch64=%d\n",
1237 (long) tid
, regno
, arch64
);
1239 /* General-purpose registers. */
1241 || (tdep
->ppc_gp0_regnum
<= regno
1242 && regno
< tdep
->ppc_gp0_regnum
+ ppc_num_gprs
))
1246 if (!ptrace64aix (PTT_READ_GPRS
, tid
,
1247 (unsigned long) gprs64
, 0, NULL
))
1248 memset (gprs64
, 0, sizeof (gprs64
));
1249 supply_gprs64 (regcache
, gprs64
);
1253 if (!ptrace32 (PTT_READ_GPRS
, tid
, (uintptr_t) gprs32
, 0, NULL
))
1254 memset (gprs32
, 0, sizeof (gprs32
));
1255 for (i
= 0; i
< ppc_num_gprs
; i
++)
1256 supply_reg32 (regcache
, tdep
->ppc_gp0_regnum
+ i
, gprs32
[i
]);
1260 /* Floating-point registers. */
1262 if (ppc_floating_point_unit_p (gdbarch
)
1264 || (regno
>= tdep
->ppc_fp0_regnum
1265 && regno
< tdep
->ppc_fp0_regnum
+ ppc_num_fprs
)))
1267 if (!ptrace32 (PTT_READ_FPRS
, tid
, (uintptr_t) fprs
, 0, NULL
))
1268 memset (fprs
, 0, sizeof (fprs
));
1269 supply_fprs (regcache
, fprs
);
1272 /* Special-purpose registers. */
1274 if (regno
== -1 || special_register_p (gdbarch
, regno
))
1278 if (!ptrace64aix (PTT_READ_SPRS
, tid
,
1279 (unsigned long) &sprs64
, 0, NULL
))
1280 memset (&sprs64
, 0, sizeof (sprs64
));
1281 supply_sprs64 (regcache
, sprs64
.pt_iar
, sprs64
.pt_msr
,
1282 sprs64
.pt_cr
, sprs64
.pt_lr
, sprs64
.pt_ctr
,
1283 sprs64
.pt_xer
, sprs64
.pt_fpscr
);
1287 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1289 if (!ptrace32 (PTT_READ_SPRS
, tid
, (uintptr_t) &sprs32
, 0, NULL
))
1290 memset (&sprs32
, 0, sizeof (sprs32
));
1291 supply_sprs32 (regcache
, sprs32
.pt_iar
, sprs32
.pt_msr
, sprs32
.pt_cr
,
1292 sprs32
.pt_lr
, sprs32
.pt_ctr
, sprs32
.pt_xer
,
1295 if (tdep
->ppc_mq_regnum
>= 0)
1296 regcache_raw_supply (regcache
, tdep
->ppc_mq_regnum
,
1297 (char *) &sprs32
.pt_mq
);
1302 /* Fetch register REGNO if != -1 or all registers otherwise in the
1303 thread/process specified by inferior_ptid. */
1306 aix_thread_fetch_registers (struct target_ops
*ops
,
1307 struct regcache
*regcache
, int regno
)
1309 struct thread_info
*thread
;
1311 struct target_ops
*beneath
= find_target_beneath (ops
);
1313 if (!PD_TID (inferior_ptid
))
1314 beneath
->to_fetch_registers (beneath
, regcache
, regno
);
1317 thread
= find_thread_ptid (inferior_ptid
);
1318 tid
= thread
->private->tid
;
1320 if (tid
== PTHDB_INVALID_TID
)
1321 fetch_regs_user_thread (regcache
, thread
->private->pdtid
);
1323 fetch_regs_kernel_thread (regcache
, regno
, tid
);
1327 /* Store the gp registers into an array of uint32_t or uint64_t. */
1330 fill_gprs64 (const struct regcache
*regcache
, uint64_t *vals
)
1332 struct gdbarch_tdep
*tdep
= gdbarch_tdep (get_regcache_arch (regcache
));
1335 for (regno
= 0; regno
< ppc_num_gprs
; regno
++)
1336 if (REG_VALID
== regcache_register_status (regcache
,
1337 tdep
->ppc_gp0_regnum
+ regno
))
1338 regcache_raw_collect (regcache
, tdep
->ppc_gp0_regnum
+ regno
,
1343 fill_gprs32 (const struct regcache
*regcache
, uint32_t *vals
)
1345 struct gdbarch_tdep
*tdep
= gdbarch_tdep (get_regcache_arch (regcache
));
1348 for (regno
= 0; regno
< ppc_num_gprs
; regno
++)
1349 if (REG_VALID
== regcache_register_status (regcache
,
1350 tdep
->ppc_gp0_regnum
+ regno
))
1351 regcache_raw_collect (regcache
, tdep
->ppc_gp0_regnum
+ regno
,
1355 /* Store the floating point registers into a double array. */
1357 fill_fprs (const struct regcache
*regcache
, double *vals
)
1359 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1360 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1363 /* This function should never be called on architectures without
1364 floating-point registers. */
1365 gdb_assert (ppc_floating_point_unit_p (gdbarch
));
1367 for (regno
= tdep
->ppc_fp0_regnum
;
1368 regno
< tdep
->ppc_fp0_regnum
+ ppc_num_fprs
;
1370 if (REG_VALID
== regcache_register_status (regcache
, regno
))
1371 regcache_raw_collect (regcache
, regno
,
1372 vals
+ regno
- tdep
->ppc_fp0_regnum
);
1375 /* Store the special registers into the specified 64-bit and 32-bit
1379 fill_sprs64 (const struct regcache
*regcache
,
1380 uint64_t *iar
, uint64_t *msr
, uint32_t *cr
,
1381 uint64_t *lr
, uint64_t *ctr
, uint32_t *xer
,
1384 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1385 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1387 /* Verify that the size of the size of the IAR buffer is the
1388 same as the raw size of the PC (in the register cache). If
1389 they're not, then either GDB has been built incorrectly, or
1390 there's some other kind of internal error. To be really safe,
1391 we should check all of the sizes. */
1392 gdb_assert (sizeof (*iar
) == register_size
1393 (gdbarch
, gdbarch_pc_regnum (gdbarch
)));
1395 if (REG_VALID
== regcache_register_status (regcache
,
1396 gdbarch_pc_regnum (gdbarch
)))
1397 regcache_raw_collect (regcache
, gdbarch_pc_regnum (gdbarch
), iar
);
1398 if (REG_VALID
== regcache_register_status (regcache
, tdep
->ppc_ps_regnum
))
1399 regcache_raw_collect (regcache
, tdep
->ppc_ps_regnum
, msr
);
1400 if (REG_VALID
== regcache_register_status (regcache
, tdep
->ppc_cr_regnum
))
1401 regcache_raw_collect (regcache
, tdep
->ppc_cr_regnum
, cr
);
1402 if (REG_VALID
== regcache_register_status (regcache
, tdep
->ppc_lr_regnum
))
1403 regcache_raw_collect (regcache
, tdep
->ppc_lr_regnum
, lr
);
1404 if (REG_VALID
== regcache_register_status (regcache
, tdep
->ppc_ctr_regnum
))
1405 regcache_raw_collect (regcache
, tdep
->ppc_ctr_regnum
, ctr
);
1406 if (REG_VALID
== regcache_register_status (regcache
, tdep
->ppc_xer_regnum
))
1407 regcache_raw_collect (regcache
, tdep
->ppc_xer_regnum
, xer
);
1408 if (tdep
->ppc_fpscr_regnum
>= 0
1409 && REG_VALID
== regcache_register_status (regcache
,
1410 tdep
->ppc_fpscr_regnum
))
1411 regcache_raw_collect (regcache
, tdep
->ppc_fpscr_regnum
, fpscr
);
1415 fill_sprs32 (const struct regcache
*regcache
,
1416 uint32_t *iar
, uint32_t *msr
, uint32_t *cr
,
1417 uint32_t *lr
, uint32_t *ctr
, uint32_t *xer
,
1420 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1421 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1423 /* Verify that the size of the size of the IAR buffer is the
1424 same as the raw size of the PC (in the register cache). If
1425 they're not, then either GDB has been built incorrectly, or
1426 there's some other kind of internal error. To be really safe,
1427 we should check all of the sizes. */
1428 gdb_assert (sizeof (*iar
) == register_size (gdbarch
,
1429 gdbarch_pc_regnum (gdbarch
)));
1431 if (REG_VALID
== regcache_register_status (regcache
,
1432 gdbarch_pc_regnum (gdbarch
)))
1433 regcache_raw_collect (regcache
, gdbarch_pc_regnum (gdbarch
), iar
);
1434 if (REG_VALID
== regcache_register_status (regcache
, tdep
->ppc_ps_regnum
))
1435 regcache_raw_collect (regcache
, tdep
->ppc_ps_regnum
, msr
);
1436 if (REG_VALID
== regcache_register_status (regcache
, tdep
->ppc_cr_regnum
))
1437 regcache_raw_collect (regcache
, tdep
->ppc_cr_regnum
, cr
);
1438 if (REG_VALID
== regcache_register_status (regcache
, tdep
->ppc_lr_regnum
))
1439 regcache_raw_collect (regcache
, tdep
->ppc_lr_regnum
, lr
);
1440 if (REG_VALID
== regcache_register_status (regcache
, tdep
->ppc_ctr_regnum
))
1441 regcache_raw_collect (regcache
, tdep
->ppc_ctr_regnum
, ctr
);
1442 if (REG_VALID
== regcache_register_status (regcache
, tdep
->ppc_xer_regnum
))
1443 regcache_raw_collect (regcache
, tdep
->ppc_xer_regnum
, xer
);
1444 if (tdep
->ppc_fpscr_regnum
>= 0
1445 && REG_VALID
== regcache_register_status (regcache
, tdep
->ppc_fpscr_regnum
))
1446 regcache_raw_collect (regcache
, tdep
->ppc_fpscr_regnum
, fpscr
);
1449 /* Store all registers into pthread PDTID, which doesn't have a kernel
1452 It's possible to store a single register into a non-kernel pthread,
1453 but I doubt it's worth the effort. */
1456 store_regs_user_thread (const struct regcache
*regcache
, pthdb_pthread_t pdtid
)
1458 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1459 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1461 pthdb_context_t ctx
;
1466 if (debug_aix_thread
)
1467 fprintf_unfiltered (gdb_stdlog
,
1468 "store_regs_user_thread %lx\n", (long) pdtid
);
1470 /* Retrieve the thread's current context for its non-register
1472 status
= pthdb_pthread_context (pd_session
, pdtid
, &ctx
);
1473 if (status
!= PTHDB_SUCCESS
)
1474 error (_("aix-thread: store_registers: pthdb_pthread_context returned %s"),
1475 pd_status2str (status
));
1477 /* Collect general-purpose register values from the regcache. */
1479 for (i
= 0; i
< ppc_num_gprs
; i
++)
1480 if (REG_VALID
== regcache_register_status (regcache
,
1481 tdep
->ppc_gp0_regnum
+ i
))
1485 regcache_raw_collect (regcache
, tdep
->ppc_gp0_regnum
+ i
,
1491 regcache_raw_collect (regcache
, tdep
->ppc_gp0_regnum
+ i
,
1497 /* Collect floating-point register values from the regcache. */
1498 if (ppc_floating_point_unit_p (gdbarch
))
1499 fill_fprs (regcache
, ctx
.fpr
);
1501 /* Special registers (always kept in ctx as 64 bits). */
1504 fill_sprs64 (regcache
, &ctx
.iar
, &ctx
.msr
, &ctx
.cr
, &ctx
.lr
, &ctx
.ctr
,
1505 &ctx
.xer
, &ctx
.fpscr
);
1509 /* Problem: ctx.iar etc. are 64 bits, but raw_registers are 32.
1510 Solution: use 32-bit temp variables. */
1511 uint32_t tmp_iar
, tmp_msr
, tmp_cr
, tmp_lr
, tmp_ctr
, tmp_xer
,
1514 fill_sprs32 (regcache
, &tmp_iar
, &tmp_msr
, &tmp_cr
, &tmp_lr
, &tmp_ctr
,
1515 &tmp_xer
, &tmp_fpscr
);
1516 if (REG_VALID
== regcache_register_status (regcache
,
1517 gdbarch_pc_regnum (gdbarch
)))
1519 if (REG_VALID
== regcache_register_status (regcache
, tdep
->ppc_ps_regnum
))
1521 if (REG_VALID
== regcache_register_status (regcache
, tdep
->ppc_cr_regnum
))
1523 if (REG_VALID
== regcache_register_status (regcache
, tdep
->ppc_lr_regnum
))
1525 if (REG_VALID
== regcache_register_status (regcache
,
1526 tdep
->ppc_ctr_regnum
))
1528 if (REG_VALID
== regcache_register_status (regcache
,
1529 tdep
->ppc_xer_regnum
))
1531 if (REG_VALID
== regcache_register_status (regcache
,
1532 tdep
->ppc_xer_regnum
))
1533 ctx
.fpscr
= tmp_fpscr
;
1536 status
= pthdb_pthread_setcontext (pd_session
, pdtid
, &ctx
);
1537 if (status
!= PTHDB_SUCCESS
)
1538 error (_("aix-thread: store_registers: "
1539 "pthdb_pthread_setcontext returned %s"),
1540 pd_status2str (status
));
1543 /* Store register REGNO if != -1 or all registers otherwise into
1546 AIX provides a way to set all of a kernel thread's GPRs, FPRs, or
1547 SPRs, but there's no way to set individual registers within those
1548 groups. Therefore, if REGNO != -1, this function stores an entire
1552 store_regs_kernel_thread (const struct regcache
*regcache
, int regno
,
1555 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1556 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1557 uint64_t gprs64
[ppc_num_gprs
];
1558 uint32_t gprs32
[ppc_num_gprs
];
1559 double fprs
[ppc_num_fprs
];
1560 struct ptxsprs sprs64
;
1561 struct ptsprs sprs32
;
1564 if (debug_aix_thread
)
1565 fprintf_unfiltered (gdb_stdlog
,
1566 "store_regs_kernel_thread tid=%lx regno=%d\n",
1569 /* General-purpose registers. */
1571 || (tdep
->ppc_gp0_regnum
<= regno
1572 && regno
< tdep
->ppc_gp0_regnum
+ ppc_num_fprs
))
1576 /* Pre-fetch: some regs may not be in the cache. */
1577 ptrace64aix (PTT_READ_GPRS
, tid
, (unsigned long) gprs64
, 0, NULL
);
1578 fill_gprs64 (regcache
, gprs64
);
1579 ptrace64aix (PTT_WRITE_GPRS
, tid
, (unsigned long) gprs64
, 0, NULL
);
1583 /* Pre-fetch: some regs may not be in the cache. */
1584 ptrace32 (PTT_READ_GPRS
, tid
, (uintptr_t) gprs32
, 0, NULL
);
1585 fill_gprs32 (regcache
, gprs32
);
1586 ptrace32 (PTT_WRITE_GPRS
, tid
, (uintptr_t) gprs32
, 0, NULL
);
1590 /* Floating-point registers. */
1592 if (ppc_floating_point_unit_p (gdbarch
)
1594 || (regno
>= tdep
->ppc_fp0_regnum
1595 && regno
< tdep
->ppc_fp0_regnum
+ ppc_num_fprs
)))
1597 /* Pre-fetch: some regs may not be in the cache. */
1598 ptrace32 (PTT_READ_FPRS
, tid
, (uintptr_t) fprs
, 0, NULL
);
1599 fill_fprs (regcache
, fprs
);
1600 ptrace32 (PTT_WRITE_FPRS
, tid
, (uintptr_t) fprs
, 0, NULL
);
1603 /* Special-purpose registers. */
1605 if (regno
== -1 || special_register_p (gdbarch
, regno
))
1609 /* Pre-fetch: some registers won't be in the cache. */
1610 ptrace64aix (PTT_READ_SPRS
, tid
,
1611 (unsigned long) &sprs64
, 0, NULL
);
1612 fill_sprs64 (regcache
, &sprs64
.pt_iar
, &sprs64
.pt_msr
,
1613 &sprs64
.pt_cr
, &sprs64
.pt_lr
, &sprs64
.pt_ctr
,
1614 &sprs64
.pt_xer
, &sprs64
.pt_fpscr
);
1615 ptrace64aix (PTT_WRITE_SPRS
, tid
,
1616 (unsigned long) &sprs64
, 0, NULL
);
1620 /* The contents of "struct ptspr" were declared as "unsigned
1621 long" up to AIX 5.2, but are "unsigned int" since 5.3.
1622 Use temporaries to work around this problem. Also, add an
1623 assert here to make sure we fail if the system header files
1624 use "unsigned long", and the size of that type is not what
1625 the headers expect. */
1626 uint32_t tmp_iar
, tmp_msr
, tmp_cr
, tmp_lr
, tmp_ctr
, tmp_xer
,
1629 gdb_assert (sizeof (sprs32
.pt_iar
) == 4);
1631 /* Pre-fetch: some registers won't be in the cache. */
1632 ptrace32 (PTT_READ_SPRS
, tid
, (uintptr_t) &sprs32
, 0, NULL
);
1634 fill_sprs32 (regcache
, &tmp_iar
, &tmp_msr
, &tmp_cr
, &tmp_lr
,
1635 &tmp_ctr
, &tmp_xer
, &tmp_fpscr
);
1637 sprs32
.pt_iar
= tmp_iar
;
1638 sprs32
.pt_msr
= tmp_msr
;
1639 sprs32
.pt_cr
= tmp_cr
;
1640 sprs32
.pt_lr
= tmp_lr
;
1641 sprs32
.pt_ctr
= tmp_ctr
;
1642 sprs32
.pt_xer
= tmp_xer
;
1643 sprs32
.pt_fpscr
= tmp_fpscr
;
1645 if (tdep
->ppc_mq_regnum
>= 0)
1646 if (REG_VALID
== regcache_register_status (regcache
,
1647 tdep
->ppc_mq_regnum
))
1648 regcache_raw_collect (regcache
, tdep
->ppc_mq_regnum
,
1651 ptrace32 (PTT_WRITE_SPRS
, tid
, (uintptr_t) &sprs32
, 0, NULL
);
1656 /* Store gdb's current view of the register set into the
1657 thread/process specified by inferior_ptid. */
1660 aix_thread_store_registers (struct target_ops
*ops
,
1661 struct regcache
*regcache
, int regno
)
1663 struct thread_info
*thread
;
1665 struct target_ops
*beneath
= find_target_beneath (ops
);
1667 if (!PD_TID (inferior_ptid
))
1668 beneath
->to_store_registers (beneath
, regcache
, regno
);
1671 thread
= find_thread_ptid (inferior_ptid
);
1672 tid
= thread
->private->tid
;
1674 if (tid
== PTHDB_INVALID_TID
)
1675 store_regs_user_thread (regcache
, thread
->private->pdtid
);
1677 store_regs_kernel_thread (regcache
, regno
, tid
);
1681 /* Attempt a transfer all LEN bytes starting at OFFSET between the
1682 inferior's OBJECT:ANNEX space and GDB's READBUF/WRITEBUF buffer.
1683 Return the number of bytes actually transferred. */
1686 aix_thread_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1687 const char *annex
, gdb_byte
*readbuf
,
1688 const gdb_byte
*writebuf
,
1689 ULONGEST offset
, LONGEST len
)
1691 struct cleanup
*old_chain
= save_inferior_ptid ();
1693 struct target_ops
*beneath
= find_target_beneath (ops
);
1695 inferior_ptid
= pid_to_ptid (ptid_get_pid (inferior_ptid
));
1696 xfer
= beneath
->to_xfer_partial (beneath
, object
, annex
,
1697 readbuf
, writebuf
, offset
, len
);
1699 do_cleanups (old_chain
);
1703 /* Clean up after the inferior exits. */
1706 aix_thread_mourn_inferior (struct target_ops
*ops
)
1708 struct target_ops
*beneath
= find_target_beneath (ops
);
1711 beneath
->to_mourn_inferior (beneath
);
1714 /* Return whether thread PID is still valid. */
1717 aix_thread_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
1719 struct target_ops
*beneath
= find_target_beneath (ops
);
1722 return beneath
->to_thread_alive (beneath
, ptid
);
1724 /* We update the thread list every time the child stops, so all
1725 valid threads should be in the thread list. */
1726 return in_thread_list (ptid
);
1729 /* Return a printable representation of composite PID for use in
1730 "info threads" output. */
1733 aix_thread_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
1735 static char *ret
= NULL
;
1736 struct target_ops
*beneath
= find_target_beneath (ops
);
1739 return beneath
->to_pid_to_str (beneath
, ptid
);
1741 /* Free previous return value; a new one will be allocated by
1745 ret
= xstrprintf (_("Thread %ld"), ptid_get_tid (ptid
));
1749 /* Return a printable representation of extra information about
1750 THREAD, for use in "info threads" output. */
1753 aix_thread_extra_thread_info (struct thread_info
*thread
)
1755 struct ui_file
*buf
;
1757 pthdb_pthread_t pdtid
;
1759 pthdb_state_t state
;
1760 pthdb_suspendstate_t suspendstate
;
1761 pthdb_detachstate_t detachstate
;
1763 static char *ret
= NULL
;
1765 if (!PD_TID (thread
->ptid
))
1768 buf
= mem_fileopen ();
1770 pdtid
= thread
->private->pdtid
;
1771 tid
= thread
->private->tid
;
1773 if (tid
!= PTHDB_INVALID_TID
)
1774 /* i18n: Like "thread-identifier %d, [state] running, suspended" */
1775 fprintf_unfiltered (buf
, _("tid %d"), (int)tid
);
1777 status
= pthdb_pthread_state (pd_session
, pdtid
, &state
);
1778 if (status
!= PTHDB_SUCCESS
)
1780 fprintf_unfiltered (buf
, ", %s", state2str (state
));
1782 status
= pthdb_pthread_suspendstate (pd_session
, pdtid
,
1784 if (status
== PTHDB_SUCCESS
&& suspendstate
== PSS_SUSPENDED
)
1785 /* i18n: Like "Thread-Id %d, [state] running, suspended" */
1786 fprintf_unfiltered (buf
, _(", suspended"));
1788 status
= pthdb_pthread_detachstate (pd_session
, pdtid
,
1790 if (status
== PTHDB_SUCCESS
&& detachstate
== PDS_DETACHED
)
1791 /* i18n: Like "Thread-Id %d, [state] running, detached" */
1792 fprintf_unfiltered (buf
, _(", detached"));
1794 pthdb_pthread_cancelpend (pd_session
, pdtid
, &cancelpend
);
1795 if (status
== PTHDB_SUCCESS
&& cancelpend
)
1796 /* i18n: Like "Thread-Id %d, [state] running, cancel pending" */
1797 fprintf_unfiltered (buf
, _(", cancel pending"));
1799 ui_file_write (buf
, "", 1);
1801 xfree (ret
); /* Free old buffer. */
1803 ret
= ui_file_xstrdup (buf
, NULL
);
1804 ui_file_delete (buf
);
1810 aix_thread_get_ada_task_ptid (long lwp
, long thread
)
1812 return ptid_build (ptid_get_pid (inferior_ptid
), 0, thread
);
1815 /* Initialize target aix_thread_ops. */
1818 init_aix_thread_ops (void)
1820 aix_thread_ops
.to_shortname
= "aix-threads";
1821 aix_thread_ops
.to_longname
= _("AIX pthread support");
1822 aix_thread_ops
.to_doc
= _("AIX pthread support");
1824 aix_thread_ops
.to_attach
= aix_thread_attach
;
1825 aix_thread_ops
.to_detach
= aix_thread_detach
;
1826 aix_thread_ops
.to_resume
= aix_thread_resume
;
1827 aix_thread_ops
.to_wait
= aix_thread_wait
;
1828 aix_thread_ops
.to_fetch_registers
= aix_thread_fetch_registers
;
1829 aix_thread_ops
.to_store_registers
= aix_thread_store_registers
;
1830 aix_thread_ops
.to_xfer_partial
= aix_thread_xfer_partial
;
1831 /* No need for aix_thread_ops.to_create_inferior, because we activate thread
1832 debugging when the inferior reaches pd_brk_addr. */
1833 aix_thread_ops
.to_mourn_inferior
= aix_thread_mourn_inferior
;
1834 aix_thread_ops
.to_thread_alive
= aix_thread_thread_alive
;
1835 aix_thread_ops
.to_pid_to_str
= aix_thread_pid_to_str
;
1836 aix_thread_ops
.to_extra_thread_info
= aix_thread_extra_thread_info
;
1837 aix_thread_ops
.to_get_ada_task_ptid
= aix_thread_get_ada_task_ptid
;
1838 aix_thread_ops
.to_stratum
= thread_stratum
;
1839 aix_thread_ops
.to_magic
= OPS_MAGIC
;
1842 /* Module startup initialization function, automagically called by
1845 void _initialize_aix_thread (void);
1848 _initialize_aix_thread (void)
1850 init_aix_thread_ops ();
1851 complete_target_initialization (&aix_thread_ops
);
1853 /* Notice when object files get loaded and unloaded. */
1854 observer_attach_new_objfile (new_objfile
);
1856 add_setshow_boolean_cmd ("aix-thread", class_maintenance
, &debug_aix_thread
,
1857 _("Set debugging of AIX thread module."),
1858 _("Show debugging of AIX thread module."),
1859 _("Enables debugging output (used to debug GDB)."),
1861 /* FIXME: i18n: Debugging of AIX thread
1862 module is \"%d\". */
1863 &setdebuglist
, &showdebuglist
);