1 /* Low level interface for debugging AIX 4.3+ pthreads.
3 Copyright 1999, 2000, 2002 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 2 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, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
24 /* This module uses the libpthdebug.a library provided by AIX 4.3+ for
25 debugging pthread applications.
27 Some name prefix conventions:
28 pthdb_ provided by libpthdebug.a
29 pdc_ callbacks that this module provides to libpthdebug.a
30 pd_ variables or functions interfacing with libpthdebug.a
32 libpthdebug peculiarities:
34 - pthdb_ptid_pthread() is prototyped in <sys/pthdebug.h>, but
35 it's not documented, and after several calls it stops working
36 and causes other libpthdebug functions to fail.
38 - pthdb_tid_pthread() doesn't always work after
39 pthdb_session_update(), but it does work after cycling through
40 all threads using pthdb_pthread().
45 #include "gdb_assert.h"
46 #include "gdbthread.h"
51 #include "language.h" /* for local_hex_string() */
53 #include "gdb_string.h"
56 #include <sys/types.h>
57 #include <sys/ptrace.h>
60 #include <sys/pthdebug.h>
62 /* Whether to emit debugging output. */
63 static int debug_aix_thread
;
65 /* In AIX 5.1, functions use pthdb_tid_t instead of tid_t. */
66 #ifndef PTHDB_VERSION_3
67 #define pthdb_tid_t tid_t
70 /* Return whether to treat PID as a debuggable thread id. */
72 #define PD_TID(ptid) (pd_active && ptid_get_tid (ptid) != 0)
74 /* Build a thread ptid. */
75 #define BUILD_THREAD(TID, PID) ptid_build (PID, 0, TID)
77 /* Build and lwp ptid. */
78 #define BUILD_LWP(LWP, PID) MERGEPID (PID, LWP)
80 /* pthdb_user_t value that we pass to pthdb functions. 0 causes
81 PTHDB_BAD_USER errors, so use 1. */
85 /* Success and failure values returned by pthdb callbacks. */
87 #define PDC_SUCCESS PTHDB_SUCCESS
88 #define PDC_FAILURE PTHDB_CALLBACK
90 /* Private data attached to each element in GDB's thread list. */
92 struct private_thread_info
{
93 pthdb_pthread_t pdtid
; /* thread's libpthdebug id */
94 pthdb_tid_t tid
; /* kernel thread id */
97 /* Information about a thread of which libpthdebug is aware. */
100 pthdb_pthread_t pdtid
;
105 /* This module's target-specific operations, active while pd_able is true. */
107 static struct target_ops aix_thread_ops
;
109 /* Copy of the target over which ops is pushed.
110 This is more convenient than a pointer to child_ops or core_ops,
111 because they lack current_target's default callbacks. */
113 static struct target_ops base_target
;
115 /* Address of the function that libpthread will call when libpthdebug
116 is ready to be initialized. */
118 static CORE_ADDR pd_brk_addr
;
120 /* Whether the current application is debuggable by pthdb. */
122 static int pd_able
= 0;
124 /* Whether a threaded application is being debugged. */
126 static int pd_active
= 0;
128 /* Whether the current architecture is 64-bit.
129 Only valid when pd_able is true. */
133 /* Saved pointer to previous owner of
134 deprecated_target_new_objfile_hook. */
136 static void (*target_new_objfile_chain
)(struct objfile
*);
138 /* Forward declarations for pthdb callbacks. */
140 static int pdc_symbol_addrs (pthdb_user_t
, pthdb_symbol_t
*, int);
141 static int pdc_read_data (pthdb_user_t
, void *, pthdb_addr_t
, size_t);
142 static int pdc_write_data (pthdb_user_t
, void *, pthdb_addr_t
, size_t);
143 static int pdc_read_regs (pthdb_user_t user
, pthdb_tid_t tid
,
144 unsigned long long flags
,
145 pthdb_context_t
*context
);
146 static int pdc_write_regs (pthdb_user_t user
, pthdb_tid_t tid
,
147 unsigned long long flags
,
148 pthdb_context_t
*context
);
149 static int pdc_alloc (pthdb_user_t
, size_t, void **);
150 static int pdc_realloc (pthdb_user_t
, void *, size_t, void **);
151 static int pdc_dealloc (pthdb_user_t
, void *);
153 /* pthdb callbacks. */
155 static pthdb_callbacks_t pd_callbacks
= {
167 /* Current pthdb session. */
169 static pthdb_session_t pd_session
;
171 /* Return a printable representation of pthdebug function return
175 pd_status2str (int status
)
179 case PTHDB_SUCCESS
: return "SUCCESS";
180 case PTHDB_NOSYS
: return "NOSYS";
181 case PTHDB_NOTSUP
: return "NOTSUP";
182 case PTHDB_BAD_VERSION
: return "BAD_VERSION";
183 case PTHDB_BAD_USER
: return "BAD_USER";
184 case PTHDB_BAD_SESSION
: return "BAD_SESSION";
185 case PTHDB_BAD_MODE
: return "BAD_MODE";
186 case PTHDB_BAD_FLAGS
: return "BAD_FLAGS";
187 case PTHDB_BAD_CALLBACK
: return "BAD_CALLBACK";
188 case PTHDB_BAD_POINTER
: return "BAD_POINTER";
189 case PTHDB_BAD_CMD
: return "BAD_CMD";
190 case PTHDB_BAD_PTHREAD
: return "BAD_PTHREAD";
191 case PTHDB_BAD_ATTR
: return "BAD_ATTR";
192 case PTHDB_BAD_MUTEX
: return "BAD_MUTEX";
193 case PTHDB_BAD_MUTEXATTR
: return "BAD_MUTEXATTR";
194 case PTHDB_BAD_COND
: return "BAD_COND";
195 case PTHDB_BAD_CONDATTR
: return "BAD_CONDATTR";
196 case PTHDB_BAD_RWLOCK
: return "BAD_RWLOCK";
197 case PTHDB_BAD_RWLOCKATTR
: return "BAD_RWLOCKATTR";
198 case PTHDB_BAD_KEY
: return "BAD_KEY";
199 case PTHDB_BAD_PTID
: return "BAD_PTID";
200 case PTHDB_BAD_TID
: return "BAD_TID";
201 case PTHDB_CALLBACK
: return "CALLBACK";
202 case PTHDB_CONTEXT
: return "CONTEXT";
203 case PTHDB_HELD
: return "HELD";
204 case PTHDB_NOT_HELD
: return "NOT_HELD";
205 case PTHDB_MEMORY
: return "MEMORY";
206 case PTHDB_NOT_PTHREADED
: return "NOT_PTHREADED";
207 case PTHDB_SYMBOL
: return "SYMBOL";
208 case PTHDB_NOT_AVAIL
: return "NOT_AVAIL";
209 case PTHDB_INTERNAL
: return "INTERNAL";
210 default: return "UNKNOWN";
214 /* A call to ptrace(REQ, ID, ...) just returned RET. Check for
215 exceptional conditions and either return nonlocally or else return
216 1 for success and 0 for failure. */
219 ptrace_check (int req
, int id
, int ret
)
221 if (ret
== 0 && !errno
)
224 /* According to ptrace(2), ptrace may fail with EPERM if "the
225 Identifier parameter corresponds to a kernel thread which is
226 stopped in kernel mode and whose computational state cannot be
227 read or written." This happens quite often with register reads. */
234 if (ret
== -1 && errno
== EPERM
)
236 if (debug_aix_thread
)
237 fprintf_unfiltered (gdb_stdlog
,
238 "ptrace (%d, %d) = %d (errno = %d)\n",
239 req
, id
, ret
, errno
);
240 return ret
== -1 ? 0 : 1;
244 error ("aix-thread: ptrace (%d, %d) returned %d (errno = %d %s)",
245 req
, id
, ret
, errno
, safe_strerror (errno
));
246 return 0; /* Not reached. */
249 /* Call ptracex (REQ, ID, ADDR, DATA, BUF). Return success. */
252 ptrace64aix (int req
, int id
, long long addr
, int data
, int *buf
)
255 return ptrace_check (req
, id
, ptracex (req
, id
, addr
, data
, buf
));
258 /* Call ptrace (REQ, ID, ADDR, DATA, BUF). Return success. */
261 ptrace32 (int req
, int id
, int *addr
, int data
, int *buf
)
264 return ptrace_check (req
, id
,
265 ptrace (req
, id
, (int *) addr
, data
, buf
));
268 /* If *PIDP is a composite process/thread id, convert it to a
272 pid_to_prc (ptid_t
*ptidp
)
278 *ptidp
= pid_to_ptid (PIDGET (ptid
));
281 /* pthdb callback: for <i> from 0 to COUNT, set SYMBOLS[<i>].addr to
282 the address of SYMBOLS[<i>].name. */
285 pdc_symbol_addrs (pthdb_user_t user
, pthdb_symbol_t
*symbols
, int count
)
287 struct minimal_symbol
*ms
;
291 if (debug_aix_thread
)
292 fprintf_unfiltered (gdb_stdlog
,
293 "pdc_symbol_addrs (user = %ld, symbols = 0x%lx, count = %d)\n",
294 user
, (long) symbols
, count
);
296 for (i
= 0; i
< count
; i
++)
298 name
= symbols
[i
].name
;
299 if (debug_aix_thread
)
300 fprintf_unfiltered (gdb_stdlog
,
301 " symbols[%d].name = \"%s\"\n", i
, name
);
307 if (!(ms
= lookup_minimal_symbol (name
, NULL
, NULL
)))
309 if (debug_aix_thread
)
310 fprintf_unfiltered (gdb_stdlog
, " returning PDC_FAILURE\n");
313 symbols
[i
].addr
= SYMBOL_VALUE_ADDRESS (ms
);
315 if (debug_aix_thread
)
316 fprintf_unfiltered (gdb_stdlog
, " symbols[%d].addr = %s\n",
317 i
, local_hex_string (symbols
[i
].addr
));
319 if (debug_aix_thread
)
320 fprintf_unfiltered (gdb_stdlog
, " returning PDC_SUCCESS\n");
324 /* Read registers call back function should be able to read the
325 context information of a debuggee kernel thread from an active
326 process or from a core file. The information should be formatted
327 in context64 form for both 32-bit and 64-bit process.
328 If successful return 0, else non-zero is returned. */
331 pdc_read_regs (pthdb_user_t user
,
333 unsigned long long flags
,
334 pthdb_context_t
*context
)
336 /* This function doesn't appear to be used, so we could probably
337 just return 0 here. HOWEVER, if it is not defined, the OS will
338 complain and several thread debug functions will fail. In case
339 this is needed, I have implemented what I think it should do,
340 however this code is untested. */
342 uint64_t gprs64
[ppc_num_gprs
];
343 uint32_t gprs32
[ppc_num_gprs
];
344 double fprs
[ppc_num_fprs
];
345 struct ptxsprs sprs64
;
346 struct ptsprs sprs32
;
348 if (debug_aix_thread
)
349 fprintf_unfiltered (gdb_stdlog
, "pdc_read_regs tid=%d flags=%s\n",
350 (int) tid
, local_hex_string (flags
));
352 /* General-purpose registers. */
353 if (flags
& PTHDB_FLAG_GPRS
)
357 if (!ptrace64aix (PTT_READ_GPRS
, tid
,
358 (unsigned long) gprs64
, 0, NULL
))
359 memset (gprs64
, 0, sizeof (gprs64
));
360 memcpy (context
->gpr
, gprs64
, sizeof(gprs64
));
364 if (!ptrace32 (PTT_READ_GPRS
, tid
, gprs32
, 0, NULL
))
365 memset (gprs32
, 0, sizeof (gprs32
));
366 memcpy (context
->gpr
, gprs32
, sizeof(gprs32
));
370 /* Floating-point registers. */
371 if (flags
& PTHDB_FLAG_FPRS
)
373 if (!ptrace32 (PTT_READ_FPRS
, tid
, (int *) fprs
, 0, NULL
))
374 memset (fprs
, 0, sizeof (fprs
));
375 memcpy (context
->fpr
, fprs
, sizeof(fprs
));
378 /* Special-purpose registers. */
379 if (flags
& PTHDB_FLAG_SPRS
)
383 if (!ptrace64aix (PTT_READ_SPRS
, tid
,
384 (unsigned long) &sprs64
, 0, NULL
))
385 memset (&sprs64
, 0, sizeof (sprs64
));
386 memcpy (&context
->msr
, &sprs64
, sizeof(sprs64
));
390 if (!ptrace32 (PTT_READ_SPRS
, tid
, (int *) &sprs32
, 0, NULL
))
391 memset (&sprs32
, 0, sizeof (sprs32
));
392 memcpy (&context
->msr
, &sprs32
, sizeof(sprs32
));
398 /* Write register function should be able to write requested context
399 information to specified debuggee's kernel thread id.
400 If successful return 0, else non-zero is returned. */
403 pdc_write_regs (pthdb_user_t user
,
405 unsigned long long flags
,
406 pthdb_context_t
*context
)
408 /* This function doesn't appear to be used, so we could probably
409 just return 0 here. HOWEVER, if it is not defined, the OS will
410 complain and several thread debug functions will fail. In case
411 this is needed, I have implemented what I think it should do,
412 however this code is untested. */
414 if (debug_aix_thread
)
415 fprintf_unfiltered (gdb_stdlog
, "pdc_write_regs tid=%d flags=%s\n",
416 (int) tid
, local_hex_string (flags
));
418 /* General-purpose registers. */
419 if (flags
& PTHDB_FLAG_GPRS
)
422 ptrace64aix (PTT_WRITE_GPRS
, tid
,
423 (unsigned long) context
->gpr
, 0, NULL
);
425 ptrace32 (PTT_WRITE_GPRS
, tid
, (int *) context
->gpr
, 0, NULL
);
428 /* Floating-point registers. */
429 if (flags
& PTHDB_FLAG_FPRS
)
431 ptrace32 (PTT_WRITE_FPRS
, tid
, (int *) context
->fpr
, 0, NULL
);
434 /* Special-purpose registers. */
435 if (flags
& PTHDB_FLAG_SPRS
)
439 ptrace64aix (PTT_WRITE_SPRS
, tid
,
440 (unsigned long) &context
->msr
, 0, NULL
);
444 ptrace32 (PTT_WRITE_SPRS
, tid
, (int *) &context
->msr
, 0, NULL
);
450 /* pthdb callback: read LEN bytes from process ADDR into BUF. */
453 pdc_read_data (pthdb_user_t user
, void *buf
,
454 pthdb_addr_t addr
, size_t len
)
458 if (debug_aix_thread
)
459 fprintf_unfiltered (gdb_stdlog
,
460 "pdc_read_data (user = %ld, buf = 0x%lx, addr = %s, len = %ld)\n",
461 user
, (long) buf
, local_hex_string (addr
), len
);
463 status
= target_read_memory (addr
, buf
, len
);
464 ret
= status
== 0 ? PDC_SUCCESS
: PDC_FAILURE
;
466 if (debug_aix_thread
)
467 fprintf_unfiltered (gdb_stdlog
, " status=%d, returning %s\n",
468 status
, pd_status2str (ret
));
472 /* pthdb callback: write LEN bytes from BUF to process ADDR. */
475 pdc_write_data (pthdb_user_t user
, void *buf
,
476 pthdb_addr_t addr
, size_t len
)
480 if (debug_aix_thread
)
481 fprintf_unfiltered (gdb_stdlog
,
482 "pdc_write_data (user = %ld, buf = 0x%lx, addr = %s, len = %ld)\n",
483 user
, (long) buf
, local_hex_string (addr
), len
);
485 status
= target_write_memory (addr
, buf
, len
);
486 ret
= status
== 0 ? PDC_SUCCESS
: PDC_FAILURE
;
488 if (debug_aix_thread
)
489 fprintf_unfiltered (gdb_stdlog
, " status=%d, returning %s\n", status
,
490 pd_status2str (ret
));
494 /* pthdb callback: allocate a LEN-byte buffer and store a pointer to it
498 pdc_alloc (pthdb_user_t user
, size_t len
, void **bufp
)
500 if (debug_aix_thread
)
501 fprintf_unfiltered (gdb_stdlog
,
502 "pdc_alloc (user = %ld, len = %ld, bufp = 0x%lx)\n",
503 user
, len
, (long) bufp
);
504 *bufp
= xmalloc (len
);
505 if (debug_aix_thread
)
506 fprintf_unfiltered (gdb_stdlog
,
507 " malloc returned 0x%lx\n", (long) *bufp
);
509 /* Note: xmalloc() can't return 0; therefore PDC_FAILURE will never
512 return *bufp
? PDC_SUCCESS
: PDC_FAILURE
;
515 /* pthdb callback: reallocate BUF, which was allocated by the alloc or
516 realloc callback, so that it contains LEN bytes, and store a
517 pointer to the result in BUFP. */
520 pdc_realloc (pthdb_user_t user
, void *buf
, size_t len
, void **bufp
)
522 if (debug_aix_thread
)
523 fprintf_unfiltered (gdb_stdlog
,
524 "pdc_realloc (user = %ld, buf = 0x%lx, len = %ld, bufp = 0x%lx)\n",
525 user
, (long) buf
, len
, (long) bufp
);
526 *bufp
= xrealloc (buf
, len
);
527 if (debug_aix_thread
)
528 fprintf_unfiltered (gdb_stdlog
,
529 " realloc returned 0x%lx\n", (long) *bufp
);
530 return *bufp
? PDC_SUCCESS
: PDC_FAILURE
;
533 /* pthdb callback: free BUF, which was allocated by the alloc or
537 pdc_dealloc (pthdb_user_t user
, void *buf
)
539 if (debug_aix_thread
)
540 fprintf_unfiltered (gdb_stdlog
,
541 "pdc_free (user = %ld, buf = 0x%lx)\n", user
,
547 /* Return a printable representation of pthread STATE. */
550 state2str (pthdb_state_t state
)
554 case PST_IDLE
: return "idle"; /* being created */
555 case PST_RUN
: return "running"; /* running */
556 case PST_SLEEP
: return "sleeping"; /* awaiting an event */
557 case PST_READY
: return "ready"; /* runnable */
558 case PST_TERM
: return "finished"; /* awaiting a join/detach */
559 default: return "unknown";
563 /* qsort() comparison function for sorting pd_thread structs by pthid. */
566 pcmp (const void *p1v
, const void *p2v
)
568 struct pd_thread
*p1
= (struct pd_thread
*) p1v
;
569 struct pd_thread
*p2
= (struct pd_thread
*) p2v
;
570 return p1
->pthid
< p2
->pthid
? -1 : p1
->pthid
> p2
->pthid
;
573 /* iterate_over_threads() callback for counting GDB threads. */
576 giter_count (struct thread_info
*thread
, void *countp
)
582 /* iterate_over_threads() callback for accumulating GDB thread pids. */
585 giter_accum (struct thread_info
*thread
, void *bufp
)
587 **(struct thread_info
***) bufp
= thread
;
588 (*(struct thread_info
***) bufp
)++;
592 /* ptid comparison function */
595 ptid_cmp (ptid_t ptid1
, ptid_t ptid2
)
599 if (ptid_get_pid (ptid1
) < ptid_get_pid (ptid2
))
601 else if (ptid_get_pid (ptid1
) > ptid_get_pid (ptid2
))
603 else if (ptid_get_tid (ptid1
) < ptid_get_tid (ptid2
))
605 else if (ptid_get_tid (ptid1
) > ptid_get_tid (ptid2
))
607 else if (ptid_get_lwp (ptid1
) < ptid_get_lwp (ptid2
))
609 else if (ptid_get_lwp (ptid1
) > ptid_get_lwp (ptid2
))
615 /* qsort() comparison function for sorting thread_info structs by pid. */
618 gcmp (const void *t1v
, const void *t2v
)
620 struct thread_info
*t1
= *(struct thread_info
**) t1v
;
621 struct thread_info
*t2
= *(struct thread_info
**) t2v
;
622 return ptid_cmp (t1
->ptid
, t2
->ptid
);
625 /* Synchronize GDB's thread list with libpthdebug's.
627 There are some benefits of doing this every time the inferior stops:
629 - allows users to run thread-specific commands without needing to
630 run "info threads" first
632 - helps pthdb_tid_pthread() work properly (see "libpthdebug
633 peculiarities" at the top of this module)
635 - simplifies the demands placed on libpthdebug, which seems to
636 have difficulty with certain call patterns */
639 sync_threadlists (void)
641 int cmd
, status
, infpid
;
642 int pcount
, psize
, pi
, gcount
, gi
;
643 struct pd_thread
*pbuf
;
644 struct thread_info
**gbuf
, **g
, *thread
;
645 pthdb_pthread_t pdtid
;
649 /* Accumulate an array of libpthdebug threads sorted by pthread id. */
653 pbuf
= (struct pd_thread
*) xmalloc (psize
* sizeof *pbuf
);
655 for (cmd
= PTHDB_LIST_FIRST
;; cmd
= PTHDB_LIST_NEXT
)
657 status
= pthdb_pthread (pd_session
, &pdtid
, cmd
);
658 if (status
!= PTHDB_SUCCESS
|| pdtid
== PTHDB_INVALID_PTHREAD
)
661 status
= pthdb_pthread_ptid (pd_session
, pdtid
, &pthid
);
662 if (status
!= PTHDB_SUCCESS
|| pthid
== PTHDB_INVALID_PTID
)
668 pbuf
= (struct pd_thread
*) xrealloc (pbuf
,
669 psize
* sizeof *pbuf
);
671 pbuf
[pcount
].pdtid
= pdtid
;
672 pbuf
[pcount
].pthid
= pthid
;
676 for (pi
= 0; pi
< pcount
; pi
++)
678 status
= pthdb_pthread_tid (pd_session
, pbuf
[pi
].pdtid
, &tid
);
679 if (status
!= PTHDB_SUCCESS
)
680 tid
= PTHDB_INVALID_TID
;
684 qsort (pbuf
, pcount
, sizeof *pbuf
, pcmp
);
686 /* Accumulate an array of GDB threads sorted by pid. */
689 iterate_over_threads (giter_count
, &gcount
);
690 g
= gbuf
= (struct thread_info
**) xmalloc (gcount
* sizeof *gbuf
);
691 iterate_over_threads (giter_accum
, &g
);
692 qsort (gbuf
, gcount
, sizeof *gbuf
, gcmp
);
694 /* Apply differences between the two arrays to GDB's thread list. */
696 infpid
= PIDGET (inferior_ptid
);
697 for (pi
= gi
= 0; pi
< pcount
|| gi
< gcount
;)
701 delete_thread (gbuf
[gi
]->ptid
);
704 else if (gi
== gcount
)
706 thread
= add_thread (BUILD_THREAD (pbuf
[pi
].pthid
, infpid
));
707 thread
->private = xmalloc (sizeof (struct private_thread_info
));
708 thread
->private->pdtid
= pbuf
[pi
].pdtid
;
709 thread
->private->tid
= pbuf
[pi
].tid
;
717 pptid
= BUILD_THREAD (pbuf
[pi
].pthid
, infpid
);
718 gptid
= gbuf
[gi
]->ptid
;
719 pdtid
= pbuf
[pi
].pdtid
;
722 cmp_result
= ptid_cmp (pptid
, gptid
);
726 gbuf
[gi
]->private->pdtid
= pdtid
;
727 gbuf
[gi
]->private->tid
= tid
;
731 else if (cmp_result
> 0)
733 delete_thread (gptid
);
738 thread
= add_thread (pptid
);
739 thread
->private = xmalloc (sizeof (struct private_thread_info
));
740 thread
->private->pdtid
= pdtid
;
741 thread
->private->tid
= tid
;
751 /* Iterate_over_threads() callback for locating a thread whose kernel
752 thread just received a trap signal. */
755 iter_trap (struct thread_info
*thread
, void *unused
)
757 struct thrdsinfo64 thrinf
;
760 /* getthrds(3) isn't prototyped in any AIX 4.3.3 #include file. */
761 extern int getthrds (pid_t
, struct thrdsinfo64
*,
762 int, pthdb_tid_t
*, int);
764 tid
= thread
->private->tid
;
765 if (tid
== PTHDB_INVALID_TID
)
768 if (getthrds (PIDGET (inferior_ptid
), &thrinf
,
769 sizeof (thrinf
), &tid
, 1) != 1)
772 return thrinf
.ti_cursig
== SIGTRAP
;
775 /* Synchronize libpthdebug's state with the inferior and with GDB,
776 generate a composite process/thread <pid> for the current thread,
777 set inferior_ptid to <pid> if SET_INFPID, and return <pid>. */
780 pd_update (int set_infpid
)
784 struct thread_info
*thread
;
787 return inferior_ptid
;
789 status
= pthdb_session_update (pd_session
);
790 if (status
!= PTHDB_SUCCESS
)
791 return inferior_ptid
;
795 /* Define "current thread" as one that just received a trap signal. */
797 thread
= iterate_over_threads (iter_trap
, NULL
);
799 ptid
= inferior_ptid
;
804 inferior_ptid
= ptid
;
809 /* Try to start debugging threads in the current process.
810 If successful and SET_INFPID, set inferior_ptid to reflect the
814 pd_activate (int set_infpid
)
818 status
= pthdb_session_init (PD_USER
, arch64
? PEM_64BIT
: PEM_32BIT
,
819 PTHDB_FLAG_REGS
, &pd_callbacks
,
821 if (status
!= PTHDB_SUCCESS
)
823 return inferior_ptid
;
826 return pd_update (set_infpid
);
829 /* Undo the effects of pd_activate(). */
836 pthdb_session_destroy (pd_session
);
838 pid_to_prc (&inferior_ptid
);
842 /* An object file has just been loaded. Check whether the current
843 application is pthreaded, and if so, prepare for thread debugging. */
850 struct minimal_symbol
*ms
;
852 /* Don't initialize twice. */
856 /* Check application word size. */
857 arch64
= register_size (current_gdbarch
, 0) == 8;
859 /* Check whether the application is pthreaded. */
861 status
= pthdb_session_pthreaded (PD_USER
, PTHDB_FLAG_REGS
,
862 &pd_callbacks
, &stub_name
);
863 if ((status
!= PTHDB_SUCCESS
&&
864 status
!= PTHDB_NOT_PTHREADED
) || !stub_name
)
867 /* Set a breakpoint on the returned stub function. */
868 if (!(ms
= lookup_minimal_symbol (stub_name
, NULL
, NULL
)))
870 pd_brk_addr
= SYMBOL_VALUE_ADDRESS (ms
);
871 if (!create_thread_event_breakpoint (pd_brk_addr
))
874 /* Prepare for thread debugging. */
875 base_target
= current_target
;
876 push_target (&aix_thread_ops
);
879 /* If we're debugging a core file or an attached inferior, the
880 pthread library may already have been initialized, so try to
881 activate thread debugging. */
885 /* Undo the effects of pd_enable(). */
895 unpush_target (&aix_thread_ops
);
898 /* deprecated_target_new_objfile_hook callback.
900 If OBJFILE is non-null, check whether a threaded application is
901 being debugged, and if so, prepare for thread debugging.
903 If OBJFILE is null, stop debugging threads. */
906 new_objfile (struct objfile
*objfile
)
913 if (target_new_objfile_chain
)
914 target_new_objfile_chain (objfile
);
917 /* Attach to process specified by ARGS. */
920 aix_thread_attach (char *args
, int from_tty
)
922 base_target
.to_attach (args
, from_tty
);
926 /* Detach from the process attached to by aix_thread_attach(). */
929 aix_thread_detach (char *args
, int from_tty
)
932 base_target
.to_detach (args
, from_tty
);
935 /* Tell the inferior process to continue running thread PID if != -1
936 and all threads otherwise. */
939 aix_thread_resume (ptid_t ptid
, int step
, enum target_signal sig
)
941 struct thread_info
*thread
;
946 struct cleanup
*cleanup
= save_inferior_ptid ();
947 inferior_ptid
= pid_to_ptid (PIDGET (inferior_ptid
));
948 base_target
.to_resume (ptid
, step
, sig
);
949 do_cleanups (cleanup
);
953 thread
= find_thread_pid (ptid
);
955 error ("aix-thread resume: unknown pthread %ld",
958 tid
[0] = thread
->private->tid
;
959 if (tid
[0] == PTHDB_INVALID_TID
)
960 error ("aix-thread resume: no tid for pthread %ld",
965 ptrace64aix (PTT_CONTINUE
, tid
[0], 1,
966 target_signal_to_host (sig
), (int *) tid
);
968 ptrace32 (PTT_CONTINUE
, tid
[0], (int *) 1,
969 target_signal_to_host (sig
), (int *) tid
);
973 /* Wait for thread/process ID if != -1 or for any thread otherwise.
974 If an error occurs, return -1, else return the pid of the stopped
978 aix_thread_wait (ptid_t ptid
, struct target_waitstatus
*status
)
980 struct cleanup
*cleanup
= save_inferior_ptid ();
984 inferior_ptid
= pid_to_ptid (PIDGET (inferior_ptid
));
985 ptid
= base_target
.to_wait (ptid
, status
);
986 do_cleanups (cleanup
);
988 if (PIDGET (ptid
) == -1)
989 return pid_to_ptid (-1);
991 /* Check whether libpthdebug might be ready to be initialized. */
992 if (!pd_active
&& status
->kind
== TARGET_WAITKIND_STOPPED
&&
993 status
->value
.sig
== TARGET_SIGNAL_TRAP
&&
994 read_pc_pid (ptid
) - DECR_PC_AFTER_BREAK
== pd_brk_addr
)
995 return pd_activate (0);
997 return pd_update (0);
1000 /* Record that the 64-bit general-purpose registers contain VALS. */
1003 supply_gprs64 (uint64_t *vals
)
1005 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
1008 for (regno
= 0; regno
< ppc_num_gprs
; regno
++)
1009 regcache_raw_supply (current_regcache
, tdep
->ppc_gp0_regnum
+ regno
,
1010 (char *) (vals
+ regno
));
1013 /* Record that 32-bit register REGNO contains VAL. */
1016 supply_reg32 (int regno
, uint32_t val
)
1018 regcache_raw_supply (current_regcache
, regno
, (char *) &val
);
1021 /* Record that the floating-point registers contain VALS. */
1024 supply_fprs (double *vals
)
1026 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
1029 /* This function should never be called on architectures without
1030 floating-point registers. */
1031 gdb_assert (ppc_floating_point_unit_p (current_gdbarch
));
1033 for (regno
= 0; regno
< ppc_num_fprs
; regno
++)
1034 regcache_raw_supply (current_regcache
, regno
+ tdep
->ppc_fp0_regnum
,
1035 (char *) (vals
+ regno
));
1038 /* Predicate to test whether given register number is a "special" register. */
1040 special_register_p (int regno
)
1042 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
1044 return regno
== PC_REGNUM
1045 || regno
== tdep
->ppc_ps_regnum
1046 || regno
== tdep
->ppc_cr_regnum
1047 || regno
== tdep
->ppc_lr_regnum
1048 || regno
== tdep
->ppc_ctr_regnum
1049 || regno
== tdep
->ppc_xer_regnum
1050 || (tdep
->ppc_fpscr_regnum
>= 0 && regno
== tdep
->ppc_fpscr_regnum
)
1051 || (tdep
->ppc_mq_regnum
>= 0 && regno
== tdep
->ppc_mq_regnum
);
1055 /* Record that the special registers contain the specified 64-bit and
1059 supply_sprs64 (uint64_t iar
, uint64_t msr
, uint32_t cr
,
1060 uint64_t lr
, uint64_t ctr
, uint32_t xer
,
1063 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
1065 regcache_raw_supply (current_regcache
, PC_REGNUM
, (char *) &iar
);
1066 regcache_raw_supply (current_regcache
, tdep
->ppc_ps_regnum
, (char *) &msr
);
1067 regcache_raw_supply (current_regcache
, tdep
->ppc_cr_regnum
, (char *) &cr
);
1068 regcache_raw_supply (current_regcache
, tdep
->ppc_lr_regnum
, (char *) &lr
);
1069 regcache_raw_supply (current_regcache
, tdep
->ppc_ctr_regnum
, (char *) &ctr
);
1070 regcache_raw_supply (current_regcache
, tdep
->ppc_xer_regnum
, (char *) &xer
);
1071 if (tdep
->ppc_fpscr_regnum
>= 0)
1072 regcache_raw_supply (current_regcache
, tdep
->ppc_fpscr_regnum
,
1076 /* Record that the special registers contain the specified 32-bit
1080 supply_sprs32 (uint32_t iar
, uint32_t msr
, uint32_t cr
,
1081 uint32_t lr
, uint32_t ctr
, uint32_t xer
,
1084 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
1086 regcache_raw_supply (current_regcache
, PC_REGNUM
, (char *) &iar
);
1087 regcache_raw_supply (current_regcache
, tdep
->ppc_ps_regnum
, (char *) &msr
);
1088 regcache_raw_supply (current_regcache
, tdep
->ppc_cr_regnum
, (char *) &cr
);
1089 regcache_raw_supply (current_regcache
, tdep
->ppc_lr_regnum
, (char *) &lr
);
1090 regcache_raw_supply (current_regcache
, tdep
->ppc_ctr_regnum
, (char *) &ctr
);
1091 regcache_raw_supply (current_regcache
, tdep
->ppc_xer_regnum
, (char *) &xer
);
1092 if (tdep
->ppc_fpscr_regnum
>= 0)
1093 regcache_raw_supply (current_regcache
, tdep
->ppc_fpscr_regnum
,
1097 /* Fetch all registers from pthread PDTID, which doesn't have a kernel
1100 There's no way to query a single register from a non-kernel
1101 pthread, so there's no need for a single-register version of this
1105 fetch_regs_user_thread (pthdb_pthread_t pdtid
)
1107 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
1109 pthdb_context_t ctx
;
1111 if (debug_aix_thread
)
1112 fprintf_unfiltered (gdb_stdlog
,
1113 "fetch_regs_user_thread %lx\n", (long) pdtid
);
1114 status
= pthdb_pthread_context (pd_session
, pdtid
, &ctx
);
1115 if (status
!= PTHDB_SUCCESS
)
1116 error ("aix-thread: fetch_registers: pthdb_pthread_context returned %s",
1117 pd_status2str (status
));
1119 /* General-purpose registers. */
1122 supply_gprs64 (ctx
.gpr
);
1124 for (i
= 0; i
< ppc_num_gprs
; i
++)
1125 supply_reg32 (tdep
->ppc_gp0_regnum
+ i
, ctx
.gpr
[i
]);
1127 /* Floating-point registers. */
1129 if (ppc_floating_point_unit_p (current_gdbarch
))
1130 supply_fprs (ctx
.fpr
);
1132 /* Special registers. */
1135 supply_sprs64 (ctx
.iar
, ctx
.msr
, ctx
.cr
, ctx
.lr
, ctx
.ctr
, ctx
.xer
,
1138 supply_sprs32 (ctx
.iar
, ctx
.msr
, ctx
.cr
, ctx
.lr
, ctx
.ctr
, ctx
.xer
,
1142 /* Fetch register REGNO if != -1 or all registers otherwise from
1145 AIX provides a way to query all of a kernel thread's GPRs, FPRs, or
1146 SPRs, but there's no way to query individual registers within those
1147 groups. Therefore, if REGNO != -1, this function fetches an entire
1150 Unfortunately, kernel thread register queries often fail with
1151 EPERM, indicating that the thread is in kernel space. This breaks
1152 backtraces of threads other than the current one. To make that
1153 breakage obvious without throwing an error to top level (which is
1154 bad e.g. during "info threads" output), zero registers that can't
1158 fetch_regs_kernel_thread (int regno
, pthdb_tid_t tid
)
1160 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
1161 uint64_t gprs64
[ppc_num_gprs
];
1162 uint32_t gprs32
[ppc_num_gprs
];
1163 double fprs
[ppc_num_fprs
];
1164 struct ptxsprs sprs64
;
1165 struct ptsprs sprs32
;
1168 if (debug_aix_thread
)
1169 fprintf_unfiltered (gdb_stdlog
,
1170 "fetch_regs_kernel_thread tid=%lx regno=%d arch64=%d\n",
1171 (long) tid
, regno
, arch64
);
1173 /* General-purpose registers. */
1175 || (tdep
->ppc_gp0_regnum
<= regno
1176 && regno
< tdep
->ppc_gp0_regnum
+ ppc_num_gprs
))
1180 if (!ptrace64aix (PTT_READ_GPRS
, tid
,
1181 (unsigned long) gprs64
, 0, NULL
))
1182 memset (gprs64
, 0, sizeof (gprs64
));
1183 supply_gprs64 (gprs64
);
1187 if (!ptrace32 (PTT_READ_GPRS
, tid
, gprs32
, 0, NULL
))
1188 memset (gprs32
, 0, sizeof (gprs32
));
1189 for (i
= 0; i
< ppc_num_gprs
; i
++)
1190 supply_reg32 (tdep
->ppc_gp0_regnum
+ i
, gprs32
[i
]);
1194 /* Floating-point registers. */
1196 if (ppc_floating_point_unit_p (current_gdbarch
)
1198 || (regno
>= tdep
->ppc_fp0_regnum
1199 && regno
< tdep
->ppc_fp0_regnum
+ ppc_num_fprs
)))
1201 if (!ptrace32 (PTT_READ_FPRS
, tid
, (int *) fprs
, 0, NULL
))
1202 memset (fprs
, 0, sizeof (fprs
));
1206 /* Special-purpose registers. */
1208 if (regno
== -1 || special_register_p (regno
))
1212 if (!ptrace64aix (PTT_READ_SPRS
, tid
,
1213 (unsigned long) &sprs64
, 0, NULL
))
1214 memset (&sprs64
, 0, sizeof (sprs64
));
1215 supply_sprs64 (sprs64
.pt_iar
, sprs64
.pt_msr
, sprs64
.pt_cr
,
1216 sprs64
.pt_lr
, sprs64
.pt_ctr
, sprs64
.pt_xer
,
1221 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
1223 if (!ptrace32 (PTT_READ_SPRS
, tid
, (int *) &sprs32
, 0, NULL
))
1224 memset (&sprs32
, 0, sizeof (sprs32
));
1225 supply_sprs32 (sprs32
.pt_iar
, sprs32
.pt_msr
, sprs32
.pt_cr
,
1226 sprs32
.pt_lr
, sprs32
.pt_ctr
, sprs32
.pt_xer
,
1229 if (tdep
->ppc_mq_regnum
>= 0)
1230 regcache_raw_supply (current_regcache
, tdep
->ppc_mq_regnum
,
1231 (char *) &sprs32
.pt_mq
);
1236 /* Fetch register REGNO if != -1 or all registers otherwise in the
1237 thread/process specified by inferior_ptid. */
1240 aix_thread_fetch_registers (int regno
)
1242 struct thread_info
*thread
;
1245 if (!PD_TID (inferior_ptid
))
1246 base_target
.to_fetch_registers (regno
);
1249 thread
= find_thread_pid (inferior_ptid
);
1250 tid
= thread
->private->tid
;
1252 if (tid
== PTHDB_INVALID_TID
)
1253 fetch_regs_user_thread (thread
->private->pdtid
);
1255 fetch_regs_kernel_thread (regno
, tid
);
1259 /* Store the gp registers into an array of uint32_t or uint64_t. */
1262 fill_gprs64 (uint64_t *vals
)
1264 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
1267 for (regno
= 0; regno
< ppc_num_gprs
; regno
++)
1268 if (register_cached (tdep
->ppc_gp0_regnum
+ regno
))
1269 regcache_raw_collect (current_regcache
, tdep
->ppc_gp0_regnum
+ regno
,
1274 fill_gprs32 (uint32_t *vals
)
1276 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
1279 for (regno
= 0; regno
< ppc_num_gprs
; regno
++)
1280 if (register_cached (tdep
->ppc_gp0_regnum
+ regno
))
1281 regcache_raw_collect (current_regcache
, tdep
->ppc_gp0_regnum
+ regno
,
1285 /* Store the floating point registers into a double array. */
1287 fill_fprs (double *vals
)
1289 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
1292 /* This function should never be called on architectures without
1293 floating-point registers. */
1294 gdb_assert (ppc_floating_point_unit_p (current_gdbarch
));
1296 for (regno
= tdep
->ppc_fp0_regnum
;
1297 regno
< tdep
->ppc_fp0_regnum
+ ppc_num_fprs
;
1299 if (register_cached (regno
))
1300 regcache_raw_collect (current_regcache
, regno
, vals
+ regno
);
1303 /* Store the special registers into the specified 64-bit and 32-bit
1307 fill_sprs64 (uint64_t *iar
, uint64_t *msr
, uint32_t *cr
,
1308 uint64_t *lr
, uint64_t *ctr
, uint32_t *xer
,
1311 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
1313 /* Verify that the size of the size of the IAR buffer is the
1314 same as the raw size of the PC (in the register cache). If
1315 they're not, then either GDB has been built incorrectly, or
1316 there's some other kind of internal error. To be really safe,
1317 we should check all of the sizes. */
1318 gdb_assert (sizeof (*iar
) == register_size (current_gdbarch
, PC_REGNUM
));
1320 if (register_cached (PC_REGNUM
))
1321 regcache_raw_collect (current_regcache
, PC_REGNUM
, iar
);
1322 if (register_cached (tdep
->ppc_ps_regnum
))
1323 regcache_raw_collect (current_regcache
, tdep
->ppc_ps_regnum
, msr
);
1324 if (register_cached (tdep
->ppc_cr_regnum
))
1325 regcache_raw_collect (current_regcache
, tdep
->ppc_cr_regnum
, cr
);
1326 if (register_cached (tdep
->ppc_lr_regnum
))
1327 regcache_raw_collect (current_regcache
, tdep
->ppc_lr_regnum
, lr
);
1328 if (register_cached (tdep
->ppc_ctr_regnum
))
1329 regcache_raw_collect (current_regcache
, tdep
->ppc_ctr_regnum
, ctr
);
1330 if (register_cached (tdep
->ppc_xer_regnum
))
1331 regcache_raw_collect (current_regcache
, tdep
->ppc_xer_regnum
, xer
);
1332 if (tdep
->ppc_fpscr_regnum
>= 0
1333 && register_cached (tdep
->ppc_fpscr_regnum
))
1334 regcache_raw_collect (current_regcache
, tdep
->ppc_fpscr_regnum
, fpscr
);
1338 fill_sprs32 (unsigned long *iar
, unsigned long *msr
, unsigned long *cr
,
1339 unsigned long *lr
, unsigned long *ctr
, unsigned long *xer
,
1340 unsigned long *fpscr
)
1342 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
1344 /* Verify that the size of the size of the IAR buffer is the
1345 same as the raw size of the PC (in the register cache). If
1346 they're not, then either GDB has been built incorrectly, or
1347 there's some other kind of internal error. To be really safe,
1348 we should check all of the sizes.
1350 If this assert() fails, the most likely reason is that GDB was
1351 built incorrectly. In order to make use of many of the header
1352 files in /usr/include/sys, GDB needs to be configured so that
1353 sizeof (long) == 4). */
1354 gdb_assert (sizeof (*iar
) == register_size (current_gdbarch
, PC_REGNUM
));
1356 if (register_cached (PC_REGNUM
))
1357 regcache_raw_collect (current_regcache
, PC_REGNUM
, iar
);
1358 if (register_cached (tdep
->ppc_ps_regnum
))
1359 regcache_raw_collect (current_regcache
, tdep
->ppc_ps_regnum
, msr
);
1360 if (register_cached (tdep
->ppc_cr_regnum
))
1361 regcache_raw_collect (current_regcache
, tdep
->ppc_cr_regnum
, cr
);
1362 if (register_cached (tdep
->ppc_lr_regnum
))
1363 regcache_raw_collect (current_regcache
, tdep
->ppc_lr_regnum
, lr
);
1364 if (register_cached (tdep
->ppc_ctr_regnum
))
1365 regcache_raw_collect (current_regcache
, tdep
->ppc_ctr_regnum
, ctr
);
1366 if (register_cached (tdep
->ppc_xer_regnum
))
1367 regcache_raw_collect (current_regcache
, tdep
->ppc_xer_regnum
, xer
);
1368 if (tdep
->ppc_fpscr_regnum
>= 0
1369 && register_cached (tdep
->ppc_fpscr_regnum
))
1370 regcache_raw_collect (current_regcache
, tdep
->ppc_fpscr_regnum
, fpscr
);
1373 /* Store all registers into pthread PDTID, which doesn't have a kernel
1376 It's possible to store a single register into a non-kernel pthread,
1377 but I doubt it's worth the effort. */
1380 store_regs_user_thread (pthdb_pthread_t pdtid
)
1382 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
1384 pthdb_context_t ctx
;
1389 if (debug_aix_thread
)
1390 fprintf_unfiltered (gdb_stdlog
,
1391 "store_regs_user_thread %lx\n", (long) pdtid
);
1393 /* Retrieve the thread's current context for its non-register
1395 status
= pthdb_pthread_context (pd_session
, pdtid
, &ctx
);
1396 if (status
!= PTHDB_SUCCESS
)
1397 error ("aix-thread: store_registers: pthdb_pthread_context returned %s",
1398 pd_status2str (status
));
1400 /* Collect general-purpose register values from the regcache. */
1402 for (i
= 0; i
< ppc_num_gprs
; i
++)
1403 if (register_cached (tdep
->ppc_gp0_regnum
+ i
))
1407 regcache_raw_collect (current_regcache
, tdep
->ppc_gp0_regnum
+ i
,
1413 regcache_raw_collect (current_regcache
, tdep
->ppc_gp0_regnum
+ i
,
1419 /* Collect floating-point register values from the regcache. */
1420 if (ppc_floating_point_unit_p (current_gdbarch
))
1421 fill_fprs (ctx
.fpr
);
1423 /* Special registers (always kept in ctx as 64 bits). */
1426 fill_sprs64 (&ctx
.iar
, &ctx
.msr
, &ctx
.cr
, &ctx
.lr
, &ctx
.ctr
, &ctx
.xer
,
1431 /* Problem: ctx.iar etc. are 64 bits, but raw_registers are 32.
1432 Solution: use 32-bit temp variables. (The assert() in fill_sprs32()
1433 will fail if the size of an unsigned long is incorrect. If this
1434 happens, GDB needs to be reconfigured so that longs are 32-bits.) */
1435 unsigned long tmp_iar
, tmp_msr
, tmp_cr
, tmp_lr
, tmp_ctr
, tmp_xer
,
1438 fill_sprs32 (&tmp_iar
, &tmp_msr
, &tmp_cr
, &tmp_lr
, &tmp_ctr
, &tmp_xer
,
1440 if (register_cached (PC_REGNUM
))
1442 if (register_cached (tdep
->ppc_ps_regnum
))
1444 if (register_cached (tdep
->ppc_cr_regnum
))
1446 if (register_cached (tdep
->ppc_lr_regnum
))
1448 if (register_cached (tdep
->ppc_ctr_regnum
))
1450 if (register_cached (tdep
->ppc_xer_regnum
))
1452 if (register_cached (tdep
->ppc_xer_regnum
))
1453 ctx
.fpscr
= tmp_fpscr
;
1456 status
= pthdb_pthread_setcontext (pd_session
, pdtid
, &ctx
);
1457 if (status
!= PTHDB_SUCCESS
)
1458 error ("aix-thread: store_registers: pthdb_pthread_setcontext returned %s",
1459 pd_status2str (status
));
1462 /* Store register REGNO if != -1 or all registers otherwise into
1465 AIX provides a way to set all of a kernel thread's GPRs, FPRs, or
1466 SPRs, but there's no way to set individual registers within those
1467 groups. Therefore, if REGNO != -1, this function stores an entire
1471 store_regs_kernel_thread (int regno
, pthdb_tid_t tid
)
1473 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
1474 uint64_t gprs64
[ppc_num_gprs
];
1475 uint32_t gprs32
[ppc_num_gprs
];
1476 double fprs
[ppc_num_fprs
];
1477 struct ptxsprs sprs64
;
1478 struct ptsprs sprs32
;
1481 if (debug_aix_thread
)
1482 fprintf_unfiltered (gdb_stdlog
,
1483 "store_regs_kernel_thread tid=%lx regno=%d\n",
1486 /* General-purpose registers. */
1488 || (tdep
->ppc_gp0_regnum
<= regno
1489 && regno
< tdep
->ppc_gp0_regnum
+ ppc_num_fprs
))
1493 /* Pre-fetch: some regs may not be in the cache. */
1494 ptrace64aix (PTT_READ_GPRS
, tid
, (unsigned long) gprs64
, 0, NULL
);
1495 fill_gprs64 (gprs64
);
1496 ptrace64aix (PTT_WRITE_GPRS
, tid
, (unsigned long) gprs64
, 0, NULL
);
1500 /* Pre-fetch: some regs may not be in the cache. */
1501 ptrace32 (PTT_READ_GPRS
, tid
, gprs32
, 0, NULL
);
1502 fill_gprs32 (gprs32
);
1503 ptrace32 (PTT_WRITE_GPRS
, tid
, gprs32
, 0, NULL
);
1507 /* Floating-point registers. */
1509 if (ppc_floating_point_unit_p (current_gdbarch
)
1511 || (regno
>= tdep
->ppc_fp0_regnum
1512 && regno
< tdep
->ppc_fp0_regnum
+ ppc_num_fprs
)))
1514 /* Pre-fetch: some regs may not be in the cache. */
1515 ptrace32 (PTT_READ_FPRS
, tid
, (int *) fprs
, 0, NULL
);
1517 ptrace32 (PTT_WRITE_FPRS
, tid
, (int *) fprs
, 0, NULL
);
1520 /* Special-purpose registers. */
1522 if (regno
== -1 || special_register_p (regno
))
1526 /* Pre-fetch: some registers won't be in the cache. */
1527 ptrace64aix (PTT_READ_SPRS
, tid
,
1528 (unsigned long) &sprs64
, 0, NULL
);
1529 fill_sprs64 (&sprs64
.pt_iar
, &sprs64
.pt_msr
, &sprs64
.pt_cr
,
1530 &sprs64
.pt_lr
, &sprs64
.pt_ctr
, &sprs64
.pt_xer
,
1532 ptrace64aix (PTT_WRITE_SPRS
, tid
,
1533 (unsigned long) &sprs64
, 0, NULL
);
1537 /* Pre-fetch: some registers won't be in the cache. */
1538 ptrace32 (PTT_READ_SPRS
, tid
, (int *) &sprs32
, 0, NULL
);
1540 fill_sprs32 (&sprs32
.pt_iar
, &sprs32
.pt_msr
, &sprs32
.pt_cr
,
1541 &sprs32
.pt_lr
, &sprs32
.pt_ctr
, &sprs32
.pt_xer
,
1544 if (tdep
->ppc_mq_regnum
>= 0)
1545 if (register_cached (tdep
->ppc_mq_regnum
))
1546 regcache_raw_collect (current_regcache
, tdep
->ppc_mq_regnum
,
1549 ptrace32 (PTT_WRITE_SPRS
, tid
, (int *) &sprs32
, 0, NULL
);
1554 /* Store gdb's current view of the register set into the
1555 thread/process specified by inferior_ptid. */
1558 aix_thread_store_registers (int regno
)
1560 struct thread_info
*thread
;
1563 if (!PD_TID (inferior_ptid
))
1564 base_target
.to_store_registers (regno
);
1567 thread
= find_thread_pid (inferior_ptid
);
1568 tid
= thread
->private->tid
;
1570 if (tid
== PTHDB_INVALID_TID
)
1571 store_regs_user_thread (thread
->private->pdtid
);
1573 store_regs_kernel_thread (regno
, tid
);
1577 /* Transfer LEN bytes of memory from GDB address MYADDR to target
1578 address MEMADDR if WRITE and vice versa otherwise. */
1581 aix_thread_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
1582 struct mem_attrib
*attrib
,
1583 struct target_ops
*target
)
1586 struct cleanup
*cleanup
= save_inferior_ptid ();
1588 inferior_ptid
= pid_to_ptid (PIDGET (inferior_ptid
));
1589 n
= base_target
.to_xfer_memory (memaddr
, myaddr
, len
,
1590 write
, attrib
, &base_target
);
1591 do_cleanups (cleanup
);
1596 /* Kill and forget about the inferior process. */
1599 aix_thread_kill (void)
1601 struct cleanup
*cleanup
= save_inferior_ptid ();
1603 inferior_ptid
= pid_to_ptid (PIDGET (inferior_ptid
));
1604 base_target
.to_kill ();
1605 do_cleanups (cleanup
);
1608 /* Clean up after the inferior exits. */
1611 aix_thread_mourn_inferior (void)
1614 base_target
.to_mourn_inferior ();
1617 /* Return whether thread PID is still valid. */
1620 aix_thread_thread_alive (ptid_t ptid
)
1623 return base_target
.to_thread_alive (ptid
);
1625 /* We update the thread list every time the child stops, so all
1626 valid threads should be in the thread list. */
1627 return in_thread_list (ptid
);
1630 /* Return a printable representation of composite PID for use in
1631 "info threads" output. */
1634 aix_thread_pid_to_str (ptid_t ptid
)
1636 static char *ret
= NULL
;
1639 return base_target
.to_pid_to_str (ptid
);
1641 /* Free previous return value; a new one will be allocated by
1645 ret
= xstrprintf ("Thread %ld", ptid_get_tid (ptid
));
1649 /* Return a printable representation of extra information about
1650 THREAD, for use in "info threads" output. */
1653 aix_thread_extra_thread_info (struct thread_info
*thread
)
1655 struct ui_file
*buf
;
1657 pthdb_pthread_t pdtid
;
1659 pthdb_state_t state
;
1660 pthdb_suspendstate_t suspendstate
;
1661 pthdb_detachstate_t detachstate
;
1664 static char *ret
= NULL
;
1666 if (!PD_TID (thread
->ptid
))
1669 buf
= mem_fileopen ();
1671 pdtid
= thread
->private->pdtid
;
1672 tid
= thread
->private->tid
;
1674 if (tid
!= PTHDB_INVALID_TID
)
1675 fprintf_unfiltered (buf
, "tid %d", tid
);
1677 status
= pthdb_pthread_state (pd_session
, pdtid
, &state
);
1678 if (status
!= PTHDB_SUCCESS
)
1680 fprintf_unfiltered (buf
, ", %s", state2str (state
));
1682 status
= pthdb_pthread_suspendstate (pd_session
, pdtid
,
1684 if (status
== PTHDB_SUCCESS
&& suspendstate
== PSS_SUSPENDED
)
1685 fprintf_unfiltered (buf
, ", suspended");
1687 status
= pthdb_pthread_detachstate (pd_session
, pdtid
,
1689 if (status
== PTHDB_SUCCESS
&& detachstate
== PDS_DETACHED
)
1690 fprintf_unfiltered (buf
, ", detached");
1692 pthdb_pthread_cancelpend (pd_session
, pdtid
, &cancelpend
);
1693 if (status
== PTHDB_SUCCESS
&& cancelpend
)
1694 fprintf_unfiltered (buf
, ", cancel pending");
1696 ui_file_write (buf
, "", 1);
1698 xfree (ret
); /* Free old buffer. */
1700 ret
= ui_file_xstrdup (buf
, &length
);
1701 ui_file_delete (buf
);
1706 /* Initialize target aix_thread_ops. */
1709 init_aix_thread_ops (void)
1711 aix_thread_ops
.to_shortname
= "aix-threads";
1712 aix_thread_ops
.to_longname
= "AIX pthread support";
1713 aix_thread_ops
.to_doc
= "AIX pthread support";
1715 aix_thread_ops
.to_attach
= aix_thread_attach
;
1716 aix_thread_ops
.to_detach
= aix_thread_detach
;
1717 aix_thread_ops
.to_resume
= aix_thread_resume
;
1718 aix_thread_ops
.to_wait
= aix_thread_wait
;
1719 aix_thread_ops
.to_fetch_registers
= aix_thread_fetch_registers
;
1720 aix_thread_ops
.to_store_registers
= aix_thread_store_registers
;
1721 aix_thread_ops
.to_xfer_memory
= aix_thread_xfer_memory
;
1722 /* No need for aix_thread_ops.to_create_inferior, because we activate thread
1723 debugging when the inferior reaches pd_brk_addr. */
1724 aix_thread_ops
.to_kill
= aix_thread_kill
;
1725 aix_thread_ops
.to_mourn_inferior
= aix_thread_mourn_inferior
;
1726 aix_thread_ops
.to_thread_alive
= aix_thread_thread_alive
;
1727 aix_thread_ops
.to_pid_to_str
= aix_thread_pid_to_str
;
1728 aix_thread_ops
.to_extra_thread_info
= aix_thread_extra_thread_info
;
1729 aix_thread_ops
.to_stratum
= thread_stratum
;
1730 aix_thread_ops
.to_magic
= OPS_MAGIC
;
1733 /* Module startup initialization function, automagically called by
1737 _initialize_aix_thread (void)
1739 init_aix_thread_ops ();
1740 add_target (&aix_thread_ops
);
1742 /* Notice when object files get loaded and unloaded. */
1743 target_new_objfile_chain
= deprecated_target_new_objfile_hook
;
1744 deprecated_target_new_objfile_hook
= new_objfile
;
1746 deprecated_add_show_from_set
1747 (add_set_cmd ("aix-thread", no_class
, var_zinteger
,
1748 (char *) &debug_aix_thread
,
1749 "Set debugging of AIX thread module.\n"
1750 "Enables printf debugging output.\n",