gdb/aix-thread.c

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