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