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