gdb/aix-thread.c

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