gdb/aix-thread.c

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