gdb/aix-thread.c

   1 /* Low level interface for debugging AIX 4.3+ pthreads.
   2
   3    Copyright (C) 1999-2019 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 int debug_aix_thread;
  65
  66 /* In AIX 5.1, functions use pthdb_tid_t instead of tid_t.  */
  67 #ifndef PTHDB_VERSION_3
  68 #define pthdb_tid_t     tid_t
  69 #endif
  70
  71 /* Return whether to treat PID as a debuggable thread id.  */
  72
  73 #define PD_TID(ptid)    (pd_active && ptid.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 *
  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:
 120   const target_info &info () const override
 121   { return aix_thread_target_info; }
 122
 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   const char *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 *
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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 *
 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
 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
 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
 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
 671 ptid_cmp (ptid_t ptid1, ptid_t ptid2)
 672 {
 673   int pid1, pid2;
 674
 675   if (ptid1.pid () < ptid2.pid ())
 676     return -1;
 677   else if (ptid1.pid () > ptid2.pid ())
 678     return 1;
 679   else if (ptid1.tid () < ptid2.tid ())
 680     return -1;
 681   else if (ptid1.tid () > ptid2.tid ())
 682     return 1;
 683   else if (ptid1.lwp () < ptid2.lwp ())
 684     return -1;
 685   else if (ptid1.lwp () > ptid2.lwp ())
 686     return 1;
 687   else
 688     return 0;
 689 }
 690
 691 /* qsort() comparison function for sorting thread_info structs by pid.  */
 692
 693 static int
 694 gcmp (const void *t1v, const void *t2v)
 695 {
 696   struct thread_info *t1 = *(struct thread_info **) t1v;
 697   struct thread_info *t2 = *(struct thread_info **) t2v;
 698   return ptid_cmp (t1->ptid, t2->ptid);
 699 }
 700
 701 /* Search through the list of all kernel threads for the thread
 702    that has stopped on a SIGTRAP signal, and return its TID.
 703    Return 0 if none found.  */
 704
 705 static pthdb_tid_t
 706 get_signaled_thread (void)
 707 {
 708   struct thrdsinfo64 thrinf;
 709   tid_t ktid = 0;
 710   int result = 0;
 711
 712   while (1)
 713   {
 714     if (getthrds (inferior_ptid.pid (), &thrinf,
 715                   sizeof (thrinf), &ktid, 1) != 1)
 716       break;
 717
 718     if (thrinf.ti_cursig == SIGTRAP)
 719       return thrinf.ti_tid;
 720   }
 721
 722   /* Didn't find any thread stopped on a SIGTRAP signal.  */
 723   return 0;
 724 }
 725
 726 /* Synchronize GDB's thread list with libpthdebug's.
 727
 728    There are some benefits of doing this every time the inferior stops:
 729
 730      - allows users to run thread-specific commands without needing to
 731        run "info threads" first
 732
 733      - helps pthdb_tid_pthread() work properly (see "libpthdebug
 734        peculiarities" at the top of this module)
 735
 736      - simplifies the demands placed on libpthdebug, which seems to
 737        have difficulty with certain call patterns */
 738
 739 static void
 740 sync_threadlists (void)
 741 {
 742   int cmd, status, infpid;
 743   int pcount, psize, pi, gcount, gi;
 744   struct pd_thread *pbuf;
 745   struct thread_info **gbuf, **g, *thread;
 746   pthdb_pthread_t pdtid;
 747   pthread_t pthid;
 748   pthdb_tid_t tid;
 749
 750   /* Accumulate an array of libpthdebug threads sorted by pthread id.  */
 751
 752   pcount = 0;
 753   psize = 1;
 754   pbuf = XNEWVEC (struct pd_thread, psize);
 755
 756   for (cmd = PTHDB_LIST_FIRST;; cmd = PTHDB_LIST_NEXT)
 757     {
 758       status = pthdb_pthread (pd_session, &pdtid, cmd);
 759       if (status != PTHDB_SUCCESS || pdtid == PTHDB_INVALID_PTHREAD)
 760         break;
 761
 762       status = pthdb_pthread_ptid (pd_session, pdtid, &pthid);
 763       if (status != PTHDB_SUCCESS || pthid == PTHDB_INVALID_PTID)
 764         continue;
 765
 766       if (pcount == psize)
 767         {
 768           psize *= 2;
 769           pbuf = (struct pd_thread *) xrealloc (pbuf,
 770                                                 psize * sizeof *pbuf);
 771         }
 772       pbuf[pcount].pdtid = pdtid;
 773       pbuf[pcount].pthid = pthid;
 774       pcount++;
 775     }
 776
 777   for (pi = 0; pi < pcount; pi++)
 778     {
 779       status = pthdb_pthread_tid (pd_session, pbuf[pi].pdtid, &tid);
 780       if (status != PTHDB_SUCCESS)
 781         tid = PTHDB_INVALID_TID;
 782       pbuf[pi].tid = tid;
 783     }
 784
 785   qsort (pbuf, pcount, sizeof *pbuf, pcmp);
 786
 787   /* Accumulate an array of GDB threads sorted by pid.  */
 788
 789   gcount = 0;
 790   iterate_over_threads (giter_count, &gcount);
 791   g = gbuf = XNEWVEC (struct thread_info *, gcount);
 792   iterate_over_threads (giter_accum, &g);
 793   qsort (gbuf, gcount, sizeof *gbuf, gcmp);
 794
 795   /* Apply differences between the two arrays to GDB's thread list.  */
 796
 797   infpid = inferior_ptid.pid ();
 798   for (pi = gi = 0; pi < pcount || gi < gcount;)
 799     {
 800       if (pi == pcount)
 801         {
 802           delete_thread (gbuf[gi]);
 803           gi++;
 804         }
 805       else if (gi == gcount)
 806         {
 807           aix_thread_info *priv = new aix_thread_info;
 808           priv->pdtid = pbuf[pi].pdtid;
 809           priv->tid = pbuf[pi].tid;
 810
 811           thread = add_thread_with_info (ptid_t (infpid, 0, pbuf[pi].pthid), priv);
 812
 813           pi++;
 814         }
 815       else
 816         {
 817           ptid_t pptid, gptid;
 818           int cmp_result;
 819
 820           pptid = ptid_t (infpid, 0, pbuf[pi].pthid);
 821           gptid = gbuf[gi]->ptid;
 822           pdtid = pbuf[pi].pdtid;
 823           tid = pbuf[pi].tid;
 824
 825           cmp_result = ptid_cmp (pptid, gptid);
 826
 827           if (cmp_result == 0)
 828             {
 829               aix_thread_info *priv = get_aix_thread_info (gbuf[gi]);
 830
 831               priv->pdtid = pdtid;
 832               priv->tid = tid;
 833               pi++;
 834               gi++;
 835             }
 836           else if (cmp_result > 0)
 837             {
 838               delete_thread (gbuf[gi]);
 839               gi++;
 840             }
 841           else
 842             {
 843               thread = add_thread (pptid);
 844
 845               aix_thread_info *priv = new aix_thread_info;
 846               thread->priv.reset (priv);
 847               priv->pdtid = pdtid;
 848               priv->tid = tid;
 849               pi++;
 850             }
 851         }
 852     }
 853
 854   xfree (pbuf);
 855   xfree (gbuf);
 856 }
 857
 858 /* Iterate_over_threads() callback for locating a thread, using
 859    the TID of its associated kernel thread.  */
 860
 861 static int
 862 iter_tid (struct thread_info *thread, void *tidp)
 863 {
 864   const pthdb_tid_t tid = *(pthdb_tid_t *)tidp;
 865   aix_thread_info *priv = get_aix_thread_info (thread);
 866
 867   return priv->tid == tid;
 868 }
 869
 870 /* Synchronize libpthdebug's state with the inferior and with GDB,
 871    generate a composite process/thread <pid> for the current thread,
 872    set inferior_ptid to <pid> if SET_INFPID, and return <pid>.  */
 873
 874 static ptid_t
 875 pd_update (int set_infpid)
 876 {
 877   int status;
 878   ptid_t ptid;
 879   pthdb_tid_t tid;
 880   struct thread_info *thread = NULL;
 881
 882   if (!pd_active)
 883     return inferior_ptid;
 884
 885   status = pthdb_session_update (pd_session);
 886   if (status != PTHDB_SUCCESS)
 887     return inferior_ptid;
 888
 889   sync_threadlists ();
 890
 891   /* Define "current thread" as one that just received a trap signal.  */
 892
 893   tid = get_signaled_thread ();
 894   if (tid != 0)
 895     thread = iterate_over_threads (iter_tid, &tid);
 896   if (!thread)
 897     ptid = inferior_ptid;
 898   else
 899     {
 900       ptid = thread->ptid;
 901       if (set_infpid)
 902         inferior_ptid = ptid;
 903     }
 904   return ptid;
 905 }
 906
 907 /* Try to start debugging threads in the current process.
 908    If successful and SET_INFPID, set inferior_ptid to reflect the
 909    current thread.  */
 910
 911 static ptid_t
 912 pd_activate (int set_infpid)
 913 {
 914   int status;
 915
 916   status = pthdb_session_init (PD_USER, arch64 ? PEM_64BIT : PEM_32BIT,
 917                                PTHDB_FLAG_REGS, &pd_callbacks,
 918                                &pd_session);
 919   if (status != PTHDB_SUCCESS)
 920     {
 921       return inferior_ptid;
 922     }
 923   pd_active = 1;
 924   return pd_update (set_infpid);
 925 }
 926
 927 /* Undo the effects of pd_activate().  */
 928
 929 static void
 930 pd_deactivate (void)
 931 {
 932   if (!pd_active)
 933     return;
 934   pthdb_session_destroy (pd_session);
 935
 936   pid_to_prc (&inferior_ptid);
 937   pd_active = 0;
 938 }
 939
 940 /* An object file has just been loaded.  Check whether the current
 941    application is pthreaded, and if so, prepare for thread debugging.  */
 942
 943 static void
 944 pd_enable (void)
 945 {
 946   int status;
 947   char *stub_name;
 948   struct bound_minimal_symbol ms;
 949
 950   /* Don't initialize twice.  */
 951   if (pd_able)
 952     return;
 953
 954   /* Check application word size.  */
 955   arch64 = register_size (target_gdbarch (), 0) == 8;
 956
 957   /* Check whether the application is pthreaded.  */
 958   stub_name = NULL;
 959   status = pthdb_session_pthreaded (PD_USER, PTHDB_FLAG_REGS,
 960                                     &pd_callbacks, &stub_name);
 961   if ((status != PTHDB_SUCCESS
 962        && status != PTHDB_NOT_PTHREADED) || !stub_name)
 963     return;
 964
 965   /* Set a breakpoint on the returned stub function.  */
 966   ms = lookup_minimal_symbol (stub_name, NULL, NULL);
 967   if (ms.minsym == NULL)
 968     return;
 969   pd_brk_addr = BMSYMBOL_VALUE_ADDRESS (ms);
 970   if (!create_thread_event_breakpoint (target_gdbarch (), pd_brk_addr))
 971     return;
 972
 973   /* Prepare for thread debugging.  */
 974   push_target (&aix_thread_ops);
 975   pd_able = 1;
 976
 977   /* If we're debugging a core file or an attached inferior, the
 978      pthread library may already have been initialized, so try to
 979      activate thread debugging.  */
 980   pd_activate (1);
 981 }
 982
 983 /* Undo the effects of pd_enable().  */
 984
 985 static void
 986 pd_disable (void)
 987 {
 988   if (!pd_able)
 989     return;
 990   if (pd_active)
 991     pd_deactivate ();
 992   pd_able = 0;
 993   unpush_target (&aix_thread_ops);
 994 }
 995
 996 /* new_objfile observer callback.
 997
 998    If OBJFILE is non-null, check whether a threaded application is
 999    being debugged, and if so, prepare for thread debugging.
1000
1001    If OBJFILE is null, stop debugging threads.  */
1002
1003 static void
1004 new_objfile (struct objfile *objfile)
1005 {
1006   if (objfile)
1007     pd_enable ();
1008   else
1009     pd_disable ();
1010 }
1011
1012 /* Attach to process specified by ARGS.  */
1013
1014 static void
1015 aix_thread_inferior_created (struct target_ops *ops, int from_tty)
1016 {
1017   pd_enable ();
1018 }
1019
1020 /* Detach from the process attached to by aix_thread_attach().  */
1021
1022 void
1023 aix_thread_target::detach (inferior *inf, int from_tty)
1024 {
1025   target_ops *beneath = this->beneath ();
1026
1027   pd_disable ();
1028   beneath->detach (inf, from_tty);
1029 }
1030
1031 /* Tell the inferior process to continue running thread PID if != -1
1032    and all threads otherwise.  */
1033
1034 void
1035 aix_thread_target::resume (ptid_t ptid, int step, enum gdb_signal sig)
1036 {
1037   struct thread_info *thread;
1038   pthdb_tid_t tid[2];
1039
1040   if (!PD_TID (ptid))
1041     {
1042       scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid);
1043
1044       inferior_ptid = ptid_t (inferior_ptid.pid ());
1045       beneath ()->resume (ptid, step, sig);
1046     }
1047   else
1048     {
1049       thread = find_thread_ptid (ptid);
1050       if (!thread)
1051         error (_("aix-thread resume: unknown pthread %ld"),
1052                ptid.lwp ());
1053
1054       aix_thread_info *priv = get_aix_thread_info (thread);
1055
1056       tid[0] = priv->tid;
1057       if (tid[0] == PTHDB_INVALID_TID)
1058         error (_("aix-thread resume: no tid for pthread %ld"),
1059                ptid.lwp ());
1060       tid[1] = 0;
1061
1062       if (arch64)
1063         ptrace64aix (PTT_CONTINUE, tid[0], (long long) 1,
1064                      gdb_signal_to_host (sig), (PTRACE_TYPE_ARG5) tid);
1065       else
1066         ptrace32 (PTT_CONTINUE, tid[0], (addr_ptr) 1,
1067                   gdb_signal_to_host (sig), (PTRACE_TYPE_ARG5) tid);
1068     }
1069 }
1070
1071 /* Wait for thread/process ID if != -1 or for any thread otherwise.
1072    If an error occurs, return -1, else return the pid of the stopped
1073    thread.  */
1074
1075 ptid_t
1076 aix_thread_target::wait (ptid_t ptid, struct target_waitstatus *status,
1077                          int options)
1078 {
1079   {
1080     scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid);
1081
1082     pid_to_prc (&ptid);
1083
1084     inferior_ptid = ptid_t (inferior_ptid.pid ());
1085     ptid = beneath ()->wait (ptid, status, options);
1086   }
1087
1088   if (ptid.pid () == -1)
1089     return ptid_t (-1);
1090
1091   /* Check whether libpthdebug might be ready to be initialized.  */
1092   if (!pd_active && status->kind == TARGET_WAITKIND_STOPPED
1093       && status->value.sig == GDB_SIGNAL_TRAP)
1094     {
1095       struct regcache *regcache = get_thread_regcache (ptid);
1096       struct gdbarch *gdbarch = regcache->arch ();
1097
1098       if (regcache_read_pc (regcache)
1099           - gdbarch_decr_pc_after_break (gdbarch) == pd_brk_addr)
1100         return pd_activate (0);
1101     }
1102
1103   return pd_update (0);
1104 }
1105
1106 /* Record that the 64-bit general-purpose registers contain VALS.  */
1107
1108 static void
1109 supply_gprs64 (struct regcache *regcache, uint64_t *vals)
1110 {
1111   struct gdbarch_tdep *tdep = gdbarch_tdep (regcache->arch ());
1112   int regno;
1113
1114   for (regno = 0; regno < ppc_num_gprs; regno++)
1115     regcache->raw_supply (tdep->ppc_gp0_regnum + regno,
1116                           (char *) (vals + regno));
1117 }
1118
1119 /* Record that 32-bit register REGNO contains VAL.  */
1120
1121 static void
1122 supply_reg32 (struct regcache *regcache, int regno, uint32_t val)
1123 {
1124   regcache->raw_supply (regno, (char *) &val);
1125 }
1126
1127 /* Record that the floating-point registers contain VALS.  */
1128
1129 static void
1130 supply_fprs (struct regcache *regcache, double *vals)
1131 {
1132   struct gdbarch *gdbarch = regcache->arch ();
1133   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1134   int regno;
1135
1136   /* This function should never be called on architectures without
1137      floating-point registers.  */
1138   gdb_assert (ppc_floating_point_unit_p (gdbarch));
1139
1140   for (regno = tdep->ppc_fp0_regnum;
1141        regno < tdep->ppc_fp0_regnum + ppc_num_fprs;
1142        regno++)
1143     regcache->raw_supply (regno,
1144                           (char *) (vals + regno - tdep->ppc_fp0_regnum));
1145 }
1146
1147 /* Predicate to test whether given register number is a "special" register.  */
1148 static int
1149 special_register_p (struct gdbarch *gdbarch, int regno)
1150 {
1151   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1152
1153   return regno == gdbarch_pc_regnum (gdbarch)
1154       || regno == tdep->ppc_ps_regnum
1155       || regno == tdep->ppc_cr_regnum
1156       || regno == tdep->ppc_lr_regnum
1157       || regno == tdep->ppc_ctr_regnum
1158       || regno == tdep->ppc_xer_regnum
1159       || (tdep->ppc_fpscr_regnum >= 0 && regno == tdep->ppc_fpscr_regnum)
1160       || (tdep->ppc_mq_regnum >= 0 && regno == tdep->ppc_mq_regnum);
1161 }
1162
1163
1164 /* Record that the special registers contain the specified 64-bit and
1165    32-bit values.  */
1166
1167 static void
1168 supply_sprs64 (struct regcache *regcache,
1169                uint64_t iar, uint64_t msr, uint32_t cr,
1170                uint64_t lr, uint64_t ctr, uint32_t xer,
1171                uint32_t fpscr)
1172 {
1173   struct gdbarch *gdbarch = regcache->arch ();
1174   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1175
1176   regcache->raw_supply (gdbarch_pc_regnum (gdbarch), (char *) &iar);
1177   regcache->raw_supply (tdep->ppc_ps_regnum, (char *) &msr);
1178   regcache->raw_supply (tdep->ppc_cr_regnum, (char *) &cr);
1179   regcache->raw_supply (tdep->ppc_lr_regnum, (char *) &lr);
1180   regcache->raw_supply (tdep->ppc_ctr_regnum, (char *) &ctr);
1181   regcache->raw_supply (tdep->ppc_xer_regnum, (char *) &xer);
1182   if (tdep->ppc_fpscr_regnum >= 0)
1183     regcache->raw_supply (tdep->ppc_fpscr_regnum, (char *) &fpscr);
1184 }
1185
1186 /* Record that the special registers contain the specified 32-bit
1187    values.  */
1188
1189 static void
1190 supply_sprs32 (struct regcache *regcache,
1191                uint32_t iar, uint32_t msr, uint32_t cr,
1192                uint32_t lr, uint32_t ctr, uint32_t xer,
1193                uint32_t fpscr)
1194 {
1195   struct gdbarch *gdbarch = regcache->arch ();
1196   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1197
1198   regcache->raw_supply (gdbarch_pc_regnum (gdbarch), (char *) &iar);
1199   regcache->raw_supply (tdep->ppc_ps_regnum, (char *) &msr);
1200   regcache->raw_supply (tdep->ppc_cr_regnum, (char *) &cr);
1201   regcache->raw_supply (tdep->ppc_lr_regnum, (char *) &lr);
1202   regcache->raw_supply (tdep->ppc_ctr_regnum, (char *) &ctr);
1203   regcache->raw_supply (tdep->ppc_xer_regnum, (char *) &xer);
1204   if (tdep->ppc_fpscr_regnum >= 0)
1205     regcache->raw_supply (tdep->ppc_fpscr_regnum, (char *) &fpscr);
1206 }
1207
1208 /* Fetch all registers from pthread PDTID, which doesn't have a kernel
1209    thread.
1210
1211    There's no way to query a single register from a non-kernel
1212    pthread, so there's no need for a single-register version of this
1213    function.  */
1214
1215 static void
1216 fetch_regs_user_thread (struct regcache *regcache, pthdb_pthread_t pdtid)
1217 {
1218   struct gdbarch *gdbarch = regcache->arch ();
1219   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1220   int status, i;
1221   pthdb_context_t ctx;
1222
1223   if (debug_aix_thread)
1224     fprintf_unfiltered (gdb_stdlog,
1225                         "fetch_regs_user_thread %lx\n", (long) pdtid);
1226   status = pthdb_pthread_context (pd_session, pdtid, &ctx);
1227   if (status != PTHDB_SUCCESS)
1228     error (_("aix-thread: fetch_registers: pthdb_pthread_context returned %s"),
1229            pd_status2str (status));
1230
1231   /* General-purpose registers.  */
1232
1233   if (arch64)
1234     supply_gprs64 (regcache, ctx.gpr);
1235   else
1236     for (i = 0; i < ppc_num_gprs; i++)
1237       supply_reg32 (regcache, tdep->ppc_gp0_regnum + i, ctx.gpr[i]);
1238
1239   /* Floating-point registers.  */
1240
1241   if (ppc_floating_point_unit_p (gdbarch))
1242     supply_fprs (regcache, ctx.fpr);
1243
1244   /* Special registers.  */
1245
1246   if (arch64)
1247     supply_sprs64 (regcache, ctx.iar, ctx.msr, ctx.cr, ctx.lr, ctx.ctr,
1248                              ctx.xer, ctx.fpscr);
1249   else
1250     supply_sprs32 (regcache, ctx.iar, ctx.msr, ctx.cr, ctx.lr, ctx.ctr,
1251                              ctx.xer, ctx.fpscr);
1252 }
1253
1254 /* Fetch register REGNO if != -1 or all registers otherwise from
1255    kernel thread TID.
1256
1257    AIX provides a way to query all of a kernel thread's GPRs, FPRs, or
1258    SPRs, but there's no way to query individual registers within those
1259    groups.  Therefore, if REGNO != -1, this function fetches an entire
1260    group.
1261
1262    Unfortunately, kernel thread register queries often fail with
1263    EPERM, indicating that the thread is in kernel space.  This breaks
1264    backtraces of threads other than the current one.  To make that
1265    breakage obvious without throwing an error to top level (which is
1266    bad e.g. during "info threads" output), zero registers that can't
1267    be retrieved.  */
1268
1269 static void
1270 fetch_regs_kernel_thread (struct regcache *regcache, int regno,
1271                           pthdb_tid_t tid)
1272 {
1273   struct gdbarch *gdbarch = regcache->arch ();
1274   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1275   uint64_t gprs64[ppc_num_gprs];
1276   uint32_t gprs32[ppc_num_gprs];
1277   double fprs[ppc_num_fprs];
1278   struct ptxsprs sprs64;
1279   struct ptsprs sprs32;
1280   int i;
1281
1282   if (debug_aix_thread)
1283     fprintf_unfiltered (gdb_stdlog,
1284         "fetch_regs_kernel_thread tid=%lx regno=%d arch64=%d\n",
1285         (long) tid, regno, arch64);
1286
1287   /* General-purpose registers.  */
1288   if (regno == -1
1289       || (tdep->ppc_gp0_regnum <= regno
1290           && regno < tdep->ppc_gp0_regnum + ppc_num_gprs))
1291     {
1292       if (arch64)
1293         {
1294           if (!ptrace64aix (PTT_READ_GPRS, tid,
1295                             (unsigned long) gprs64, 0, NULL))
1296             memset (gprs64, 0, sizeof (gprs64));
1297           supply_gprs64 (regcache, gprs64);
1298         }
1299       else
1300         {
1301           if (!ptrace32 (PTT_READ_GPRS, tid, (uintptr_t) gprs32, 0, NULL))
1302             memset (gprs32, 0, sizeof (gprs32));
1303           for (i = 0; i < ppc_num_gprs; i++)
1304             supply_reg32 (regcache, tdep->ppc_gp0_regnum + i, gprs32[i]);
1305         }
1306     }
1307
1308   /* Floating-point registers.  */
1309
1310   if (ppc_floating_point_unit_p (gdbarch)
1311       && (regno == -1
1312           || (regno >= tdep->ppc_fp0_regnum
1313               && regno < tdep->ppc_fp0_regnum + ppc_num_fprs)))
1314     {
1315       if (!ptrace32 (PTT_READ_FPRS, tid, (uintptr_t) fprs, 0, NULL))
1316         memset (fprs, 0, sizeof (fprs));
1317       supply_fprs (regcache, fprs);
1318     }
1319
1320   /* Special-purpose registers.  */
1321
1322   if (regno == -1 || special_register_p (gdbarch, regno))
1323     {
1324       if (arch64)
1325         {
1326           if (!ptrace64aix (PTT_READ_SPRS, tid,
1327                             (unsigned long) &sprs64, 0, NULL))
1328             memset (&sprs64, 0, sizeof (sprs64));
1329           supply_sprs64 (regcache, sprs64.pt_iar, sprs64.pt_msr,
1330                          sprs64.pt_cr, sprs64.pt_lr, sprs64.pt_ctr,
1331                          sprs64.pt_xer, sprs64.pt_fpscr);
1332         }
1333       else
1334         {
1335           struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1336
1337           if (!ptrace32 (PTT_READ_SPRS, tid, (uintptr_t) &sprs32, 0, NULL))
1338             memset (&sprs32, 0, sizeof (sprs32));
1339           supply_sprs32 (regcache, sprs32.pt_iar, sprs32.pt_msr, sprs32.pt_cr,
1340                          sprs32.pt_lr, sprs32.pt_ctr, sprs32.pt_xer,
1341                          sprs32.pt_fpscr);
1342
1343           if (tdep->ppc_mq_regnum >= 0)
1344             regcache->raw_supply (tdep->ppc_mq_regnum, (char *) &sprs32.pt_mq);
1345         }
1346     }
1347 }
1348
1349 /* Fetch register REGNO if != -1 or all registers otherwise from the
1350    thread/process connected to REGCACHE.  */
1351
1352 void
1353 aix_thread_target::fetch_registers (struct regcache *regcache, int regno)
1354 {
1355   struct thread_info *thread;
1356   pthdb_tid_t tid;
1357
1358   if (!PD_TID (regcache->ptid ()))
1359     beneath ()->fetch_registers (regcache, regno);
1360   else
1361     {
1362       thread = find_thread_ptid (regcache->ptid ());
1363       aix_thread_info *priv = get_aix_thread_info (thread);
1364       tid = priv->tid;
1365
1366       if (tid == PTHDB_INVALID_TID)
1367         fetch_regs_user_thread (regcache, priv->pdtid);
1368       else
1369         fetch_regs_kernel_thread (regcache, regno, tid);
1370     }
1371 }
1372
1373 /* Store the gp registers into an array of uint32_t or uint64_t.  */
1374
1375 static void
1376 fill_gprs64 (const struct regcache *regcache, uint64_t *vals)
1377 {
1378   struct gdbarch_tdep *tdep = gdbarch_tdep (regcache->arch ());
1379   int regno;
1380
1381   for (regno = 0; regno < ppc_num_gprs; regno++)
1382     if (REG_VALID == regcache->get_register_status
1383                        (tdep->ppc_gp0_regnum + regno))
1384       regcache->raw_collect (tdep->ppc_gp0_regnum + regno, vals + regno);
1385 }
1386
1387 static void
1388 fill_gprs32 (const struct regcache *regcache, uint32_t *vals)
1389 {
1390   struct gdbarch_tdep *tdep = gdbarch_tdep (regcache->arch ());
1391   int regno;
1392
1393   for (regno = 0; regno < ppc_num_gprs; regno++)
1394     if (REG_VALID == regcache->get_register_status
1395                        (tdep->ppc_gp0_regnum + regno))
1396       regcache->raw_collect (tdep->ppc_gp0_regnum + regno, vals + regno);
1397 }
1398
1399 /* Store the floating point registers into a double array.  */
1400 static void
1401 fill_fprs (const struct regcache *regcache, double *vals)
1402 {
1403   struct gdbarch *gdbarch = regcache->arch ();
1404   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1405   int regno;
1406
1407   /* This function should never be called on architectures without
1408      floating-point registers.  */
1409   gdb_assert (ppc_floating_point_unit_p (gdbarch));
1410
1411   for (regno = tdep->ppc_fp0_regnum;
1412        regno < tdep->ppc_fp0_regnum + ppc_num_fprs;
1413        regno++)
1414     if (REG_VALID == regcache->get_register_status (regno))
1415       regcache->raw_collect (regno, vals + regno - tdep->ppc_fp0_regnum);
1416 }
1417
1418 /* Store the special registers into the specified 64-bit and 32-bit
1419    locations.  */
1420
1421 static void
1422 fill_sprs64 (const struct regcache *regcache,
1423              uint64_t *iar, uint64_t *msr, uint32_t *cr,
1424              uint64_t *lr, uint64_t *ctr, uint32_t *xer,
1425              uint32_t *fpscr)
1426 {
1427   struct gdbarch *gdbarch = regcache->arch ();
1428   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1429
1430   /* Verify that the size of the size of the IAR buffer is the
1431      same as the raw size of the PC (in the register cache).  If
1432      they're not, then either GDB has been built incorrectly, or
1433      there's some other kind of internal error.  To be really safe,
1434      we should check all of the sizes.   */
1435   gdb_assert (sizeof (*iar) == register_size
1436                                  (gdbarch, gdbarch_pc_regnum (gdbarch)));
1437
1438   if (REG_VALID == regcache->get_register_status (gdbarch_pc_regnum (gdbarch)))
1439     regcache->raw_collect (gdbarch_pc_regnum (gdbarch), iar);
1440   if (REG_VALID == regcache->get_register_status (tdep->ppc_ps_regnum))
1441     regcache->raw_collect (tdep->ppc_ps_regnum, msr);
1442   if (REG_VALID == regcache->get_register_status (tdep->ppc_cr_regnum))
1443     regcache->raw_collect (tdep->ppc_cr_regnum, cr);
1444   if (REG_VALID == regcache->get_register_status (tdep->ppc_lr_regnum))
1445     regcache->raw_collect (tdep->ppc_lr_regnum, lr);
1446   if (REG_VALID == regcache->get_register_status (tdep->ppc_ctr_regnum))
1447     regcache->raw_collect (tdep->ppc_ctr_regnum, ctr);
1448   if (REG_VALID == regcache->get_register_status (tdep->ppc_xer_regnum))
1449     regcache->raw_collect (tdep->ppc_xer_regnum, xer);
1450   if (tdep->ppc_fpscr_regnum >= 0
1451       && REG_VALID == regcache->get_register_status (tdep->ppc_fpscr_regnum))
1452     regcache->raw_collect (tdep->ppc_fpscr_regnum, fpscr);
1453 }
1454
1455 static void
1456 fill_sprs32 (const struct regcache *regcache,
1457              uint32_t *iar, uint32_t *msr, uint32_t *cr,
1458              uint32_t *lr, uint32_t *ctr, uint32_t *xer,
1459              uint32_t *fpscr)
1460 {
1461   struct gdbarch *gdbarch = regcache->arch ();
1462   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1463
1464   /* Verify that the size of the size of the IAR buffer is the
1465      same as the raw size of the PC (in the register cache).  If
1466      they're not, then either GDB has been built incorrectly, or
1467      there's some other kind of internal error.  To be really safe,
1468      we should check all of the sizes.  */
1469   gdb_assert (sizeof (*iar) == register_size (gdbarch,
1470                                               gdbarch_pc_regnum (gdbarch)));
1471
1472   if (REG_VALID == regcache->get_register_status (gdbarch_pc_regnum (gdbarch)))
1473     regcache->raw_collect (gdbarch_pc_regnum (gdbarch), iar);
1474   if (REG_VALID == regcache->get_register_status (tdep->ppc_ps_regnum))
1475     regcache->raw_collect (tdep->ppc_ps_regnum, msr);
1476   if (REG_VALID == regcache->get_register_status (tdep->ppc_cr_regnum))
1477     regcache->raw_collect (tdep->ppc_cr_regnum, cr);
1478   if (REG_VALID == regcache->get_register_status (tdep->ppc_lr_regnum))
1479     regcache->raw_collect (tdep->ppc_lr_regnum, lr);
1480   if (REG_VALID == regcache->get_register_status (tdep->ppc_ctr_regnum))
1481     regcache->raw_collect (tdep->ppc_ctr_regnum, ctr);
1482   if (REG_VALID == regcache->get_register_status (tdep->ppc_xer_regnum))
1483     regcache->raw_collect (tdep->ppc_xer_regnum, xer);
1484   if (tdep->ppc_fpscr_regnum >= 0
1485       && REG_VALID == regcache->get_register_status (tdep->ppc_fpscr_regnum))
1486     regcache->raw_collect (tdep->ppc_fpscr_regnum, fpscr);
1487 }
1488
1489 /* Store all registers into pthread PDTID, which doesn't have a kernel
1490    thread.
1491
1492    It's possible to store a single register into a non-kernel pthread,
1493    but I doubt it's worth the effort.  */
1494
1495 static void
1496 store_regs_user_thread (const struct regcache *regcache, pthdb_pthread_t pdtid)
1497 {
1498   struct gdbarch *gdbarch = regcache->arch ();
1499   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1500   int status, i;
1501   pthdb_context_t ctx;
1502   uint32_t int32;
1503   uint64_t int64;
1504   double   dbl;
1505
1506   if (debug_aix_thread)
1507     fprintf_unfiltered (gdb_stdlog,
1508                         "store_regs_user_thread %lx\n", (long) pdtid);
1509
1510   /* Retrieve the thread's current context for its non-register
1511      values.  */
1512   status = pthdb_pthread_context (pd_session, pdtid, &ctx);
1513   if (status != PTHDB_SUCCESS)
1514     error (_("aix-thread: store_registers: pthdb_pthread_context returned %s"),
1515            pd_status2str (status));
1516
1517   /* Collect general-purpose register values from the regcache.  */
1518
1519   for (i = 0; i < ppc_num_gprs; i++)
1520     if (REG_VALID == regcache->get_register_status (tdep->ppc_gp0_regnum + i))
1521       {
1522         if (arch64)
1523           {
1524             regcache->raw_collect (tdep->ppc_gp0_regnum + i, (void *) &int64);
1525             ctx.gpr[i] = int64;
1526           }
1527         else
1528           {
1529             regcache->raw_collect (tdep->ppc_gp0_regnum + i, (void *) &int32);
1530             ctx.gpr[i] = int32;
1531           }
1532       }
1533
1534   /* Collect floating-point register values from the regcache.  */
1535   if (ppc_floating_point_unit_p (gdbarch))
1536     fill_fprs (regcache, ctx.fpr);
1537
1538   /* Special registers (always kept in ctx as 64 bits).  */
1539   if (arch64)
1540     {
1541       fill_sprs64 (regcache, &ctx.iar, &ctx.msr, &ctx.cr, &ctx.lr, &ctx.ctr,
1542                              &ctx.xer, &ctx.fpscr);
1543     }
1544   else
1545     {
1546       /* Problem: ctx.iar etc. are 64 bits, but raw_registers are 32.
1547          Solution: use 32-bit temp variables.  */
1548       uint32_t tmp_iar, tmp_msr, tmp_cr, tmp_lr, tmp_ctr, tmp_xer,
1549                tmp_fpscr;
1550
1551       fill_sprs32 (regcache, &tmp_iar, &tmp_msr, &tmp_cr, &tmp_lr, &tmp_ctr,
1552                              &tmp_xer, &tmp_fpscr);
1553       if (REG_VALID == regcache->get_register_status
1554                          (gdbarch_pc_regnum (gdbarch)))
1555         ctx.iar = tmp_iar;
1556       if (REG_VALID == regcache->get_register_status (tdep->ppc_ps_regnum))
1557         ctx.msr = tmp_msr;
1558       if (REG_VALID == regcache->get_register_status (tdep->ppc_cr_regnum))
1559         ctx.cr  = tmp_cr;
1560       if (REG_VALID == regcache->get_register_status (tdep->ppc_lr_regnum))
1561         ctx.lr  = tmp_lr;
1562       if (REG_VALID == regcache->get_register_status (tdep->ppc_ctr_regnum))
1563         ctx.ctr = tmp_ctr;
1564       if (REG_VALID == regcache->get_register_status (tdep->ppc_xer_regnum))
1565         ctx.xer = tmp_xer;
1566       if (REG_VALID == regcache->get_register_status (tdep->ppc_xer_regnum))
1567         ctx.fpscr = tmp_fpscr;
1568     }
1569
1570   status = pthdb_pthread_setcontext (pd_session, pdtid, &ctx);
1571   if (status != PTHDB_SUCCESS)
1572     error (_("aix-thread: store_registers: "
1573              "pthdb_pthread_setcontext returned %s"),
1574            pd_status2str (status));
1575 }
1576
1577 /* Store register REGNO if != -1 or all registers otherwise into
1578    kernel thread TID.
1579
1580    AIX provides a way to set all of a kernel thread's GPRs, FPRs, or
1581    SPRs, but there's no way to set individual registers within those
1582    groups.  Therefore, if REGNO != -1, this function stores an entire
1583    group.  */
1584
1585 static void
1586 store_regs_kernel_thread (const struct regcache *regcache, int regno,
1587                           pthdb_tid_t tid)
1588 {
1589   struct gdbarch *gdbarch = regcache->arch ();
1590   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1591   uint64_t gprs64[ppc_num_gprs];
1592   uint32_t gprs32[ppc_num_gprs];
1593   double fprs[ppc_num_fprs];
1594   struct ptxsprs sprs64;
1595   struct ptsprs  sprs32;
1596   int i;
1597
1598   if (debug_aix_thread)
1599     fprintf_unfiltered (gdb_stdlog,
1600                         "store_regs_kernel_thread tid=%lx regno=%d\n",
1601                         (long) tid, regno);
1602
1603   /* General-purpose registers.  */
1604   if (regno == -1
1605       || (tdep->ppc_gp0_regnum <= regno
1606           && regno < tdep->ppc_gp0_regnum + ppc_num_fprs))
1607     {
1608       if (arch64)
1609         {
1610           /* Pre-fetch: some regs may not be in the cache.  */
1611           ptrace64aix (PTT_READ_GPRS, tid, (unsigned long) gprs64, 0, NULL);
1612           fill_gprs64 (regcache, gprs64);
1613           ptrace64aix (PTT_WRITE_GPRS, tid, (unsigned long) gprs64, 0, NULL);
1614         }
1615       else
1616         {
1617           /* Pre-fetch: some regs may not be in the cache.  */
1618           ptrace32 (PTT_READ_GPRS, tid, (uintptr_t) gprs32, 0, NULL);
1619           fill_gprs32 (regcache, gprs32);
1620           ptrace32 (PTT_WRITE_GPRS, tid, (uintptr_t) gprs32, 0, NULL);
1621         }
1622     }
1623
1624   /* Floating-point registers.  */
1625
1626   if (ppc_floating_point_unit_p (gdbarch)
1627       && (regno == -1
1628           || (regno >= tdep->ppc_fp0_regnum
1629               && regno < tdep->ppc_fp0_regnum + ppc_num_fprs)))
1630     {
1631       /* Pre-fetch: some regs may not be in the cache.  */
1632       ptrace32 (PTT_READ_FPRS, tid, (uintptr_t) fprs, 0, NULL);
1633       fill_fprs (regcache, fprs);
1634       ptrace32 (PTT_WRITE_FPRS, tid, (uintptr_t) fprs, 0, NULL);
1635     }
1636
1637   /* Special-purpose registers.  */
1638
1639   if (regno == -1 || special_register_p (gdbarch, regno))
1640     {
1641       if (arch64)
1642         {
1643           /* Pre-fetch: some registers won't be in the cache.  */
1644           ptrace64aix (PTT_READ_SPRS, tid,
1645                        (unsigned long) &sprs64, 0, NULL);
1646           fill_sprs64 (regcache, &sprs64.pt_iar, &sprs64.pt_msr,
1647                        &sprs64.pt_cr, &sprs64.pt_lr, &sprs64.pt_ctr,
1648                        &sprs64.pt_xer, &sprs64.pt_fpscr);
1649           ptrace64aix (PTT_WRITE_SPRS, tid,
1650                        (unsigned long) &sprs64, 0, NULL);
1651         }
1652       else
1653         {
1654           /* The contents of "struct ptspr" were declared as "unsigned
1655              long" up to AIX 5.2, but are "unsigned int" since 5.3.
1656              Use temporaries to work around this problem.  Also, add an
1657              assert here to make sure we fail if the system header files
1658              use "unsigned long", and the size of that type is not what
1659              the headers expect.  */
1660           uint32_t tmp_iar, tmp_msr, tmp_cr, tmp_lr, tmp_ctr, tmp_xer,
1661                    tmp_fpscr;
1662
1663           gdb_assert (sizeof (sprs32.pt_iar) == 4);
1664
1665           /* Pre-fetch: some registers won't be in the cache.  */
1666           ptrace32 (PTT_READ_SPRS, tid, (uintptr_t) &sprs32, 0, NULL);
1667
1668           fill_sprs32 (regcache, &tmp_iar, &tmp_msr, &tmp_cr, &tmp_lr,
1669                        &tmp_ctr, &tmp_xer, &tmp_fpscr);
1670
1671           sprs32.pt_iar = tmp_iar;
1672           sprs32.pt_msr = tmp_msr;
1673           sprs32.pt_cr = tmp_cr;
1674           sprs32.pt_lr = tmp_lr;
1675           sprs32.pt_ctr = tmp_ctr;
1676           sprs32.pt_xer = tmp_xer;
1677           sprs32.pt_fpscr = tmp_fpscr;
1678
1679           if (tdep->ppc_mq_regnum >= 0)
1680             if (REG_VALID == regcache->get_register_status
1681                                (tdep->ppc_mq_regnum))
1682               regcache->raw_collect (tdep->ppc_mq_regnum, &sprs32.pt_mq);
1683
1684           ptrace32 (PTT_WRITE_SPRS, tid, (uintptr_t) &sprs32, 0, NULL);
1685         }
1686     }
1687 }
1688
1689 /* Store gdb's current view of the register set into the
1690    thread/process connected to REGCACHE.  */
1691
1692 void
1693 aix_thread_target::store_registers (struct regcache *regcache, int regno)
1694 {
1695   struct thread_info *thread;
1696   pthdb_tid_t tid;
1697
1698   if (!PD_TID (regcache->ptid ()))
1699     beneath ()->store_registers (regcache, regno);
1700   else
1701     {
1702       thread = find_thread_ptid (regcache->ptid ());
1703       aix_thread_info *priv = get_aix_thread_info (thread);
1704       tid = priv->tid;
1705
1706       if (tid == PTHDB_INVALID_TID)
1707         store_regs_user_thread (regcache, priv->pdtid);
1708       else
1709         store_regs_kernel_thread (regcache, regno, tid);
1710     }
1711 }
1712
1713 /* Implement the to_xfer_partial target_ops method.  */
1714
1715 enum target_xfer_status
1716 aix_thread_target::xfer_partial (enum target_object object,
1717                                  const char *annex, gdb_byte *readbuf,
1718                                  const gdb_byte *writebuf,
1719                                  ULONGEST offset, ULONGEST len,
1720                                  ULONGEST *xfered_len)
1721 {
1722   scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid);
1723
1724   inferior_ptid = ptid_t (inferior_ptid.pid ());
1725   return beneath ()->xfer_partial (object, annex, readbuf,
1726                                    writebuf, offset, len, xfered_len);
1727 }
1728
1729 /* Clean up after the inferior exits.  */
1730
1731 void
1732 aix_thread_target::mourn_inferior ()
1733 {
1734   target_ops *beneath = this->beneath ();
1735
1736   pd_deactivate ();
1737   beneath->mourn_inferior ();
1738 }
1739
1740 /* Return whether thread PID is still valid.  */
1741
1742 bool
1743 aix_thread_target::thread_alive (ptid_t ptid)
1744 {
1745   if (!PD_TID (ptid))
1746     return beneath ()->thread_alive (ptid);
1747
1748   /* We update the thread list every time the child stops, so all
1749      valid threads should be in the thread list.  */
1750   return in_thread_list (ptid);
1751 }
1752
1753 /* Return a printable representation of composite PID for use in
1754    "info threads" output.  */
1755
1756 const char *
1757 aix_thread_target::pid_to_str (ptid_t ptid)
1758 {
1759   static char *ret = NULL;
1760
1761   if (!PD_TID (ptid))
1762     return beneath ()->pid_to_str (ptid);
1763
1764   /* Free previous return value; a new one will be allocated by
1765      xstrprintf().  */
1766   xfree (ret);
1767
1768   ret = xstrprintf (_("Thread %ld"), ptid.tid ());
1769   return ret;
1770 }
1771
1772 /* Return a printable representation of extra information about
1773    THREAD, for use in "info threads" output.  */
1774
1775 const char *
1776 aix_thread_target::extra_thread_info (struct thread_info *thread)
1777 {
1778   int status;
1779   pthdb_pthread_t pdtid;
1780   pthdb_tid_t tid;
1781   pthdb_state_t state;
1782   pthdb_suspendstate_t suspendstate;
1783   pthdb_detachstate_t detachstate;
1784   int cancelpend;
1785   static char *ret = NULL;
1786
1787   if (!PD_TID (thread->ptid))
1788     return NULL;
1789
1790   string_file buf;
1791   aix_thread_info *priv = get_aix_thread_info (thread);
1792
1793   pdtid = priv->pdtid;
1794   tid = priv->tid;
1795
1796   if (tid != PTHDB_INVALID_TID)
1797     /* i18n: Like "thread-identifier %d, [state] running, suspended" */
1798     buf.printf (_("tid %d"), (int)tid);
1799
1800   status = pthdb_pthread_state (pd_session, pdtid, &state);
1801   if (status != PTHDB_SUCCESS)
1802     state = PST_NOTSUP;
1803   buf.printf (", %s", state2str (state));
1804
1805   status = pthdb_pthread_suspendstate (pd_session, pdtid,
1806                                        &suspendstate);
1807   if (status == PTHDB_SUCCESS && suspendstate == PSS_SUSPENDED)
1808     /* i18n: Like "Thread-Id %d, [state] running, suspended" */
1809     buf.printf (_(", suspended"));
1810
1811   status = pthdb_pthread_detachstate (pd_session, pdtid,
1812                                       &detachstate);
1813   if (status == PTHDB_SUCCESS && detachstate == PDS_DETACHED)
1814     /* i18n: Like "Thread-Id %d, [state] running, detached" */
1815     buf.printf (_(", detached"));
1816
1817   pthdb_pthread_cancelpend (pd_session, pdtid, &cancelpend);
1818   if (status == PTHDB_SUCCESS && cancelpend)
1819     /* i18n: Like "Thread-Id %d, [state] running, cancel pending" */
1820     buf.printf (_(", cancel pending"));
1821
1822   buf.write ("", 1);
1823
1824   xfree (ret);                  /* Free old buffer.  */
1825
1826   ret = xstrdup (buf.c_str ());
1827
1828   return ret;
1829 }
1830
1831 ptid_t
1832 aix_thread_target::get_ada_task_ptid (long lwp, long thread)
1833 {
1834   return ptid_t (inferior_ptid.pid (), 0, thread);
1835 }
1836
1837
1838 /* Module startup initialization function, automagically called by
1839    init.c.  */
1840
1841 void
1842 _initialize_aix_thread (void)
1843 {
1844   /* Notice when object files get loaded and unloaded.  */
1845   gdb::observers::new_objfile.attach (new_objfile);
1846
1847   /* Add ourselves to inferior_created event chain.
1848      This is needed to enable the thread target on "attach".  */
1849   gdb::observers::inferior_created.attach (aix_thread_inferior_created);
1850
1851   add_setshow_boolean_cmd ("aix-thread", class_maintenance, &debug_aix_thread,
1852                            _("Set debugging of AIX thread module."),
1853                            _("Show debugging of AIX thread module."),
1854                            _("Enables debugging output (used to debug GDB)."),
1855                            NULL, NULL,
1856                            /* FIXME: i18n: Debugging of AIX thread
1857                               module is \"%d\".  */
1858                            &setdebuglist, &showdebuglist);
1859 }