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