gdb/aix-thread.c

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