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 <[email protected]>.
   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   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
1024   int regno;
1025
1026   for (regno = 0; regno < 32; regno++)
1027     supply_register (regno + tdep->ppc_fp0_regnum, (char *) (vals + regno));
1028 }
1029
1030 /* Predicate to test whether given register number is a "special" register.  */
1031 static int
1032 special_register_p (int regno)
1033 {
1034   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
1035
1036   return regno == PC_REGNUM
1037       || regno == tdep->ppc_ps_regnum
1038       || regno == tdep->ppc_cr_regnum
1039       || regno == tdep->ppc_lr_regnum
1040       || regno == tdep->ppc_ctr_regnum
1041       || regno == tdep->ppc_xer_regnum
1042       || regno == tdep->ppc_fpscr_regnum
1043       || (tdep->ppc_mq_regnum >= 0 && regno == tdep->ppc_mq_regnum);
1044 }
1045
1046
1047 /* Record that the special registers contain the specified 64-bit and
1048    32-bit values.  */
1049
1050 static void
1051 supply_sprs64 (uint64_t iar, uint64_t msr, uint32_t cr,
1052                uint64_t lr, uint64_t ctr, uint32_t xer,
1053                uint32_t fpscr)
1054 {
1055   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
1056
1057   supply_register (PC_REGNUM,     (char *) &iar);
1058   supply_register (tdep->ppc_ps_regnum, (char *) &msr);
1059   supply_register (tdep->ppc_cr_regnum, (char *) &cr);
1060   supply_register (tdep->ppc_lr_regnum, (char *) &lr);
1061   supply_register (tdep->ppc_ctr_regnum, (char *) &ctr);
1062   supply_register (tdep->ppc_xer_regnum, (char *) &xer);
1063   supply_register (tdep->ppc_fpscr_regnum, (char *) &fpscr);
1064 }
1065
1066 /* Record that the special registers contain the specified 32-bit
1067    values.  */
1068
1069 static void
1070 supply_sprs32 (uint32_t iar, uint32_t msr, uint32_t cr,
1071                uint32_t lr, uint32_t ctr, uint32_t xer,
1072                uint32_t fpscr)
1073 {
1074   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
1075
1076   supply_register (PC_REGNUM,     (char *) &iar);
1077   supply_register (tdep->ppc_ps_regnum, (char *) &msr);
1078   supply_register (tdep->ppc_cr_regnum, (char *) &cr);
1079   supply_register (tdep->ppc_lr_regnum, (char *) &lr);
1080   supply_register (tdep->ppc_ctr_regnum, (char *) &ctr);
1081   supply_register (tdep->ppc_xer_regnum, (char *) &xer);
1082   supply_register (tdep->ppc_fpscr_regnum, (char *) &fpscr);
1083 }
1084
1085 /* Fetch all registers from pthread PDTID, which doesn't have a kernel
1086    thread.
1087
1088    There's no way to query a single register from a non-kernel
1089    pthread, so there's no need for a single-register version of this
1090    function.  */
1091
1092 static void
1093 fetch_regs_user_thread (pthdb_pthread_t pdtid)
1094 {
1095   int status, i;
1096   pthdb_context_t ctx;
1097
1098   if (debug_aix_thread)
1099     fprintf_unfiltered (gdb_stdlog,
1100                         "fetch_regs_user_thread %lx\n", (long) pdtid);
1101   status = pthdb_pthread_context (pd_session, pdtid, &ctx);
1102   if (status != PTHDB_SUCCESS)
1103     error ("aix-thread: fetch_registers: pthdb_pthread_context returned %s",
1104            pd_status2str (status));
1105
1106   /* General-purpose registers.  */
1107
1108   if (arch64)
1109     supply_gprs64 (ctx.gpr);
1110   else
1111     for (i = 0; i < 32; i++)
1112       supply_reg32 (i, ctx.gpr[i]);
1113
1114   /* Floating-point registers.  */
1115
1116   supply_fprs (ctx.fpr);
1117
1118   /* Special registers.  */
1119
1120   if (arch64)
1121     supply_sprs64 (ctx.iar, ctx.msr, ctx.cr, ctx.lr, ctx.ctr, ctx.xer,
1122                    ctx.fpscr);
1123   else
1124     supply_sprs32 (ctx.iar, ctx.msr, ctx.cr, ctx.lr, ctx.ctr, ctx.xer,
1125                    ctx.fpscr);
1126 }
1127
1128 /* Fetch register REGNO if != -1 or all registers otherwise from
1129    kernel thread TID.
1130
1131    AIX provides a way to query all of a kernel thread's GPRs, FPRs, or
1132    SPRs, but there's no way to query individual registers within those
1133    groups.  Therefore, if REGNO != -1, this function fetches an entire
1134    group.
1135
1136    Unfortunately, kernel thread register queries often fail with
1137    EPERM, indicating that the thread is in kernel space.  This breaks
1138    backtraces of threads other than the current one.  To make that
1139    breakage obvious without throwing an error to top level (which is
1140    bad e.g. during "info threads" output), zero registers that can't
1141    be retrieved.  */
1142
1143 static void
1144 fetch_regs_kernel_thread (int regno, pthdb_tid_t tid)
1145 {
1146   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
1147   uint64_t gprs64[32];
1148   uint32_t gprs32[32];
1149   double fprs[32];
1150   struct ptxsprs sprs64;
1151   struct ptsprs sprs32;
1152   int i;
1153
1154   if (debug_aix_thread)
1155     fprintf_unfiltered (gdb_stdlog,
1156         "fetch_regs_kernel_thread tid=%lx regno=%d arch64=%d\n",
1157         (long) tid, regno, arch64);
1158
1159   /* General-purpose registers.  */
1160   if (regno == -1 || regno < tdep->ppc_fp0_regnum)
1161     {
1162       if (arch64)
1163         {
1164           if (!ptrace64aix (PTT_READ_GPRS, tid,
1165                             (unsigned long) gprs64, 0, NULL))
1166             memset (gprs64, 0, sizeof (gprs64));
1167           supply_gprs64 (gprs64);
1168         }
1169       else
1170         {
1171           if (!ptrace32 (PTT_READ_GPRS, tid, gprs32, 0, NULL))
1172             memset (gprs32, 0, sizeof (gprs32));
1173           for (i = 0; i < 32; i++)
1174             supply_reg32 (i, gprs32[i]);
1175         }
1176     }
1177
1178   /* Floating-point registers.  */
1179
1180   if (regno == -1
1181       || (regno >= tdep->ppc_fp0_regnum
1182           && regno < tdep->ppc_fp0_regnum + ppc_num_fprs))
1183     {
1184       if (!ptrace32 (PTT_READ_FPRS, tid, (int *) fprs, 0, NULL))
1185         memset (fprs, 0, sizeof (fprs));
1186       supply_fprs (fprs);
1187     }
1188
1189   /* Special-purpose registers.  */
1190
1191   if (regno == -1 || special_register_p (regno))
1192     {
1193       if (arch64)
1194         {
1195           if (!ptrace64aix (PTT_READ_SPRS, tid,
1196                             (unsigned long) &sprs64, 0, NULL))
1197             memset (&sprs64, 0, sizeof (sprs64));
1198           supply_sprs64 (sprs64.pt_iar, sprs64.pt_msr, sprs64.pt_cr,
1199                          sprs64.pt_lr, sprs64.pt_ctr, sprs64.pt_xer,
1200                          sprs64.pt_fpscr);
1201         }
1202       else
1203         {
1204           struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
1205
1206           if (!ptrace32 (PTT_READ_SPRS, tid, (int *) &sprs32, 0, NULL))
1207             memset (&sprs32, 0, sizeof (sprs32));
1208           supply_sprs32 (sprs32.pt_iar, sprs32.pt_msr, sprs32.pt_cr,
1209                          sprs32.pt_lr, sprs32.pt_ctr, sprs32.pt_xer,
1210                          sprs32.pt_fpscr);
1211
1212           if (tdep->ppc_mq_regnum >= 0)
1213             supply_register (tdep->ppc_mq_regnum, (char *) &sprs32.pt_mq);
1214         }
1215     }
1216 }
1217
1218 /* Fetch register REGNO if != -1 or all registers otherwise in the
1219    thread/process specified by inferior_ptid.  */
1220
1221 static void
1222 aix_thread_fetch_registers (int regno)
1223 {
1224   struct thread_info *thread;
1225   pthdb_tid_t tid;
1226
1227   if (!PD_TID (inferior_ptid))
1228     base_target.to_fetch_registers (regno);
1229   else
1230     {
1231       thread = find_thread_pid (inferior_ptid);
1232       tid = thread->private->tid;
1233
1234       if (tid == PTHDB_INVALID_TID)
1235         fetch_regs_user_thread (thread->private->pdtid);
1236       else
1237         fetch_regs_kernel_thread (regno, tid);
1238     }
1239 }
1240
1241 /* Store the gp registers into an array of uint32_t or uint64_t.  */
1242
1243 static void
1244 fill_gprs64 (uint64_t *vals)
1245 {
1246   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
1247   int regno;
1248
1249   for (regno = 0; regno < tdep->ppc_fp0_regnum; regno++)
1250     if (register_cached (regno))
1251       regcache_collect (regno, vals + regno);
1252 }
1253
1254 static void
1255 fill_gprs32 (uint32_t *vals)
1256 {
1257   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
1258   int regno;
1259
1260   for (regno = 0; regno < tdep->ppc_fp0_regnum; regno++)
1261     if (register_cached (regno))
1262       regcache_collect (regno, vals + regno);
1263 }
1264
1265 /* Store the floating point registers into a double array.  */
1266 static void
1267 fill_fprs (double *vals)
1268 {
1269   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
1270   int regno;
1271
1272   for (regno = tdep->ppc_fp0_regnum;
1273        regno < tdep->ppc_fp0_regnum + ppc_num_fprs;
1274        regno++)
1275     if (register_cached (regno))
1276       regcache_collect (regno, vals + regno);
1277 }
1278
1279 /* Store the special registers into the specified 64-bit and 32-bit
1280    locations.  */
1281
1282 static void
1283 fill_sprs64 (uint64_t *iar, uint64_t *msr, uint32_t *cr,
1284              uint64_t *lr, uint64_t *ctr, uint32_t *xer,
1285              uint32_t *fpscr)
1286 {
1287   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
1288
1289   /* Verify that the size of the size of the IAR buffer is the
1290      same as the raw size of the PC (in the register cache).  If
1291      they're not, then either GDB has been built incorrectly, or
1292      there's some other kind of internal error.  To be really safe,
1293      we should check all of the sizes.   */
1294   gdb_assert (sizeof (*iar) == DEPRECATED_REGISTER_RAW_SIZE (PC_REGNUM));
1295
1296   if (register_cached (PC_REGNUM))
1297     regcache_collect (PC_REGNUM, iar);
1298   if (register_cached (tdep->ppc_ps_regnum))
1299     regcache_collect (tdep->ppc_ps_regnum, msr);
1300   if (register_cached (tdep->ppc_cr_regnum))
1301     regcache_collect (tdep->ppc_cr_regnum, cr);
1302   if (register_cached (tdep->ppc_lr_regnum))
1303     regcache_collect (tdep->ppc_lr_regnum, lr);
1304   if (register_cached (tdep->ppc_ctr_regnum))
1305     regcache_collect (tdep->ppc_ctr_regnum, ctr);
1306   if (register_cached (tdep->ppc_xer_regnum))
1307     regcache_collect (tdep->ppc_xer_regnum, xer);
1308   if (register_cached (tdep->ppc_fpscr_regnum))
1309     regcache_collect (tdep->ppc_fpscr_regnum, fpscr);
1310 }
1311
1312 static void
1313 fill_sprs32 (unsigned long *iar, unsigned long *msr, unsigned long *cr,
1314              unsigned long *lr,  unsigned long *ctr, unsigned long *xer,
1315              unsigned long *fpscr)
1316 {
1317   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
1318
1319   /* Verify that the size of the size of the IAR buffer is the
1320      same as the raw size of the PC (in the register cache).  If
1321      they're not, then either GDB has been built incorrectly, or
1322      there's some other kind of internal error.  To be really safe,
1323      we should check all of the sizes.
1324
1325      If this assert() fails, the most likely reason is that GDB was
1326      built incorrectly.  In order to make use of many of the header
1327      files in /usr/include/sys, GDB needs to be configured so that
1328      sizeof (long) == 4).  */
1329   gdb_assert (sizeof (*iar) == DEPRECATED_REGISTER_RAW_SIZE (PC_REGNUM));
1330
1331   if (register_cached (PC_REGNUM))
1332     regcache_collect (PC_REGNUM, iar);
1333   if (register_cached (tdep->ppc_ps_regnum))
1334     regcache_collect (tdep->ppc_ps_regnum, msr);
1335   if (register_cached (tdep->ppc_cr_regnum))
1336     regcache_collect (tdep->ppc_cr_regnum, cr);
1337   if (register_cached (tdep->ppc_lr_regnum))
1338     regcache_collect (tdep->ppc_lr_regnum, lr);
1339   if (register_cached (tdep->ppc_ctr_regnum))
1340     regcache_collect (tdep->ppc_ctr_regnum, ctr);
1341   if (register_cached (tdep->ppc_xer_regnum))
1342     regcache_collect (tdep->ppc_xer_regnum, xer);
1343   if (register_cached (tdep->ppc_fpscr_regnum))
1344     regcache_collect (tdep->ppc_fpscr_regnum, fpscr);
1345 }
1346
1347 /* Store all registers into pthread PDTID, which doesn't have a kernel
1348    thread.
1349
1350    It's possible to store a single register into a non-kernel pthread,
1351    but I doubt it's worth the effort.  */
1352
1353 static void
1354 store_regs_user_thread (pthdb_pthread_t pdtid)
1355 {
1356   int status, i;
1357   pthdb_context_t ctx;
1358   uint32_t int32;
1359   uint64_t int64;
1360   double   dbl;
1361
1362   if (debug_aix_thread)
1363     fprintf_unfiltered (gdb_stdlog,
1364                         "store_regs_user_thread %lx\n", (long) pdtid);
1365
1366   /* Retrieve the thread's current context for its non-register
1367      values.  */
1368   status = pthdb_pthread_context (pd_session, pdtid, &ctx);
1369   if (status != PTHDB_SUCCESS)
1370     error ("aix-thread: store_registers: pthdb_pthread_context returned %s",
1371            pd_status2str (status));
1372
1373   /* Collect general-purpose register values from the regcache.  */
1374
1375   for (i = 0; i < 32; i++)
1376     if (register_cached (i))
1377       {
1378         if (arch64)
1379           {
1380             regcache_collect (i, (void *) &int64);
1381             ctx.gpr[i] = int64;
1382           }
1383         else
1384           {
1385             regcache_collect (i, (void *) &int32);
1386             ctx.gpr[i] = int32;
1387           }
1388       }
1389
1390   /* Collect floating-point register values from the regcache.  */
1391   fill_fprs (ctx.fpr);
1392
1393   /* Special registers (always kept in ctx as 64 bits).  */
1394   if (arch64)
1395     {
1396       fill_sprs64 (&ctx.iar, &ctx.msr, &ctx.cr, &ctx.lr, &ctx.ctr, &ctx.xer,
1397                    &ctx.fpscr);
1398     }
1399   else
1400     {
1401       /* Problem: ctx.iar etc. are 64 bits, but raw_registers are 32.
1402          Solution: use 32-bit temp variables.  (The assert() in fill_sprs32()
1403          will fail if the size of an unsigned long is incorrect.  If this
1404          happens, GDB needs to be reconfigured so that longs are 32-bits.)  */
1405       unsigned long tmp_iar, tmp_msr, tmp_cr, tmp_lr, tmp_ctr, tmp_xer,
1406                     tmp_fpscr;
1407       struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
1408
1409       fill_sprs32 (&tmp_iar, &tmp_msr, &tmp_cr, &tmp_lr, &tmp_ctr, &tmp_xer,
1410                    &tmp_fpscr);
1411       if (register_cached (PC_REGNUM))
1412         ctx.iar = tmp_iar;
1413       if (register_cached (tdep->ppc_ps_regnum))
1414         ctx.msr = tmp_msr;
1415       if (register_cached (tdep->ppc_cr_regnum))
1416         ctx.cr  = tmp_cr;
1417       if (register_cached (tdep->ppc_lr_regnum))
1418         ctx.lr  = tmp_lr;
1419       if (register_cached (tdep->ppc_ctr_regnum))
1420         ctx.ctr = tmp_ctr;
1421       if (register_cached (tdep->ppc_xer_regnum))
1422         ctx.xer = tmp_xer;
1423       if (register_cached (tdep->ppc_xer_regnum))
1424         ctx.fpscr = tmp_fpscr;
1425     }
1426
1427   status = pthdb_pthread_setcontext (pd_session, pdtid, &ctx);
1428   if (status != PTHDB_SUCCESS)
1429     error ("aix-thread: store_registers: pthdb_pthread_setcontext returned %s",
1430            pd_status2str (status));
1431 }
1432
1433 /* Store register REGNO if != -1 or all registers otherwise into
1434    kernel thread TID.
1435
1436    AIX provides a way to set all of a kernel thread's GPRs, FPRs, or
1437    SPRs, but there's no way to set individual registers within those
1438    groups.  Therefore, if REGNO != -1, this function stores an entire
1439    group.  */
1440
1441 static void
1442 store_regs_kernel_thread (int regno, pthdb_tid_t tid)
1443 {
1444   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
1445   uint64_t gprs64[32];
1446   uint32_t gprs32[32];
1447   double fprs[32];
1448   struct ptxsprs sprs64;
1449   struct ptsprs  sprs32;
1450   int i;
1451   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
1452
1453   if (debug_aix_thread)
1454     fprintf_unfiltered (gdb_stdlog,
1455                         "store_regs_kernel_thread tid=%lx regno=%d\n",
1456                         (long) tid, regno);
1457
1458   /* General-purpose registers.  */
1459   if (regno == -1 || regno < tdep->ppc_fp0_regnum)
1460     {
1461       if (arch64)
1462         {
1463           /* Pre-fetch: some regs may not be in the cache.  */
1464           ptrace64aix (PTT_READ_GPRS, tid, (unsigned long) gprs64, 0, NULL);
1465           fill_gprs64 (gprs64);
1466           ptrace64aix (PTT_WRITE_GPRS, tid, (unsigned long) gprs64, 0, NULL);
1467         }
1468       else
1469         {
1470           /* Pre-fetch: some regs may not be in the cache.  */
1471           ptrace32 (PTT_READ_GPRS, tid, gprs32, 0, NULL);
1472           fill_gprs32 (gprs32);
1473           ptrace32 (PTT_WRITE_GPRS, tid, gprs32, 0, NULL);
1474         }
1475     }
1476
1477   /* Floating-point registers.  */
1478
1479   if (regno == -1
1480       || (regno >= tdep->ppc_fp0_regnum
1481           && regno < tdep->ppc_fp0_regnum + ppc_num_fprs))
1482     {
1483       /* Pre-fetch: some regs may not be in the cache.  */
1484       ptrace32 (PTT_READ_FPRS, tid, (int *) fprs, 0, NULL);
1485       fill_fprs (fprs);
1486       ptrace32 (PTT_WRITE_FPRS, tid, (int *) fprs, 0, NULL);
1487     }
1488
1489   /* Special-purpose registers.  */
1490
1491   if (regno == -1 || special_register_p (regno))
1492     {
1493       if (arch64)
1494         {
1495           /* Pre-fetch: some registers won't be in the cache.  */
1496           ptrace64aix (PTT_READ_SPRS, tid,
1497                        (unsigned long) &sprs64, 0, NULL);
1498           fill_sprs64 (&sprs64.pt_iar, &sprs64.pt_msr, &sprs64.pt_cr,
1499                        &sprs64.pt_lr,  &sprs64.pt_ctr, &sprs64.pt_xer,
1500                        &sprs64.pt_fpscr);
1501           ptrace64aix (PTT_WRITE_SPRS, tid,
1502                        (unsigned long) &sprs64, 0, NULL);
1503         }
1504       else
1505         {
1506           /* Pre-fetch: some registers won't be in the cache.  */
1507           ptrace32 (PTT_READ_SPRS, tid, (int *) &sprs32, 0, NULL);
1508
1509           fill_sprs32 (&sprs32.pt_iar, &sprs32.pt_msr, &sprs32.pt_cr,
1510                        &sprs32.pt_lr,  &sprs32.pt_ctr, &sprs32.pt_xer,
1511                        &sprs32.pt_fpscr);
1512
1513           if (tdep->ppc_mq_regnum >= 0)
1514             if (register_cached (tdep->ppc_mq_regnum))
1515               regcache_collect (tdep->ppc_mq_regnum, &sprs32.pt_mq);
1516
1517           ptrace32 (PTT_WRITE_SPRS, tid, (int *) &sprs32, 0, NULL);
1518         }
1519     }
1520 }
1521
1522 /* Store gdb's current view of the register set into the
1523    thread/process specified by inferior_ptid.  */
1524
1525 static void
1526 aix_thread_store_registers (int regno)
1527 {
1528   struct thread_info *thread;
1529   pthdb_tid_t tid;
1530
1531   if (!PD_TID (inferior_ptid))
1532     base_target.to_store_registers (regno);
1533   else
1534     {
1535       thread = find_thread_pid (inferior_ptid);
1536       tid = thread->private->tid;
1537
1538       if (tid == PTHDB_INVALID_TID)
1539         store_regs_user_thread (thread->private->pdtid);
1540       else
1541         store_regs_kernel_thread (regno, tid);
1542     }
1543 }
1544
1545 /* Transfer LEN bytes of memory from GDB address MYADDR to target
1546    address MEMADDR if WRITE and vice versa otherwise.  */
1547
1548 static int
1549 aix_thread_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
1550                       struct mem_attrib *attrib,
1551                       struct target_ops *target)
1552 {
1553   int n;
1554   struct cleanup *cleanup = save_inferior_ptid ();
1555
1556   inferior_ptid = pid_to_ptid (PIDGET (inferior_ptid));
1557   n = base_target.to_xfer_memory (memaddr, myaddr, len,
1558                                   write, attrib, &base_target);
1559   do_cleanups (cleanup);
1560
1561   return n;
1562 }
1563
1564 /* Kill and forget about the inferior process.  */
1565
1566 static void
1567 aix_thread_kill (void)
1568 {
1569   struct cleanup *cleanup = save_inferior_ptid ();
1570
1571   inferior_ptid = pid_to_ptid (PIDGET (inferior_ptid));
1572   base_target.to_kill ();
1573   do_cleanups (cleanup);
1574 }
1575
1576 /* Clean up after the inferior exits.  */
1577
1578 static void
1579 aix_thread_mourn_inferior (void)
1580 {
1581   pd_deactivate ();
1582   base_target.to_mourn_inferior ();
1583 }
1584
1585 /* Return whether thread PID is still valid.  */
1586
1587 static int
1588 aix_thread_thread_alive (ptid_t ptid)
1589 {
1590   if (!PD_TID (ptid))
1591     return base_target.to_thread_alive (ptid);
1592
1593   /* We update the thread list every time the child stops, so all
1594      valid threads should be in the thread list.  */
1595   return in_thread_list (ptid);
1596 }
1597
1598 /* Return a printable representation of composite PID for use in
1599    "info threads" output.  */
1600
1601 static char *
1602 aix_thread_pid_to_str (ptid_t ptid)
1603 {
1604   static char *ret = NULL;
1605
1606   if (!PD_TID (ptid))
1607     return base_target.to_pid_to_str (ptid);
1608
1609   /* Free previous return value; a new one will be allocated by
1610      xasprintf().  */
1611   xfree (ret);
1612
1613   xasprintf (&ret, "Thread %ld", ptid_get_tid (ptid));
1614   return ret;
1615 }
1616
1617 /* Return a printable representation of extra information about
1618    THREAD, for use in "info threads" output.  */
1619
1620 static char *
1621 aix_thread_extra_thread_info (struct thread_info *thread)
1622 {
1623   struct ui_file *buf;
1624   int status;
1625   pthdb_pthread_t pdtid;
1626   pthdb_tid_t tid;
1627   pthdb_state_t state;
1628   pthdb_suspendstate_t suspendstate;
1629   pthdb_detachstate_t detachstate;
1630   int cancelpend;
1631   long length;
1632   static char *ret = NULL;
1633
1634   if (!PD_TID (thread->ptid))
1635     return NULL;
1636
1637   buf = mem_fileopen ();
1638
1639   pdtid = thread->private->pdtid;
1640   tid = thread->private->tid;
1641
1642   if (tid != PTHDB_INVALID_TID)
1643     fprintf_unfiltered (buf, "tid %d", tid);
1644
1645   status = pthdb_pthread_state (pd_session, pdtid, &state);
1646   if (status != PTHDB_SUCCESS)
1647     state = PST_NOTSUP;
1648   fprintf_unfiltered (buf, ", %s", state2str (state));
1649
1650   status = pthdb_pthread_suspendstate (pd_session, pdtid,
1651                                        &suspendstate);
1652   if (status == PTHDB_SUCCESS && suspendstate == PSS_SUSPENDED)
1653     fprintf_unfiltered (buf, ", suspended");
1654
1655   status = pthdb_pthread_detachstate (pd_session, pdtid,
1656                                       &detachstate);
1657   if (status == PTHDB_SUCCESS && detachstate == PDS_DETACHED)
1658     fprintf_unfiltered (buf, ", detached");
1659
1660   pthdb_pthread_cancelpend (pd_session, pdtid, &cancelpend);
1661   if (status == PTHDB_SUCCESS && cancelpend)
1662     fprintf_unfiltered (buf, ", cancel pending");
1663
1664   ui_file_write (buf, "", 1);
1665
1666   xfree (ret);                  /* Free old buffer.  */
1667
1668   ret = ui_file_xstrdup (buf, &length);
1669   ui_file_delete (buf);
1670
1671   return ret;
1672 }
1673
1674 /* Initialize target aix_thread_ops.  */
1675
1676 static void
1677 init_aix_thread_ops (void)
1678 {
1679   aix_thread_ops.to_shortname          = "aix-threads";
1680   aix_thread_ops.to_longname           = "AIX pthread support";
1681   aix_thread_ops.to_doc                = "AIX pthread support";
1682
1683   aix_thread_ops.to_attach             = aix_thread_attach;
1684   aix_thread_ops.to_detach             = aix_thread_detach;
1685   aix_thread_ops.to_resume             = aix_thread_resume;
1686   aix_thread_ops.to_wait               = aix_thread_wait;
1687   aix_thread_ops.to_fetch_registers    = aix_thread_fetch_registers;
1688   aix_thread_ops.to_store_registers    = aix_thread_store_registers;
1689   aix_thread_ops.to_xfer_memory        = aix_thread_xfer_memory;
1690   /* No need for aix_thread_ops.to_create_inferior, because we activate thread
1691      debugging when the inferior reaches pd_brk_addr.  */
1692   aix_thread_ops.to_kill               = aix_thread_kill;
1693   aix_thread_ops.to_mourn_inferior     = aix_thread_mourn_inferior;
1694   aix_thread_ops.to_thread_alive       = aix_thread_thread_alive;
1695   aix_thread_ops.to_pid_to_str         = aix_thread_pid_to_str;
1696   aix_thread_ops.to_extra_thread_info  = aix_thread_extra_thread_info;
1697   aix_thread_ops.to_stratum            = thread_stratum;
1698   aix_thread_ops.to_magic              = OPS_MAGIC;
1699 }
1700
1701 /* Module startup initialization function, automagically called by
1702    init.c.  */
1703
1704 void
1705 _initialize_aix_thread (void)
1706 {
1707   init_aix_thread_ops ();
1708   add_target (&aix_thread_ops);
1709
1710   /* Notice when object files get loaded and unloaded.  */
1711   target_new_objfile_chain = deprecated_target_new_objfile_hook;
1712   deprecated_target_new_objfile_hook = new_objfile;
1713
1714   add_show_from_set (add_set_cmd ("aix-thread", no_class, var_zinteger,
1715                                   (char *) &debug_aix_thread,
1716                                   "Set debugging of AIX thread module.\n"
1717                                   "Enables printf debugging output.\n",
1718                                   &setdebuglist),
1719                                   &showdebuglist);
1720 }