gdb/aix-thread.c

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