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