gdb/aix-thread.c

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