gdb/aix-thread.c

   1 /* Low level interface for debugging AIX 4.3+ pthreads.
   2
   3    Copyright (C) 1999, 2000, 2002 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 (unsigned long *iar, unsigned long *msr, unsigned long *cr,
1369              unsigned long *lr,  unsigned long *ctr, unsigned long *xer,
1370              unsigned long *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
1380      If this assert() fails, the most likely reason is that GDB was
1381      built incorrectly.  In order to make use of many of the header
1382      files in /usr/include/sys, GDB needs to be configured so that
1383      sizeof (long) == 4).  */
1384   gdb_assert (sizeof (*iar) == register_size (current_gdbarch, PC_REGNUM));
1385
1386   if (register_cached (PC_REGNUM))
1387     regcache_raw_collect (current_regcache, PC_REGNUM, iar);
1388   if (register_cached (tdep->ppc_ps_regnum))
1389     regcache_raw_collect (current_regcache, tdep->ppc_ps_regnum, msr);
1390   if (register_cached (tdep->ppc_cr_regnum))
1391     regcache_raw_collect (current_regcache, tdep->ppc_cr_regnum, cr);
1392   if (register_cached (tdep->ppc_lr_regnum))
1393     regcache_raw_collect (current_regcache, tdep->ppc_lr_regnum, lr);
1394   if (register_cached (tdep->ppc_ctr_regnum))
1395     regcache_raw_collect (current_regcache, tdep->ppc_ctr_regnum, ctr);
1396   if (register_cached (tdep->ppc_xer_regnum))
1397     regcache_raw_collect (current_regcache, tdep->ppc_xer_regnum, xer);
1398   if (tdep->ppc_fpscr_regnum >= 0
1399       && register_cached (tdep->ppc_fpscr_regnum))
1400     regcache_raw_collect (current_regcache, tdep->ppc_fpscr_regnum, fpscr);
1401 }
1402
1403 /* Store all registers into pthread PDTID, which doesn't have a kernel
1404    thread.
1405
1406    It's possible to store a single register into a non-kernel pthread,
1407    but I doubt it's worth the effort.  */
1408
1409 static void
1410 store_regs_user_thread (pthdb_pthread_t pdtid)
1411 {
1412   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
1413   int status, i;
1414   pthdb_context_t ctx;
1415   uint32_t int32;
1416   uint64_t int64;
1417   double   dbl;
1418
1419   if (debug_aix_thread)
1420     fprintf_unfiltered (gdb_stdlog,
1421                         "store_regs_user_thread %lx\n", (long) pdtid);
1422
1423   /* Retrieve the thread's current context for its non-register
1424      values.  */
1425   status = pthdb_pthread_context (pd_session, pdtid, &ctx);
1426   if (status != PTHDB_SUCCESS)
1427     error (_("aix-thread: store_registers: pthdb_pthread_context returned %s"),
1428            pd_status2str (status));
1429
1430   /* Collect general-purpose register values from the regcache.  */
1431
1432   for (i = 0; i < ppc_num_gprs; i++)
1433     if (register_cached (tdep->ppc_gp0_regnum + i))
1434       {
1435         if (arch64)
1436           {
1437             regcache_raw_collect (current_regcache, tdep->ppc_gp0_regnum + i,
1438                                   (void *) &int64);
1439             ctx.gpr[i] = int64;
1440           }
1441         else
1442           {
1443             regcache_raw_collect (current_regcache, tdep->ppc_gp0_regnum + i,
1444                                   (void *) &int32);
1445             ctx.gpr[i] = int32;
1446           }
1447       }
1448
1449   /* Collect floating-point register values from the regcache.  */
1450   if (ppc_floating_point_unit_p (current_gdbarch))
1451     fill_fprs (ctx.fpr);
1452
1453   /* Special registers (always kept in ctx as 64 bits).  */
1454   if (arch64)
1455     {
1456       fill_sprs64 (&ctx.iar, &ctx.msr, &ctx.cr, &ctx.lr, &ctx.ctr, &ctx.xer,
1457                    &ctx.fpscr);
1458     }
1459   else
1460     {
1461       /* Problem: ctx.iar etc. are 64 bits, but raw_registers are 32.
1462          Solution: use 32-bit temp variables.  (The assert() in fill_sprs32()
1463          will fail if the size of an unsigned long is incorrect.  If this
1464          happens, GDB needs to be reconfigured so that longs are 32-bits.)  */
1465       unsigned long tmp_iar, tmp_msr, tmp_cr, tmp_lr, tmp_ctr, tmp_xer,
1466                     tmp_fpscr;
1467
1468       fill_sprs32 (&tmp_iar, &tmp_msr, &tmp_cr, &tmp_lr, &tmp_ctr, &tmp_xer,
1469                    &tmp_fpscr);
1470       if (register_cached (PC_REGNUM))
1471         ctx.iar = tmp_iar;
1472       if (register_cached (tdep->ppc_ps_regnum))
1473         ctx.msr = tmp_msr;
1474       if (register_cached (tdep->ppc_cr_regnum))
1475         ctx.cr  = tmp_cr;
1476       if (register_cached (tdep->ppc_lr_regnum))
1477         ctx.lr  = tmp_lr;
1478       if (register_cached (tdep->ppc_ctr_regnum))
1479         ctx.ctr = tmp_ctr;
1480       if (register_cached (tdep->ppc_xer_regnum))
1481         ctx.xer = tmp_xer;
1482       if (register_cached (tdep->ppc_xer_regnum))
1483         ctx.fpscr = tmp_fpscr;
1484     }
1485
1486   status = pthdb_pthread_setcontext (pd_session, pdtid, &ctx);
1487   if (status != PTHDB_SUCCESS)
1488     error (_("aix-thread: store_registers: pthdb_pthread_setcontext returned %s"),
1489            pd_status2str (status));
1490 }
1491
1492 /* Store register REGNO if != -1 or all registers otherwise into
1493    kernel thread TID.
1494
1495    AIX provides a way to set all of a kernel thread's GPRs, FPRs, or
1496    SPRs, but there's no way to set individual registers within those
1497    groups.  Therefore, if REGNO != -1, this function stores an entire
1498    group.  */
1499
1500 static void
1501 store_regs_kernel_thread (int regno, pthdb_tid_t tid)
1502 {
1503   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
1504   uint64_t gprs64[ppc_num_gprs];
1505   uint32_t gprs32[ppc_num_gprs];
1506   double fprs[ppc_num_fprs];
1507   struct ptxsprs sprs64;
1508   struct ptsprs  sprs32;
1509   int i;
1510
1511   if (debug_aix_thread)
1512     fprintf_unfiltered (gdb_stdlog,
1513                         "store_regs_kernel_thread tid=%lx regno=%d\n",
1514                         (long) tid, regno);
1515
1516   /* General-purpose registers.  */
1517   if (regno == -1
1518       || (tdep->ppc_gp0_regnum <= regno
1519           && regno < tdep->ppc_gp0_regnum + ppc_num_fprs))
1520     {
1521       if (arch64)
1522         {
1523           /* Pre-fetch: some regs may not be in the cache.  */
1524           ptrace64aix (PTT_READ_GPRS, tid, (unsigned long) gprs64, 0, NULL);
1525           fill_gprs64 (gprs64);
1526           ptrace64aix (PTT_WRITE_GPRS, tid, (unsigned long) gprs64, 0, NULL);
1527         }
1528       else
1529         {
1530           /* Pre-fetch: some regs may not be in the cache.  */
1531           ptrace32 (PTT_READ_GPRS, tid, gprs32, 0, NULL);
1532           fill_gprs32 (gprs32);
1533           ptrace32 (PTT_WRITE_GPRS, tid, gprs32, 0, NULL);
1534         }
1535     }
1536
1537   /* Floating-point registers.  */
1538
1539   if (ppc_floating_point_unit_p (current_gdbarch)
1540       && (regno == -1
1541           || (regno >= tdep->ppc_fp0_regnum
1542               && regno < tdep->ppc_fp0_regnum + ppc_num_fprs)))
1543     {
1544       /* Pre-fetch: some regs may not be in the cache.  */
1545       ptrace32 (PTT_READ_FPRS, tid, (int *) fprs, 0, NULL);
1546       fill_fprs (fprs);
1547       ptrace32 (PTT_WRITE_FPRS, tid, (int *) fprs, 0, NULL);
1548     }
1549
1550   /* Special-purpose registers.  */
1551
1552   if (regno == -1 || special_register_p (regno))
1553     {
1554       if (arch64)
1555         {
1556           /* Pre-fetch: some registers won't be in the cache.  */
1557           ptrace64aix (PTT_READ_SPRS, tid,
1558                        (unsigned long) &sprs64, 0, NULL);
1559           fill_sprs64 (&sprs64.pt_iar, &sprs64.pt_msr, &sprs64.pt_cr,
1560                        &sprs64.pt_lr,  &sprs64.pt_ctr, &sprs64.pt_xer,
1561                        &sprs64.pt_fpscr);
1562           ptrace64aix (PTT_WRITE_SPRS, tid,
1563                        (unsigned long) &sprs64, 0, NULL);
1564         }
1565       else
1566         {
1567           /* Pre-fetch: some registers won't be in the cache.  */
1568           ptrace32 (PTT_READ_SPRS, tid, (int *) &sprs32, 0, NULL);
1569
1570           fill_sprs32 (&sprs32.pt_iar, &sprs32.pt_msr, &sprs32.pt_cr,
1571                        &sprs32.pt_lr,  &sprs32.pt_ctr, &sprs32.pt_xer,
1572                        &sprs32.pt_fpscr);
1573
1574           if (tdep->ppc_mq_regnum >= 0)
1575             if (register_cached (tdep->ppc_mq_regnum))
1576               regcache_raw_collect (current_regcache, tdep->ppc_mq_regnum,
1577                                     &sprs32.pt_mq);
1578
1579           ptrace32 (PTT_WRITE_SPRS, tid, (int *) &sprs32, 0, NULL);
1580         }
1581     }
1582 }
1583
1584 /* Store gdb's current view of the register set into the
1585    thread/process specified by inferior_ptid.  */
1586
1587 static void
1588 aix_thread_store_registers (int regno)
1589 {
1590   struct thread_info *thread;
1591   pthdb_tid_t tid;
1592
1593   if (!PD_TID (inferior_ptid))
1594     base_target.to_store_registers (regno);
1595   else
1596     {
1597       thread = find_thread_pid (inferior_ptid);
1598       tid = thread->private->tid;
1599
1600       if (tid == PTHDB_INVALID_TID)
1601         store_regs_user_thread (thread->private->pdtid);
1602       else
1603         store_regs_kernel_thread (regno, tid);
1604     }
1605 }
1606
1607 /* Transfer LEN bytes of memory from GDB address MYADDR to target
1608    address MEMADDR if WRITE and vice versa otherwise.  */
1609
1610 static int
1611 aix_thread_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
1612                       struct mem_attrib *attrib,
1613                       struct target_ops *target)
1614 {
1615   int n;
1616   struct cleanup *cleanup = save_inferior_ptid ();
1617
1618   inferior_ptid = pid_to_ptid (PIDGET (inferior_ptid));
1619   n = base_target.deprecated_xfer_memory (memaddr, myaddr, len,
1620                                           write, attrib, &base_target);
1621   do_cleanups (cleanup);
1622
1623   return n;
1624 }
1625
1626 /* Kill and forget about the inferior process.  */
1627
1628 static void
1629 aix_thread_kill (void)
1630 {
1631   struct cleanup *cleanup = save_inferior_ptid ();
1632
1633   inferior_ptid = pid_to_ptid (PIDGET (inferior_ptid));
1634   base_target.to_kill ();
1635   do_cleanups (cleanup);
1636 }
1637
1638 /* Clean up after the inferior exits.  */
1639
1640 static void
1641 aix_thread_mourn_inferior (void)
1642 {
1643   pd_deactivate ();
1644   base_target.to_mourn_inferior ();
1645 }
1646
1647 /* Return whether thread PID is still valid.  */
1648
1649 static int
1650 aix_thread_thread_alive (ptid_t ptid)
1651 {
1652   if (!PD_TID (ptid))
1653     return base_target.to_thread_alive (ptid);
1654
1655   /* We update the thread list every time the child stops, so all
1656      valid threads should be in the thread list.  */
1657   return in_thread_list (ptid);
1658 }
1659
1660 /* Return a printable representation of composite PID for use in
1661    "info threads" output.  */
1662
1663 static char *
1664 aix_thread_pid_to_str (ptid_t ptid)
1665 {
1666   static char *ret = NULL;
1667
1668   if (!PD_TID (ptid))
1669     return base_target.to_pid_to_str (ptid);
1670
1671   /* Free previous return value; a new one will be allocated by
1672      xstrprintf().  */
1673   xfree (ret);
1674
1675   ret = xstrprintf (_("Thread %ld"), ptid_get_tid (ptid));
1676   return ret;
1677 }
1678
1679 /* Return a printable representation of extra information about
1680    THREAD, for use in "info threads" output.  */
1681
1682 static char *
1683 aix_thread_extra_thread_info (struct thread_info *thread)
1684 {
1685   struct ui_file *buf;
1686   int status;
1687   pthdb_pthread_t pdtid;
1688   pthdb_tid_t tid;
1689   pthdb_state_t state;
1690   pthdb_suspendstate_t suspendstate;
1691   pthdb_detachstate_t detachstate;
1692   int cancelpend;
1693   long length;
1694   static char *ret = NULL;
1695
1696   if (!PD_TID (thread->ptid))
1697     return NULL;
1698
1699   buf = mem_fileopen ();
1700
1701   pdtid = thread->private->pdtid;
1702   tid = thread->private->tid;
1703
1704   if (tid != PTHDB_INVALID_TID)
1705     /* i18n: Like "thread-identifier %d, [state] running, suspended" */
1706     fprintf_unfiltered (buf, _("tid %d"), tid);
1707
1708   status = pthdb_pthread_state (pd_session, pdtid, &state);
1709   if (status != PTHDB_SUCCESS)
1710     state = PST_NOTSUP;
1711   fprintf_unfiltered (buf, ", %s", state2str (state));
1712
1713   status = pthdb_pthread_suspendstate (pd_session, pdtid,
1714                                        &suspendstate);
1715   if (status == PTHDB_SUCCESS && suspendstate == PSS_SUSPENDED)
1716     /* i18n: Like "Thread-Id %d, [state] running, suspended" */
1717     fprintf_unfiltered (buf, _(", suspended"));
1718
1719   status = pthdb_pthread_detachstate (pd_session, pdtid,
1720                                       &detachstate);
1721   if (status == PTHDB_SUCCESS && detachstate == PDS_DETACHED)
1722     /* i18n: Like "Thread-Id %d, [state] running, detached" */
1723     fprintf_unfiltered (buf, _(", detached"));
1724
1725   pthdb_pthread_cancelpend (pd_session, pdtid, &cancelpend);
1726   if (status == PTHDB_SUCCESS && cancelpend)
1727     /* i18n: Like "Thread-Id %d, [state] running, cancel pending" */
1728     fprintf_unfiltered (buf, _(", cancel pending"));
1729
1730   ui_file_write (buf, "", 1);
1731
1732   xfree (ret);                  /* Free old buffer.  */
1733
1734   ret = ui_file_xstrdup (buf, &length);
1735   ui_file_delete (buf);
1736
1737   return ret;
1738 }
1739
1740 /* Initialize target aix_thread_ops.  */
1741
1742 static void
1743 init_aix_thread_ops (void)
1744 {
1745   aix_thread_ops.to_shortname          = "aix-threads";
1746   aix_thread_ops.to_longname           = _("AIX pthread support");
1747   aix_thread_ops.to_doc                = _("AIX pthread support");
1748
1749   aix_thread_ops.to_attach             = aix_thread_attach;
1750   aix_thread_ops.to_detach             = aix_thread_detach;
1751   aix_thread_ops.to_resume             = aix_thread_resume;
1752   aix_thread_ops.to_wait               = aix_thread_wait;
1753   aix_thread_ops.to_fetch_registers    = aix_thread_fetch_registers;
1754   aix_thread_ops.to_store_registers    = aix_thread_store_registers;
1755   aix_thread_ops.deprecated_xfer_memory = aix_thread_xfer_memory;
1756   /* No need for aix_thread_ops.to_create_inferior, because we activate thread
1757      debugging when the inferior reaches pd_brk_addr.  */
1758   aix_thread_ops.to_kill               = aix_thread_kill;
1759   aix_thread_ops.to_mourn_inferior     = aix_thread_mourn_inferior;
1760   aix_thread_ops.to_thread_alive       = aix_thread_thread_alive;
1761   aix_thread_ops.to_pid_to_str         = aix_thread_pid_to_str;
1762   aix_thread_ops.to_extra_thread_info  = aix_thread_extra_thread_info;
1763   aix_thread_ops.to_stratum            = thread_stratum;
1764   aix_thread_ops.to_magic              = OPS_MAGIC;
1765 }
1766
1767 /* Module startup initialization function, automagically called by
1768    init.c.  */
1769
1770 void
1771 _initialize_aix_thread (void)
1772 {
1773   init_aix_thread_ops ();
1774   add_target (&aix_thread_ops);
1775
1776   /* Notice when object files get loaded and unloaded.  */
1777   target_new_objfile_chain = deprecated_target_new_objfile_hook;
1778   deprecated_target_new_objfile_hook = new_objfile;
1779
1780   add_setshow_boolean_cmd ("aix-thread", class_maintenance, &debug_aix_thread,
1781                             _("Set debugging of AIX thread module."),
1782                             _("Show debugging of AIX thread module."),
1783                             _("Enables debugging output (used to debug GDB)."),
1784                             NULL, NULL, /* FIXME: i18n: Debugging of AIX thread module is \"%d\".  */
1785                             &setdebuglist, &showdebuglist);
1786 }