projects / deliverable / binutils-gdb.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
2004-08-02 Andrew Cagney <cagney@gnu.org>
[deliverable/binutils-gdb.git] / gdb / aix-thread.c
... / ...
CommitLineData
1/* Low level interface for debugging AIX 4.3+ pthreads.
2
3 Copyright 1999, 2000, 2002 Free Software Foundation, Inc.
4 Written by Nick Duffek <nsd@redhat.com>.
5
6 This file is part of GDB.
7
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.
12
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.
17
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. */
22
23
24/* This module uses the libpthdebug.a library provided by AIX 4.3+ for
25 debugging pthread applications.
26
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
31
32 libpthdebug peculiarities:
33
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.
37
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().
41
42 */
43
44#include "defs.h"
45#include "gdb_assert.h"
46#include "gdbthread.h"
47#include "target.h"
48#include "inferior.h"
49#include "regcache.h"
50#include "gdbcmd.h"
51#include "language.h" /* for local_hex_string() */
52#include "ppc-tdep.h"
53#include "gdb_string.h"
54
55#include <procinfo.h>
56#include <sys/types.h>
57#include <sys/ptrace.h>
58#include <sys/reg.h>
59#include <sched.h>
60#include <sys/pthdebug.h>
61
62/* Whether to emit debugging output. */
63static int debug_aix_thread;
64
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
68#endif
69
70/* Return whether to treat PID as a debuggable thread id. */
71
72#define PD_TID(ptid) (pd_active && ptid_get_tid (ptid) != 0)
73
74/* Build a thread ptid. */
75#define BUILD_THREAD(TID, PID) ptid_build (PID, 0, TID)
76
77/* Build and lwp ptid. */
78#define BUILD_LWP(LWP, PID) MERGEPID (PID, LWP)
79
80/* pthdb_user_t value that we pass to pthdb functions. 0 causes
81 PTHDB_BAD_USER errors, so use 1. */
82
83#define PD_USER 1
84
85/* Success and failure values returned by pthdb callbacks. */
86
87#define PDC_SUCCESS PTHDB_SUCCESS
88#define PDC_FAILURE PTHDB_CALLBACK
89
90/* Private data attached to each element in GDB's thread list. */
91
92struct private_thread_info {
93 pthdb_pthread_t pdtid; /* thread's libpthdebug id */
94 pthdb_tid_t tid; /* kernel thread id */
95};
96
97/* Information about a thread of which libpthdebug is aware. */
98
99struct pd_thread {
100 pthdb_pthread_t pdtid;
101 pthread_t pthid;
102 pthdb_tid_t tid;
103};
104
105/* This module's target-specific operations, active while pd_able is true. */
106
107static struct target_ops aix_thread_ops;
108
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. */
112
113static struct target_ops base_target;
114
115/* Address of the function that libpthread will call when libpthdebug
116 is ready to be initialized. */
117
118static CORE_ADDR pd_brk_addr;
119
120/* Whether the current application is debuggable by pthdb. */
121
122static int pd_able = 0;
123
124/* Whether a threaded application is being debugged. */
125
126static int pd_active = 0;
127
128/* Whether the current architecture is 64-bit.
129 Only valid when pd_able is true. */
130
131static int arch64;
132
133/* Saved pointer to previous owner of
134 deprecated_target_new_objfile_hook. */
135
136static void (*target_new_objfile_chain)(struct objfile *);
137
138/* Forward declarations for pthdb callbacks. */
139
140static int pdc_symbol_addrs (pthdb_user_t, pthdb_symbol_t *, int);
141static int pdc_read_data (pthdb_user_t, void *, pthdb_addr_t, size_t);
142static int pdc_write_data (pthdb_user_t, void *, pthdb_addr_t, size_t);
143static int pdc_read_regs (pthdb_user_t user, pthdb_tid_t tid,
144 unsigned long long flags,
145 pthdb_context_t *context);
146static int pdc_write_regs (pthdb_user_t user, pthdb_tid_t tid,
147 unsigned long long flags,
148 pthdb_context_t *context);
149static int pdc_alloc (pthdb_user_t, size_t, void **);
150static int pdc_realloc (pthdb_user_t, void *, size_t, void **);
151static int pdc_dealloc (pthdb_user_t, void *);
152
153/* pthdb callbacks. */
154
155static pthdb_callbacks_t pd_callbacks = {
156 pdc_symbol_addrs,
157 pdc_read_data,
158 pdc_write_data,
159 pdc_read_regs,
160 pdc_write_regs,
161 pdc_alloc,
162 pdc_realloc,
163 pdc_dealloc,
164 NULL
165};
166
167/* Current pthdb session. */
168
169static pthdb_session_t pd_session;
170
171/* Return a printable representation of pthdebug function return
172 STATUS. */
173
174static char *
175pd_status2str (int status)
176{
177 switch (status)
178 {
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";
211 }
212}
213
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. */
217
218static int
219ptrace_check (int req, int id, int ret)
220{
221 if (ret == 0 && !errno)
222 return 1;
223
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. */
228
229 switch (req)
230 {
231 case PTT_READ_GPRS:
232 case PTT_READ_FPRS:
233 case PTT_READ_SPRS:
234 if (ret == -1 && errno == EPERM)
235 {
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;
241 }
242 break;
243 }
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. */
247}
248
249/* Call ptracex (REQ, ID, ADDR, DATA, BUF). Return success. */
250
251static int
252ptrace64aix (int req, int id, long long addr, int data, int *buf)
253{
254 errno = 0;
255 return ptrace_check (req, id, ptracex (req, id, addr, data, buf));
256}
257
258/* Call ptrace (REQ, ID, ADDR, DATA, BUF). Return success. */
259
260static int
261ptrace32 (int req, int id, int *addr, int data, int *buf)
262{
263 errno = 0;
264 return ptrace_check (req, id,
265 ptrace (req, id, (int *) addr, data, buf));
266}
267
268/* If *PIDP is a composite process/thread id, convert it to a
269 process id. */
270
271static void
272pid_to_prc (ptid_t *ptidp)
273{
274 ptid_t ptid;
275
276 ptid = *ptidp;
277 if (PD_TID (ptid))
278 *ptidp = pid_to_ptid (PIDGET (ptid));
279}
280
281/* pthdb callback: for <i> from 0 to COUNT, set SYMBOLS[<i>].addr to
282 the address of SYMBOLS[<i>].name. */
283
284static int
285pdc_symbol_addrs (pthdb_user_t user, pthdb_symbol_t *symbols, int count)
286{
287 struct minimal_symbol *ms;
288 int i;
289 char *name;
290
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);
295
296 for (i = 0; i < count; i++)
297 {
298 name = symbols[i].name;
299 if (debug_aix_thread)
300 fprintf_unfiltered (gdb_stdlog,
301 " symbols[%d].name = \"%s\"\n", i, name);
302
303 if (!*name)
304 symbols[i].addr = 0;
305 else
306 {
307 if (!(ms = lookup_minimal_symbol (name, NULL, NULL)))
308 {
309 if (debug_aix_thread)
310 fprintf_unfiltered (gdb_stdlog, " returning PDC_FAILURE\n");
311 return PDC_FAILURE;
312 }
313 symbols[i].addr = SYMBOL_VALUE_ADDRESS (ms);
314 }
315 if (debug_aix_thread)
316 fprintf_unfiltered (gdb_stdlog, " symbols[%d].addr = %s\n",
317 i, local_hex_string (symbols[i].addr));
318 }
319 if (debug_aix_thread)
320 fprintf_unfiltered (gdb_stdlog, " returning PDC_SUCCESS\n");
321 return PDC_SUCCESS;
322}
323
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. */
329
330static int
331pdc_read_regs (pthdb_user_t user,
332 pthdb_tid_t tid,
333 unsigned long long flags,
334 pthdb_context_t *context)
335{
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. */
341
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;
347
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));
351
352 /* General-purpose registers. */
353 if (flags & PTHDB_FLAG_GPRS)
354 {
355 if (arch64)
356 {
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));
361 }
362 else
363 {
364 if (!ptrace32 (PTT_READ_GPRS, tid, gprs32, 0, NULL))
365 memset (gprs32, 0, sizeof (gprs32));
366 memcpy (context->gpr, gprs32, sizeof(gprs32));
367 }
368 }
369
370 /* Floating-point registers. */
371 if (flags & PTHDB_FLAG_FPRS)
372 {
373 if (!ptrace32 (PTT_READ_FPRS, tid, (int *) fprs, 0, NULL))
374 memset (fprs, 0, sizeof (fprs));
375 memcpy (context->fpr, fprs, sizeof(fprs));
376 }
377
378 /* Special-purpose registers. */
379 if (flags & PTHDB_FLAG_SPRS)
380 {
381 if (arch64)
382 {
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));
387 }
388 else
389 {
390 if (!ptrace32 (PTT_READ_SPRS, tid, (int *) &sprs32, 0, NULL))
391 memset (&sprs32, 0, sizeof (sprs32));
392 memcpy (&context->msr, &sprs32, sizeof(sprs32));
393 }
394 }
395 return 0;
396}
397
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. */
401
402static int
403pdc_write_regs (pthdb_user_t user,
404 pthdb_tid_t tid,
405 unsigned long long flags,
406 pthdb_context_t *context)
407{
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. */
413
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));
417
418 /* General-purpose registers. */
419 if (flags & PTHDB_FLAG_GPRS)
420 {
421 if (arch64)
422 ptrace64aix (PTT_WRITE_GPRS, tid,
423 (unsigned long) context->gpr, 0, NULL);
424 else
425 ptrace32 (PTT_WRITE_GPRS, tid, (int *) context->gpr, 0, NULL);
426 }
427
428 /* Floating-point registers. */
429 if (flags & PTHDB_FLAG_FPRS)
430 {
431 ptrace32 (PTT_WRITE_FPRS, tid, (int *) context->fpr, 0, NULL);
432 }
433
434 /* Special-purpose registers. */
435 if (flags & PTHDB_FLAG_SPRS)
436 {
437 if (arch64)
438 {
439 ptrace64aix (PTT_WRITE_SPRS, tid,
440 (unsigned long) &context->msr, 0, NULL);
441 }
442 else
443 {
444 ptrace32 (PTT_WRITE_SPRS, tid, (int *) &context->msr, 0, NULL);
445 }
446 }
447 return 0;
448}
449
450/* pthdb callback: read LEN bytes from process ADDR into BUF. */
451
452static int
453pdc_read_data (pthdb_user_t user, void *buf,
454 pthdb_addr_t addr, size_t len)
455{
456 int status, ret;
457
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);
462
463 status = target_read_memory (addr, buf, len);
464 ret = status == 0 ? PDC_SUCCESS : PDC_FAILURE;
465
466 if (debug_aix_thread)
467 fprintf_unfiltered (gdb_stdlog, " status=%d, returning %s\n",
468 status, pd_status2str (ret));
469 return ret;
470}
471
472/* pthdb callback: write LEN bytes from BUF to process ADDR. */
473
474static int
475pdc_write_data (pthdb_user_t user, void *buf,
476 pthdb_addr_t addr, size_t len)
477{
478 int status, ret;
479
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);
484
485 status = target_write_memory (addr, buf, len);
486 ret = status == 0 ? PDC_SUCCESS : PDC_FAILURE;
487
488 if (debug_aix_thread)
489 fprintf_unfiltered (gdb_stdlog, " status=%d, returning %s\n", status,
490 pd_status2str (ret));
491 return ret;
492}
493
494/* pthdb callback: allocate a LEN-byte buffer and store a pointer to it
495 in BUFP. */
496
497static int
498pdc_alloc (pthdb_user_t user, size_t len, void **bufp)
499{
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);
508
509 /* Note: xmalloc() can't return 0; therefore PDC_FAILURE will never
510 be returned. */
511
512 return *bufp ? PDC_SUCCESS : PDC_FAILURE;
513}
514
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. */
518
519static int
520pdc_realloc (pthdb_user_t user, void *buf, size_t len, void **bufp)
521{
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;
531}
532
533/* pthdb callback: free BUF, which was allocated by the alloc or
534 realloc callback. */
535
536static int
537pdc_dealloc (pthdb_user_t user, void *buf)
538{
539 if (debug_aix_thread)
540 fprintf_unfiltered (gdb_stdlog,
541 "pdc_free (user = %ld, buf = 0x%lx)\n", user,
542 (long) buf);
543 xfree (buf);
544 return PDC_SUCCESS;
545}
546
547/* Return a printable representation of pthread STATE. */
548
549static char *
550state2str (pthdb_state_t state)
551{
552 switch (state)
553 {
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";
560 }
561}
562
563/* qsort() comparison function for sorting pd_thread structs by pthid. */
564
565static int
566pcmp (const void *p1v, const void *p2v)
567{
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;
571}
572
573/* iterate_over_threads() callback for counting GDB threads. */
574
575static int
576giter_count (struct thread_info *thread, void *countp)
577{
578 (*(int *) countp)++;
579 return 0;
580}
581
582/* iterate_over_threads() callback for accumulating GDB thread pids. */
583
584static int
585giter_accum (struct thread_info *thread, void *bufp)
586{
587 **(struct thread_info ***) bufp = thread;
588 (*(struct thread_info ***) bufp)++;
589 return 0;
590}
591
592/* ptid comparison function */
593
594static int
595ptid_cmp (ptid_t ptid1, ptid_t ptid2)
596{
597 int pid1, pid2;
598
599 if (ptid_get_pid (ptid1) < ptid_get_pid (ptid2))
600 return -1;
601 else if (ptid_get_pid (ptid1) > ptid_get_pid (ptid2))
602 return 1;
603 else if (ptid_get_tid (ptid1) < ptid_get_tid (ptid2))
604 return -1;
605 else if (ptid_get_tid (ptid1) > ptid_get_tid (ptid2))
606 return 1;
607 else if (ptid_get_lwp (ptid1) < ptid_get_lwp (ptid2))
608 return -1;
609 else if (ptid_get_lwp (ptid1) > ptid_get_lwp (ptid2))
610 return 1;
611 else
612 return 0;
613}
614
615/* qsort() comparison function for sorting thread_info structs by pid. */
616
617static int
618gcmp (const void *t1v, const void *t2v)
619{
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);
623}
624
625/* Synchronize GDB's thread list with libpthdebug's.
626
627 There are some benefits of doing this every time the inferior stops:
628
629 - allows users to run thread-specific commands without needing to
630 run "info threads" first
631
632 - helps pthdb_tid_pthread() work properly (see "libpthdebug
633 peculiarities" at the top of this module)
634
635 - simplifies the demands placed on libpthdebug, which seems to
636 have difficulty with certain call patterns */
637
638static void
639sync_threadlists (void)
640{
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;
646 pthread_t pthid;
647 pthdb_tid_t tid;
648
649 /* Accumulate an array of libpthdebug threads sorted by pthread id. */
650
651 pcount = 0;
652 psize = 1;
653 pbuf = (struct pd_thread *) xmalloc (psize * sizeof *pbuf);
654
655 for (cmd = PTHDB_LIST_FIRST;; cmd = PTHDB_LIST_NEXT)
656 {
657 status = pthdb_pthread (pd_session, &pdtid, cmd);
658 if (status != PTHDB_SUCCESS || pdtid == PTHDB_INVALID_PTHREAD)
659 break;
660
661 status = pthdb_pthread_ptid (pd_session, pdtid, &pthid);
662 if (status != PTHDB_SUCCESS || pthid == PTHDB_INVALID_PTID)
663 continue;
664
665 if (pcount == psize)
666 {
667 psize *= 2;
668 pbuf = (struct pd_thread *) xrealloc (pbuf,
669 psize * sizeof *pbuf);
670 }
671 pbuf[pcount].pdtid = pdtid;
672 pbuf[pcount].pthid = pthid;
673 pcount++;
674 }
675
676 for (pi = 0; pi < pcount; pi++)
677 {
678 status = pthdb_pthread_tid (pd_session, pbuf[pi].pdtid, &tid);
679 if (status != PTHDB_SUCCESS)
680 tid = PTHDB_INVALID_TID;
681 pbuf[pi].tid = tid;
682 }
683
684 qsort (pbuf, pcount, sizeof *pbuf, pcmp);
685
686 /* Accumulate an array of GDB threads sorted by pid. */
687
688 gcount = 0;
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);
693
694 /* Apply differences between the two arrays to GDB's thread list. */
695
696 infpid = PIDGET (inferior_ptid);
697 for (pi = gi = 0; pi < pcount || gi < gcount;)
698 {
699 if (pi == pcount)
700 {
701 delete_thread (gbuf[gi]->ptid);
702 gi++;
703 }
704 else if (gi == gcount)
705 {
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;
710 pi++;
711 }
712 else
713 {
714 ptid_t pptid, gptid;
715 int cmp_result;
716
717 pptid = BUILD_THREAD (pbuf[pi].pthid, infpid);
718 gptid = gbuf[gi]->ptid;
719 pdtid = pbuf[pi].pdtid;
720 tid = pbuf[pi].tid;
721
722 cmp_result = ptid_cmp (pptid, gptid);
723
724 if (cmp_result == 0)
725 {
726 gbuf[gi]->private->pdtid = pdtid;
727 gbuf[gi]->private->tid = tid;
728 pi++;
729 gi++;
730 }
731 else if (cmp_result > 0)
732 {
733 delete_thread (gptid);
734 gi++;
735 }
736 else
737 {
738 thread = add_thread (pptid);
739 thread->private = xmalloc (sizeof (struct private_thread_info));
740 thread->private->pdtid = pdtid;
741 thread->private->tid = tid;
742 pi++;
743 }
744 }
745 }
746
747 xfree (pbuf);
748 xfree (gbuf);
749}
750
751/* Iterate_over_threads() callback for locating a thread whose kernel
752 thread just received a trap signal. */
753
754static int
755iter_trap (struct thread_info *thread, void *unused)
756{
757 struct thrdsinfo64 thrinf;
758 pthdb_tid_t tid;
759
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);
763
764 tid = thread->private->tid;
765 if (tid == PTHDB_INVALID_TID)
766 return 0;
767
768 if (getthrds (PIDGET (inferior_ptid), &thrinf,
769 sizeof (thrinf), &tid, 1) != 1)
770 return 0;
771
772 return thrinf.ti_cursig == SIGTRAP;
773}
774
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>. */
778
779static ptid_t
780pd_update (int set_infpid)
781{
782 int status;
783 ptid_t ptid;
784 struct thread_info *thread;
785
786 if (!pd_active)
787 return inferior_ptid;
788
789 status = pthdb_session_update (pd_session);
790 if (status != PTHDB_SUCCESS)
791 return inferior_ptid;
792
793 sync_threadlists ();
794
795 /* Define "current thread" as one that just received a trap signal. */
796
797 thread = iterate_over_threads (iter_trap, NULL);
798 if (!thread)
799 ptid = inferior_ptid;
800 else
801 {
802 ptid = thread->ptid;
803 if (set_infpid)
804 inferior_ptid = ptid;
805 }
806 return ptid;
807}
808
809/* Try to start debugging threads in the current process.
810 If successful and SET_INFPID, set inferior_ptid to reflect the
811 current thread. */
812
813static ptid_t
814pd_activate (int set_infpid)
815{
816 int status;
817
818 status = pthdb_session_init (PD_USER, arch64 ? PEM_64BIT : PEM_32BIT,
819 PTHDB_FLAG_REGS, &pd_callbacks,
820 &pd_session);
821 if (status != PTHDB_SUCCESS)
822 {
823 return inferior_ptid;
824 }
825 pd_active = 1;
826 return pd_update (set_infpid);
827}
828
829/* Undo the effects of pd_activate(). */
830
831static void
832pd_deactivate (void)
833{
834 if (!pd_active)
835 return;
836 pthdb_session_destroy (pd_session);
837
838 pid_to_prc (&inferior_ptid);
839 pd_active = 0;
840}
841
842/* An object file has just been loaded. Check whether the current
843 application is pthreaded, and if so, prepare for thread debugging. */
844
845static void
846pd_enable (void)
847{
848 int status;
849 char *stub_name;
850 struct minimal_symbol *ms;
851
852 /* Don't initialize twice. */
853 if (pd_able)
854 return;
855
856 /* Check application word size. */
857 arch64 = register_size (current_gdbarch, 0) == 8;
858
859 /* Check whether the application is pthreaded. */
860 stub_name = NULL;
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)
865 return;
866
867 /* Set a breakpoint on the returned stub function. */
868 if (!(ms = lookup_minimal_symbol (stub_name, NULL, NULL)))
869 return;
870 pd_brk_addr = SYMBOL_VALUE_ADDRESS (ms);
871 if (!create_thread_event_breakpoint (pd_brk_addr))
872 return;
873
874 /* Prepare for thread debugging. */
875 base_target = current_target;
876 push_target (&aix_thread_ops);
877 pd_able = 1;
878
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. */
882 pd_activate (1);
883}
884
885/* Undo the effects of pd_enable(). */
886
887static void
888pd_disable (void)
889{
890 if (!pd_able)
891 return;
892 if (pd_active)
893 pd_deactivate ();
894 pd_able = 0;
895 unpush_target (&aix_thread_ops);
896}
897
898/* deprecated_target_new_objfile_hook callback.
899
900 If OBJFILE is non-null, check whether a threaded application is
901 being debugged, and if so, prepare for thread debugging.
902
903 If OBJFILE is null, stop debugging threads. */
904
905static void
906new_objfile (struct objfile *objfile)
907{
908 if (objfile)
909 pd_enable ();
910 else
911 pd_disable ();
912
913 if (target_new_objfile_chain)
914 target_new_objfile_chain (objfile);
915}
916
917/* Attach to process specified by ARGS. */
918
919static void
920aix_thread_attach (char *args, int from_tty)
921{
922 base_target.to_attach (args, from_tty);
923 pd_activate (1);
924}
925
926/* Detach from the process attached to by aix_thread_attach(). */
927
928static void
929aix_thread_detach (char *args, int from_tty)
930{
931 pd_disable ();
932 base_target.to_detach (args, from_tty);
933}
934
935/* Tell the inferior process to continue running thread PID if != -1
936 and all threads otherwise. */
937
938static void
939aix_thread_resume (ptid_t ptid, int step, enum target_signal sig)
940{
941 struct thread_info *thread;
942 pthdb_tid_t tid[2];
943
944 if (!PD_TID (ptid))
945 {
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);
950 }
951 else
952 {
953 thread = find_thread_pid (ptid);
954 if (!thread)
955 error ("aix-thread resume: unknown pthread %ld",
956 TIDGET (ptid));
957
958 tid[0] = thread->private->tid;
959 if (tid[0] == PTHDB_INVALID_TID)
960 error ("aix-thread resume: no tid for pthread %ld",
961 TIDGET (ptid));
962 tid[1] = 0;
963
964 if (arch64)
965 ptrace64aix (PTT_CONTINUE, tid[0], 1,
966 target_signal_to_host (sig), (int *) tid);
967 else
968 ptrace32 (PTT_CONTINUE, tid[0], (int *) 1,
969 target_signal_to_host (sig), (int *) tid);
970 }
971}
972
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
975 thread. */
976
977static ptid_t
978aix_thread_wait (ptid_t ptid, struct target_waitstatus *status)
979{
980 struct cleanup *cleanup = save_inferior_ptid ();
981
982 pid_to_prc (&ptid);
983
984 inferior_ptid = pid_to_ptid (PIDGET (inferior_ptid));
985 ptid = base_target.to_wait (ptid, status);
986 do_cleanups (cleanup);
987
988 if (PIDGET (ptid) == -1)
989 return pid_to_ptid (-1);
990
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);
996
997 return pd_update (0);
998}
999
1000/* Record that the 64-bit general-purpose registers contain VALS. */
1001
1002static void
1003supply_gprs64 (uint64_t *vals)
1004{
1005 struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
1006 int regno;
1007
1008 for (regno = 0; regno < ppc_num_gprs; regno++)
1009 regcache_raw_supply (current_regcache, tdep->ppc_gp0_regnum + regno,
1010 (char *) (vals + regno));
1011}
1012
1013/* Record that 32-bit register REGNO contains VAL. */
1014
1015static void
1016supply_reg32 (int regno, uint32_t val)
1017{
1018 regcache_raw_supply (current_regcache, regno, (char *) &val);
1019}
1020
1021/* Record that the floating-point registers contain VALS. */
1022
1023static void
1024supply_fprs (double *vals)
1025{
1026 struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
1027 int regno;
1028
1029 /* This function should never be called on architectures without
1030 floating-point registers. */
1031 gdb_assert (ppc_floating_point_unit_p (current_gdbarch));
1032
1033 for (regno = 0; regno < ppc_num_fprs; regno++)
1034 regcache_raw_supply (current_regcache, regno + tdep->ppc_fp0_regnum,
1035 (char *) (vals + regno));
1036}
1037
1038/* Predicate to test whether given register number is a "special" register. */
1039static int
1040special_register_p (int regno)
1041{
1042 struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
1043
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);
1052}
1053
1054
1055/* Record that the special registers contain the specified 64-bit and
1056 32-bit values. */
1057
1058static void
1059supply_sprs64 (uint64_t iar, uint64_t msr, uint32_t cr,
1060 uint64_t lr, uint64_t ctr, uint32_t xer,
1061 uint32_t fpscr)
1062{
1063 struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
1064
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,
1073 (char *) &fpscr);
1074}
1075
1076/* Record that the special registers contain the specified 32-bit
1077 values. */
1078
1079static void
1080supply_sprs32 (uint32_t iar, uint32_t msr, uint32_t cr,
1081 uint32_t lr, uint32_t ctr, uint32_t xer,
1082 uint32_t fpscr)
1083{
1084 struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
1085
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,
1094 (char *) &fpscr);
1095}
1096
1097/* Fetch all registers from pthread PDTID, which doesn't have a kernel
1098 thread.
1099
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
1102 function. */
1103
1104static void
1105fetch_regs_user_thread (pthdb_pthread_t pdtid)
1106{
1107 struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
1108 int status, i;
1109 pthdb_context_t ctx;
1110
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));
1118
1119 /* General-purpose registers. */
1120
1121 if (arch64)
1122 supply_gprs64 (ctx.gpr);
1123 else
1124 for (i = 0; i < ppc_num_gprs; i++)
1125 supply_reg32 (tdep->ppc_gp0_regnum + i, ctx.gpr[i]);
1126
1127 /* Floating-point registers. */
1128
1129 if (ppc_floating_point_unit_p (current_gdbarch))
1130 supply_fprs (ctx.fpr);
1131
1132 /* Special registers. */
1133
1134 if (arch64)
1135 supply_sprs64 (ctx.iar, ctx.msr, ctx.cr, ctx.lr, ctx.ctr, ctx.xer,
1136 ctx.fpscr);
1137 else
1138 supply_sprs32 (ctx.iar, ctx.msr, ctx.cr, ctx.lr, ctx.ctr, ctx.xer,
1139 ctx.fpscr);
1140}
1141
1142/* Fetch register REGNO if != -1 or all registers otherwise from
1143 kernel thread TID.
1144
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
1148 group.
1149
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
1155 be retrieved. */
1156
1157static void
1158fetch_regs_kernel_thread (int regno, pthdb_tid_t tid)
1159{
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;
1166 int i;
1167
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);
1172
1173 /* General-purpose registers. */
1174 if (regno == -1
1175 || (tdep->ppc_gp0_regnum <= regno
1176 && regno < tdep->ppc_gp0_regnum + ppc_num_gprs))
1177 {
1178 if (arch64)
1179 {
1180 if (!ptrace64aix (PTT_READ_GPRS, tid,
1181 (unsigned long) gprs64, 0, NULL))
1182 memset (gprs64, 0, sizeof (gprs64));
1183 supply_gprs64 (gprs64);
1184 }
1185 else
1186 {
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]);
1191 }
1192 }
1193
1194 /* Floating-point registers. */
1195
1196 if (ppc_floating_point_unit_p (current_gdbarch)
1197 && (regno == -1
1198 || (regno >= tdep->ppc_fp0_regnum
1199 && regno < tdep->ppc_fp0_regnum + ppc_num_fprs)))
1200 {
1201 if (!ptrace32 (PTT_READ_FPRS, tid, (int *) fprs, 0, NULL))
1202 memset (fprs, 0, sizeof (fprs));
1203 supply_fprs (fprs);
1204 }
1205
1206 /* Special-purpose registers. */
1207
1208 if (regno == -1 || special_register_p (regno))
1209 {
1210 if (arch64)
1211 {
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,
1217 sprs64.pt_fpscr);
1218 }
1219 else
1220 {
1221 struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
1222
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,
1227 sprs32.pt_fpscr);
1228
1229 if (tdep->ppc_mq_regnum >= 0)
1230 regcache_raw_supply (current_regcache, tdep->ppc_mq_regnum,
1231 (char *) &sprs32.pt_mq);
1232 }
1233 }
1234}
1235
1236/* Fetch register REGNO if != -1 or all registers otherwise in the
1237 thread/process specified by inferior_ptid. */
1238
1239static void
1240aix_thread_fetch_registers (int regno)
1241{
1242 struct thread_info *thread;
1243 pthdb_tid_t tid;
1244
1245 if (!PD_TID (inferior_ptid))
1246 base_target.to_fetch_registers (regno);
1247 else
1248 {
1249 thread = find_thread_pid (inferior_ptid);
1250 tid = thread->private->tid;
1251
1252 if (tid == PTHDB_INVALID_TID)
1253 fetch_regs_user_thread (thread->private->pdtid);
1254 else
1255 fetch_regs_kernel_thread (regno, tid);
1256 }
1257}
1258
1259/* Store the gp registers into an array of uint32_t or uint64_t. */
1260
1261static void
1262fill_gprs64 (uint64_t *vals)
1263{
1264 struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
1265 int regno;
1266
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,
1270 vals + regno);
1271}
1272
1273static void
1274fill_gprs32 (uint32_t *vals)
1275{
1276 struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
1277 int regno;
1278
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,
1282 vals + regno);
1283}
1284
1285/* Store the floating point registers into a double array. */
1286static void
1287fill_fprs (double *vals)
1288{
1289 struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
1290 int regno;
1291
1292 /* This function should never be called on architectures without
1293 floating-point registers. */
1294 gdb_assert (ppc_floating_point_unit_p (current_gdbarch));
1295
1296 for (regno = tdep->ppc_fp0_regnum;
1297 regno < tdep->ppc_fp0_regnum + ppc_num_fprs;
1298 regno++)
1299 if (register_cached (regno))
1300 regcache_raw_collect (current_regcache, regno, vals + regno);
1301}
1302
1303/* Store the special registers into the specified 64-bit and 32-bit
1304 locations. */
1305
1306static void
1307fill_sprs64 (uint64_t *iar, uint64_t *msr, uint32_t *cr,
1308 uint64_t *lr, uint64_t *ctr, uint32_t *xer,
1309 uint32_t *fpscr)
1310{
1311 struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
1312
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));
1319
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);
1335}
1336
1337static void
1338fill_sprs32 (unsigned long *iar, unsigned long *msr, unsigned long *cr,
1339 unsigned long *lr, unsigned long *ctr, unsigned long *xer,
1340 unsigned long *fpscr)
1341{
1342 struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
1343
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.
1349
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));
1355
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);
1371}
1372
1373/* Store all registers into pthread PDTID, which doesn't have a kernel
1374 thread.
1375
1376 It's possible to store a single register into a non-kernel pthread,
1377 but I doubt it's worth the effort. */
1378
1379static void
1380store_regs_user_thread (pthdb_pthread_t pdtid)
1381{
1382 struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
1383 int status, i;
1384 pthdb_context_t ctx;
1385 uint32_t int32;
1386 uint64_t int64;
1387 double dbl;
1388
1389 if (debug_aix_thread)
1390 fprintf_unfiltered (gdb_stdlog,
1391 "store_regs_user_thread %lx\n", (long) pdtid);
1392
1393 /* Retrieve the thread's current context for its non-register
1394 values. */
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));
1399
1400 /* Collect general-purpose register values from the regcache. */
1401
1402 for (i = 0; i < ppc_num_gprs; i++)
1403 if (register_cached (tdep->ppc_gp0_regnum + i))
1404 {
1405 if (arch64)
1406 {
1407 regcache_raw_collect (current_regcache, tdep->ppc_gp0_regnum + i,
1408 (void *) &int64);
1409 ctx.gpr[i] = int64;
1410 }
1411 else
1412 {
1413 regcache_raw_collect (current_regcache, tdep->ppc_gp0_regnum + i,
1414 (void *) &int32);
1415 ctx.gpr[i] = int32;
1416 }
1417 }
1418
1419 /* Collect floating-point register values from the regcache. */
1420 if (ppc_floating_point_unit_p (current_gdbarch))
1421 fill_fprs (ctx.fpr);
1422
1423 /* Special registers (always kept in ctx as 64 bits). */
1424 if (arch64)
1425 {
1426 fill_sprs64 (&ctx.iar, &ctx.msr, &ctx.cr, &ctx.lr, &ctx.ctr, &ctx.xer,
1427 &ctx.fpscr);
1428 }
1429 else
1430 {
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,
1436 tmp_fpscr;
1437
1438 fill_sprs32 (&tmp_iar, &tmp_msr, &tmp_cr, &tmp_lr, &tmp_ctr, &tmp_xer,
1439 &tmp_fpscr);
1440 if (register_cached (PC_REGNUM))
1441 ctx.iar = tmp_iar;
1442 if (register_cached (tdep->ppc_ps_regnum))
1443 ctx.msr = tmp_msr;
1444 if (register_cached (tdep->ppc_cr_regnum))
1445 ctx.cr = tmp_cr;
1446 if (register_cached (tdep->ppc_lr_regnum))
1447 ctx.lr = tmp_lr;
1448 if (register_cached (tdep->ppc_ctr_regnum))
1449 ctx.ctr = tmp_ctr;
1450 if (register_cached (tdep->ppc_xer_regnum))
1451 ctx.xer = tmp_xer;
1452 if (register_cached (tdep->ppc_xer_regnum))
1453 ctx.fpscr = tmp_fpscr;
1454 }
1455
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));
1460}
1461
1462/* Store register REGNO if != -1 or all registers otherwise into
1463 kernel thread TID.
1464
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
1468 group. */
1469
1470static void
1471store_regs_kernel_thread (int regno, pthdb_tid_t tid)
1472{
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;
1479 int i;
1480
1481 if (debug_aix_thread)
1482 fprintf_unfiltered (gdb_stdlog,
1483 "store_regs_kernel_thread tid=%lx regno=%d\n",
1484 (long) tid, regno);
1485
1486 /* General-purpose registers. */
1487 if (regno == -1
1488 || (tdep->ppc_gp0_regnum <= regno
1489 && regno < tdep->ppc_gp0_regnum + ppc_num_fprs))
1490 {
1491 if (arch64)
1492 {
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);
1497 }
1498 else
1499 {
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);
1504 }
1505 }
1506
1507 /* Floating-point registers. */
1508
1509 if (ppc_floating_point_unit_p (current_gdbarch)
1510 && (regno == -1
1511 || (regno >= tdep->ppc_fp0_regnum
1512 && regno < tdep->ppc_fp0_regnum + ppc_num_fprs)))
1513 {
1514 /* Pre-fetch: some regs may not be in the cache. */
1515 ptrace32 (PTT_READ_FPRS, tid, (int *) fprs, 0, NULL);
1516 fill_fprs (fprs);
1517 ptrace32 (PTT_WRITE_FPRS, tid, (int *) fprs, 0, NULL);
1518 }
1519
1520 /* Special-purpose registers. */
1521
1522 if (regno == -1 || special_register_p (regno))
1523 {
1524 if (arch64)
1525 {
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,
1531 &sprs64.pt_fpscr);
1532 ptrace64aix (PTT_WRITE_SPRS, tid,
1533 (unsigned long) &sprs64, 0, NULL);
1534 }
1535 else
1536 {
1537 /* Pre-fetch: some registers won't be in the cache. */
1538 ptrace32 (PTT_READ_SPRS, tid, (int *) &sprs32, 0, NULL);
1539
1540 fill_sprs32 (&sprs32.pt_iar, &sprs32.pt_msr, &sprs32.pt_cr,
1541 &sprs32.pt_lr, &sprs32.pt_ctr, &sprs32.pt_xer,
1542 &sprs32.pt_fpscr);
1543
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,
1547 &sprs32.pt_mq);
1548
1549 ptrace32 (PTT_WRITE_SPRS, tid, (int *) &sprs32, 0, NULL);
1550 }
1551 }
1552}
1553
1554/* Store gdb's current view of the register set into the
1555 thread/process specified by inferior_ptid. */
1556
1557static void
1558aix_thread_store_registers (int regno)
1559{
1560 struct thread_info *thread;
1561 pthdb_tid_t tid;
1562
1563 if (!PD_TID (inferior_ptid))
1564 base_target.to_store_registers (regno);
1565 else
1566 {
1567 thread = find_thread_pid (inferior_ptid);
1568 tid = thread->private->tid;
1569
1570 if (tid == PTHDB_INVALID_TID)
1571 store_regs_user_thread (thread->private->pdtid);
1572 else
1573 store_regs_kernel_thread (regno, tid);
1574 }
1575}
1576
1577/* Transfer LEN bytes of memory from GDB address MYADDR to target
1578 address MEMADDR if WRITE and vice versa otherwise. */
1579
1580static int
1581aix_thread_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
1582 struct mem_attrib *attrib,
1583 struct target_ops *target)
1584{
1585 int n;
1586 struct cleanup *cleanup = save_inferior_ptid ();
1587
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);
1592
1593 return n;
1594}
1595
1596/* Kill and forget about the inferior process. */
1597
1598static void
1599aix_thread_kill (void)
1600{
1601 struct cleanup *cleanup = save_inferior_ptid ();
1602
1603 inferior_ptid = pid_to_ptid (PIDGET (inferior_ptid));
1604 base_target.to_kill ();
1605 do_cleanups (cleanup);
1606}
1607
1608/* Clean up after the inferior exits. */
1609
1610static void
1611aix_thread_mourn_inferior (void)
1612{
1613 pd_deactivate ();
1614 base_target.to_mourn_inferior ();
1615}
1616
1617/* Return whether thread PID is still valid. */
1618
1619static int
1620aix_thread_thread_alive (ptid_t ptid)
1621{
1622 if (!PD_TID (ptid))
1623 return base_target.to_thread_alive (ptid);
1624
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);
1628}
1629
1630/* Return a printable representation of composite PID for use in
1631 "info threads" output. */
1632
1633static char *
1634aix_thread_pid_to_str (ptid_t ptid)
1635{
1636 static char *ret = NULL;
1637
1638 if (!PD_TID (ptid))
1639 return base_target.to_pid_to_str (ptid);
1640
1641 /* Free previous return value; a new one will be allocated by
1642 xstrprintf(). */
1643 xfree (ret);
1644
1645 ret = xstrprintf ("Thread %ld", ptid_get_tid (ptid));
1646 return ret;
1647}
1648
1649/* Return a printable representation of extra information about
1650 THREAD, for use in "info threads" output. */
1651
1652static char *
1653aix_thread_extra_thread_info (struct thread_info *thread)
1654{
1655 struct ui_file *buf;
1656 int status;
1657 pthdb_pthread_t pdtid;
1658 pthdb_tid_t tid;
1659 pthdb_state_t state;
1660 pthdb_suspendstate_t suspendstate;
1661 pthdb_detachstate_t detachstate;
1662 int cancelpend;
1663 long length;
1664 static char *ret = NULL;
1665
1666 if (!PD_TID (thread->ptid))
1667 return NULL;
1668
1669 buf = mem_fileopen ();
1670
1671 pdtid = thread->private->pdtid;
1672 tid = thread->private->tid;
1673
1674 if (tid != PTHDB_INVALID_TID)
1675 fprintf_unfiltered (buf, "tid %d", tid);
1676
1677 status = pthdb_pthread_state (pd_session, pdtid, &state);
1678 if (status != PTHDB_SUCCESS)
1679 state = PST_NOTSUP;
1680 fprintf_unfiltered (buf, ", %s", state2str (state));
1681
1682 status = pthdb_pthread_suspendstate (pd_session, pdtid,
1683 &suspendstate);
1684 if (status == PTHDB_SUCCESS && suspendstate == PSS_SUSPENDED)
1685 fprintf_unfiltered (buf, ", suspended");
1686
1687 status = pthdb_pthread_detachstate (pd_session, pdtid,
1688 &detachstate);
1689 if (status == PTHDB_SUCCESS && detachstate == PDS_DETACHED)
1690 fprintf_unfiltered (buf, ", detached");
1691
1692 pthdb_pthread_cancelpend (pd_session, pdtid, &cancelpend);
1693 if (status == PTHDB_SUCCESS && cancelpend)
1694 fprintf_unfiltered (buf, ", cancel pending");
1695
1696 ui_file_write (buf, "", 1);
1697
1698 xfree (ret); /* Free old buffer. */
1699
1700 ret = ui_file_xstrdup (buf, &length);
1701 ui_file_delete (buf);
1702
1703 return ret;
1704}
1705
1706/* Initialize target aix_thread_ops. */
1707
1708static void
1709init_aix_thread_ops (void)
1710{
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";
1714
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;
1731}
1732
1733/* Module startup initialization function, automagically called by
1734 init.c. */
1735
1736void
1737_initialize_aix_thread (void)
1738{
1739 init_aix_thread_ops ();
1740 add_target (&aix_thread_ops);
1741
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;
1745
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",
1751 &setdebuglist),
1752 &showdebuglist);
1753}
GDB Binutils - Deliverables
This page took 0.033682 seconds and 4 git commands to generate.