GDB (xrefs)

/tmp/gdb-8.1/gdb/aix-thread.c
Go to the documentation of this file.
1 /* Low level interface for debugging AIX 4.3+ pthreads.
2
3 Copyright (C) 1999-2018 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 3 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, see <http://www.gnu.org/licenses/>. */
20
21
22 /* This module uses the libpthdebug.a library provided by AIX 4.3+ for
23 debugging pthread applications.
24
25 Some name prefix conventions:
26 pthdb_ provided by libpthdebug.a
27 pdc_ callbacks that this module provides to libpthdebug.a
28 pd_ variables or functions interfacing with libpthdebug.a
29
30 libpthdebug peculiarities:
31
32 - pthdb_ptid_pthread() is prototyped in <sys/pthdebug.h>, but
33 it's not documented, and after several calls it stops working
34 and causes other libpthdebug functions to fail.
35
36 - pthdb_tid_pthread() doesn't always work after
37 pthdb_session_update(), but it does work after cycling through
38 all threads using pthdb_pthread().
39
40 */
41
42 #include "defs.h"
43 #include "gdbthread.h"
44 #include "target.h"
45 #include "inferior.h"
46 #include "regcache.h"
47 #include "gdbcmd.h"
48 #include "ppc-tdep.h"
49 #include "observer.h"
50 #include "objfiles.h"
51
52 #include <procinfo.h>
53 #include <sys/types.h>
54 #include <sys/ptrace.h>
55 #include <sys/reg.h>
56 #include <sched.h>
57 #include <sys/pthdebug.h>
58
59 #if !HAVE_DECL_GETTHRDS
60 extern int getthrds (pid_t, struct thrdsinfo64 *, int, tid_t *, int);
61 #endif
62
63 /* Whether to emit debugging output. */
64 static int debug_aix_thread;
65
66 /* In AIX 5.1, functions use pthdb_tid_t instead of tid_t. */
67 #ifndef PTHDB_VERSION_3
68 #define pthdb_tid_t tid_t
69 #endif
70
71 /* Return whether to treat PID as a debuggable thread id. */
72
73 #define PD_TID(ptid) (pd_active && ptid_get_tid (ptid) != 0)
74
75 /* pthdb_user_t value that we pass to pthdb functions. 0 causes
76 PTHDB_BAD_USER errors, so use 1. */
77
78 #define PD_USER 1
79
80 /* Success and failure values returned by pthdb callbacks. */
81
82 #define PDC_SUCCESS PTHDB_SUCCESS
83 #define PDC_FAILURE PTHDB_CALLBACK
84
85 /* Private data attached to each element in GDB's thread list. */
86
87 struct aix_thread_info : public private_thread_info
88 {
89 pthdb_pthread_t pdtid; /* thread's libpthdebug id */
90 pthdb_tid_t tid; /* kernel thread id */
91 };
92
93 /* Return the aix_thread_info attached to THREAD. */
94
95 static aix_thread_info *
96 get_aix_thread_info (thread_info *thread)
97 {
98 return static_cast<aix_thread_info *> (thread->priv.get ());
99 }
100
101 /* Information about a thread of which libpthdebug is aware. */
102
103 struct pd_thread {
104 pthdb_pthread_t pdtid;
105 pthread_t pthid;
106 pthdb_tid_t tid;
107 };
108
109 /* This module's target-specific operations, active while pd_able is true. */
110
111 static struct target_ops aix_thread_ops;
112
113 /* Address of the function that libpthread will call when libpthdebug
114 is ready to be initialized. */
115
116 static CORE_ADDR pd_brk_addr;
117
118 /* Whether the current application is debuggable by pthdb. */
119
120 static int pd_able = 0;
121
122 /* Whether a threaded application is being debugged. */
123
124 static int pd_active = 0;
125
126 /* Whether the current architecture is 64-bit.
127 Only valid when pd_able is true. */
128
129 static int arch64;
130
131 /* Forward declarations for pthdb callbacks. */
132
133 static int pdc_symbol_addrs (pthdb_user_t, pthdb_symbol_t *, int);
134 static int pdc_read_data (pthdb_user_t, void *, pthdb_addr_t, size_t);
135 static int pdc_write_data (pthdb_user_t, void *, pthdb_addr_t, size_t);
136 static int pdc_read_regs (pthdb_user_t user, pthdb_tid_t tid,
137 unsigned long long flags,
138 pthdb_context_t *context);
139 static int pdc_write_regs (pthdb_user_t user, pthdb_tid_t tid,
140 unsigned long long flags,
141 pthdb_context_t *context);
142 static int pdc_alloc (pthdb_user_t, size_t, void **);
143 static int pdc_realloc (pthdb_user_t, void *, size_t, void **);
144 static int pdc_dealloc (pthdb_user_t, void *);
145
146 /* pthdb callbacks. */
147
148 static pthdb_callbacks_t pd_callbacks = {
149 pdc_symbol_addrs,
150 pdc_read_data,
151 pdc_write_data,
152 pdc_read_regs,
153 pdc_write_regs,
154 pdc_alloc,
155 pdc_realloc,
156 pdc_dealloc,
157 NULL
158 };
159
160 /* Current pthdb session. */
161
162 static pthdb_session_t pd_session;
163
164 /* Return a printable representation of pthdebug function return
165 STATUS. */
166
167 static const char *
168 pd_status2str (int status)
169 {
170 switch (status)
171 {
172 case PTHDB_SUCCESS: return "SUCCESS";
173 case PTHDB_NOSYS: return "NOSYS";
174 case PTHDB_NOTSUP: return "NOTSUP";
175 case PTHDB_BAD_VERSION: return "BAD_VERSION";
176 case PTHDB_BAD_USER: return "BAD_USER";
177 case PTHDB_BAD_SESSION: return "BAD_SESSION";
178 case PTHDB_BAD_MODE: return "BAD_MODE";
179 case PTHDB_BAD_FLAGS: return "BAD_FLAGS";
180 case PTHDB_BAD_CALLBACK: return "BAD_CALLBACK";
181 case PTHDB_BAD_POINTER: return "BAD_POINTER";
182 case PTHDB_BAD_CMD: return "BAD_CMD";
183 case PTHDB_BAD_PTHREAD: return "BAD_PTHREAD";
184 case PTHDB_BAD_ATTR: return "BAD_ATTR";
185 case PTHDB_BAD_MUTEX: return "BAD_MUTEX";
186 case PTHDB_BAD_MUTEXATTR: return "BAD_MUTEXATTR";
187 case PTHDB_BAD_COND: return "BAD_COND";
188 case PTHDB_BAD_CONDATTR: return "BAD_CONDATTR";
189 case PTHDB_BAD_RWLOCK: return "BAD_RWLOCK";
190 case PTHDB_BAD_RWLOCKATTR: return "BAD_RWLOCKATTR";
191 case PTHDB_BAD_KEY: return "BAD_KEY";
192 case PTHDB_BAD_PTID: return "BAD_PTID";
193 case PTHDB_BAD_TID: return "BAD_TID";
194 case PTHDB_CALLBACK: return "CALLBACK";
195 case PTHDB_CONTEXT: return "CONTEXT";
196 case PTHDB_HELD: return "HELD";
197 case PTHDB_NOT_HELD: return "NOT_HELD";
198 case PTHDB_MEMORY: return "MEMORY";
199 case PTHDB_NOT_PTHREADED: return "NOT_PTHREADED";
200 case PTHDB_SYMBOL: return "SYMBOL";
201 case PTHDB_NOT_AVAIL: return "NOT_AVAIL";
202 case PTHDB_INTERNAL: return "INTERNAL";
203 default: return "UNKNOWN";
204 }
205 }
206
207 /* A call to ptrace(REQ, ID, ...) just returned RET. Check for
208 exceptional conditions and either return nonlocally or else return
209 1 for success and 0 for failure. */
210
211 static int
212 ptrace_check (int req, int id, int ret)
213 {
214 if (ret == 0 && !errno)
215 return 1;
216
217 /* According to ptrace(2), ptrace may fail with EPERM if "the
218 Identifier parameter corresponds to a kernel thread which is
219 stopped in kernel mode and whose computational state cannot be
220 read or written." This happens quite often with register reads. */
221
222 switch (req)
223 {
224 case PTT_READ_GPRS:
225 case PTT_READ_FPRS:
226 case PTT_READ_SPRS:
227 if (ret == -1 && errno == EPERM)
228 {
229 if (debug_aix_thread)
230 fprintf_unfiltered (gdb_stdlog,
231 "ptrace (%d, %d) = %d (errno = %d)\n",
232 req, id, ret, errno);
233 return ret == -1 ? 0 : 1;
234 }
235 break;
236 }
237 error (_("aix-thread: ptrace (%d, %d) returned %d (errno = %d %s)"),
238 req, id, ret, errno, safe_strerror (errno));
239 return 0; /* Not reached. */
240 }
241
242 /* Call ptracex (REQ, ID, ADDR, DATA, BUF) or
243 ptrace64 (REQ, ID, ADDR, DATA, BUF) if HAVE_PTRACE64.
244 Return success. */
245
246 #ifdef HAVE_PTRACE64
247 # define ptracex(request, pid, addr, data, buf) \
248 ptrace64 (request, pid, addr, data, buf)
249 #endif
250
251 static int
252 ptrace64aix (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) or
259 ptrace64 (REQ, ID, ADDR, DATA, BUF) if HAVE_PTRACE64.
260 Return success. */
261
262 #ifdef HAVE_PTRACE64
263 # define ptrace(request, pid, addr, data, buf) \
264 ptrace64 (request, pid, addr, data, buf)
265 # define addr_ptr long long
266 #else
267 # define addr_ptr int *
268 #endif
269
270 static int
271 ptrace32 (int req, int id, addr_ptr addr, int data, int *buf)
272 {
273 errno = 0;
274 return ptrace_check (req, id,
275 ptrace (req, id, addr, data, buf));
276 }
277
278 /* If *PIDP is a composite process/thread id, convert it to a
279 process id. */
280
281 static void
282 pid_to_prc (ptid_t *ptidp)
283 {
284 ptid_t ptid;
285
286 ptid = *ptidp;
287 if (PD_TID (ptid))
288 *ptidp = pid_to_ptid (ptid_get_pid (ptid));
289 }
290
291 /* pthdb callback: for <i> from 0 to COUNT, set SYMBOLS[<i>].addr to
292 the address of SYMBOLS[<i>].name. */
293
294 static int
295 pdc_symbol_addrs (pthdb_user_t user, pthdb_symbol_t *symbols, int count)
296 {
297 struct bound_minimal_symbol ms;
298 int i;
299 char *name;
300
301 if (debug_aix_thread)
302 fprintf_unfiltered (gdb_stdlog,
303 "pdc_symbol_addrs (user = %ld, symbols = 0x%lx, count = %d)\n",
304 user, (long) symbols, count);
305
306 for (i = 0; i < count; i++)
307 {
308 name = symbols[i].name;
309 if (debug_aix_thread)
310 fprintf_unfiltered (gdb_stdlog,
311 " symbols[%d].name = \"%s\"\n", i, name);
312
313 if (!*name)
314 symbols[i].addr = 0;
315 else
316 {
317 ms = lookup_minimal_symbol (name, NULL, NULL);
318 if (ms.minsym == NULL)
319 {
320 if (debug_aix_thread)
321 fprintf_unfiltered (gdb_stdlog, " returning PDC_FAILURE\n");
322 return PDC_FAILURE;
323 }
324 symbols[i].addr = BMSYMBOL_VALUE_ADDRESS (ms);
325 }
326 if (debug_aix_thread)
327 fprintf_unfiltered (gdb_stdlog, " symbols[%d].addr = %s\n",
328 i, hex_string (symbols[i].addr));
329 }
330 if (debug_aix_thread)
331 fprintf_unfiltered (gdb_stdlog, " returning PDC_SUCCESS\n");
332 return PDC_SUCCESS;
333 }
334
335 /* Read registers call back function should be able to read the
336 context information of a debuggee kernel thread from an active
337 process or from a core file. The information should be formatted
338 in context64 form for both 32-bit and 64-bit process.
339 If successful return 0, else non-zero is returned. */
340
341 static int
342 pdc_read_regs (pthdb_user_t user,
343 pthdb_tid_t tid,
344 unsigned long long flags,
345 pthdb_context_t *context)
346 {
347 /* This function doesn't appear to be used, so we could probably
348 just return 0 here. HOWEVER, if it is not defined, the OS will
349 complain and several thread debug functions will fail. In case
350 this is needed, I have implemented what I think it should do,
351 however this code is untested. */
352
353 uint64_t gprs64[ppc_num_gprs];
354 uint32_t gprs32[ppc_num_gprs];
355 double fprs[ppc_num_fprs];
356 struct ptxsprs sprs64;
357 struct ptsprs sprs32;
358
359 if (debug_aix_thread)
360 fprintf_unfiltered (gdb_stdlog, "pdc_read_regs tid=%d flags=%s\n",
361 (int) tid, hex_string (flags));
362
363 /* General-purpose registers. */
364 if (flags & PTHDB_FLAG_GPRS)
365 {
366 if (arch64)
367 {
368 if (!ptrace64aix (PTT_READ_GPRS, tid,
369 (unsigned long) gprs64, 0, NULL))
370 memset (gprs64, 0, sizeof (gprs64));
371 memcpy (context->gpr, gprs64, sizeof(gprs64));
372 }
373 else
374 {
375 if (!ptrace32 (PTT_READ_GPRS, tid, (uintptr_t) gprs32, 0, NULL))
376 memset (gprs32, 0, sizeof (gprs32));
377 memcpy (context->gpr, gprs32, sizeof(gprs32));
378 }
379 }
380
381 /* Floating-point registers. */
382 if (flags & PTHDB_FLAG_FPRS)
383 {
384 if (!ptrace32 (PTT_READ_FPRS, tid, (uintptr_t) fprs, 0, NULL))
385 memset (fprs, 0, sizeof (fprs));
386 memcpy (context->fpr, fprs, sizeof(fprs));
387 }
388
389 /* Special-purpose registers. */
390 if (flags & PTHDB_FLAG_SPRS)
391 {
392 if (arch64)
393 {
394 if (!ptrace64aix (PTT_READ_SPRS, tid,
395 (unsigned long) &sprs64, 0, NULL))
396 memset (&sprs64, 0, sizeof (sprs64));
397 memcpy (&context->msr, &sprs64, sizeof(sprs64));
398 }
399 else
400 {
401 if (!ptrace32 (PTT_READ_SPRS, tid, (uintptr_t) &sprs32, 0, NULL))
402 memset (&sprs32, 0, sizeof (sprs32));
403 memcpy (&context->msr, &sprs32, sizeof(sprs32));
404 }
405 }
406 return 0;
407 }
408
409 /* Write register function should be able to write requested context
410 information to specified debuggee's kernel thread id.
411 If successful return 0, else non-zero is returned. */
412
413 static int
414 pdc_write_regs (pthdb_user_t user,
415 pthdb_tid_t tid,
416 unsigned long long flags,
417 pthdb_context_t *context)
418 {
419 /* This function doesn't appear to be used, so we could probably
420 just return 0 here. HOWEVER, if it is not defined, the OS will
421 complain and several thread debug functions will fail. In case
422 this is needed, I have implemented what I think it should do,
423 however this code is untested. */
424
425 if (debug_aix_thread)
426 fprintf_unfiltered (gdb_stdlog, "pdc_write_regs tid=%d flags=%s\n",
427 (int) tid, hex_string (flags));
428
429 /* General-purpose registers. */
430 if (flags & PTHDB_FLAG_GPRS)
431 {
432 if (arch64)
433 ptrace64aix (PTT_WRITE_GPRS, tid,
434 (unsigned long) context->gpr, 0, NULL);
435 else
436 ptrace32 (PTT_WRITE_GPRS, tid, (uintptr_t) context->gpr, 0, NULL);
437 }
438
439 /* Floating-point registers. */
440 if (flags & PTHDB_FLAG_FPRS)
441 {
442 ptrace32 (PTT_WRITE_FPRS, tid, (uintptr_t) context->fpr, 0, NULL);
443 }
444
445 /* Special-purpose registers. */
446 if (flags & PTHDB_FLAG_SPRS)
447 {
448 if (arch64)
449 {
450 ptrace64aix (PTT_WRITE_SPRS, tid,
451 (unsigned long) &context->msr, 0, NULL);
452 }
453 else
454 {
455 ptrace32 (PTT_WRITE_SPRS, tid, (uintptr_t) &context->msr, 0, NULL);
456 }
457 }
458 return 0;
459 }
460
461 /* pthdb callback: read LEN bytes from process ADDR into BUF. */
462
463 static int
464 pdc_read_data (pthdb_user_t user, void *buf,
465 pthdb_addr_t addr, size_t len)
466 {
467 int status, ret;
468
469 if (debug_aix_thread)
470 fprintf_unfiltered (gdb_stdlog,
471 "pdc_read_data (user = %ld, buf = 0x%lx, addr = %s, len = %ld)\n",
472 user, (long) buf, hex_string (addr), len);
473
474 status = target_read_memory (addr, (gdb_byte *) buf, len);
475 ret = status == 0 ? PDC_SUCCESS : PDC_FAILURE;
476
477 if (debug_aix_thread)
478 fprintf_unfiltered (gdb_stdlog, " status=%d, returning %s\n",
479 status, pd_status2str (ret));
480 return ret;
481 }
482
483 /* pthdb callback: write LEN bytes from BUF to process ADDR. */
484
485 static int
486 pdc_write_data (pthdb_user_t user, void *buf,
487 pthdb_addr_t addr, size_t len)
488 {
489 int status, ret;
490
491 if (debug_aix_thread)
492 fprintf_unfiltered (gdb_stdlog,
493 "pdc_write_data (user = %ld, buf = 0x%lx, addr = %s, len = %ld)\n",
494 user, (long) buf, hex_string (addr), len);
495
496 status = target_write_memory (addr, (gdb_byte *) buf, len);
497 ret = status == 0 ? PDC_SUCCESS : PDC_FAILURE;
498
499 if (debug_aix_thread)
500 fprintf_unfiltered (gdb_stdlog, " status=%d, returning %s\n", status,
501 pd_status2str (ret));
502 return ret;
503 }
504
505 /* pthdb callback: allocate a LEN-byte buffer and store a pointer to it
506 in BUFP. */
507
508 static int
509 pdc_alloc (pthdb_user_t user, size_t len, void **bufp)
510 {
511 if (debug_aix_thread)
512 fprintf_unfiltered (gdb_stdlog,
513 "pdc_alloc (user = %ld, len = %ld, bufp = 0x%lx)\n",
514 user, len, (long) bufp);
515 *bufp = xmalloc (len);
516 if (debug_aix_thread)
517 fprintf_unfiltered (gdb_stdlog,
518 " malloc returned 0x%lx\n", (long) *bufp);
519
520 /* Note: xmalloc() can't return 0; therefore PDC_FAILURE will never
521 be returned. */
522
523 return *bufp ? PDC_SUCCESS : PDC_FAILURE;
524 }
525
526 /* pthdb callback: reallocate BUF, which was allocated by the alloc or
527 realloc callback, so that it contains LEN bytes, and store a
528 pointer to the result in BUFP. */
529
530 static int
531 pdc_realloc (pthdb_user_t user, void *buf, size_t len, void **bufp)
532 {
533 if (debug_aix_thread)
534 fprintf_unfiltered (gdb_stdlog,
535 "pdc_realloc (user = %ld, buf = 0x%lx, len = %ld, bufp = 0x%lx)\n",
536 user, (long) buf, len, (long) bufp);
537 *bufp = xrealloc (buf, len);
538 if (debug_aix_thread)
539 fprintf_unfiltered (gdb_stdlog,
540 " realloc returned 0x%lx\n", (long) *bufp);
541 return *bufp ? PDC_SUCCESS : PDC_FAILURE;
542 }
543
544 /* pthdb callback: free BUF, which was allocated by the alloc or
545 realloc callback. */
546
547 static int
548 pdc_dealloc (pthdb_user_t user, void *buf)
549 {
550 if (debug_aix_thread)
551 fprintf_unfiltered (gdb_stdlog,
552 "pdc_free (user = %ld, buf = 0x%lx)\n", user,
553 (long) buf);
554 xfree (buf);
555 return PDC_SUCCESS;
556 }
557
558 /* Return a printable representation of pthread STATE. */
559
560 static char *
561 state2str (pthdb_state_t state)
562 {
563 switch (state)
564 {
565 case PST_IDLE:
566 /* i18n: Like "Thread-Id %d, [state] idle" */
567 return _("idle"); /* being created */
568 case PST_RUN:
569 /* i18n: Like "Thread-Id %d, [state] running" */
570 return _("running"); /* running */
571 case PST_SLEEP:
572 /* i18n: Like "Thread-Id %d, [state] sleeping" */
573 return _("sleeping"); /* awaiting an event */
574 case PST_READY:
575 /* i18n: Like "Thread-Id %d, [state] ready" */
576 return _("ready"); /* runnable */
577 case PST_TERM:
578 /* i18n: Like "Thread-Id %d, [state] finished" */
579 return _("finished"); /* awaiting a join/detach */
580 default:
581 /* i18n: Like "Thread-Id %d, [state] unknown" */
582 return _("unknown");
583 }
584 }
585
586 /* qsort() comparison function for sorting pd_thread structs by pthid. */
587
588 static int
589 pcmp (const void *p1v, const void *p2v)
590 {
591 struct pd_thread *p1 = (struct pd_thread *) p1v;
592 struct pd_thread *p2 = (struct pd_thread *) p2v;
593 return p1->pthid < p2->pthid ? -1 : p1->pthid > p2->pthid;
594 }
595
596 /* iterate_over_threads() callback for counting GDB threads.
597
598 Do not count the main thread (whose tid is zero). This matches
599 the list of threads provided by the pthreaddebug library, which
600 does not include that main thread either, and thus allows us
601 to compare the two lists. */
602
603 static int
604 giter_count (struct thread_info *thread, void *countp)
605 {
606 if (PD_TID (thread->ptid))
607 (*(int *) countp)++;
608 return 0;
609 }
610
611 /* iterate_over_threads() callback for accumulating GDB thread pids.
612
613 Do not include the main thread (whose tid is zero). This matches
614 the list of threads provided by the pthreaddebug library, which
615 does not include that main thread either, and thus allows us
616 to compare the two lists. */
617
618 static int
619 giter_accum (struct thread_info *thread, void *bufp)
620 {
621 if (PD_TID (thread->ptid))
622 {
623 **(struct thread_info ***) bufp = thread;
624 (*(struct thread_info ***) bufp)++;
625 }
626 return 0;
627 }
628
629 /* ptid comparison function */
630
631 static int
632 ptid_cmp (ptid_t ptid1, ptid_t ptid2)
633 {
634 int pid1, pid2;
635
636 if (ptid_get_pid (ptid1) < ptid_get_pid (ptid2))
637 return -1;
638 else if (ptid_get_pid (ptid1) > ptid_get_pid (ptid2))
639 return 1;
640 else if (ptid_get_tid (ptid1) < ptid_get_tid (ptid2))
641 return -1;
642 else if (ptid_get_tid (ptid1) > ptid_get_tid (ptid2))
643 return 1;
644 else if (ptid_get_lwp (ptid1) < ptid_get_lwp (ptid2))
645 return -1;
646 else if (ptid_get_lwp (ptid1) > ptid_get_lwp (ptid2))
647 return 1;
648 else
649 return 0;
650 }
651
652 /* qsort() comparison function for sorting thread_info structs by pid. */
653
654 static int
655 gcmp (const void *t1v, const void *t2v)
656 {
657 struct thread_info *t1 = *(struct thread_info **) t1v;
658 struct thread_info *t2 = *(struct thread_info **) t2v;
659 return ptid_cmp (t1->ptid, t2->ptid);
660 }
661
662 /* Search through the list of all kernel threads for the thread
663 that has stopped on a SIGTRAP signal, and return its TID.
664 Return 0 if none found. */
665
666 static pthdb_tid_t
667 get_signaled_thread (void)
668 {
669 struct thrdsinfo64 thrinf;
670 tid_t ktid = 0;
671 int result = 0;
672
673 while (1)
674 {
675 if (getthrds (ptid_get_pid (inferior_ptid), &thrinf,
676 sizeof (thrinf), &ktid, 1) != 1)
677 break;
678
679 if (thrinf.ti_cursig == SIGTRAP)
680 return thrinf.ti_tid;
681 }
682
683 /* Didn't find any thread stopped on a SIGTRAP signal. */
684 return 0;
685 }
686
687 /* Synchronize GDB's thread list with libpthdebug's.
688
689 There are some benefits of doing this every time the inferior stops:
690
691 - allows users to run thread-specific commands without needing to
692 run "info threads" first
693
694 - helps pthdb_tid_pthread() work properly (see "libpthdebug
695 peculiarities" at the top of this module)
696
697 - simplifies the demands placed on libpthdebug, which seems to
698 have difficulty with certain call patterns */
699
700 static void
701 sync_threadlists (void)
702 {
703 int cmd, status, infpid;
704 int pcount, psize, pi, gcount, gi;
705 struct pd_thread *pbuf;
706 struct thread_info **gbuf, **g, *thread;
707 pthdb_pthread_t pdtid;
708 pthread_t pthid;
709 pthdb_tid_t tid;
710
711 /* Accumulate an array of libpthdebug threads sorted by pthread id. */
712
713 pcount = 0;
714 psize = 1;
715 pbuf = XNEWVEC (struct pd_thread, psize);
716
717 for (cmd = PTHDB_LIST_FIRST;; cmd = PTHDB_LIST_NEXT)
718 {
719 status = pthdb_pthread (pd_session, &pdtid, cmd);
720 if (status != PTHDB_SUCCESS || pdtid == PTHDB_INVALID_PTHREAD)
721 break;
722
723 status = pthdb_pthread_ptid (pd_session, pdtid, &pthid);
724 if (status != PTHDB_SUCCESS || pthid == PTHDB_INVALID_PTID)
725 continue;
726
727 if (pcount == psize)
728 {
729 psize *= 2;
730 pbuf = (struct pd_thread *) xrealloc (pbuf,
731 psize * sizeof *pbuf);
732 }
733 pbuf[pcount].pdtid = pdtid;
734 pbuf[pcount].pthid = pthid;
735 pcount++;
736 }
737
738 for (pi = 0; pi < pcount; pi++)
739 {
740 status = pthdb_pthread_tid (pd_session, pbuf[pi].pdtid, &tid);
741 if (status != PTHDB_SUCCESS)
742 tid = PTHDB_INVALID_TID;
743 pbuf[pi].tid = tid;
744 }
745
746 qsort (pbuf, pcount, sizeof *pbuf, pcmp);
747
748 /* Accumulate an array of GDB threads sorted by pid. */
749
750 gcount = 0;
751 iterate_over_threads (giter_count, &gcount);
752 g = gbuf = XNEWVEC (struct thread_info *, gcount);
753 iterate_over_threads (giter_accum, &g);
754 qsort (gbuf, gcount, sizeof *gbuf, gcmp);
755
756 /* Apply differences between the two arrays to GDB's thread list. */
757
758 infpid = ptid_get_pid (inferior_ptid);
759 for (pi = gi = 0; pi < pcount || gi < gcount;)
760 {
761 if (pi == pcount)
762 {
763 delete_thread (gbuf[gi]->ptid);
764 gi++;
765 }
766 else if (gi == gcount)
767 {
768 aix_thread_info *priv = new aix_thread_info;
769 priv->pdtid = pbuf[pi].pdtid;
770 priv->tid = pbuf[pi].tid;
771
772 thread = add_thread_with_info (ptid_t (infpid, 0, pbuf[pi].pthid), priv);
773
774 pi++;
775 }
776 else
777 {
778 ptid_t pptid, gptid;
779 int cmp_result;
780
781 pptid = ptid_build (infpid, 0, pbuf[pi].pthid);
782 gptid = gbuf[gi]->ptid;
783 pdtid = pbuf[pi].pdtid;
784 tid = pbuf[pi].tid;
785
786 cmp_result = ptid_cmp (pptid, gptid);
787
788 if (cmp_result == 0)
789 {
790 aix_thread_info *priv = get_aix_thread_info (gbuf[gi]);
791
792 priv->pdtid = pdtid;
793 priv->tid = tid;
794 pi++;
795 gi++;
796 }
797 else if (cmp_result > 0)
798 {
799 delete_thread (gptid);
800 gi++;
801 }
802 else
803 {
804 thread = add_thread (pptid);
805
806 aix_thread_info *priv = new aix_thread_info;
807 thread->priv.reset (priv);
808 priv->pdtid = pdtid;
809 priv->tid = tid;
810 pi++;
811 }
812 }
813 }
814
815 xfree (pbuf);
816 xfree (gbuf);
817 }
818
819 /* Iterate_over_threads() callback for locating a thread, using
820 the TID of its associated kernel thread. */
821
822 static int
823 iter_tid (struct thread_info *thread, void *tidp)
824 {
825 const pthdb_tid_t tid = *(pthdb_tid_t *)tidp;
826 aix_thread_info *priv = get_aix_thread_info (thread);
827
828 return priv->tid == tid;
829 }
830
831 /* Synchronize libpthdebug's state with the inferior and with GDB,
832 generate a composite process/thread <pid> for the current thread,
833 set inferior_ptid to <pid> if SET_INFPID, and return <pid>. */
834
835 static ptid_t
836 pd_update (int set_infpid)
837 {
838 int status;
839 ptid_t ptid;
840 pthdb_tid_t tid;
841 struct thread_info *thread = NULL;
842
843 if (!pd_active)
844 return inferior_ptid;
845
846 status = pthdb_session_update (pd_session);
847 if (status != PTHDB_SUCCESS)
848 return inferior_ptid;
849
850 sync_threadlists ();
851
852 /* Define "current thread" as one that just received a trap signal. */
853
854 tid = get_signaled_thread ();
855 if (tid != 0)
856 thread = iterate_over_threads (iter_tid, &tid);
857 if (!thread)
858 ptid = inferior_ptid;
859 else
860 {
861 ptid = thread->ptid;
862 if (set_infpid)
863 inferior_ptid = ptid;
864 }
865 return ptid;
866 }
867
868 /* Try to start debugging threads in the current process.
869 If successful and SET_INFPID, set inferior_ptid to reflect the
870 current thread. */
871
872 static ptid_t
873 pd_activate (int set_infpid)
874 {
875 int status;
876
877 status = pthdb_session_init (PD_USER, arch64 ? PEM_64BIT : PEM_32BIT,
878 PTHDB_FLAG_REGS, &pd_callbacks,
879 &pd_session);
880 if (status != PTHDB_SUCCESS)
881 {
882 return inferior_ptid;
883 }
884 pd_active = 1;
885 return pd_update (set_infpid);
886 }
887
888 /* Undo the effects of pd_activate(). */
889
890 static void
891 pd_deactivate (void)
892 {
893 if (!pd_active)
894 return;
895 pthdb_session_destroy (pd_session);
896
897 pid_to_prc (&inferior_ptid);
898 pd_active = 0;
899 }
900
901 /* An object file has just been loaded. Check whether the current
902 application is pthreaded, and if so, prepare for thread debugging. */
903
904 static void
905 pd_enable (void)
906 {
907 int status;
908 char *stub_name;
909 struct bound_minimal_symbol ms;
910
911 /* Don't initialize twice. */
912 if (pd_able)
913 return;
914
915 /* Check application word size. */
916 arch64 = register_size (target_gdbarch (), 0) == 8;
917
918 /* Check whether the application is pthreaded. */
919 stub_name = NULL;
920 status = pthdb_session_pthreaded (PD_USER, PTHDB_FLAG_REGS,
921 &pd_callbacks, &stub_name);
922 if ((status != PTHDB_SUCCESS
923 && status != PTHDB_NOT_PTHREADED) || !stub_name)
924 return;
925
926 /* Set a breakpoint on the returned stub function. */
927 ms = lookup_minimal_symbol (stub_name, NULL, NULL);
928 if (ms.minsym == NULL)
929 return;
930 pd_brk_addr = BMSYMBOL_VALUE_ADDRESS (ms);
931 if (!create_thread_event_breakpoint (target_gdbarch (), pd_brk_addr))
932 return;
933
934 /* Prepare for thread debugging. */
935 push_target (&aix_thread_ops);
936 pd_able = 1;
937
938 /* If we're debugging a core file or an attached inferior, the
939 pthread library may already have been initialized, so try to
940 activate thread debugging. */
941 pd_activate (1);
942 }
943
944 /* Undo the effects of pd_enable(). */
945
946 static void
947 pd_disable (void)
948 {
949 if (!pd_able)
950 return;
951 if (pd_active)
952 pd_deactivate ();
953 pd_able = 0;
954 unpush_target (&aix_thread_ops);
955 }
956
957 /* new_objfile observer callback.
958
959 If OBJFILE is non-null, check whether a threaded application is
960 being debugged, and if so, prepare for thread debugging.
961
962 If OBJFILE is null, stop debugging threads. */
963
964 static void
965 new_objfile (struct objfile *objfile)
966 {
967 if (objfile)
968 pd_enable ();
969 else
970 pd_disable ();
971 }
972
973 /* Attach to process specified by ARGS. */
974
975 static void
976 aix_thread_inferior_created (struct target_ops *ops, int from_tty)
977 {
978 pd_enable ();
979 }
980
981 /* Detach from the process attached to by aix_thread_attach(). */
982
983 static void
984 aix_thread_detach (struct target_ops *ops, const char *args, int from_tty)
985 {
986 struct target_ops *beneath = find_target_beneath (ops);
987
988 pd_disable ();
989 beneath->to_detach (beneath, args, from_tty);
990 }
991
992 /* Tell the inferior process to continue running thread PID if != -1
993 and all threads otherwise. */
994
995 static void
996 aix_thread_resume (struct target_ops *ops,
997 ptid_t ptid, int step, enum gdb_signal sig)
998 {
999 struct thread_info *thread;
1000 pthdb_tid_t tid[2];
1001
1002 if (!PD_TID (ptid))
1003 {
1004 scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid);
1005 struct target_ops *beneath = find_target_beneath (ops);
1006
1007 inferior_ptid = pid_to_ptid (ptid_get_pid (inferior_ptid));
1008 beneath->to_resume (beneath, ptid, step, sig);
1009 }
1010 else
1011 {
1012 thread = find_thread_ptid (ptid);
1013 if (!thread)
1014 error (_("aix-thread resume: unknown pthread %ld"),
1015 ptid_get_lwp (ptid));
1016
1017 aix_thread_info *priv = get_aix_thread_info (thread);
1018
1019 tid[0] = priv->tid;
1020 if (tid[0] == PTHDB_INVALID_TID)
1021 error (_("aix-thread resume: no tid for pthread %ld"),
1022 ptid_get_lwp (ptid));
1023 tid[1] = 0;
1024
1025 if (arch64)
1026 ptrace64aix (PTT_CONTINUE, tid[0], (long long) 1,
1027 gdb_signal_to_host (sig), (PTRACE_TYPE_ARG5) tid);
1028 else
1029 ptrace32 (PTT_CONTINUE, tid[0], (addr_ptr) 1,
1030 gdb_signal_to_host (sig), (PTRACE_TYPE_ARG5) tid);
1031 }
1032 }
1033
1034 /* Wait for thread/process ID if != -1 or for any thread otherwise.
1035 If an error occurs, return -1, else return the pid of the stopped
1036 thread. */
1037
1038 static ptid_t
1039 aix_thread_wait (struct target_ops *ops,
1040 ptid_t ptid, struct target_waitstatus *status, int options)
1041 {
1042 struct target_ops *beneath = find_target_beneath (ops);
1043
1044 {
1045 scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid);
1046
1047 pid_to_prc (&ptid);
1048
1049 inferior_ptid = pid_to_ptid (ptid_get_pid (inferior_ptid));
1050 ptid = beneath->to_wait (beneath, ptid, status, options);
1051 }
1052
1053 if (ptid_get_pid (ptid) == -1)
1054 return pid_to_ptid (-1);
1055
1056 /* Check whether libpthdebug might be ready to be initialized. */
1057 if (!pd_active && status->kind == TARGET_WAITKIND_STOPPED
1058 && status->value.sig == GDB_SIGNAL_TRAP)
1059 {
1060 struct regcache *regcache = get_thread_regcache (ptid);
1061 struct gdbarch *gdbarch = regcache->arch ();
1062
1063 if (regcache_read_pc (regcache)
1064 - gdbarch_decr_pc_after_break (gdbarch) == pd_brk_addr)
1065 return pd_activate (0);
1066 }
1067
1068 return pd_update (0);
1069 }
1070
1071 /* Record that the 64-bit general-purpose registers contain VALS. */
1072
1073 static void
1074 supply_gprs64 (struct regcache *regcache, uint64_t *vals)
1075 {
1076 struct gdbarch_tdep *tdep = gdbarch_tdep (regcache->arch ());
1077 int regno;
1078
1079 for (regno = 0; regno < ppc_num_gprs; regno++)
1080 regcache_raw_supply (regcache, tdep->ppc_gp0_regnum + regno,
1081 (char *) (vals + regno));
1082 }
1083
1084 /* Record that 32-bit register REGNO contains VAL. */
1085
1086 static void
1087 supply_reg32 (struct regcache *regcache, int regno, uint32_t val)
1088 {
1089 regcache_raw_supply (regcache, regno, (char *) &val);
1090 }
1091
1092 /* Record that the floating-point registers contain VALS. */
1093
1094 static void
1095 supply_fprs (struct regcache *regcache, double *vals)
1096 {
1097 struct gdbarch *gdbarch = regcache->arch ();
1098 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1099 int regno;
1100
1101 /* This function should never be called on architectures without
1102 floating-point registers. */
1103 gdb_assert (ppc_floating_point_unit_p (gdbarch));
1104
1105 for (regno = tdep->ppc_fp0_regnum;
1106 regno < tdep->ppc_fp0_regnum + ppc_num_fprs;
1107 regno++)
1108 regcache_raw_supply (regcache, regno,
1109 (char *) (vals + regno - tdep->ppc_fp0_regnum));
1110 }
1111
1112 /* Predicate to test whether given register number is a "special" register. */
1113 static int
1114 special_register_p (struct gdbarch *gdbarch, int regno)
1115 {
1116 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1117
1118 return regno == gdbarch_pc_regnum (gdbarch)
1119 || regno == tdep->ppc_ps_regnum
1120 || regno == tdep->ppc_cr_regnum
1121 || regno == tdep->ppc_lr_regnum
1122 || regno == tdep->ppc_ctr_regnum
1123 || regno == tdep->ppc_xer_regnum
1124 || (tdep->ppc_fpscr_regnum >= 0 && regno == tdep->ppc_fpscr_regnum)
1125 || (tdep->ppc_mq_regnum >= 0 && regno == tdep->ppc_mq_regnum);
1126 }
1127
1128
1129 /* Record that the special registers contain the specified 64-bit and
1130 32-bit values. */
1131
1132 static void
1133 supply_sprs64 (struct regcache *regcache,
1134 uint64_t iar, uint64_t msr, uint32_t cr,
1135 uint64_t lr, uint64_t ctr, uint32_t xer,
1136 uint32_t fpscr)
1137 {
1138 struct gdbarch *gdbarch = regcache->arch ();
1139 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1140
1141 regcache_raw_supply (regcache, gdbarch_pc_regnum (gdbarch),
1142 (char *) &iar);
1143 regcache_raw_supply (regcache, tdep->ppc_ps_regnum, (char *) &msr);
1144 regcache_raw_supply (regcache, tdep->ppc_cr_regnum, (char *) &cr);
1145 regcache_raw_supply (regcache, tdep->ppc_lr_regnum, (char *) &lr);
1146 regcache_raw_supply (regcache, tdep->ppc_ctr_regnum, (char *) &ctr);
1147 regcache_raw_supply (regcache, tdep->ppc_xer_regnum, (char *) &xer);
1148 if (tdep->ppc_fpscr_regnum >= 0)
1149 regcache_raw_supply (regcache, tdep->ppc_fpscr_regnum,
1150 (char *) &fpscr);
1151 }
1152
1153 /* Record that the special registers contain the specified 32-bit
1154 values. */
1155
1156 static void
1157 supply_sprs32 (struct regcache *regcache,
1158 uint32_t iar, uint32_t msr, uint32_t cr,
1159 uint32_t lr, uint32_t ctr, uint32_t xer,
1160 uint32_t fpscr)
1161 {
1162 struct gdbarch *gdbarch = regcache->arch ();
1163 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1164
1165 regcache_raw_supply (regcache, gdbarch_pc_regnum (gdbarch),
1166 (char *) &iar);
1167 regcache_raw_supply (regcache, tdep->ppc_ps_regnum, (char *) &msr);
1168 regcache_raw_supply (regcache, tdep->ppc_cr_regnum, (char *) &cr);
1169 regcache_raw_supply (regcache, tdep->ppc_lr_regnum, (char *) &lr);
1170 regcache_raw_supply (regcache, tdep->ppc_ctr_regnum, (char *) &ctr);
1171 regcache_raw_supply (regcache, tdep->ppc_xer_regnum, (char *) &xer);
1172 if (tdep->ppc_fpscr_regnum >= 0)
1173 regcache_raw_supply (regcache, tdep->ppc_fpscr_regnum,
1174 (char *) &fpscr);
1175 }
1176
1177 /* Fetch all registers from pthread PDTID, which doesn't have a kernel
1178 thread.
1179
1180 There's no way to query a single register from a non-kernel
1181 pthread, so there's no need for a single-register version of this
1182 function. */
1183
1184 static void
1185 fetch_regs_user_thread (struct regcache *regcache, pthdb_pthread_t pdtid)
1186 {
1187 struct gdbarch *gdbarch = regcache->arch ();
1188 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1189 int status, i;
1190 pthdb_context_t ctx;
1191
1192 if (debug_aix_thread)
1193 fprintf_unfiltered (gdb_stdlog,
1194 "fetch_regs_user_thread %lx\n", (long) pdtid);
1195 status = pthdb_pthread_context (pd_session, pdtid, &ctx);
1196 if (status != PTHDB_SUCCESS)
1197 error (_("aix-thread: fetch_registers: pthdb_pthread_context returned %s"),
1198 pd_status2str (status));
1199
1200 /* General-purpose registers. */
1201
1202 if (arch64)
1203 supply_gprs64 (regcache, ctx.gpr);
1204 else
1205 for (i = 0; i < ppc_num_gprs; i++)
1206 supply_reg32 (regcache, tdep->ppc_gp0_regnum + i, ctx.gpr[i]);
1207
1208 /* Floating-point registers. */
1209
1210 if (ppc_floating_point_unit_p (gdbarch))
1211 supply_fprs (regcache, ctx.fpr);
1212
1213 /* Special registers. */
1214
1215 if (arch64)
1216 supply_sprs64 (regcache, ctx.iar, ctx.msr, ctx.cr, ctx.lr, ctx.ctr,
1217 ctx.xer, ctx.fpscr);
1218 else
1219 supply_sprs32 (regcache, ctx.iar, ctx.msr, ctx.cr, ctx.lr, ctx.ctr,
1220 ctx.xer, ctx.fpscr);
1221 }
1222
1223 /* Fetch register REGNO if != -1 or all registers otherwise from
1224 kernel thread TID.
1225
1226 AIX provides a way to query all of a kernel thread's GPRs, FPRs, or
1227 SPRs, but there's no way to query individual registers within those
1228 groups. Therefore, if REGNO != -1, this function fetches an entire
1229 group.
1230
1231 Unfortunately, kernel thread register queries often fail with
1232 EPERM, indicating that the thread is in kernel space. This breaks
1233 backtraces of threads other than the current one. To make that
1234 breakage obvious without throwing an error to top level (which is
1235 bad e.g. during "info threads" output), zero registers that can't
1236 be retrieved. */
1237
1238 static void
1239 fetch_regs_kernel_thread (struct regcache *regcache, int regno,
1240 pthdb_tid_t tid)
1241 {
1242 struct gdbarch *gdbarch = regcache->arch ();
1243 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1244 uint64_t gprs64[ppc_num_gprs];
1245 uint32_t gprs32[ppc_num_gprs];
1246 double fprs[ppc_num_fprs];
1247 struct ptxsprs sprs64;
1248 struct ptsprs sprs32;
1249 int i;
1250
1251 if (debug_aix_thread)
1252 fprintf_unfiltered (gdb_stdlog,
1253 "fetch_regs_kernel_thread tid=%lx regno=%d arch64=%d\n",
1254 (long) tid, regno, arch64);
1255
1256 /* General-purpose registers. */
1257 if (regno == -1
1258 || (tdep->ppc_gp0_regnum <= regno
1259 && regno < tdep->ppc_gp0_regnum + ppc_num_gprs))
1260 {
1261 if (arch64)
1262 {
1263 if (!ptrace64aix (PTT_READ_GPRS, tid,
1264 (unsigned long) gprs64, 0, NULL))
1265 memset (gprs64, 0, sizeof (gprs64));
1266 supply_gprs64 (regcache, gprs64);
1267 }
1268 else
1269 {
1270 if (!ptrace32 (PTT_READ_GPRS, tid, (uintptr_t) gprs32, 0, NULL))
1271 memset (gprs32, 0, sizeof (gprs32));
1272 for (i = 0; i < ppc_num_gprs; i++)
1273 supply_reg32 (regcache, tdep->ppc_gp0_regnum + i, gprs32[i]);
1274 }
1275 }
1276
1277 /* Floating-point registers. */
1278
1279 if (ppc_floating_point_unit_p (gdbarch)
1280 && (regno == -1
1281 || (regno >= tdep->ppc_fp0_regnum
1282 && regno < tdep->ppc_fp0_regnum + ppc_num_fprs)))
1283 {
1284 if (!ptrace32 (PTT_READ_FPRS, tid, (uintptr_t) fprs, 0, NULL))
1285 memset (fprs, 0, sizeof (fprs));
1286 supply_fprs (regcache, fprs);
1287 }
1288
1289 /* Special-purpose registers. */
1290
1291 if (regno == -1 || special_register_p (gdbarch, regno))
1292 {
1293 if (arch64)
1294 {
1295 if (!ptrace64aix (PTT_READ_SPRS, tid,
1296 (unsigned long) &sprs64, 0, NULL))
1297 memset (&sprs64, 0, sizeof (sprs64));
1298 supply_sprs64 (regcache, sprs64.pt_iar, sprs64.pt_msr,
1299 sprs64.pt_cr, sprs64.pt_lr, sprs64.pt_ctr,
1300 sprs64.pt_xer, sprs64.pt_fpscr);
1301 }
1302 else
1303 {
1304 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1305
1306 if (!ptrace32 (PTT_READ_SPRS, tid, (uintptr_t) &sprs32, 0, NULL))
1307 memset (&sprs32, 0, sizeof (sprs32));
1308 supply_sprs32 (regcache, sprs32.pt_iar, sprs32.pt_msr, sprs32.pt_cr,
1309 sprs32.pt_lr, sprs32.pt_ctr, sprs32.pt_xer,
1310 sprs32.pt_fpscr);
1311
1312 if (tdep->ppc_mq_regnum >= 0)
1313 regcache_raw_supply (regcache, tdep->ppc_mq_regnum,
1314 (char *) &sprs32.pt_mq);
1315 }
1316 }
1317 }
1318
1319 /* Fetch register REGNO if != -1 or all registers otherwise from the
1320 thread/process connected to REGCACHE. */
1321
1322 static void
1323 aix_thread_fetch_registers (struct target_ops *ops,
1324 struct regcache *regcache, int regno)
1325 {
1326 struct thread_info *thread;
1327 pthdb_tid_t tid;
1328 struct target_ops *beneath = find_target_beneath (ops);
1329
1330 if (!PD_TID (regcache_get_ptid (regcache)))
1331 beneath->to_fetch_registers (beneath, regcache, regno);
1332 else
1333 {
1334 thread = find_thread_ptid (regcache_get_ptid (regcache));
1335 aix_thread_info *priv = get_aix_thread_info (thread);
1336 tid = priv->tid;
1337
1338 if (tid == PTHDB_INVALID_TID)
1339 fetch_regs_user_thread (regcache, priv->pdtid);
1340 else
1341 fetch_regs_kernel_thread (regcache, regno, tid);
1342 }
1343 }
1344
1345 /* Store the gp registers into an array of uint32_t or uint64_t. */
1346
1347 static void
1348 fill_gprs64 (const struct regcache *regcache, uint64_t *vals)
1349 {
1350 struct gdbarch_tdep *tdep = gdbarch_tdep (regcache->arch ());
1351 int regno;
1352
1353 for (regno = 0; regno < ppc_num_gprs; regno++)
1354 if (REG_VALID == regcache_register_status (regcache,
1355 tdep->ppc_gp0_regnum + regno))
1356 regcache_raw_collect (regcache, tdep->ppc_gp0_regnum + regno,
1357 vals + regno);
1358 }
1359
1360 static void
1361 fill_gprs32 (const struct regcache *regcache, uint32_t *vals)
1362 {
1363 struct gdbarch_tdep *tdep = gdbarch_tdep (regcache->arch ());
1364 int regno;
1365
1366 for (regno = 0; regno < ppc_num_gprs; regno++)
1367 if (REG_VALID == regcache_register_status (regcache,
1368 tdep->ppc_gp0_regnum + regno))
1369 regcache_raw_collect (regcache, tdep->ppc_gp0_regnum + regno,
1370 vals + regno);
1371 }
1372
1373 /* Store the floating point registers into a double array. */
1374 static void
1375 fill_fprs (const struct regcache *regcache, double *vals)
1376 {
1377 struct gdbarch *gdbarch = regcache->arch ();
1378 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1379 int regno;
1380
1381 /* This function should never be called on architectures without
1382 floating-point registers. */
1383 gdb_assert (ppc_floating_point_unit_p (gdbarch));
1384
1385 for (regno = tdep->ppc_fp0_regnum;
1386 regno < tdep->ppc_fp0_regnum + ppc_num_fprs;
1387 regno++)
1388 if (REG_VALID == regcache_register_status (regcache, regno))
1389 regcache_raw_collect (regcache, regno,
1390 vals + regno - tdep->ppc_fp0_regnum);
1391 }
1392
1393 /* Store the special registers into the specified 64-bit and 32-bit
1394 locations. */
1395
1396 static void
1397 fill_sprs64 (const struct regcache *regcache,
1398 uint64_t *iar, uint64_t *msr, uint32_t *cr,
1399 uint64_t *lr, uint64_t *ctr, uint32_t *xer,
1400 uint32_t *fpscr)
1401 {
1402 struct gdbarch *gdbarch = regcache->arch ();
1403 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1404
1405 /* Verify that the size of the size of the IAR buffer is the
1406 same as the raw size of the PC (in the register cache). If
1407 they're not, then either GDB has been built incorrectly, or
1408 there's some other kind of internal error. To be really safe,
1409 we should check all of the sizes. */
1410 gdb_assert (sizeof (*iar) == register_size
1411 (gdbarch, gdbarch_pc_regnum (gdbarch)));
1412
1413 if (REG_VALID == regcache_register_status (regcache,
1414 gdbarch_pc_regnum (gdbarch)))
1415 regcache_raw_collect (regcache, gdbarch_pc_regnum (gdbarch), iar);
1416 if (REG_VALID == regcache_register_status (regcache, tdep->ppc_ps_regnum))
1417 regcache_raw_collect (regcache, tdep->ppc_ps_regnum, msr);
1418 if (REG_VALID == regcache_register_status (regcache, tdep->ppc_cr_regnum))
1419 regcache_raw_collect (regcache, tdep->ppc_cr_regnum, cr);
1420 if (REG_VALID == regcache_register_status (regcache, tdep->ppc_lr_regnum))
1421 regcache_raw_collect (regcache, tdep->ppc_lr_regnum, lr);
1422 if (REG_VALID == regcache_register_status (regcache, tdep->ppc_ctr_regnum))
1423 regcache_raw_collect (regcache, tdep->ppc_ctr_regnum, ctr);
1424 if (REG_VALID == regcache_register_status (regcache, tdep->ppc_xer_regnum))
1425 regcache_raw_collect (regcache, tdep->ppc_xer_regnum, xer);
1426 if (tdep->ppc_fpscr_regnum >= 0
1427 && REG_VALID == regcache_register_status (regcache,
1428 tdep->ppc_fpscr_regnum))
1429 regcache_raw_collect (regcache, tdep->ppc_fpscr_regnum, fpscr);
1430 }
1431
1432 static void
1433 fill_sprs32 (const struct regcache *regcache,
1434 uint32_t *iar, uint32_t *msr, uint32_t *cr,
1435 uint32_t *lr, uint32_t *ctr, uint32_t *xer,
1436 uint32_t *fpscr)
1437 {
1438 struct gdbarch *gdbarch = regcache->arch ();
1439 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1440
1441 /* Verify that the size of the size of the IAR buffer is the
1442 same as the raw size of the PC (in the register cache). If
1443 they're not, then either GDB has been built incorrectly, or
1444 there's some other kind of internal error. To be really safe,
1445 we should check all of the sizes. */
1446 gdb_assert (sizeof (*iar) == register_size (gdbarch,
1447 gdbarch_pc_regnum (gdbarch)));
1448
1449 if (REG_VALID == regcache_register_status (regcache,
1450 gdbarch_pc_regnum (gdbarch)))
1451 regcache_raw_collect (regcache, gdbarch_pc_regnum (gdbarch), iar);
1452 if (REG_VALID == regcache_register_status (regcache, tdep->ppc_ps_regnum))
1453 regcache_raw_collect (regcache, tdep->ppc_ps_regnum, msr);
1454 if (REG_VALID == regcache_register_status (regcache, tdep->ppc_cr_regnum))
1455 regcache_raw_collect (regcache, tdep->ppc_cr_regnum, cr);
1456 if (REG_VALID == regcache_register_status (regcache, tdep->ppc_lr_regnum))
1457 regcache_raw_collect (regcache, tdep->ppc_lr_regnum, lr);
1458 if (REG_VALID == regcache_register_status (regcache, tdep->ppc_ctr_regnum))
1459 regcache_raw_collect (regcache, tdep->ppc_ctr_regnum, ctr);
1460 if (REG_VALID == regcache_register_status (regcache, tdep->ppc_xer_regnum))
1461 regcache_raw_collect (regcache, tdep->ppc_xer_regnum, xer);
1462 if (tdep->ppc_fpscr_regnum >= 0
1463 && REG_VALID == regcache_register_status (regcache, tdep->ppc_fpscr_regnum))
1464 regcache_raw_collect (regcache, tdep->ppc_fpscr_regnum, fpscr);
1465 }
1466
1467 /* Store all registers into pthread PDTID, which doesn't have a kernel
1468 thread.
1469
1470 It's possible to store a single register into a non-kernel pthread,
1471 but I doubt it's worth the effort. */
1472
1473 static void
1474 store_regs_user_thread (const struct regcache *regcache, pthdb_pthread_t pdtid)
1475 {
1476 struct gdbarch *gdbarch = regcache->arch ();
1477 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1478 int status, i;
1479 pthdb_context_t ctx;
1480 uint32_t int32;
1481 uint64_t int64;
1482 double dbl;
1483
1484 if (debug_aix_thread)
1485 fprintf_unfiltered (gdb_stdlog,
1486 "store_regs_user_thread %lx\n", (long) pdtid);
1487
1488 /* Retrieve the thread's current context for its non-register
1489 values. */
1490 status = pthdb_pthread_context (pd_session, pdtid, &ctx);
1491 if (status != PTHDB_SUCCESS)
1492 error (_("aix-thread: store_registers: pthdb_pthread_context returned %s"),
1493 pd_status2str (status));
1494
1495 /* Collect general-purpose register values from the regcache. */
1496
1497 for (i = 0; i < ppc_num_gprs; i++)
1498 if (REG_VALID == regcache_register_status (regcache,
1499 tdep->ppc_gp0_regnum + i))
1500 {
1501 if (arch64)
1502 {
1503 regcache_raw_collect (regcache, tdep->ppc_gp0_regnum + i,
1504 (void *) &int64);
1505 ctx.gpr[i] = int64;
1506 }
1507 else
1508 {
1509 regcache_raw_collect (regcache, tdep->ppc_gp0_regnum + i,
1510 (void *) &int32);
1511 ctx.gpr[i] = int32;
1512 }
1513 }
1514
1515 /* Collect floating-point register values from the regcache. */
1516 if (ppc_floating_point_unit_p (gdbarch))
1517 fill_fprs (regcache, ctx.fpr);
1518
1519 /* Special registers (always kept in ctx as 64 bits). */
1520 if (arch64)
1521 {
1522 fill_sprs64 (regcache, &ctx.iar, &ctx.msr, &ctx.cr, &ctx.lr, &ctx.ctr,
1523 &ctx.xer, &ctx.fpscr);
1524 }
1525 else
1526 {
1527 /* Problem: ctx.iar etc. are 64 bits, but raw_registers are 32.
1528 Solution: use 32-bit temp variables. */
1529 uint32_t tmp_iar, tmp_msr, tmp_cr, tmp_lr, tmp_ctr, tmp_xer,
1530 tmp_fpscr;
1531
1532 fill_sprs32 (regcache, &tmp_iar, &tmp_msr, &tmp_cr, &tmp_lr, &tmp_ctr,
1533 &tmp_xer, &tmp_fpscr);
1534 if (REG_VALID == regcache_register_status (regcache,
1535 gdbarch_pc_regnum (gdbarch)))
1536 ctx.iar = tmp_iar;
1537 if (REG_VALID == regcache_register_status (regcache, tdep->ppc_ps_regnum))
1538 ctx.msr = tmp_msr;
1539 if (REG_VALID == regcache_register_status (regcache, tdep->ppc_cr_regnum))
1540 ctx.cr = tmp_cr;
1541 if (REG_VALID == regcache_register_status (regcache, tdep->ppc_lr_regnum))
1542 ctx.lr = tmp_lr;
1543 if (REG_VALID == regcache_register_status (regcache,
1544 tdep->ppc_ctr_regnum))
1545 ctx.ctr = tmp_ctr;
1546 if (REG_VALID == regcache_register_status (regcache,
1547 tdep->ppc_xer_regnum))
1548 ctx.xer = tmp_xer;
1549 if (REG_VALID == regcache_register_status (regcache,
1550 tdep->ppc_xer_regnum))
1551 ctx.fpscr = tmp_fpscr;
1552 }
1553
1554 status = pthdb_pthread_setcontext (pd_session, pdtid, &ctx);
1555 if (status != PTHDB_SUCCESS)
1556 error (_("aix-thread: store_registers: "
1557 "pthdb_pthread_setcontext returned %s"),
1558 pd_status2str (status));
1559 }
1560
1561 /* Store register REGNO if != -1 or all registers otherwise into
1562 kernel thread TID.
1563
1564 AIX provides a way to set all of a kernel thread's GPRs, FPRs, or
1565 SPRs, but there's no way to set individual registers within those
1566 groups. Therefore, if REGNO != -1, this function stores an entire
1567 group. */
1568
1569 static void
1570 store_regs_kernel_thread (const struct regcache *regcache, int regno,
1571 pthdb_tid_t tid)
1572 {
1573 struct gdbarch *gdbarch = regcache->arch ();
1574 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1575 uint64_t gprs64[ppc_num_gprs];
1576 uint32_t gprs32[ppc_num_gprs];
1577 double fprs[ppc_num_fprs];
1578 struct ptxsprs sprs64;
1579 struct ptsprs sprs32;
1580 int i;
1581
1582 if (debug_aix_thread)
1583 fprintf_unfiltered (gdb_stdlog,
1584 "store_regs_kernel_thread tid=%lx regno=%d\n",
1585 (long) tid, regno);
1586
1587 /* General-purpose registers. */
1588 if (regno == -1
1589 || (tdep->ppc_gp0_regnum <= regno
1590 && regno < tdep->ppc_gp0_regnum + ppc_num_fprs))
1591 {
1592 if (arch64)
1593 {
1594 /* Pre-fetch: some regs may not be in the cache. */
1595 ptrace64aix (PTT_READ_GPRS, tid, (unsigned long) gprs64, 0, NULL);
1596 fill_gprs64 (regcache, gprs64);
1597 ptrace64aix (PTT_WRITE_GPRS, tid, (unsigned long) gprs64, 0, NULL);
1598 }
1599 else
1600 {
1601 /* Pre-fetch: some regs may not be in the cache. */
1602 ptrace32 (PTT_READ_GPRS, tid, (uintptr_t) gprs32, 0, NULL);
1603 fill_gprs32 (regcache, gprs32);
1604 ptrace32 (PTT_WRITE_GPRS, tid, (uintptr_t) gprs32, 0, NULL);
1605 }
1606 }
1607
1608 /* Floating-point registers. */
1609
1610 if (ppc_floating_point_unit_p (gdbarch)
1611 && (regno == -1
1612 || (regno >= tdep->ppc_fp0_regnum
1613 && regno < tdep->ppc_fp0_regnum + ppc_num_fprs)))
1614 {
1615 /* Pre-fetch: some regs may not be in the cache. */
1616 ptrace32 (PTT_READ_FPRS, tid, (uintptr_t) fprs, 0, NULL);
1617 fill_fprs (regcache, fprs);
1618 ptrace32 (PTT_WRITE_FPRS, tid, (uintptr_t) fprs, 0, NULL);
1619 }
1620
1621 /* Special-purpose registers. */
1622
1623 if (regno == -1 || special_register_p (gdbarch, regno))
1624 {
1625 if (arch64)
1626 {
1627 /* Pre-fetch: some registers won't be in the cache. */
1628 ptrace64aix (PTT_READ_SPRS, tid,
1629 (unsigned long) &sprs64, 0, NULL);
1630 fill_sprs64 (regcache, &sprs64.pt_iar, &sprs64.pt_msr,
1631 &sprs64.pt_cr, &sprs64.pt_lr, &sprs64.pt_ctr,
1632 &sprs64.pt_xer, &sprs64.pt_fpscr);
1633 ptrace64aix (PTT_WRITE_SPRS, tid,
1634 (unsigned long) &sprs64, 0, NULL);
1635 }
1636 else
1637 {
1638 /* The contents of "struct ptspr" were declared as "unsigned
1639 long" up to AIX 5.2, but are "unsigned int" since 5.3.
1640 Use temporaries to work around this problem. Also, add an
1641 assert here to make sure we fail if the system header files
1642 use "unsigned long", and the size of that type is not what
1643 the headers expect. */
1644 uint32_t tmp_iar, tmp_msr, tmp_cr, tmp_lr, tmp_ctr, tmp_xer,
1645 tmp_fpscr;
1646
1647 gdb_assert (sizeof (sprs32.pt_iar) == 4);
1648
1649 /* Pre-fetch: some registers won't be in the cache. */
1650 ptrace32 (PTT_READ_SPRS, tid, (uintptr_t) &sprs32, 0, NULL);
1651
1652 fill_sprs32 (regcache, &tmp_iar, &tmp_msr, &tmp_cr, &tmp_lr,
1653 &tmp_ctr, &tmp_xer, &tmp_fpscr);
1654
1655 sprs32.pt_iar = tmp_iar;
1656 sprs32.pt_msr = tmp_msr;
1657 sprs32.pt_cr = tmp_cr;
1658 sprs32.pt_lr = tmp_lr;
1659 sprs32.pt_ctr = tmp_ctr;
1660 sprs32.pt_xer = tmp_xer;
1661 sprs32.pt_fpscr = tmp_fpscr;
1662
1663 if (tdep->ppc_mq_regnum >= 0)
1664 if (REG_VALID == regcache_register_status (regcache,
1665 tdep->ppc_mq_regnum))
1666 regcache_raw_collect (regcache, tdep->ppc_mq_regnum,
1667 &sprs32.pt_mq);
1668
1669 ptrace32 (PTT_WRITE_SPRS, tid, (uintptr_t) &sprs32, 0, NULL);
1670 }
1671 }
1672 }
1673
1674 /* Store gdb's current view of the register set into the
1675 thread/process connected to REGCACHE. */
1676
1677 static void
1678 aix_thread_store_registers (struct target_ops *ops,
1679 struct regcache *regcache, int regno)
1680 {
1681 struct thread_info *thread;
1682 pthdb_tid_t tid;
1683 struct target_ops *beneath = find_target_beneath (ops);
1684
1685 if (!PD_TID (regcache_get_ptid (regcache)))
1686 beneath->to_store_registers (beneath, regcache, regno);
1687 else
1688 {
1689 thread = find_thread_ptid (regcache_get_ptid (regcache));
1690 aix_thread_info *priv = get_aix_thread_info (thread);
1691 tid = priv->tid;
1692
1693 if (tid == PTHDB_INVALID_TID)
1694 store_regs_user_thread (regcache, priv->pdtid);
1695 else
1696 store_regs_kernel_thread (regcache, regno, tid);
1697 }
1698 }
1699
1700 /* Implement the to_xfer_partial target_ops method. */
1701
1702 static enum target_xfer_status
1703 aix_thread_xfer_partial (struct target_ops *ops, enum target_object object,
1704 const char *annex, gdb_byte *readbuf,
1705 const gdb_byte *writebuf,
1706 ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
1707 {
1708 scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid);
1709 struct target_ops *beneath = find_target_beneath (ops);
1710
1711 inferior_ptid = pid_to_ptid (ptid_get_pid (inferior_ptid));
1712 return beneath->to_xfer_partial (beneath, object, annex, readbuf,
1713 writebuf, offset, len, xfered_len);
1714 }
1715
1716 /* Clean up after the inferior exits. */
1717
1718 static void
1719 aix_thread_mourn_inferior (struct target_ops *ops)
1720 {
1721 struct target_ops *beneath = find_target_beneath (ops);
1722
1723 pd_deactivate ();
1724 beneath->to_mourn_inferior (beneath);
1725 }
1726
1727 /* Return whether thread PID is still valid. */
1728
1729 static int
1730 aix_thread_thread_alive (struct target_ops *ops, ptid_t ptid)
1731 {
1732 struct target_ops *beneath = find_target_beneath (ops);
1733
1734 if (!PD_TID (ptid))
1735 return beneath->to_thread_alive (beneath, ptid);
1736
1737 /* We update the thread list every time the child stops, so all
1738 valid threads should be in the thread list. */
1739 return in_thread_list (ptid);
1740 }
1741
1742 /* Return a printable representation of composite PID for use in
1743 "info threads" output. */
1744
1745 static const char *
1746 aix_thread_pid_to_str (struct target_ops *ops, ptid_t ptid)
1747 {
1748 static char *ret = NULL;
1749 struct target_ops *beneath = find_target_beneath (ops);
1750
1751 if (!PD_TID (ptid))
1752 return beneath->to_pid_to_str (beneath, ptid);
1753
1754 /* Free previous return value; a new one will be allocated by
1755 xstrprintf(). */
1756 xfree (ret);
1757
1758 ret = xstrprintf (_("Thread %ld"), ptid_get_tid (ptid));
1759 return ret;
1760 }
1761
1762 /* Return a printable representation of extra information about
1763 THREAD, for use in "info threads" output. */
1764
1765 static const char *
1766 aix_thread_extra_thread_info (struct target_ops *self,
1767 struct thread_info *thread)
1768 {
1769 int status;
1770 pthdb_pthread_t pdtid;
1771 pthdb_tid_t tid;
1772 pthdb_state_t state;
1773 pthdb_suspendstate_t suspendstate;
1774 pthdb_detachstate_t detachstate;
1775 int cancelpend;
1776 static char *ret = NULL;
1777
1778 if (!PD_TID (thread->ptid))
1779 return NULL;
1780
1781 string_file buf;
1782 aix_thread_info *priv = get_aix_thread_info (thread);
1783
1784 pdtid = priv->pdtid;
1785 tid = priv->tid;
1786
1787 if (tid != PTHDB_INVALID_TID)
1788 /* i18n: Like "thread-identifier %d, [state] running, suspended" */
1789 buf.printf (_("tid %d"), (int)tid);
1790
1791 status = pthdb_pthread_state (pd_session, pdtid, &state);
1792 if (status != PTHDB_SUCCESS)
1793 state = PST_NOTSUP;
1794 buf.printf (", %s", state2str (state));
1795
1796 status = pthdb_pthread_suspendstate (pd_session, pdtid,
1797 &suspendstate);
1798 if (status == PTHDB_SUCCESS && suspendstate == PSS_SUSPENDED)
1799 /* i18n: Like "Thread-Id %d, [state] running, suspended" */
1800 buf.printf (_(", suspended"));
1801
1802 status = pthdb_pthread_detachstate (pd_session, pdtid,
1803 &detachstate);
1804 if (status == PTHDB_SUCCESS && detachstate == PDS_DETACHED)
1805 /* i18n: Like "Thread-Id %d, [state] running, detached" */
1806 buf.printf (_(", detached"));
1807
1808 pthdb_pthread_cancelpend (pd_session, pdtid, &cancelpend);
1809 if (status == PTHDB_SUCCESS && cancelpend)
1810 /* i18n: Like "Thread-Id %d, [state] running, cancel pending" */
1811 buf.printf (_(", cancel pending"));
1812
1813 buf.write ("", 1);
1814
1815 xfree (ret); /* Free old buffer. */
1816
1817 ret = xstrdup (buf.c_str ());
1818
1819 return ret;
1820 }
1821
1822 static ptid_t
1823 aix_thread_get_ada_task_ptid (struct target_ops *self, long lwp, long thread)
1824 {
1825 return ptid_build (ptid_get_pid (inferior_ptid), 0, thread);
1826 }
1827
1828 /* Initialize target aix_thread_ops. */
1829
1830 static void
1831 init_aix_thread_ops (void)
1832 {
1833 aix_thread_ops.to_shortname = "aix-threads";
1834 aix_thread_ops.to_longname = _("AIX pthread support");
1835 aix_thread_ops.to_doc = _("AIX pthread support");
1836
1837 aix_thread_ops.to_detach = aix_thread_detach;
1838 aix_thread_ops.to_resume = aix_thread_resume;
1839 aix_thread_ops.to_wait = aix_thread_wait;
1840 aix_thread_ops.to_fetch_registers = aix_thread_fetch_registers;
1841 aix_thread_ops.to_store_registers = aix_thread_store_registers;
1842 aix_thread_ops.to_xfer_partial = aix_thread_xfer_partial;
1843 aix_thread_ops.to_mourn_inferior = aix_thread_mourn_inferior;
1844 aix_thread_ops.to_thread_alive = aix_thread_thread_alive;
1845 aix_thread_ops.to_pid_to_str = aix_thread_pid_to_str;
1846 aix_thread_ops.to_extra_thread_info = aix_thread_extra_thread_info;
1847 aix_thread_ops.to_get_ada_task_ptid = aix_thread_get_ada_task_ptid;
1848 aix_thread_ops.to_stratum = thread_stratum;
1849 aix_thread_ops.to_magic = OPS_MAGIC;
1850 }
1851
1852 /* Module startup initialization function, automagically called by
1853 init.c. */
1854
1855 void
1856 _initialize_aix_thread (void)
1857 {
1858 init_aix_thread_ops ();
1859 complete_target_initialization (&aix_thread_ops);
1860
1861 /* Notice when object files get loaded and unloaded. */
1862 observer_attach_new_objfile (new_objfile);
1863
1864 /* Add ourselves to inferior_created event chain.
1865 This is needed to enable the thread target on "attach". */
1866 observer_attach_inferior_created (aix_thread_inferior_created);
1867
1868 add_setshow_boolean_cmd ("aix-thread", class_maintenance, &debug_aix_thread,
1869 _("Set debugging of AIX thread module."),
1870 _("Show debugging of AIX thread module."),
1871 _("Enables debugging output (used to debug GDB)."),
1872 NULL, NULL,
1873 /* FIXME: i18n: Debugging of AIX thread
1874 module is \"%d\". */
1875 &setdebuglist, &showdebuglist);
1876 }
fill_fprs
static void fill_fprs(const struct regcache *regcache, double *vals)
Definition: aix-thread.c:1375
target_gdbarch
struct gdbarch * target_gdbarch(void)
Definition: gdbarch.c:5467
gdbarch
Definition: gdbarch.c:127
hex_string
char * hex_string(LONGEST num)
Definition: print-utils.c:220
pd_disable
static void pd_disable(void)
Definition: aix-thread.c:947
selftests::ptid::tid
static constexpr ptid_t tid
Definition: ptid-selftests.c:43
add_thread
struct thread_info * add_thread(ptid_t ptid)
Definition: thread.c:333
find_thread_ptid
struct thread_info * find_thread_ptid(ptid_t ptid)
Definition: thread.c:514
ptid_cmp
static int ptid_cmp(ptid_t ptid1, ptid_t ptid2)
Definition: aix-thread.c:632
target_ops::to_longname
const char * to_longname
Definition: target.h:416
REG_VALID
Definition: common-regcache.h:32
getthrds
int getthrds(pid_t, struct thrdsinfo64 *, int, tid_t *, int)
target_waitstatus
Definition: waitstatus.h:104
CORE_ADDR
bfd_vma CORE_ADDR
Definition: common-types.h:41
target_write_memory
int target_write_memory(CORE_ADDR memaddr, const gdb_byte *myaddr, ssize_t len)
Definition: target.c:1451
ptid_get_pid
int ptid_get_pid(const ptid_t &ptid)
Definition: ptid.c:47
get_thread_regcache
struct regcache * get_thread_regcache(ptid_t ptid)
Definition: regcache.c:434
delete_thread
void delete_thread(ptid_t)
Definition: thread.c:476
xfree
void xfree(void *)
aix_thread_detach
static void aix_thread_detach(struct target_ops *ops, const char *args, int from_tty)
Definition: aix-thread.c:984
pd_callbacks
static pthdb_callbacks_t pd_callbacks
Definition: aix-thread.c:148
gdbarch_tdep::ppc_lr_regnum
int ppc_lr_regnum
Definition: ppc-tdep.h:231
ppc_num_fprs
Definition: ppc-tdep.h:284
BMSYMBOL_VALUE_ADDRESS
#define BMSYMBOL_VALUE_ADDRESS(symbol)
Definition: symtab.h:691
push_target
void push_target(struct target_ops *t)
Definition: target.c:642
add_thread_with_info
struct thread_info * add_thread_with_info(ptid_t ptid, struct private_thread_info *)
Definition: thread.c:319
gdbarch_tdep::ppc_fpscr_regnum
int ppc_fpscr_regnum
Definition: ppc-tdep.h:241
regcache_get_ptid
ptid_t regcache_get_ptid(const struct regcache *regcache)
Definition: regcache.c:229
unpush_target
int unpush_target(struct target_ops *t)
Definition: target.c:689
ppc-tdep.h
pd_brk_addr
static CORE_ADDR pd_brk_addr
Definition: aix-thread.c:116
pdc_read_data
static int pdc_read_data(pthdb_user_t, void *, pthdb_addr_t, size_t)
Definition: aix-thread.c:464
memset
void * memset(T *s, int c, size_t n)=delete
aix_thread_xfer_partial
static enum target_xfer_status aix_thread_xfer_partial(struct target_ops *ops, enum target_object object, const char *annex, gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
Definition: aix-thread.c:1703
gdbarch_tdep
Definition: aarch64-tdep.h:55
aix_thread_extra_thread_info
static const char * aix_thread_extra_thread_info(struct target_ops *self, struct thread_info *thread)
Definition: aix-thread.c:1766
aix_thread_fetch_registers
static void aix_thread_fetch_registers(struct target_ops *ops, struct regcache *regcache, int regno)
Definition: aix-thread.c:1323
_initialize_aix_thread
void _initialize_aix_thread(void)
Definition: aix-thread.c:1856
target_ops::to_pid_to_str
const char *(* to_pid_to_str)(struct target_ops *, ptid_t) TARGET_DEFAULT_FUNC(default_pid_to_str)
Definition: target.h:630
aix_thread_info
Definition: aix-thread.c:87
giter_accum
static int giter_accum(struct thread_info *thread, void *bufp)
Definition: aix-thread.c:619
store_regs_kernel_thread
static void store_regs_kernel_thread(const struct regcache *regcache, int regno, pthdb_tid_t tid)
Definition: aix-thread.c:1570
string_file::write
void write(const char *buf, long length_buf) override
Definition: ui-file.c:138
pdc_alloc
static int pdc_alloc(pthdb_user_t, size_t, void **)
Definition: aix-thread.c:509
create_thread_event_breakpoint
struct breakpoint * create_thread_event_breakpoint(struct gdbarch *gdbarch, CORE_ADDR address)
Definition: breakpoint.c:7475
pd_enable
static void pd_enable(void)
Definition: aix-thread.c:905
supply_fprs
static void supply_fprs(struct regcache *regcache, double *vals)
Definition: aix-thread.c:1095
_
#define _(String)
Definition: gdb_locale.h:35
giter_count
static int giter_count(struct thread_info *thread, void *countp)
Definition: aix-thread.c:604
defs.h
gdbarch_tdep::ppc_cr_regnum
int ppc_cr_regnum
Definition: ppc-tdep.h:230
gdbarch_tdep
struct gdbarch_tdep * gdbarch_tdep(struct gdbarch *gdbarch)
Definition: gdbarch.c:1491
ptrace
PTRACE_TYPE_RET ptrace()
objfiles.h
ptid_build
ptid_t ptid_build(int pid, long lwp, long tid)
Definition: ptid.c:31
observer.h
make_scoped_restore
scoped_restore_tmpl< T > make_scoped_restore(T *var)
Definition: scoped_restore.h:105
flags
mach_port_t kern_return_t mach_port_t msgports mach_port_t kern_return_t pid_t pid mach_port_t kern_return_t mach_port_t task mach_port_t kern_return_t int flags
Definition: gnu-nat.c:1891
observer_attach_inferior_created
struct observer * observer_attach_inferior_created(observer_inferior_created_ftype *f)
in_thread_list
int in_thread_list(ptid_t ptid)
Definition: thread.c:628
aix_thread_info::pdtid
pthdb_pthread_t pdtid
Definition: aix-thread.c:89
iterate_over_threads
struct thread_info * iterate_over_threads(thread_callback_func, void *)
Definition: thread.c:551
pdc_write_regs
static int pdc_write_regs(pthdb_user_t user, pthdb_tid_t tid, unsigned long long flags, pthdb_context_t *context)
Definition: aix-thread.c:414
get_aix_thread_info
static aix_thread_info * get_aix_thread_info(thread_info *thread)
Definition: aix-thread.c:96
thread_stratum
Definition: target.h:88
name
const char *const name
Definition: aarch64-tdep.c:76
iter_tid
static int iter_tid(struct thread_info *thread, void *tidp)
Definition: aix-thread.c:823
OPS_MAGIC
#define OPS_MAGIC
Definition: target.h:1270
gdbarch_decr_pc_after_break
CORE_ADDR gdbarch_decr_pc_after_break(struct gdbarch *gdbarch)
Definition: gdbarch.c:2970
pdc_write_data
static int pdc_write_data(pthdb_user_t, void *, pthdb_addr_t, size_t)
Definition: aix-thread.c:486
pid_to_prc
static void pid_to_prc(ptid_t *ptidp)
Definition: aix-thread.c:282
store_regs_user_thread
static void store_regs_user_thread(const struct regcache *regcache, pthdb_pthread_t pdtid)
Definition: aix-thread.c:1474
complete_target_initialization
void complete_target_initialization(struct target_ops *t)
Definition: target.c:317
target_ops
Definition: target.h:412
pd_session
static pthdb_session_t pd_session
Definition: aix-thread.c:162
regcache.h
bound_minimal_symbol
Definition: minsyms.h:29
aix_thread_info::tid
pthdb_tid_t tid
Definition: aix-thread.c:90
ptid_get_tid
long ptid_get_tid(const ptid_t &ptid)
Definition: ptid.c:63
ptid_t
Definition: ptid.h:35
state2str
static char * state2str(pthdb_state_t state)
Definition: aix-thread.c:561
fprintf_unfiltered
void fprintf_unfiltered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2018
target_ops::to_resume
void(* to_resume)(struct target_ops *, ptid_t, int TARGET_DEBUG_PRINTER(target_debug_print_step), enum gdb_signal) TARGET_DEFAULT_NORETURN(noprocess())
Definition: target.h:447
gdbarch_tdep::ppc_gp0_regnum
int ppc_gp0_regnum
Definition: ppc-tdep.h:227
supply_sprs32
static void supply_sprs32(struct regcache *regcache, uint32_t iar, uint32_t msr, uint32_t cr, uint32_t lr, uint32_t ctr, uint32_t xer, uint32_t fpscr)
Definition: aix-thread.c:1157
supply_gprs64
static void supply_gprs64(struct regcache *regcache, uint64_t *vals)
Definition: aix-thread.c:1074
pid_to_ptid
ptid_t pid_to_ptid(int pid)
Definition: ptid.c:39
gdbthread.h
inferior.h
gdbarch_tdep::int32
struct type * int32
Definition: m32c-tdep.c:130
fill_sprs64
static void fill_sprs64(const struct regcache *regcache, uint64_t *iar, uint64_t *msr, uint32_t *cr, uint64_t *lr, uint64_t *ctr, uint32_t *xer, uint32_t *fpscr)
Definition: aix-thread.c:1397
target_xfer_status
target_xfer_status
Definition: target.h:206
pcmp
static int pcmp(const void *p1v, const void *p2v)
Definition: aix-thread.c:589
scoped_restore_base
Definition: scoped_restore.h:24
gdbarch_tdep::int64
struct type * int64
Definition: m32c-tdep.c:130
gdb_signal_to_host
int gdb_signal_to_host(enum gdb_signal)
Definition: signals.c:639
get_signaled_thread
static pthdb_tid_t get_signaled_thread(void)
Definition: aix-thread.c:667
private_thread_info
Definition: gdbthread.h:183
sync_threadlists
static void sync_threadlists(void)
Definition: aix-thread.c:701
PD_USER
#define PD_USER
Definition: aix-thread.c:78
status
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t int status
Definition: gnu-nat.c:1822
aix_thread_pid_to_str
static const char * aix_thread_pid_to_str(struct target_ops *ops, ptid_t ptid)
Definition: aix-thread.c:1746
target_ops::to_doc
const char * to_doc
Definition: target.h:417
pdc_symbol_addrs
static int pdc_symbol_addrs(pthdb_user_t, pthdb_symbol_t *, int)
Definition: aix-thread.c:295
new_objfile
static void new_objfile(struct objfile *objfile)
Definition: aix-thread.c:965
PDC_SUCCESS
#define PDC_SUCCESS
Definition: aix-thread.c:82
thread_info::ptid
ptid_t ptid
Definition: gdbthread.h:219
aix_thread_mourn_inferior
static void aix_thread_mourn_inferior(struct target_ops *ops)
Definition: aix-thread.c:1719
target_ops::to_xfer_partial
enum target_xfer_status(* to_xfer_partial)(struct target_ops *ops, enum target_object object, const char *annex, gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST offset, ULONGEST len, ULONGEST *xfered_len) TARGET_DEFAULT_RETURN(TARGET_XFER_E_IO)
Definition: target.h:739
find_target_beneath
struct target_ops * find_target_beneath(struct target_ops *t)
Definition: target.c:3153
xstrprintf
char * xstrprintf(const char *format,...)
Definition: common-utils.c:107
aix_thread_wait
static ptid_t aix_thread_wait(struct target_ops *ops, ptid_t ptid, struct target_waitstatus *status, int options)
Definition: aix-thread.c:1039
setdebuglist
struct cmd_list_element * setdebuglist
Definition: cli-cmds.c:153
target_ops::to_detach
void(* to_detach)(struct target_ops *ops, const char *, int) TARGET_DEFAULT_IGNORE()
Definition: target.h:443
xmalloc
void * xmalloc(YYSIZE_T)
ptid_get_lwp
long ptid_get_lwp(const ptid_t &ptid)
Definition: ptid.c:55
target_object
target_object
Definition: target.h:132
pdc_realloc
static int pdc_realloc(pthdb_user_t, void *, size_t, void **)
Definition: aix-thread.c:531
gdb_assert
#define gdb_assert(expr)
Definition: gdb_assert.h:32
aix_thread_thread_alive
static int aix_thread_thread_alive(struct target_ops *ops, ptid_t ptid)
Definition: aix-thread.c:1730
pd_thread::pthid
pthread_t pthid
Definition: aix-thread.c:105
aix_thread_get_ada_task_ptid
static ptid_t aix_thread_get_ada_task_ptid(struct target_ops *self, long lwp, long thread)
Definition: aix-thread.c:1823
addr_ptr
#define addr_ptr
Definition: aix-thread.c:267
supply_sprs64
static void supply_sprs64(struct regcache *regcache, uint64_t iar, uint64_t msr, uint32_t cr, uint64_t lr, uint64_t ctr, uint32_t xer, uint32_t fpscr)
Definition: aix-thread.c:1133
xrealloc
PTR xrealloc(PTR ptr, size_t size)
Definition: common-utils.c:52
fill_gprs64
static void fill_gprs64(const struct regcache *regcache, uint64_t *vals)
Definition: aix-thread.c:1348
objfile
Definition: objfiles.h:286
ui_file::printf
void printf(const char *,...) ATTRIBUTE_PRINTF(2
Definition: ui-file.c:37
gdb_byte
bfd_byte gdb_byte
Definition: common-types.h:38
gdbarch_tdep::ppc_ctr_regnum
int ppc_ctr_regnum
Definition: ppc-tdep.h:232
XNEWVEC
#define XNEWVEC(T, N)
Definition: poison.h:145
pd_able
static int pd_able
Definition: aix-thread.c:120
target_ops::to_fetch_registers
void(* to_fetch_registers)(struct target_ops *, struct regcache *, int) TARGET_DEFAULT_IGNORE()
Definition: target.h:457
pd_active
static int pd_active
Definition: aix-thread.c:124
target_ops::to_mourn_inferior
void(* to_mourn_inferior)(struct target_ops *) TARGET_DEFAULT_FUNC(default_mourn_inferior)
Definition: target.h:606
target_ops::to_extra_thread_info
const char *(* to_extra_thread_info)(struct target_ops *, struct thread_info *) TARGET_DEFAULT_RETURN(NULL)
Definition: target.h:632
regcache_register_status
enum register_status regcache_register_status(const struct regcache *regcache, int regnum)
Definition: regcache.c:359
thread_info::priv
std::unique_ptr< private_thread_info > priv
Definition: gdbthread.h:354
pd_status2str
static const char * pd_status2str(int status)
Definition: aix-thread.c:168
string_file::c_str
const char * c_str() const
Definition: ui-file.h:137
target_read_memory
int target_read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition: target.c:1370
regcache_read_pc
CORE_ADDR regcache_read_pc(struct regcache *regcache)
Definition: regcache.c:1229
inferior_ptid
ptid_t inferior_ptid
Definition: infcmd.c:94
bound_minimal_symbol::minsym
struct minimal_symbol * minsym
Definition: minsyms.h:34
safe_strerror
char * safe_strerror(int)
Definition: mingw-strerror.c:32
target_ops::to_stratum
enum strata to_stratum
Definition: target.h:656
gdbarch_tdep::ppc_ps_regnum
int ppc_ps_regnum
Definition: ppc-tdep.h:229
fill_sprs32
static void fill_sprs32(const struct regcache *regcache, uint32_t *iar, uint32_t *msr, uint32_t *cr, uint32_t *lr, uint32_t *ctr, uint32_t *xer, uint32_t *fpscr)
Definition: aix-thread.c:1433
offset
int offset
Definition: agent.c:65
add_setshow_boolean_cmd
void add_setshow_boolean_cmd(const char *name, enum command_class theclass, int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_const_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:569
init_aix_thread_ops
static void init_aix_thread_ops(void)
Definition: aix-thread.c:1831
gdbarch_tdep::ppc_xer_regnum
int ppc_xer_regnum
Definition: ppc-tdep.h:233
selftests::ptid::lwp
static constexpr ptid_t lwp
Definition: ptid-selftests.c:42
qsort
#define qsort
Definition: ada-exp.c:2694
regcache::arch
gdbarch * arch() const
Definition: regcache.c:221
gcmp
static int gcmp(const void *t1v, const void *t2v)
Definition: aix-thread.c:655
gdbarch_tdep::ppc_mq_regnum
int ppc_mq_regnum
Definition: ppc-tdep.h:244
target.h
ptrace32
static int ptrace32(int req, int id, addr_ptr addr, int data, int *buf)
Definition: aix-thread.c:271
fill_gprs32
static void fill_gprs32(const struct regcache *regcache, uint32_t *vals)
Definition: aix-thread.c:1361
supply_reg32
static void supply_reg32(struct regcache *regcache, int regno, uint32_t val)
Definition: aix-thread.c:1087
regcache_raw_supply
void regcache_raw_supply(struct regcache *regcache, int regnum, const void *buf)
Definition: regcache.c:1004
PDC_FAILURE
#define PDC_FAILURE
Definition: aix-thread.c:83
target_ops::to_shortname
const char * to_shortname
Definition: target.h:415
ULONGEST
unsigned long long ULONGEST
Definition: common-types.h:53
ptrace64aix
static int ptrace64aix(int req, int id, long long addr, int data, int *buf)
Definition: aix-thread.c:252
target_ops::to_magic
int to_magic
Definition: target.h:1261
register_size
int register_size(struct gdbarch *gdbarch, int regnum)
Definition: regcache.c:164
regcache
Definition: regcache.h:232
observer_attach_new_objfile
struct observer * observer_attach_new_objfile(observer_new_objfile_ftype *f)
gdb_stdlog
#define gdb_stdlog
Definition: utils.h:349
aix_thread_inferior_created
static void aix_thread_inferior_created(struct target_ops *ops, int from_tty)
Definition: aix-thread.c:976
aix_thread_ops
static struct target_ops aix_thread_ops
Definition: aix-thread.c:111
pdc_read_regs
static int pdc_read_regs(pthdb_user_t user, pthdb_tid_t tid, unsigned long long flags, pthdb_context_t *context)
Definition: aix-thread.c:342
pthdb_tid_t
#define pthdb_tid_t
Definition: aix-thread.c:68
pd_thread::tid
pthdb_tid_t tid
Definition: aix-thread.c:106
aix_thread_resume
static void aix_thread_resume(struct target_ops *ops, ptid_t ptid, int step, enum gdb_signal sig)
Definition: aix-thread.c:996
regcache_raw_collect
void regcache_raw_collect(const struct regcache *regcache, int regnum, void *buf)
Definition: regcache.c:1085
showdebuglist
struct cmd_list_element * showdebuglist
Definition: cli-cmds.c:155
gdbarch_pc_regnum
int gdbarch_pc_regnum(struct gdbarch *gdbarch)
Definition: gdbarch.c:2163
target_ops::to_thread_alive
int(* to_thread_alive)(struct target_ops *, ptid_t ptid) TARGET_DEFAULT_RETURN(0)
Definition: target.h:626
fetch_regs_user_thread
static void fetch_regs_user_thread(struct regcache *regcache, pthdb_pthread_t pdtid)
Definition: aix-thread.c:1185
class_maintenance
Definition: command.h:43
pd_deactivate
static void pd_deactivate(void)
Definition: aix-thread.c:891
regcache::ptid
ptid_t ptid() const
Definition: regcache.h:325
aix_thread_store_registers
static void aix_thread_store_registers(struct target_ops *ops, struct regcache *regcache, int regno)
Definition: aix-thread.c:1678
PD_TID
#define PD_TID(ptid)
Definition: aix-thread.c:73
pd_activate
static ptid_t pd_activate(int set_infpid)
Definition: aix-thread.c:873
pd_thread
Definition: aix-thread.c:103
ptrace_check
static int ptrace_check(int req, int id, int ret)
Definition: aix-thread.c:212
special_register_p
static int special_register_p(struct gdbarch *gdbarch, int regno)
Definition: aix-thread.c:1114
target_ops::to_store_registers
void(* to_store_registers)(struct target_ops *, struct regcache *, int) TARGET_DEFAULT_NORETURN(noprocess())
Definition: target.h:459
lookup_minimal_symbol
struct bound_minimal_symbol lookup_minimal_symbol(const char *name, const char *sfile, struct objfile *objf)
Definition: minsyms.c:311
ppc_floating_point_unit_p
int ppc_floating_point_unit_p(struct gdbarch *gdbarch)
Definition: rs6000-tdep.c:218
arch64
static int arch64
Definition: aix-thread.c:129
target_ops::to_wait
ptid_t(* to_wait)(struct target_ops *, ptid_t, struct target_waitstatus *, int TARGET_DEBUG_PRINTER(target_debug_print_options)) TARGET_DEFAULT_FUNC(default_target_wait)
Definition: target.h:453
TARGET_WAITKIND_STOPPED
Definition: waitstatus.h:35
target_ops::to_get_ada_task_ptid
ptid_t(* to_get_ada_task_ptid)(struct target_ops *, long lwp, long thread) TARGET_DEFAULT_FUNC(default_get_ada_task_ptid)
Definition: target.h:797
gdbcmd.h
thread_info
Definition: gdbthread.h:205
error
void error(const char *fmt,...)
Definition: errors.c:38
gdbarch_tdep::ppc_fp0_regnum
int ppc_fp0_regnum
Definition: ppc-tdep.h:240
ppc_num_gprs
Definition: ppc-tdep.h:283
pd_update
static ptid_t pd_update(int set_infpid)
Definition: aix-thread.c:836
target_ops::beneath
struct target_ops * beneath
Definition: target.h:414
pd_thread::pdtid
pthdb_pthread_t pdtid
Definition: aix-thread.c:104
debug_aix_thread
static int debug_aix_thread
Definition: aix-thread.c:64
pdc_dealloc
static int pdc_dealloc(pthdb_user_t, void *)
Definition: aix-thread.c:548
fetch_regs_kernel_thread
static void fetch_regs_kernel_thread(struct regcache *regcache, int regno, pthdb_tid_t tid)
Definition: aix-thread.c:1239
string_file
Definition: ui-file.h:106