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