gdb/aix-thread.c

   1 /* Low level interface for debugging AIX 4.3+ pthreads.
   2
   3    Copyright 1999, 2000, 2002 Free Software Foundation, Inc.
   4    Written by Nick Duffek <nsd@redhat.com>.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 59 Temple Place - Suite 330,
  21    Boston, MA 02111-1307, USA.  */
  22
  23
  24 /* This module uses the libpthdebug.a library provided by AIX 4.3+ for
  25    debugging pthread applications.
  26
  27    Some name prefix conventions:
  28      pthdb_     provided by libpthdebug.a
  29      pdc_       callbacks that this module provides to libpthdebug.a
  30      pd_        variables or functions interfacing with libpthdebug.a
  31
  32    libpthdebug peculiarities:
  33
  34      - pthdb_ptid_pthread() is prototyped in <sys/pthdebug.h>, but
  35        it's not documented, and after several calls it stops working
  36        and causes other libpthdebug functions to fail.
  37
  38      - pthdb_tid_pthread() doesn't always work after
  39        pthdb_session_update(), but it does work after cycling through
  40        all threads using pthdb_pthread().
  41
  42      */
  43
  44 #include "defs.h"
  45 #include "gdb_assert.h"
  46 #include "gdbthread.h"
  47 #include "target.h"
  48 #include "inferior.h"
  49 #include "regcache.h"
  50 #include "gdbcmd.h"
  51 #include "ppc-tdep.h"
  52 #include "gdb_string.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.  This is more
 109    convenient than a pointer to deprecated_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, 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[ppc_num_gprs];
 342   uint32_t gprs32[ppc_num_gprs];
 343   double fprs[ppc_num_fprs];
 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, 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, 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, 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, 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 /* Search through the list of all kernel threads for the thread
 625    that has stopped on a SIGTRAP signal, and return its TID.
 626    Return 0 if none found.  */
 627
 628 static pthdb_tid_t
 629 get_signaled_thread (void)
 630 {
 631   struct thrdsinfo64 thrinf;
 632   pthdb_tid_t ktid = 0;
 633   int result = 0;
 634
 635   /* getthrds(3) isn't prototyped in any AIX 4.3.3 #include file.  */
 636   extern int getthrds (pid_t, struct thrdsinfo64 *,
 637                        int, pthdb_tid_t *, int);
 638
 639   while (1)
 640   {
 641     if (getthrds (PIDGET (inferior_ptid), &thrinf,
 642                   sizeof (thrinf), &ktid, 1) != 1)
 643       break;
 644
 645     if (thrinf.ti_cursig == SIGTRAP)
 646       return thrinf.ti_tid;
 647   }
 648
 649   /* Didn't find any thread stopped on a SIGTRAP signal.  */
 650   return 0;
 651 }
 652
 653 /* Synchronize GDB's thread list with libpthdebug's.
 654
 655    There are some benefits of doing this every time the inferior stops:
 656
 657      - allows users to run thread-specific commands without needing to
 658        run "info threads" first
 659
 660      - helps pthdb_tid_pthread() work properly (see "libpthdebug
 661        peculiarities" at the top of this module)
 662
 663      - simplifies the demands placed on libpthdebug, which seems to
 664        have difficulty with certain call patterns */
 665
 666 static void
 667 sync_threadlists (void)
 668 {
 669   int cmd, status, infpid;
 670   int pcount, psize, pi, gcount, gi;
 671   struct pd_thread *pbuf;
 672   struct thread_info **gbuf, **g, *thread;
 673   pthdb_pthread_t pdtid;
 674   pthread_t pthid;
 675   pthdb_tid_t tid;
 676
 677   /* Accumulate an array of libpthdebug threads sorted by pthread id.  */
 678
 679   pcount = 0;
 680   psize = 1;
 681   pbuf = (struct pd_thread *) xmalloc (psize * sizeof *pbuf);
 682
 683   for (cmd = PTHDB_LIST_FIRST;; cmd = PTHDB_LIST_NEXT)
 684     {
 685       status = pthdb_pthread (pd_session, &pdtid, cmd);
 686       if (status != PTHDB_SUCCESS || pdtid == PTHDB_INVALID_PTHREAD)
 687         break;
 688
 689       status = pthdb_pthread_ptid (pd_session, pdtid, &pthid);
 690       if (status != PTHDB_SUCCESS || pthid == PTHDB_INVALID_PTID)
 691         continue;
 692
 693       if (pcount == psize)
 694         {
 695           psize *= 2;
 696           pbuf = (struct pd_thread *) xrealloc (pbuf,
 697                                                 psize * sizeof *pbuf);
 698         }
 699       pbuf[pcount].pdtid = pdtid;
 700       pbuf[pcount].pthid = pthid;
 701       pcount++;
 702     }
 703
 704   for (pi = 0; pi < pcount; pi++)
 705     {
 706       status = pthdb_pthread_tid (pd_session, pbuf[pi].pdtid, &tid);
 707       if (status != PTHDB_SUCCESS)
 708         tid = PTHDB_INVALID_TID;
 709       pbuf[pi].tid = tid;
 710     }
 711
 712   qsort (pbuf, pcount, sizeof *pbuf, pcmp);
 713
 714   /* Accumulate an array of GDB threads sorted by pid.  */
 715
 716   gcount = 0;
 717   iterate_over_threads (giter_count, &gcount);
 718   g = gbuf = (struct thread_info **) xmalloc (gcount * sizeof *gbuf);
 719   iterate_over_threads (giter_accum, &g);
 720   qsort (gbuf, gcount, sizeof *gbuf, gcmp);
 721
 722   /* Apply differences between the two arrays to GDB's thread list.  */
 723
 724   infpid = PIDGET (inferior_ptid);
 725   for (pi = gi = 0; pi < pcount || gi < gcount;)
 726     {
 727       if (pi == pcount)
 728         {
 729           delete_thread (gbuf[gi]->ptid);
 730           gi++;
 731         }
 732       else if (gi == gcount)
 733         {
 734           thread = add_thread (BUILD_THREAD (pbuf[pi].pthid, infpid));
 735           thread->private = xmalloc (sizeof (struct private_thread_info));
 736           thread->private->pdtid = pbuf[pi].pdtid;
 737           thread->private->tid = pbuf[pi].tid;
 738           pi++;
 739         }
 740       else
 741         {
 742           ptid_t pptid, gptid;
 743           int cmp_result;
 744
 745           pptid = BUILD_THREAD (pbuf[pi].pthid, infpid);
 746           gptid = gbuf[gi]->ptid;
 747           pdtid = pbuf[pi].pdtid;
 748           tid = pbuf[pi].tid;
 749
 750           cmp_result = ptid_cmp (pptid, gptid);
 751
 752           if (cmp_result == 0)
 753             {
 754               gbuf[gi]->private->pdtid = pdtid;
 755               gbuf[gi]->private->tid = tid;
 756               pi++;
 757               gi++;
 758             }
 759           else if (cmp_result > 0)
 760             {
 761               delete_thread (gptid);
 762               gi++;
 763             }
 764           else
 765             {
 766               thread = add_thread (pptid);
 767               thread->private = xmalloc (sizeof (struct private_thread_info));
 768               thread->private->pdtid = pdtid;
 769               thread->private->tid = tid;
 770               pi++;
 771             }
 772         }
 773     }
 774
 775   xfree (pbuf);
 776   xfree (gbuf);
 777 }
 778
 779 /* Iterate_over_threads() callback for locating a thread, using
 780    the TID of its associated kernel thread.  */
 781
 782 static int
 783 iter_tid (struct thread_info *thread, void *tidp)
 784 {
 785   const pthdb_tid_t tid = *(pthdb_tid_t *)tidp;
 786
 787   return (thread->private->tid == tid);
 788 }
 789
 790 /* Synchronize libpthdebug's state with the inferior and with GDB,
 791    generate a composite process/thread <pid> for the current thread,
 792    set inferior_ptid to <pid> if SET_INFPID, and return <pid>.  */
 793
 794 static ptid_t
 795 pd_update (int set_infpid)
 796 {
 797   int status;
 798   ptid_t ptid;
 799   pthdb_tid_t tid;
 800   struct thread_info *thread = NULL;
 801
 802   if (!pd_active)
 803     return inferior_ptid;
 804
 805   status = pthdb_session_update (pd_session);
 806   if (status != PTHDB_SUCCESS)
 807     return inferior_ptid;
 808
 809   sync_threadlists ();
 810
 811   /* Define "current thread" as one that just received a trap signal.  */
 812
 813   tid = get_signaled_thread ();
 814   if (tid != 0)
 815     thread = iterate_over_threads (iter_tid, &tid);
 816   if (!thread)
 817     ptid = inferior_ptid;
 818   else
 819     {
 820       ptid = thread->ptid;
 821       if (set_infpid)
 822         inferior_ptid = ptid;
 823     }
 824   return ptid;
 825 }
 826
 827 /* Try to start debugging threads in the current process.
 828    If successful and SET_INFPID, set inferior_ptid to reflect the
 829    current thread.  */
 830
 831 static ptid_t
 832 pd_activate (int set_infpid)
 833 {
 834   int status;
 835
 836   status = pthdb_session_init (PD_USER, arch64 ? PEM_64BIT : PEM_32BIT,
 837                                PTHDB_FLAG_REGS, &pd_callbacks,
 838                                &pd_session);
 839   if (status != PTHDB_SUCCESS)
 840     {
 841       return inferior_ptid;
 842     }
 843   pd_active = 1;
 844   return pd_update (set_infpid);
 845 }
 846
 847 /* Undo the effects of pd_activate().  */
 848
 849 static void
 850 pd_deactivate (void)
 851 {
 852   if (!pd_active)
 853     return;
 854   pthdb_session_destroy (pd_session);
 855
 856   pid_to_prc (&inferior_ptid);
 857   pd_active = 0;
 858 }
 859
 860 /* An object file has just been loaded.  Check whether the current
 861    application is pthreaded, and if so, prepare for thread debugging.  */
 862
 863 static void
 864 pd_enable (void)
 865 {
 866   int status;
 867   char *stub_name;
 868   struct minimal_symbol *ms;
 869
 870   /* Don't initialize twice.  */
 871   if (pd_able)
 872     return;
 873
 874   /* Check application word size.  */
 875   arch64 = register_size (current_gdbarch, 0) == 8;
 876
 877   /* Check whether the application is pthreaded.  */
 878   stub_name = NULL;
 879   status = pthdb_session_pthreaded (PD_USER, PTHDB_FLAG_REGS,
 880                                     &pd_callbacks, &stub_name);
 881   if ((status != PTHDB_SUCCESS &&
 882        status != PTHDB_NOT_PTHREADED) || !stub_name)
 883     return;
 884
 885   /* Set a breakpoint on the returned stub function.  */
 886   if (!(ms = lookup_minimal_symbol (stub_name, NULL, NULL)))
 887     return;
 888   pd_brk_addr = SYMBOL_VALUE_ADDRESS (ms);
 889   if (!create_thread_event_breakpoint (pd_brk_addr))
 890     return;
 891
 892   /* Prepare for thread debugging.  */
 893   base_target = current_target;
 894   push_target (&aix_thread_ops);
 895   pd_able = 1;
 896
 897   /* If we're debugging a core file or an attached inferior, the
 898      pthread library may already have been initialized, so try to
 899      activate thread debugging.  */
 900   pd_activate (1);
 901 }
 902
 903 /* Undo the effects of pd_enable().  */
 904
 905 static void
 906 pd_disable (void)
 907 {
 908   if (!pd_able)
 909     return;
 910   if (pd_active)
 911     pd_deactivate ();
 912   pd_able = 0;
 913   unpush_target (&aix_thread_ops);
 914 }
 915
 916 /* deprecated_target_new_objfile_hook callback.
 917
 918    If OBJFILE is non-null, check whether a threaded application is
 919    being debugged, and if so, prepare for thread debugging.
 920
 921    If OBJFILE is null, stop debugging threads.  */
 922
 923 static void
 924 new_objfile (struct objfile *objfile)
 925 {
 926   if (objfile)
 927     pd_enable ();
 928   else
 929     pd_disable ();
 930
 931   if (target_new_objfile_chain)
 932     target_new_objfile_chain (objfile);
 933 }
 934
 935 /* Attach to process specified by ARGS.  */
 936
 937 static void
 938 aix_thread_attach (char *args, int from_tty)
 939 {
 940   base_target.to_attach (args, from_tty);
 941   pd_activate (1);
 942 }
 943
 944 /* Detach from the process attached to by aix_thread_attach().  */
 945
 946 static void
 947 aix_thread_detach (char *args, int from_tty)
 948 {
 949   pd_disable ();
 950   base_target.to_detach (args, from_tty);
 951 }
 952
 953 /* Tell the inferior process to continue running thread PID if != -1
 954    and all threads otherwise.  */
 955
 956 static void
 957 aix_thread_resume (ptid_t ptid, int step, enum target_signal sig)
 958 {
 959   struct thread_info *thread;
 960   pthdb_tid_t tid[2];
 961
 962   if (!PD_TID (ptid))
 963     {
 964       struct cleanup *cleanup = save_inferior_ptid ();
 965       inferior_ptid = pid_to_ptid (PIDGET (inferior_ptid));
 966       base_target.to_resume (ptid, step, sig);
 967       do_cleanups (cleanup);
 968     }
 969   else
 970     {
 971       thread = find_thread_pid (ptid);
 972       if (!thread)
 973         error ("aix-thread resume: unknown pthread %ld",
 974                TIDGET (ptid));
 975
 976       tid[0] = thread->private->tid;
 977       if (tid[0] == PTHDB_INVALID_TID)
 978         error ("aix-thread resume: no tid for pthread %ld",
 979                TIDGET (ptid));
 980       tid[1] = 0;
 981
 982       if (arch64)
 983         ptrace64aix (PTT_CONTINUE, tid[0], 1,
 984                      target_signal_to_host (sig), (int *) tid);
 985       else
 986         ptrace32 (PTT_CONTINUE, tid[0], (int *) 1,
 987                   target_signal_to_host (sig), (int *) tid);
 988     }
 989 }
 990
 991 /* Wait for thread/process ID if != -1 or for any thread otherwise.
 992    If an error occurs, return -1, else return the pid of the stopped
 993    thread.  */
 994
 995 static ptid_t
 996 aix_thread_wait (ptid_t ptid, struct target_waitstatus *status)
 997 {
 998   struct cleanup *cleanup = save_inferior_ptid ();
 999
1000   pid_to_prc (&ptid);
1001
1002   inferior_ptid = pid_to_ptid (PIDGET (inferior_ptid));
1003   ptid = base_target.to_wait (ptid, status);
1004   do_cleanups (cleanup);
1005
1006   if (PIDGET (ptid) == -1)
1007     return pid_to_ptid (-1);
1008
1009   /* Check whether libpthdebug might be ready to be initialized.  */
1010   if (!pd_active && status->kind == TARGET_WAITKIND_STOPPED &&
1011       status->value.sig == TARGET_SIGNAL_TRAP &&
1012       read_pc_pid (ptid) - DECR_PC_AFTER_BREAK == pd_brk_addr)
1013     return pd_activate (0);
1014
1015   return pd_update (0);
1016 }
1017
1018 /* Record that the 64-bit general-purpose registers contain VALS.  */
1019
1020 static void
1021 supply_gprs64 (uint64_t *vals)
1022 {
1023   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
1024   int regno;
1025
1026   for (regno = 0; regno < ppc_num_gprs; regno++)
1027     regcache_raw_supply (current_regcache, tdep->ppc_gp0_regnum + regno,
1028                          (char *) (vals + regno));
1029 }
1030
1031 /* Record that 32-bit register REGNO contains VAL.  */
1032
1033 static void
1034 supply_reg32 (int regno, uint32_t val)
1035 {
1036   regcache_raw_supply (current_regcache, regno, (char *) &val);
1037 }
1038
1039 /* Record that the floating-point registers contain VALS.  */
1040
1041 static void
1042 supply_fprs (double *vals)
1043 {
1044   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
1045   int regno;
1046
1047   /* This function should never be called on architectures without
1048      floating-point registers.  */
1049   gdb_assert (ppc_floating_point_unit_p (current_gdbarch));
1050
1051   for (regno = 0; regno < ppc_num_fprs; regno++)
1052     regcache_raw_supply (current_regcache, regno + tdep->ppc_fp0_regnum,
1053                          (char *) (vals + regno));
1054 }
1055
1056 /* Predicate to test whether given register number is a "special" register.  */
1057 static int
1058 special_register_p (int regno)
1059 {
1060   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
1061
1062   return regno == PC_REGNUM
1063       || regno == tdep->ppc_ps_regnum
1064       || regno == tdep->ppc_cr_regnum
1065       || regno == tdep->ppc_lr_regnum
1066       || regno == tdep->ppc_ctr_regnum
1067       || regno == tdep->ppc_xer_regnum
1068       || (tdep->ppc_fpscr_regnum >= 0 && regno == tdep->ppc_fpscr_regnum)
1069       || (tdep->ppc_mq_regnum >= 0 && regno == tdep->ppc_mq_regnum);
1070 }
1071
1072
1073 /* Record that the special registers contain the specified 64-bit and
1074    32-bit values.  */
1075
1076 static void
1077 supply_sprs64 (uint64_t iar, uint64_t msr, uint32_t cr,
1078                uint64_t lr, uint64_t ctr, uint32_t xer,
1079                uint32_t fpscr)
1080 {
1081   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
1082
1083   regcache_raw_supply (current_regcache, PC_REGNUM, (char *) &iar);
1084   regcache_raw_supply (current_regcache, tdep->ppc_ps_regnum, (char *) &msr);
1085   regcache_raw_supply (current_regcache, tdep->ppc_cr_regnum, (char *) &cr);
1086   regcache_raw_supply (current_regcache, tdep->ppc_lr_regnum, (char *) &lr);
1087   regcache_raw_supply (current_regcache, tdep->ppc_ctr_regnum, (char *) &ctr);
1088   regcache_raw_supply (current_regcache, tdep->ppc_xer_regnum, (char *) &xer);
1089   if (tdep->ppc_fpscr_regnum >= 0)
1090     regcache_raw_supply (current_regcache, tdep->ppc_fpscr_regnum,
1091                          (char *) &fpscr);
1092 }
1093
1094 /* Record that the special registers contain the specified 32-bit
1095    values.  */
1096
1097 static void
1098 supply_sprs32 (uint32_t iar, uint32_t msr, uint32_t cr,
1099                uint32_t lr, uint32_t ctr, uint32_t xer,
1100                uint32_t fpscr)
1101 {
1102   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
1103
1104   regcache_raw_supply (current_regcache, PC_REGNUM, (char *) &iar);
1105   regcache_raw_supply (current_regcache, tdep->ppc_ps_regnum, (char *) &msr);
1106   regcache_raw_supply (current_regcache, tdep->ppc_cr_regnum, (char *) &cr);
1107   regcache_raw_supply (current_regcache, tdep->ppc_lr_regnum, (char *) &lr);
1108   regcache_raw_supply (current_regcache, tdep->ppc_ctr_regnum, (char *) &ctr);
1109   regcache_raw_supply (current_regcache, tdep->ppc_xer_regnum, (char *) &xer);
1110   if (tdep->ppc_fpscr_regnum >= 0)
1111     regcache_raw_supply (current_regcache, tdep->ppc_fpscr_regnum,
1112                          (char *) &fpscr);
1113 }
1114
1115 /* Fetch all registers from pthread PDTID, which doesn't have a kernel
1116    thread.
1117
1118    There's no way to query a single register from a non-kernel
1119    pthread, so there's no need for a single-register version of this
1120    function.  */
1121
1122 static void
1123 fetch_regs_user_thread (pthdb_pthread_t pdtid)
1124 {
1125   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
1126   int status, i;
1127   pthdb_context_t ctx;
1128
1129   if (debug_aix_thread)
1130     fprintf_unfiltered (gdb_stdlog,
1131                         "fetch_regs_user_thread %lx\n", (long) pdtid);
1132   status = pthdb_pthread_context (pd_session, pdtid, &ctx);
1133   if (status != PTHDB_SUCCESS)
1134     error ("aix-thread: fetch_registers: pthdb_pthread_context returned %s",
1135            pd_status2str (status));
1136
1137   /* General-purpose registers.  */
1138
1139   if (arch64)
1140     supply_gprs64 (ctx.gpr);
1141   else
1142     for (i = 0; i < ppc_num_gprs; i++)
1143       supply_reg32 (tdep->ppc_gp0_regnum + i, ctx.gpr[i]);
1144
1145   /* Floating-point registers.  */
1146
1147   if (ppc_floating_point_unit_p (current_gdbarch))
1148     supply_fprs (ctx.fpr);
1149
1150   /* Special registers.  */
1151
1152   if (arch64)
1153     supply_sprs64 (ctx.iar, ctx.msr, ctx.cr, ctx.lr, ctx.ctr, ctx.xer,
1154                    ctx.fpscr);
1155   else
1156     supply_sprs32 (ctx.iar, ctx.msr, ctx.cr, ctx.lr, ctx.ctr, ctx.xer,
1157                    ctx.fpscr);
1158 }
1159
1160 /* Fetch register REGNO if != -1 or all registers otherwise from
1161    kernel thread TID.
1162
1163    AIX provides a way to query all of a kernel thread's GPRs, FPRs, or
1164    SPRs, but there's no way to query individual registers within those
1165    groups.  Therefore, if REGNO != -1, this function fetches an entire
1166    group.
1167
1168    Unfortunately, kernel thread register queries often fail with
1169    EPERM, indicating that the thread is in kernel space.  This breaks
1170    backtraces of threads other than the current one.  To make that
1171    breakage obvious without throwing an error to top level (which is
1172    bad e.g. during "info threads" output), zero registers that can't
1173    be retrieved.  */
1174
1175 static void
1176 fetch_regs_kernel_thread (int regno, pthdb_tid_t tid)
1177 {
1178   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
1179   uint64_t gprs64[ppc_num_gprs];
1180   uint32_t gprs32[ppc_num_gprs];
1181   double fprs[ppc_num_fprs];
1182   struct ptxsprs sprs64;
1183   struct ptsprs sprs32;
1184   int i;
1185
1186   if (debug_aix_thread)
1187     fprintf_unfiltered (gdb_stdlog,
1188         "fetch_regs_kernel_thread tid=%lx regno=%d arch64=%d\n",
1189         (long) tid, regno, arch64);
1190
1191   /* General-purpose registers.  */
1192   if (regno == -1
1193       || (tdep->ppc_gp0_regnum <= regno
1194           && regno < tdep->ppc_gp0_regnum + ppc_num_gprs))
1195     {
1196       if (arch64)
1197         {
1198           if (!ptrace64aix (PTT_READ_GPRS, tid,
1199                             (unsigned long) gprs64, 0, NULL))
1200             memset (gprs64, 0, sizeof (gprs64));
1201           supply_gprs64 (gprs64);
1202         }
1203       else
1204         {
1205           if (!ptrace32 (PTT_READ_GPRS, tid, gprs32, 0, NULL))
1206             memset (gprs32, 0, sizeof (gprs32));
1207           for (i = 0; i < ppc_num_gprs; i++)
1208             supply_reg32 (tdep->ppc_gp0_regnum + i, gprs32[i]);
1209         }
1210     }
1211
1212   /* Floating-point registers.  */
1213
1214   if (ppc_floating_point_unit_p (current_gdbarch)
1215       && (regno == -1
1216           || (regno >= tdep->ppc_fp0_regnum
1217               && regno < tdep->ppc_fp0_regnum + ppc_num_fprs)))
1218     {
1219       if (!ptrace32 (PTT_READ_FPRS, tid, (int *) fprs, 0, NULL))
1220         memset (fprs, 0, sizeof (fprs));
1221       supply_fprs (fprs);
1222     }
1223
1224   /* Special-purpose registers.  */
1225
1226   if (regno == -1 || special_register_p (regno))
1227     {
1228       if (arch64)
1229         {
1230           if (!ptrace64aix (PTT_READ_SPRS, tid,
1231                             (unsigned long) &sprs64, 0, NULL))
1232             memset (&sprs64, 0, sizeof (sprs64));
1233           supply_sprs64 (sprs64.pt_iar, sprs64.pt_msr, sprs64.pt_cr,
1234                          sprs64.pt_lr, sprs64.pt_ctr, sprs64.pt_xer,
1235                          sprs64.pt_fpscr);
1236         }
1237       else
1238         {
1239           struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
1240
1241           if (!ptrace32 (PTT_READ_SPRS, tid, (int *) &sprs32, 0, NULL))
1242             memset (&sprs32, 0, sizeof (sprs32));
1243           supply_sprs32 (sprs32.pt_iar, sprs32.pt_msr, sprs32.pt_cr,
1244                          sprs32.pt_lr, sprs32.pt_ctr, sprs32.pt_xer,
1245                          sprs32.pt_fpscr);
1246
1247           if (tdep->ppc_mq_regnum >= 0)
1248             regcache_raw_supply (current_regcache, tdep->ppc_mq_regnum,
1249                                  (char *) &sprs32.pt_mq);
1250         }
1251     }
1252 }
1253
1254 /* Fetch register REGNO if != -1 or all registers otherwise in the
1255    thread/process specified by inferior_ptid.  */
1256
1257 static void
1258 aix_thread_fetch_registers (int regno)
1259 {
1260   struct thread_info *thread;
1261   pthdb_tid_t tid;
1262
1263   if (!PD_TID (inferior_ptid))
1264     base_target.to_fetch_registers (regno);
1265   else
1266     {
1267       thread = find_thread_pid (inferior_ptid);
1268       tid = thread->private->tid;
1269
1270       if (tid == PTHDB_INVALID_TID)
1271         fetch_regs_user_thread (thread->private->pdtid);
1272       else
1273         fetch_regs_kernel_thread (regno, tid);
1274     }
1275 }
1276
1277 /* Store the gp registers into an array of uint32_t or uint64_t.  */
1278
1279 static void
1280 fill_gprs64 (uint64_t *vals)
1281 {
1282   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
1283   int regno;
1284
1285   for (regno = 0; regno < ppc_num_gprs; regno++)
1286     if (register_cached (tdep->ppc_gp0_regnum + regno))
1287       regcache_raw_collect (current_regcache, tdep->ppc_gp0_regnum + regno,
1288                             vals + regno);
1289 }
1290
1291 static void
1292 fill_gprs32 (uint32_t *vals)
1293 {
1294   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
1295   int regno;
1296
1297   for (regno = 0; regno < ppc_num_gprs; regno++)
1298     if (register_cached (tdep->ppc_gp0_regnum + regno))
1299       regcache_raw_collect (current_regcache, tdep->ppc_gp0_regnum + regno,
1300                             vals + regno);
1301 }
1302
1303 /* Store the floating point registers into a double array.  */
1304 static void
1305 fill_fprs (double *vals)
1306 {
1307   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
1308   int regno;
1309
1310   /* This function should never be called on architectures without
1311      floating-point registers.  */
1312   gdb_assert (ppc_floating_point_unit_p (current_gdbarch));
1313
1314   for (regno = tdep->ppc_fp0_regnum;
1315        regno < tdep->ppc_fp0_regnum + ppc_num_fprs;
1316        regno++)
1317     if (register_cached (regno))
1318       regcache_raw_collect (current_regcache, regno, vals + regno);
1319 }
1320
1321 /* Store the special registers into the specified 64-bit and 32-bit
1322    locations.  */
1323
1324 static void
1325 fill_sprs64 (uint64_t *iar, uint64_t *msr, uint32_t *cr,
1326              uint64_t *lr, uint64_t *ctr, uint32_t *xer,
1327              uint32_t *fpscr)
1328 {
1329   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
1330
1331   /* Verify that the size of the size of the IAR buffer is the
1332      same as the raw size of the PC (in the register cache).  If
1333      they're not, then either GDB has been built incorrectly, or
1334      there's some other kind of internal error.  To be really safe,
1335      we should check all of the sizes.   */
1336   gdb_assert (sizeof (*iar) == register_size (current_gdbarch, PC_REGNUM));
1337
1338   if (register_cached (PC_REGNUM))
1339     regcache_raw_collect (current_regcache, PC_REGNUM, iar);
1340   if (register_cached (tdep->ppc_ps_regnum))
1341     regcache_raw_collect (current_regcache, tdep->ppc_ps_regnum, msr);
1342   if (register_cached (tdep->ppc_cr_regnum))
1343     regcache_raw_collect (current_regcache, tdep->ppc_cr_regnum, cr);
1344   if (register_cached (tdep->ppc_lr_regnum))
1345     regcache_raw_collect (current_regcache, tdep->ppc_lr_regnum, lr);
1346   if (register_cached (tdep->ppc_ctr_regnum))
1347     regcache_raw_collect (current_regcache, tdep->ppc_ctr_regnum, ctr);
1348   if (register_cached (tdep->ppc_xer_regnum))
1349     regcache_raw_collect (current_regcache, tdep->ppc_xer_regnum, xer);
1350   if (tdep->ppc_fpscr_regnum >= 0
1351       && register_cached (tdep->ppc_fpscr_regnum))
1352     regcache_raw_collect (current_regcache, tdep->ppc_fpscr_regnum, fpscr);
1353 }
1354
1355 static void
1356 fill_sprs32 (unsigned long *iar, unsigned long *msr, unsigned long *cr,
1357              unsigned long *lr,  unsigned long *ctr, unsigned long *xer,
1358              unsigned long *fpscr)
1359 {
1360   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
1361
1362   /* Verify that the size of the size of the IAR buffer is the
1363      same as the raw size of the PC (in the register cache).  If
1364      they're not, then either GDB has been built incorrectly, or
1365      there's some other kind of internal error.  To be really safe,
1366      we should check all of the sizes.
1367
1368      If this assert() fails, the most likely reason is that GDB was
1369      built incorrectly.  In order to make use of many of the header
1370      files in /usr/include/sys, GDB needs to be configured so that
1371      sizeof (long) == 4).  */
1372   gdb_assert (sizeof (*iar) == register_size (current_gdbarch, PC_REGNUM));
1373
1374   if (register_cached (PC_REGNUM))
1375     regcache_raw_collect (current_regcache, PC_REGNUM, iar);
1376   if (register_cached (tdep->ppc_ps_regnum))
1377     regcache_raw_collect (current_regcache, tdep->ppc_ps_regnum, msr);
1378   if (register_cached (tdep->ppc_cr_regnum))
1379     regcache_raw_collect (current_regcache, tdep->ppc_cr_regnum, cr);
1380   if (register_cached (tdep->ppc_lr_regnum))
1381     regcache_raw_collect (current_regcache, tdep->ppc_lr_regnum, lr);
1382   if (register_cached (tdep->ppc_ctr_regnum))
1383     regcache_raw_collect (current_regcache, tdep->ppc_ctr_regnum, ctr);
1384   if (register_cached (tdep->ppc_xer_regnum))
1385     regcache_raw_collect (current_regcache, tdep->ppc_xer_regnum, xer);
1386   if (tdep->ppc_fpscr_regnum >= 0
1387       && register_cached (tdep->ppc_fpscr_regnum))
1388     regcache_raw_collect (current_regcache, tdep->ppc_fpscr_regnum, fpscr);
1389 }
1390
1391 /* Store all registers into pthread PDTID, which doesn't have a kernel
1392    thread.
1393
1394    It's possible to store a single register into a non-kernel pthread,
1395    but I doubt it's worth the effort.  */
1396
1397 static void
1398 store_regs_user_thread (pthdb_pthread_t pdtid)
1399 {
1400   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
1401   int status, i;
1402   pthdb_context_t ctx;
1403   uint32_t int32;
1404   uint64_t int64;
1405   double   dbl;
1406
1407   if (debug_aix_thread)
1408     fprintf_unfiltered (gdb_stdlog,
1409                         "store_regs_user_thread %lx\n", (long) pdtid);
1410
1411   /* Retrieve the thread's current context for its non-register
1412      values.  */
1413   status = pthdb_pthread_context (pd_session, pdtid, &ctx);
1414   if (status != PTHDB_SUCCESS)
1415     error ("aix-thread: store_registers: pthdb_pthread_context returned %s",
1416            pd_status2str (status));
1417
1418   /* Collect general-purpose register values from the regcache.  */
1419
1420   for (i = 0; i < ppc_num_gprs; i++)
1421     if (register_cached (tdep->ppc_gp0_regnum + i))
1422       {
1423         if (arch64)
1424           {
1425             regcache_raw_collect (current_regcache, tdep->ppc_gp0_regnum + i,
1426                                   (void *) &int64);
1427             ctx.gpr[i] = int64;
1428           }
1429         else
1430           {
1431             regcache_raw_collect (current_regcache, tdep->ppc_gp0_regnum + i,
1432                                   (void *) &int32);
1433             ctx.gpr[i] = int32;
1434           }
1435       }
1436
1437   /* Collect floating-point register values from the regcache.  */
1438   if (ppc_floating_point_unit_p (current_gdbarch))
1439     fill_fprs (ctx.fpr);
1440
1441   /* Special registers (always kept in ctx as 64 bits).  */
1442   if (arch64)
1443     {
1444       fill_sprs64 (&ctx.iar, &ctx.msr, &ctx.cr, &ctx.lr, &ctx.ctr, &ctx.xer,
1445                    &ctx.fpscr);
1446     }
1447   else
1448     {
1449       /* Problem: ctx.iar etc. are 64 bits, but raw_registers are 32.
1450          Solution: use 32-bit temp variables.  (The assert() in fill_sprs32()
1451          will fail if the size of an unsigned long is incorrect.  If this
1452          happens, GDB needs to be reconfigured so that longs are 32-bits.)  */
1453       unsigned long tmp_iar, tmp_msr, tmp_cr, tmp_lr, tmp_ctr, tmp_xer,
1454                     tmp_fpscr;
1455
1456       fill_sprs32 (&tmp_iar, &tmp_msr, &tmp_cr, &tmp_lr, &tmp_ctr, &tmp_xer,
1457                    &tmp_fpscr);
1458       if (register_cached (PC_REGNUM))
1459         ctx.iar = tmp_iar;
1460       if (register_cached (tdep->ppc_ps_regnum))
1461         ctx.msr = tmp_msr;
1462       if (register_cached (tdep->ppc_cr_regnum))
1463         ctx.cr  = tmp_cr;
1464       if (register_cached (tdep->ppc_lr_regnum))
1465         ctx.lr  = tmp_lr;
1466       if (register_cached (tdep->ppc_ctr_regnum))
1467         ctx.ctr = tmp_ctr;
1468       if (register_cached (tdep->ppc_xer_regnum))
1469         ctx.xer = tmp_xer;
1470       if (register_cached (tdep->ppc_xer_regnum))
1471         ctx.fpscr = tmp_fpscr;
1472     }
1473
1474   status = pthdb_pthread_setcontext (pd_session, pdtid, &ctx);
1475   if (status != PTHDB_SUCCESS)
1476     error ("aix-thread: store_registers: pthdb_pthread_setcontext returned %s",
1477            pd_status2str (status));
1478 }
1479
1480 /* Store register REGNO if != -1 or all registers otherwise into
1481    kernel thread TID.
1482
1483    AIX provides a way to set all of a kernel thread's GPRs, FPRs, or
1484    SPRs, but there's no way to set individual registers within those
1485    groups.  Therefore, if REGNO != -1, this function stores an entire
1486    group.  */
1487
1488 static void
1489 store_regs_kernel_thread (int regno, pthdb_tid_t tid)
1490 {
1491   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
1492   uint64_t gprs64[ppc_num_gprs];
1493   uint32_t gprs32[ppc_num_gprs];
1494   double fprs[ppc_num_fprs];
1495   struct ptxsprs sprs64;
1496   struct ptsprs  sprs32;
1497   int i;
1498
1499   if (debug_aix_thread)
1500     fprintf_unfiltered (gdb_stdlog,
1501                         "store_regs_kernel_thread tid=%lx regno=%d\n",
1502                         (long) tid, regno);
1503
1504   /* General-purpose registers.  */
1505   if (regno == -1
1506       || (tdep->ppc_gp0_regnum <= regno
1507           && regno < tdep->ppc_gp0_regnum + ppc_num_fprs))
1508     {
1509       if (arch64)
1510         {
1511           /* Pre-fetch: some regs may not be in the cache.  */
1512           ptrace64aix (PTT_READ_GPRS, tid, (unsigned long) gprs64, 0, NULL);
1513           fill_gprs64 (gprs64);
1514           ptrace64aix (PTT_WRITE_GPRS, tid, (unsigned long) gprs64, 0, NULL);
1515         }
1516       else
1517         {
1518           /* Pre-fetch: some regs may not be in the cache.  */
1519           ptrace32 (PTT_READ_GPRS, tid, gprs32, 0, NULL);
1520           fill_gprs32 (gprs32);
1521           ptrace32 (PTT_WRITE_GPRS, tid, gprs32, 0, NULL);
1522         }
1523     }
1524
1525   /* Floating-point registers.  */
1526
1527   if (ppc_floating_point_unit_p (current_gdbarch)
1528       && (regno == -1
1529           || (regno >= tdep->ppc_fp0_regnum
1530               && regno < tdep->ppc_fp0_regnum + ppc_num_fprs)))
1531     {
1532       /* Pre-fetch: some regs may not be in the cache.  */
1533       ptrace32 (PTT_READ_FPRS, tid, (int *) fprs, 0, NULL);
1534       fill_fprs (fprs);
1535       ptrace32 (PTT_WRITE_FPRS, tid, (int *) fprs, 0, NULL);
1536     }
1537
1538   /* Special-purpose registers.  */
1539
1540   if (regno == -1 || special_register_p (regno))
1541     {
1542       if (arch64)
1543         {
1544           /* Pre-fetch: some registers won't be in the cache.  */
1545           ptrace64aix (PTT_READ_SPRS, tid,
1546                        (unsigned long) &sprs64, 0, NULL);
1547           fill_sprs64 (&sprs64.pt_iar, &sprs64.pt_msr, &sprs64.pt_cr,
1548                        &sprs64.pt_lr,  &sprs64.pt_ctr, &sprs64.pt_xer,
1549                        &sprs64.pt_fpscr);
1550           ptrace64aix (PTT_WRITE_SPRS, tid,
1551                        (unsigned long) &sprs64, 0, NULL);
1552         }
1553       else
1554         {
1555           /* Pre-fetch: some registers won't be in the cache.  */
1556           ptrace32 (PTT_READ_SPRS, tid, (int *) &sprs32, 0, NULL);
1557
1558           fill_sprs32 (&sprs32.pt_iar, &sprs32.pt_msr, &sprs32.pt_cr,
1559                        &sprs32.pt_lr,  &sprs32.pt_ctr, &sprs32.pt_xer,
1560                        &sprs32.pt_fpscr);
1561
1562           if (tdep->ppc_mq_regnum >= 0)
1563             if (register_cached (tdep->ppc_mq_regnum))
1564               regcache_raw_collect (current_regcache, tdep->ppc_mq_regnum,
1565                                     &sprs32.pt_mq);
1566
1567           ptrace32 (PTT_WRITE_SPRS, tid, (int *) &sprs32, 0, NULL);
1568         }
1569     }
1570 }
1571
1572 /* Store gdb's current view of the register set into the
1573    thread/process specified by inferior_ptid.  */
1574
1575 static void
1576 aix_thread_store_registers (int regno)
1577 {
1578   struct thread_info *thread;
1579   pthdb_tid_t tid;
1580
1581   if (!PD_TID (inferior_ptid))
1582     base_target.to_store_registers (regno);
1583   else
1584     {
1585       thread = find_thread_pid (inferior_ptid);
1586       tid = thread->private->tid;
1587
1588       if (tid == PTHDB_INVALID_TID)
1589         store_regs_user_thread (thread->private->pdtid);
1590       else
1591         store_regs_kernel_thread (regno, tid);
1592     }
1593 }
1594
1595 /* Transfer LEN bytes of memory from GDB address MYADDR to target
1596    address MEMADDR if WRITE and vice versa otherwise.  */
1597
1598 static int
1599 aix_thread_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
1600                       struct mem_attrib *attrib,
1601                       struct target_ops *target)
1602 {
1603   int n;
1604   struct cleanup *cleanup = save_inferior_ptid ();
1605
1606   inferior_ptid = pid_to_ptid (PIDGET (inferior_ptid));
1607   n = base_target.deprecated_xfer_memory (memaddr, myaddr, len,
1608                                           write, attrib, &base_target);
1609   do_cleanups (cleanup);
1610
1611   return n;
1612 }
1613
1614 /* Kill and forget about the inferior process.  */
1615
1616 static void
1617 aix_thread_kill (void)
1618 {
1619   struct cleanup *cleanup = save_inferior_ptid ();
1620
1621   inferior_ptid = pid_to_ptid (PIDGET (inferior_ptid));
1622   base_target.to_kill ();
1623   do_cleanups (cleanup);
1624 }
1625
1626 /* Clean up after the inferior exits.  */
1627
1628 static void
1629 aix_thread_mourn_inferior (void)
1630 {
1631   pd_deactivate ();
1632   base_target.to_mourn_inferior ();
1633 }
1634
1635 /* Return whether thread PID is still valid.  */
1636
1637 static int
1638 aix_thread_thread_alive (ptid_t ptid)
1639 {
1640   if (!PD_TID (ptid))
1641     return base_target.to_thread_alive (ptid);
1642
1643   /* We update the thread list every time the child stops, so all
1644      valid threads should be in the thread list.  */
1645   return in_thread_list (ptid);
1646 }
1647
1648 /* Return a printable representation of composite PID for use in
1649    "info threads" output.  */
1650
1651 static char *
1652 aix_thread_pid_to_str (ptid_t ptid)
1653 {
1654   static char *ret = NULL;
1655
1656   if (!PD_TID (ptid))
1657     return base_target.to_pid_to_str (ptid);
1658
1659   /* Free previous return value; a new one will be allocated by
1660      xstrprintf().  */
1661   xfree (ret);
1662
1663   ret = xstrprintf ("Thread %ld", ptid_get_tid (ptid));
1664   return ret;
1665 }
1666
1667 /* Return a printable representation of extra information about
1668    THREAD, for use in "info threads" output.  */
1669
1670 static char *
1671 aix_thread_extra_thread_info (struct thread_info *thread)
1672 {
1673   struct ui_file *buf;
1674   int status;
1675   pthdb_pthread_t pdtid;
1676   pthdb_tid_t tid;
1677   pthdb_state_t state;
1678   pthdb_suspendstate_t suspendstate;
1679   pthdb_detachstate_t detachstate;
1680   int cancelpend;
1681   long length;
1682   static char *ret = NULL;
1683
1684   if (!PD_TID (thread->ptid))
1685     return NULL;
1686
1687   buf = mem_fileopen ();
1688
1689   pdtid = thread->private->pdtid;
1690   tid = thread->private->tid;
1691
1692   if (tid != PTHDB_INVALID_TID)
1693     fprintf_unfiltered (buf, "tid %d", tid);
1694
1695   status = pthdb_pthread_state (pd_session, pdtid, &state);
1696   if (status != PTHDB_SUCCESS)
1697     state = PST_NOTSUP;
1698   fprintf_unfiltered (buf, ", %s", state2str (state));
1699
1700   status = pthdb_pthread_suspendstate (pd_session, pdtid,
1701                                        &suspendstate);
1702   if (status == PTHDB_SUCCESS && suspendstate == PSS_SUSPENDED)
1703     fprintf_unfiltered (buf, ", suspended");
1704
1705   status = pthdb_pthread_detachstate (pd_session, pdtid,
1706                                       &detachstate);
1707   if (status == PTHDB_SUCCESS && detachstate == PDS_DETACHED)
1708     fprintf_unfiltered (buf, ", detached");
1709
1710   pthdb_pthread_cancelpend (pd_session, pdtid, &cancelpend);
1711   if (status == PTHDB_SUCCESS && cancelpend)
1712     fprintf_unfiltered (buf, ", cancel pending");
1713
1714   ui_file_write (buf, "", 1);
1715
1716   xfree (ret);                  /* Free old buffer.  */
1717
1718   ret = ui_file_xstrdup (buf, &length);
1719   ui_file_delete (buf);
1720
1721   return ret;
1722 }
1723
1724 /* Initialize target aix_thread_ops.  */
1725
1726 static void
1727 init_aix_thread_ops (void)
1728 {
1729   aix_thread_ops.to_shortname          = "aix-threads";
1730   aix_thread_ops.to_longname           = "AIX pthread support";
1731   aix_thread_ops.to_doc                = "AIX pthread support";
1732
1733   aix_thread_ops.to_attach             = aix_thread_attach;
1734   aix_thread_ops.to_detach             = aix_thread_detach;
1735   aix_thread_ops.to_resume             = aix_thread_resume;
1736   aix_thread_ops.to_wait               = aix_thread_wait;
1737   aix_thread_ops.to_fetch_registers    = aix_thread_fetch_registers;
1738   aix_thread_ops.to_store_registers    = aix_thread_store_registers;
1739   aix_thread_ops.deprecated_xfer_memory = aix_thread_xfer_memory;
1740   /* No need for aix_thread_ops.to_create_inferior, because we activate thread
1741      debugging when the inferior reaches pd_brk_addr.  */
1742   aix_thread_ops.to_kill               = aix_thread_kill;
1743   aix_thread_ops.to_mourn_inferior     = aix_thread_mourn_inferior;
1744   aix_thread_ops.to_thread_alive       = aix_thread_thread_alive;
1745   aix_thread_ops.to_pid_to_str         = aix_thread_pid_to_str;
1746   aix_thread_ops.to_extra_thread_info  = aix_thread_extra_thread_info;
1747   aix_thread_ops.to_stratum            = thread_stratum;
1748   aix_thread_ops.to_magic              = OPS_MAGIC;
1749 }
1750
1751 /* Module startup initialization function, automagically called by
1752    init.c.  */
1753
1754 void
1755 _initialize_aix_thread (void)
1756 {
1757   init_aix_thread_ops ();
1758   add_target (&aix_thread_ops);
1759
1760   /* Notice when object files get loaded and unloaded.  */
1761   target_new_objfile_chain = deprecated_target_new_objfile_hook;
1762   deprecated_target_new_objfile_hook = new_objfile;
1763
1764   deprecated_add_show_from_set
1765     (add_set_cmd ("aix-thread", no_class, var_zinteger,
1766                   (char *) &debug_aix_thread,
1767                   "Set debugging of AIX thread module.\n"
1768                   "Enables printf debugging output.\n",
1769                   &setdebuglist),
1770      &showdebuglist);
1771 }