gdb/aix-thread.c

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