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