gdb/aix-thread.c

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