Fix write endianness/size problem for fast tracepoint enabled flag

[deliverable/binutils-gdb.git] / gdb / aix-thread.c

diff --git a/gdb/aix-thread.c b/gdb/aix-thread.c
index e6d7a2990dc0c751e16b410a6af1e38fcfbd206c..693d6f6fae7c7852c74f63b2f72a7491a83deebb 100644 (file)
--- a/gdb/aix-thread.c
+++ b/gdb/aix-thread.c
@@ -1,13 +1,13 @@
 /* Low level interface for debugging AIX 4.3+ pthreads.
 
 /* Low level interface for debugging AIX 4.3+ pthreads.
 

-   Copyright (C) 1999, 2000, 2002, 2007 Free Software Foundation, Inc.
+   Copyright (C) 1999-2016 Free Software Foundation, Inc.

    Written by Nick Duffek <nsd@redhat.com>.
 
    This file is part of GDB.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    Written by Nick Duffek <nsd@redhat.com>.
 
    This file is part of GDB.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by

-   the Free Software Foundation; either version 2 of the License, or
+   the Free Software Foundation; either version 3 of the License, or

    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,


@@ -16,9 +16,7 @@
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License

-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 51 Franklin Street, Fifth Floor,
-   Boston, MA 02110-1301, USA.  */
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

 
 
 /* This module uses the libpthdebug.a library provided by AIX 4.3+ for
 
 
 /* This module uses the libpthdebug.a library provided by AIX 4.3+ for


@@ -42,14 +40,14 @@
      */
 
 #include "defs.h"
      */
 
 #include "defs.h"

-#include "gdb_assert.h"

 #include "gdbthread.h"
 #include "target.h"
 #include "inferior.h"
 #include "regcache.h"
 #include "gdbcmd.h"
 #include "ppc-tdep.h"
 #include "gdbthread.h"
 #include "target.h"
 #include "inferior.h"
 #include "regcache.h"
 #include "gdbcmd.h"
 #include "ppc-tdep.h"

-#include "gdb_string.h"
+#include "observer.h"
+#include "objfiles.h"

 
 #include <procinfo.h>
 #include <sys/types.h>
 
 #include <procinfo.h>
 #include <sys/types.h>


@@ -58,6 +56,10 @@
 #include <sched.h>
 #include <sys/pthdebug.h>
 
 #include <sched.h>
 #include <sys/pthdebug.h>
 

+#if !HAVE_DECL_GETTHRDS
+extern int getthrds (pid_t, struct thrdsinfo64 *, int, tid_t *, int);
+#endif
+

 /* Whether to emit debugging output.  */
 static int debug_aix_thread;
 
 /* Whether to emit debugging output.  */
 static int debug_aix_thread;
 


@@ -70,12 +72,6 @@ static int debug_aix_thread;
 
 #define PD_TID(ptid)   (pd_active && ptid_get_tid (ptid) != 0)
 
 
 #define PD_TID(ptid)   (pd_active && ptid_get_tid (ptid) != 0)
 

-/* Build a thread ptid.  */
-#define BUILD_THREAD(TID, PID) ptid_build (PID, 0, TID)
-
-/* Build and lwp ptid.  */
-#define BUILD_LWP(LWP, PID) MERGEPID (PID, LWP)
-

 /* pthdb_user_t value that we pass to pthdb functions.  0 causes
    PTHDB_BAD_USER errors, so use 1.  */
 
 /* pthdb_user_t value that we pass to pthdb functions.  0 causes
    PTHDB_BAD_USER errors, so use 1.  */
 


@@ -105,12 +101,6 @@ struct pd_thread {
 
 static struct target_ops aix_thread_ops;
 
 
 static struct target_ops aix_thread_ops;
 

-/* Copy of the target over which ops is pushed.  This is more
-   convenient than a pointer to deprecated_child_ops or core_ops,
-   because they lack current_target's default callbacks.  */
-
-static struct target_ops base_target;
-

 /* Address of the function that libpthread will call when libpthdebug
    is ready to be initialized.  */
 
 /* Address of the function that libpthread will call when libpthdebug
    is ready to be initialized.  */
 


@@ -129,11 +119,6 @@ static int pd_active = 0;
 
 static int arch64;
 
 
 static int arch64;
 

-/* Saved pointer to previous owner of
-   deprecated_target_new_objfile_hook.  */
-
-static void (*target_new_objfile_chain)(struct objfile *);
-

 /* Forward declarations for pthdb callbacks.  */
 
 static int pdc_symbol_addrs (pthdb_user_t, pthdb_symbol_t *, int);
 /* Forward declarations for pthdb callbacks.  */
 
 static int pdc_symbol_addrs (pthdb_user_t, pthdb_symbol_t *, int);


@@ -245,7 +230,14 @@ ptrace_check (int req, int id, int ret)
   return 0;  /* Not reached.  */
 }
 
   return 0;  /* Not reached.  */
 }
 

-/* Call ptracex (REQ, ID, ADDR, DATA, BUF).  Return success.  */
+/* Call ptracex (REQ, ID, ADDR, DATA, BUF) or
+   ptrace64 (REQ, ID, ADDR, DATA, BUF) if HAVE_PTRACE64.
+   Return success.  */
+
+#ifdef HAVE_PTRACE64
+# define ptracex(request, pid, addr, data, buf) \
+        ptrace64 (request, pid, addr, data, buf)
+#endif

 
 static int
 ptrace64aix (int req, int id, long long addr, int data, int *buf)
 
 static int
 ptrace64aix (int req, int id, long long addr, int data, int *buf)


@@ -254,14 +246,24 @@ ptrace64aix (int req, int id, long long addr, int data, int *buf)
   return ptrace_check (req, id, ptracex (req, id, addr, data, buf));
 }
 
   return ptrace_check (req, id, ptracex (req, id, addr, data, buf));
 }
 

-/* Call ptrace (REQ, ID, ADDR, DATA, BUF).  Return success.  */
+/* Call ptrace (REQ, ID, ADDR, DATA, BUF) or
+   ptrace64 (REQ, ID, ADDR, DATA, BUF) if HAVE_PTRACE64.
+   Return success.  */
+
+#ifdef HAVE_PTRACE64
+# define ptrace(request, pid, addr, data, buf) \
+        ptrace64 (request, pid, addr, data, buf)
+# define addr_ptr long long
+#else
+# define addr_ptr int *
+#endif

 
 static int
 
 static int

-ptrace32 (int req, int id, int *addr, int data, int *buf)
+ptrace32 (int req, int id, addr_ptr addr, int data, int *buf)

 {
   errno = 0;
   return ptrace_check (req, id, 
 {
   errno = 0;
   return ptrace_check (req, id, 

-                      ptrace (req, id, (int *) addr, data, buf));
+                      ptrace (req, id, addr, data, buf));

 }
 
 /* If *PIDP is a composite process/thread id, convert it to a
 }
 
 /* If *PIDP is a composite process/thread id, convert it to a


@@ -274,7 +276,7 @@ pid_to_prc (ptid_t *ptidp)
 
   ptid = *ptidp;
   if (PD_TID (ptid))
 
   ptid = *ptidp;
   if (PD_TID (ptid))

-    *ptidp = pid_to_ptid (PIDGET (ptid));
+    *ptidp = pid_to_ptid (ptid_get_pid (ptid));

 }
 
 /* pthdb callback: for <i> from 0 to COUNT, set SYMBOLS[<i>].addr to
 }
 
 /* pthdb callback: for <i> from 0 to COUNT, set SYMBOLS[<i>].addr to


@@ -283,7 +285,7 @@ pid_to_prc (ptid_t *ptidp)
 static int
 pdc_symbol_addrs (pthdb_user_t user, pthdb_symbol_t *symbols, int count)
 {
 static int
 pdc_symbol_addrs (pthdb_user_t user, pthdb_symbol_t *symbols, int count)
 {

-  struct minimal_symbol *ms;
+  struct bound_minimal_symbol ms;

   int i;
   char *name;
 
   int i;
   char *name;
 


@@ -303,13 +305,14 @@ pdc_symbol_addrs (pthdb_user_t user, pthdb_symbol_t *symbols, int count)
        symbols[i].addr = 0;
       else
        {
        symbols[i].addr = 0;
       else
        {

-         if (!(ms = lookup_minimal_symbol (name, NULL, NULL)))
+         ms = lookup_minimal_symbol (name, NULL, NULL);
+         if (ms.minsym == NULL)

            {
              if (debug_aix_thread)
                fprintf_unfiltered (gdb_stdlog, " returning PDC_FAILURE\n");
              return PDC_FAILURE;
            }
            {
              if (debug_aix_thread)
                fprintf_unfiltered (gdb_stdlog, " returning PDC_FAILURE\n");
              return PDC_FAILURE;
            }

-         symbols[i].addr = SYMBOL_VALUE_ADDRESS (ms);
+         symbols[i].addr = BMSYMBOL_VALUE_ADDRESS (ms);

        }
       if (debug_aix_thread)
        fprintf_unfiltered (gdb_stdlog, "  symbols[%d].addr = %s\n",
        }
       if (debug_aix_thread)
        fprintf_unfiltered (gdb_stdlog, "  symbols[%d].addr = %s\n",


@@ -360,7 +363,7 @@ pdc_read_regs (pthdb_user_t user,
        }
       else
        {
        }
       else
        {

-         if (!ptrace32 (PTT_READ_GPRS, tid, gprs32, 0, NULL))
+         if (!ptrace32 (PTT_READ_GPRS, tid, (uintptr_t) gprs32, 0, NULL))

            memset (gprs32, 0, sizeof (gprs32));
          memcpy (context->gpr, gprs32, sizeof(gprs32));
        }
            memset (gprs32, 0, sizeof (gprs32));
          memcpy (context->gpr, gprs32, sizeof(gprs32));
        }


@@ -369,9 +372,9 @@ pdc_read_regs (pthdb_user_t user,
   /* Floating-point registers.  */
   if (flags & PTHDB_FLAG_FPRS)
     {
   /* Floating-point registers.  */
   if (flags & PTHDB_FLAG_FPRS)
     {

-      if (!ptrace32 (PTT_READ_FPRS, tid, (int *) fprs, 0, NULL))
+      if (!ptrace32 (PTT_READ_FPRS, tid, (uintptr_t) fprs, 0, NULL))

        memset (fprs, 0, sizeof (fprs));
        memset (fprs, 0, sizeof (fprs));

-         memcpy (context->fpr, fprs, sizeof(fprs));
+      memcpy (context->fpr, fprs, sizeof(fprs));

     }
 
   /* Special-purpose registers.  */
     }
 
   /* Special-purpose registers.  */


@@ -386,7 +389,7 @@ pdc_read_regs (pthdb_user_t user,
        }
       else
        {
        }
       else
        {

-         if (!ptrace32 (PTT_READ_SPRS, tid, (int *) &sprs32, 0, NULL))
+         if (!ptrace32 (PTT_READ_SPRS, tid, (uintptr_t) &sprs32, 0, NULL))

            memset (&sprs32, 0, sizeof (sprs32));
          memcpy (&context->msr, &sprs32, sizeof(sprs32));
        }
            memset (&sprs32, 0, sizeof (sprs32));
          memcpy (&context->msr, &sprs32, sizeof(sprs32));
        }


@@ -395,7 +398,7 @@ pdc_read_regs (pthdb_user_t user,
 }
 
 /* Write register function should be able to write requested context
 }
 
 /* Write register function should be able to write requested context

-   information to specified debuggee's kernel thread id. 
+   information to specified debuggee's kernel thread id.

    If successful return 0, else non-zero is returned.  */
 
 static int
    If successful return 0, else non-zero is returned.  */
 
 static int


@@ -421,13 +424,13 @@ pdc_write_regs (pthdb_user_t user,
        ptrace64aix (PTT_WRITE_GPRS, tid, 
                     (unsigned long) context->gpr, 0, NULL);
       else
        ptrace64aix (PTT_WRITE_GPRS, tid, 
                     (unsigned long) context->gpr, 0, NULL);
       else

-       ptrace32 (PTT_WRITE_GPRS, tid, (int *) context->gpr, 0, NULL);
+       ptrace32 (PTT_WRITE_GPRS, tid, (uintptr_t) context->gpr, 0, NULL);

     }
 
  /* Floating-point registers.  */
   if (flags & PTHDB_FLAG_FPRS)
     {
     }
 
  /* Floating-point registers.  */
   if (flags & PTHDB_FLAG_FPRS)
     {

-      ptrace32 (PTT_WRITE_FPRS, tid, (int *) context->fpr, 0, NULL);
+      ptrace32 (PTT_WRITE_FPRS, tid, (uintptr_t) context->fpr, 0, NULL);

     }
 
   /* Special-purpose registers.  */
     }
 
   /* Special-purpose registers.  */


@@ -440,7 +443,7 @@ pdc_write_regs (pthdb_user_t user,
        }
       else
        {
        }
       else
        {

-         ptrace32 (PTT_WRITE_SPRS, tid, (int *) &context->msr, 0, NULL);
+         ptrace32 (PTT_WRITE_SPRS, tid, (uintptr_t) &context->msr, 0, NULL);

        }
     }
   return 0;
        }
     }
   return 0;


@@ -459,7 +462,7 @@ pdc_read_data (pthdb_user_t user, void *buf,
       "pdc_read_data (user = %ld, buf = 0x%lx, addr = %s, len = %ld)\n",
       user, (long) buf, hex_string (addr), len);
 
       "pdc_read_data (user = %ld, buf = 0x%lx, addr = %s, len = %ld)\n",
       user, (long) buf, hex_string (addr), len);
 

-  status = target_read_memory (addr, buf, len);
+  status = target_read_memory (addr, (gdb_byte *) buf, len);

   ret = status == 0 ? PDC_SUCCESS : PDC_FAILURE;
 
   if (debug_aix_thread)
   ret = status == 0 ? PDC_SUCCESS : PDC_FAILURE;
 
   if (debug_aix_thread)


@@ -481,7 +484,7 @@ pdc_write_data (pthdb_user_t user, void *buf,
       "pdc_write_data (user = %ld, buf = 0x%lx, addr = %s, len = %ld)\n",
       user, (long) buf, hex_string (addr), len);
 
       "pdc_write_data (user = %ld, buf = 0x%lx, addr = %s, len = %ld)\n",
       user, (long) buf, hex_string (addr), len);
 

-  status = target_write_memory (addr, buf, len);
+  status = target_write_memory (addr, (gdb_byte *) buf, len);

   ret = status == 0 ? PDC_SUCCESS : PDC_FAILURE;
 
   if (debug_aix_thread)
   ret = status == 0 ? PDC_SUCCESS : PDC_FAILURE;
 
   if (debug_aix_thread)


@@ -581,22 +584,36 @@ pcmp (const void *p1v, const void *p2v)
   return p1->pthid < p2->pthid ? -1 : p1->pthid > p2->pthid;
 }
 
   return p1->pthid < p2->pthid ? -1 : p1->pthid > p2->pthid;
 }
 

-/* iterate_over_threads() callback for counting GDB threads.  */
+/* iterate_over_threads() callback for counting GDB threads.
+
+   Do not count the main thread (whose tid is zero).  This matches
+   the list of threads provided by the pthreaddebug library, which
+   does not include that main thread either, and thus allows us
+   to compare the two lists.  */

 
 static int
 giter_count (struct thread_info *thread, void *countp)
 {
 
 static int
 giter_count (struct thread_info *thread, void *countp)
 {

-  (*(int *) countp)++;
+  if (PD_TID (thread->ptid))
+    (*(int *) countp)++;

   return 0;
 }
 
   return 0;
 }
 

-/* iterate_over_threads() callback for accumulating GDB thread pids.  */
+/* iterate_over_threads() callback for accumulating GDB thread pids.
+
+   Do not include the main thread (whose tid is zero).  This matches
+   the list of threads provided by the pthreaddebug library, which
+   does not include that main thread either, and thus allows us
+   to compare the two lists.  */

 
 static int
 giter_accum (struct thread_info *thread, void *bufp)
 {
 
 static int
 giter_accum (struct thread_info *thread, void *bufp)
 {

-  **(struct thread_info ***) bufp = thread;
-  (*(struct thread_info ***) bufp)++;
+  if (PD_TID (thread->ptid))
+    {
+      **(struct thread_info ***) bufp = thread;
+      (*(struct thread_info ***) bufp)++;
+    }

   return 0;
 }
 
   return 0;
 }
 


@@ -641,16 +658,12 @@ static pthdb_tid_t
 get_signaled_thread (void)
 {
   struct thrdsinfo64 thrinf;
 get_signaled_thread (void)
 {
   struct thrdsinfo64 thrinf;

-  pthdb_tid_t ktid = 0;
+  tid_t ktid = 0;

   int result = 0;
 
   int result = 0;
 

-  /* getthrds(3) isn't prototyped in any AIX 4.3.3 #include file.  */
-  extern int getthrds (pid_t, struct thrdsinfo64 *, 
-                      int, pthdb_tid_t *, int);
-

   while (1)
   {
   while (1)
   {

-    if (getthrds (PIDGET (inferior_ptid), &thrinf, 
+    if (getthrds (ptid_get_pid (inferior_ptid), &thrinf, 

                  sizeof (thrinf), &ktid, 1) != 1)
       break;
 
                  sizeof (thrinf), &ktid, 1) != 1)
       break;
 


@@ -690,7 +703,7 @@ sync_threadlists (void)
 
   pcount = 0;
   psize = 1;
 
   pcount = 0;
   psize = 1;

-  pbuf = (struct pd_thread *) xmalloc (psize * sizeof *pbuf);
+  pbuf = XNEWVEC (struct pd_thread, psize);

 
   for (cmd = PTHDB_LIST_FIRST;; cmd = PTHDB_LIST_NEXT)
     {
 
   for (cmd = PTHDB_LIST_FIRST;; cmd = PTHDB_LIST_NEXT)
     {


@@ -727,13 +740,13 @@ sync_threadlists (void)
 
   gcount = 0;
   iterate_over_threads (giter_count, &gcount);
 
   gcount = 0;
   iterate_over_threads (giter_count, &gcount);

-  g = gbuf = (struct thread_info **) xmalloc (gcount * sizeof *gbuf);
+  g = gbuf = XNEWVEC (struct thread_info *, gcount);

   iterate_over_threads (giter_accum, &g);
   qsort (gbuf, gcount, sizeof *gbuf, gcmp);
 
   /* Apply differences between the two arrays to GDB's thread list.  */
 
   iterate_over_threads (giter_accum, &g);
   qsort (gbuf, gcount, sizeof *gbuf, gcmp);
 
   /* Apply differences between the two arrays to GDB's thread list.  */
 

-  infpid = PIDGET (inferior_ptid);
+  infpid = ptid_get_pid (inferior_ptid);

   for (pi = gi = 0; pi < pcount || gi < gcount;)
     {
       if (pi == pcount)
   for (pi = gi = 0; pi < pcount || gi < gcount;)
     {
       if (pi == pcount)


@@ -743,10 +756,10 @@ sync_threadlists (void)
        }
       else if (gi == gcount)
        {
        }
       else if (gi == gcount)
        {

-         thread = add_thread (BUILD_THREAD (pbuf[pi].pthid, infpid));
-         thread->private = xmalloc (sizeof (struct private_thread_info));
-         thread->private->pdtid = pbuf[pi].pdtid;
-         thread->private->tid = pbuf[pi].tid;
+         thread = add_thread (ptid_build (infpid, 0, pbuf[pi].pthid));
+         thread->priv = XNEW (struct private_thread_info);
+         thread->priv->pdtid = pbuf[pi].pdtid;
+         thread->priv->tid = pbuf[pi].tid;

          pi++;
        }
       else
          pi++;
        }
       else


@@ -754,7 +767,7 @@ sync_threadlists (void)
          ptid_t pptid, gptid;
          int cmp_result;
 
          ptid_t pptid, gptid;
          int cmp_result;
 

-         pptid = BUILD_THREAD (pbuf[pi].pthid, infpid);
+         pptid = ptid_build (infpid, 0, pbuf[pi].pthid);

          gptid = gbuf[gi]->ptid;
          pdtid = pbuf[pi].pdtid;
          tid = pbuf[pi].tid;
          gptid = gbuf[gi]->ptid;
          pdtid = pbuf[pi].pdtid;
          tid = pbuf[pi].tid;


@@ -763,8 +776,8 @@ sync_threadlists (void)
 
          if (cmp_result == 0)
            {
 
          if (cmp_result == 0)
            {

-             gbuf[gi]->private->pdtid = pdtid;
-             gbuf[gi]->private->tid = tid;
+             gbuf[gi]->priv->pdtid = pdtid;
+             gbuf[gi]->priv->tid = tid;

              pi++;
              gi++;
            }
              pi++;
              gi++;
            }


@@ -776,9 +789,9 @@ sync_threadlists (void)
          else
            {
              thread = add_thread (pptid);
          else
            {
              thread = add_thread (pptid);

-             thread->private = xmalloc (sizeof (struct private_thread_info));
-             thread->private->pdtid = pdtid;
-             thread->private->tid = tid;
+             thread->priv = XNEW (struct private_thread_info);
+             thread->priv->pdtid = pdtid;
+             thread->priv->tid = tid;

              pi++;
            }
        }
              pi++;
            }
        }


@@ -796,7 +809,7 @@ iter_tid (struct thread_info *thread, void *tidp)
 {
   const pthdb_tid_t tid = *(pthdb_tid_t *)tidp;
 
 {
   const pthdb_tid_t tid = *(pthdb_tid_t *)tidp;
 

-  return (thread->private->tid == tid);
+  return (thread->priv->tid == tid);

 }
 
 /* Synchronize libpthdebug's state with the inferior and with GDB,
 }
 
 /* Synchronize libpthdebug's state with the inferior and with GDB,


@@ -836,7 +849,7 @@ pd_update (int set_infpid)
   return ptid;
 }
 
   return ptid;
 }
 

-/* Try to start debugging threads in the current process. 
+/* Try to start debugging threads in the current process.

    If successful and SET_INFPID, set inferior_ptid to reflect the
    current thread.  */
 
    If successful and SET_INFPID, set inferior_ptid to reflect the
    current thread.  */
 


@@ -877,32 +890,32 @@ pd_enable (void)
 {
   int status;
   char *stub_name;
 {
   int status;
   char *stub_name;

-  struct minimal_symbol *ms;
+  struct bound_minimal_symbol ms;

 
   /* Don't initialize twice.  */
   if (pd_able)
     return;
 
   /* Check application word size.  */
 
   /* Don't initialize twice.  */
   if (pd_able)
     return;
 
   /* Check application word size.  */

-  arch64 = register_size (current_gdbarch, 0) == 8;
+  arch64 = register_size (target_gdbarch (), 0) == 8;

 
   /* Check whether the application is pthreaded.  */
   stub_name = NULL;
   status = pthdb_session_pthreaded (PD_USER, PTHDB_FLAG_REGS,
                                    &pd_callbacks, &stub_name);
 
   /* Check whether the application is pthreaded.  */
   stub_name = NULL;
   status = pthdb_session_pthreaded (PD_USER, PTHDB_FLAG_REGS,
                                    &pd_callbacks, &stub_name);

-  if ((status != PTHDB_SUCCESS && 
-       status != PTHDB_NOT_PTHREADED) || !stub_name)
+  if ((status != PTHDB_SUCCESS
+       && status != PTHDB_NOT_PTHREADED) || !stub_name)

     return;
 
   /* Set a breakpoint on the returned stub function.  */
     return;
 
   /* Set a breakpoint on the returned stub function.  */

-  if (!(ms = lookup_minimal_symbol (stub_name, NULL, NULL)))
+  ms = lookup_minimal_symbol (stub_name, NULL, NULL);
+  if (ms.minsym == NULL)

     return;
     return;

-  pd_brk_addr = SYMBOL_VALUE_ADDRESS (ms);
-  if (!create_thread_event_breakpoint (pd_brk_addr))
+  pd_brk_addr = BMSYMBOL_VALUE_ADDRESS (ms);
+  if (!create_thread_event_breakpoint (target_gdbarch (), pd_brk_addr))

     return;
 
   /* Prepare for thread debugging.  */
     return;
 
   /* Prepare for thread debugging.  */

-  base_target = current_target;

   push_target (&aix_thread_ops);
   pd_able = 1;
 
   push_target (&aix_thread_ops);
   pd_able = 1;
 


@@ -925,7 +938,7 @@ pd_disable (void)
   unpush_target (&aix_thread_ops);
 }
 
   unpush_target (&aix_thread_ops);
 }
 

-/* deprecated_target_new_objfile_hook callback.
+/* new_objfile observer callback.

 
    If OBJFILE is non-null, check whether a threaded application is
    being debugged, and if so, prepare for thread debugging.
 
    If OBJFILE is non-null, check whether a threaded application is
    being debugged, and if so, prepare for thread debugging.


@@ -939,34 +952,33 @@ new_objfile (struct objfile *objfile)
     pd_enable ();
   else
     pd_disable ();
     pd_enable ();
   else
     pd_disable ();

-
-  if (target_new_objfile_chain)
-    target_new_objfile_chain (objfile);

 }
 
 /* Attach to process specified by ARGS.  */
 
 static void
 }
 
 /* Attach to process specified by ARGS.  */
 
 static void

-aix_thread_attach (char *args, int from_tty)
+aix_thread_inferior_created (struct target_ops *ops, int from_tty)

 {
 {

-  base_target.to_attach (args, from_tty);
-  pd_activate (1);
+  pd_enable ();

 }
 
 /* Detach from the process attached to by aix_thread_attach().  */
 
 static void
 }
 
 /* Detach from the process attached to by aix_thread_attach().  */
 
 static void

-aix_thread_detach (char *args, int from_tty)
+aix_thread_detach (struct target_ops *ops, const char *args, int from_tty)

 {
 {

+  struct target_ops *beneath = find_target_beneath (ops);
+

   pd_disable ();
   pd_disable ();

-  base_target.to_detach (args, from_tty);
+  beneath->to_detach (beneath, args, from_tty);

 }
 
 /* Tell the inferior process to continue running thread PID if != -1
    and all threads otherwise.  */
 
 static void
 }
 
 /* Tell the inferior process to continue running thread PID if != -1
    and all threads otherwise.  */
 
 static void

-aix_thread_resume (ptid_t ptid, int step, enum target_signal sig)
+aix_thread_resume (struct target_ops *ops,
+                   ptid_t ptid, int step, enum gdb_signal sig)

 {
   struct thread_info *thread;
   pthdb_tid_t tid[2];
 {
   struct thread_info *thread;
   pthdb_tid_t tid[2];


@@ -974,29 +986,31 @@ aix_thread_resume (ptid_t ptid, int step, enum target_signal sig)
   if (!PD_TID (ptid))
     {
       struct cleanup *cleanup = save_inferior_ptid ();
   if (!PD_TID (ptid))
     {
       struct cleanup *cleanup = save_inferior_ptid ();

-      inferior_ptid = pid_to_ptid (PIDGET (inferior_ptid));
-      base_target.to_resume (ptid, step, sig);
+      struct target_ops *beneath = find_target_beneath (ops);
+      
+      inferior_ptid = pid_to_ptid (ptid_get_pid (inferior_ptid));
+      beneath->to_resume (beneath, ptid, step, sig);

       do_cleanups (cleanup);
     }
   else
     {
       do_cleanups (cleanup);
     }
   else
     {

-      thread = find_thread_pid (ptid);
+      thread = find_thread_ptid (ptid);

       if (!thread)
        error (_("aix-thread resume: unknown pthread %ld"),
       if (!thread)
        error (_("aix-thread resume: unknown pthread %ld"),

-              TIDGET (ptid));
+              ptid_get_lwp (ptid));

 
 

-      tid[0] = thread->private->tid;
+      tid[0] = thread->priv->tid;

       if (tid[0] == PTHDB_INVALID_TID)
        error (_("aix-thread resume: no tid for pthread %ld"),
       if (tid[0] == PTHDB_INVALID_TID)
        error (_("aix-thread resume: no tid for pthread %ld"),

-              TIDGET (ptid));
+              ptid_get_lwp (ptid));

       tid[1] = 0;
 
       if (arch64)
       tid[1] = 0;
 
       if (arch64)

-       ptrace64aix (PTT_CONTINUE, tid[0], 1, 
-                    target_signal_to_host (sig), (int *) tid);
+       ptrace64aix (PTT_CONTINUE, tid[0], (long long) 1,
+                    gdb_signal_to_host (sig), (PTRACE_TYPE_ARG5) tid);

       else
       else

-       ptrace32 (PTT_CONTINUE, tid[0], (int *) 1,
-                 target_signal_to_host (sig), (int *) tid);
+       ptrace32 (PTT_CONTINUE, tid[0], (addr_ptr) 1,
+                 gdb_signal_to_host (sig), (PTRACE_TYPE_ARG5) tid);

     }
 }
 
     }
 }
 


@@ -1005,24 +1019,32 @@ aix_thread_resume (ptid_t ptid, int step, enum target_signal sig)
    thread.  */
 
 static ptid_t
    thread.  */
 
 static ptid_t

-aix_thread_wait (ptid_t ptid, struct target_waitstatus *status)
+aix_thread_wait (struct target_ops *ops,
+                ptid_t ptid, struct target_waitstatus *status, int options)

 {
   struct cleanup *cleanup = save_inferior_ptid ();
 {
   struct cleanup *cleanup = save_inferior_ptid ();

+  struct target_ops *beneath = find_target_beneath (ops);

 
   pid_to_prc (&ptid);
 
 
   pid_to_prc (&ptid);
 

-  inferior_ptid = pid_to_ptid (PIDGET (inferior_ptid));
-  ptid = base_target.to_wait (ptid, status);
+  inferior_ptid = pid_to_ptid (ptid_get_pid (inferior_ptid));
+  ptid = beneath->to_wait (beneath, ptid, status, options);

   do_cleanups (cleanup);
 
   do_cleanups (cleanup);
 

-  if (PIDGET (ptid) == -1)
+  if (ptid_get_pid (ptid) == -1)

     return pid_to_ptid (-1);
 
   /* Check whether libpthdebug might be ready to be initialized.  */
     return pid_to_ptid (-1);
 
   /* Check whether libpthdebug might be ready to be initialized.  */

-  if (!pd_active && status->kind == TARGET_WAITKIND_STOPPED &&
-      status->value.sig == TARGET_SIGNAL_TRAP &&
-      read_pc_pid (ptid) - DECR_PC_AFTER_BREAK == pd_brk_addr)
-    return pd_activate (0);
+  if (!pd_active && status->kind == TARGET_WAITKIND_STOPPED
+      && status->value.sig == GDB_SIGNAL_TRAP)
+    {
+      struct regcache *regcache = get_thread_regcache (ptid);
+      struct gdbarch *gdbarch = get_regcache_arch (regcache);
+
+      if (regcache_read_pc (regcache)
+         - gdbarch_decr_pc_after_break (gdbarch) == pd_brk_addr)
+       return pd_activate (0);
+    }

 
   return pd_update (0);
 }
 
   return pd_update (0);
 }


@@ -1032,7 +1054,7 @@ aix_thread_wait (ptid_t ptid, struct target_waitstatus *status)
 static void
 supply_gprs64 (struct regcache *regcache, uint64_t *vals)
 {
 static void
 supply_gprs64 (struct regcache *regcache, uint64_t *vals)
 {

-  struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+  struct gdbarch_tdep *tdep = gdbarch_tdep (get_regcache_arch (regcache));

   int regno;
 
   for (regno = 0; regno < ppc_num_gprs; regno++)
   int regno;
 
   for (regno = 0; regno < ppc_num_gprs; regno++)


@@ -1053,25 +1075,28 @@ supply_reg32 (struct regcache *regcache, int regno, uint32_t val)
 static void
 supply_fprs (struct regcache *regcache, double *vals)
 {
 static void
 supply_fprs (struct regcache *regcache, double *vals)
 {

-  struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+  struct gdbarch *gdbarch = get_regcache_arch (regcache);
+  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);

   int regno;
 
   /* This function should never be called on architectures without
      floating-point registers.  */
   int regno;
 
   /* This function should never be called on architectures without
      floating-point registers.  */

-  gdb_assert (ppc_floating_point_unit_p (current_gdbarch));
+  gdb_assert (ppc_floating_point_unit_p (gdbarch));

 
 

-  for (regno = 0; regno < ppc_num_fprs; regno++)
-    regcache_raw_supply (regcache, regno + tdep->ppc_fp0_regnum,
-                        (char *) (vals + regno));
+  for (regno = tdep->ppc_fp0_regnum;
+       regno < tdep->ppc_fp0_regnum + ppc_num_fprs;
+       regno++)
+    regcache_raw_supply (regcache, regno,
+                        (char *) (vals + regno - tdep->ppc_fp0_regnum));

 }
 
 /* Predicate to test whether given register number is a "special" register.  */
 static int
 }
 
 /* Predicate to test whether given register number is a "special" register.  */
 static int

-special_register_p (int regno)
+special_register_p (struct gdbarch *gdbarch, int regno)

 {
 {

-  struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);

 
 

-  return regno == PC_REGNUM
+  return regno == gdbarch_pc_regnum (gdbarch)

       || regno == tdep->ppc_ps_regnum
       || regno == tdep->ppc_cr_regnum
       || regno == tdep->ppc_lr_regnum
       || regno == tdep->ppc_ps_regnum
       || regno == tdep->ppc_cr_regnum
       || regno == tdep->ppc_lr_regnum


@@ -1091,9 +1116,11 @@ supply_sprs64 (struct regcache *regcache,
               uint64_t lr, uint64_t ctr, uint32_t xer,
               uint32_t fpscr)
 {
               uint64_t lr, uint64_t ctr, uint32_t xer,
               uint32_t fpscr)
 {

-  struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+  struct gdbarch *gdbarch = get_regcache_arch (regcache);
+  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);

 
 

-  regcache_raw_supply (regcache, PC_REGNUM, (char *) &iar);
+  regcache_raw_supply (regcache, gdbarch_pc_regnum (gdbarch),
+                      (char *) &iar);

   regcache_raw_supply (regcache, tdep->ppc_ps_regnum, (char *) &msr);
   regcache_raw_supply (regcache, tdep->ppc_cr_regnum, (char *) &cr);
   regcache_raw_supply (regcache, tdep->ppc_lr_regnum, (char *) &lr);
   regcache_raw_supply (regcache, tdep->ppc_ps_regnum, (char *) &msr);
   regcache_raw_supply (regcache, tdep->ppc_cr_regnum, (char *) &cr);
   regcache_raw_supply (regcache, tdep->ppc_lr_regnum, (char *) &lr);


@@ -1113,9 +1140,11 @@ supply_sprs32 (struct regcache *regcache,
               uint32_t lr, uint32_t ctr, uint32_t xer,
               uint32_t fpscr)
 {
               uint32_t lr, uint32_t ctr, uint32_t xer,
               uint32_t fpscr)
 {

-  struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+  struct gdbarch *gdbarch = get_regcache_arch (regcache);
+  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);

 
 

-  regcache_raw_supply (regcache, PC_REGNUM, (char *) &iar);
+  regcache_raw_supply (regcache, gdbarch_pc_regnum (gdbarch),
+                      (char *) &iar);

   regcache_raw_supply (regcache, tdep->ppc_ps_regnum, (char *) &msr);
   regcache_raw_supply (regcache, tdep->ppc_cr_regnum, (char *) &cr);
   regcache_raw_supply (regcache, tdep->ppc_lr_regnum, (char *) &lr);
   regcache_raw_supply (regcache, tdep->ppc_ps_regnum, (char *) &msr);
   regcache_raw_supply (regcache, tdep->ppc_cr_regnum, (char *) &cr);
   regcache_raw_supply (regcache, tdep->ppc_lr_regnum, (char *) &lr);


@@ -1136,7 +1165,8 @@ supply_sprs32 (struct regcache *regcache,
 static void
 fetch_regs_user_thread (struct regcache *regcache, pthdb_pthread_t pdtid)
 {
 static void
 fetch_regs_user_thread (struct regcache *regcache, pthdb_pthread_t pdtid)
 {

-  struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+  struct gdbarch *gdbarch = get_regcache_arch (regcache);
+  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);

   int status, i;
   pthdb_context_t ctx;
 
   int status, i;
   pthdb_context_t ctx;
 


@@ -1158,7 +1188,7 @@ fetch_regs_user_thread (struct regcache *regcache, pthdb_pthread_t pdtid)
 
   /* Floating-point registers.  */
 
 
   /* Floating-point registers.  */
 

-  if (ppc_floating_point_unit_p (current_gdbarch))
+  if (ppc_floating_point_unit_p (gdbarch))

     supply_fprs (regcache, ctx.fpr);
 
   /* Special registers.  */
     supply_fprs (regcache, ctx.fpr);
 
   /* Special registers.  */


@@ -1190,7 +1220,8 @@ static void
 fetch_regs_kernel_thread (struct regcache *regcache, int regno,
                          pthdb_tid_t tid)
 {
 fetch_regs_kernel_thread (struct regcache *regcache, int regno,
                          pthdb_tid_t tid)
 {

-  struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+  struct gdbarch *gdbarch = get_regcache_arch (regcache);
+  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);

   uint64_t gprs64[ppc_num_gprs];
   uint32_t gprs32[ppc_num_gprs];
   double fprs[ppc_num_fprs];
   uint64_t gprs64[ppc_num_gprs];
   uint32_t gprs32[ppc_num_gprs];
   double fprs[ppc_num_fprs];


@@ -1217,7 +1248,7 @@ fetch_regs_kernel_thread (struct regcache *regcache, int regno,
        }
       else
        {
        }
       else
        {

-         if (!ptrace32 (PTT_READ_GPRS, tid, gprs32, 0, NULL))
+         if (!ptrace32 (PTT_READ_GPRS, tid, (uintptr_t) gprs32, 0, NULL))

            memset (gprs32, 0, sizeof (gprs32));
          for (i = 0; i < ppc_num_gprs; i++)
            supply_reg32 (regcache, tdep->ppc_gp0_regnum + i, gprs32[i]);
            memset (gprs32, 0, sizeof (gprs32));
          for (i = 0; i < ppc_num_gprs; i++)
            supply_reg32 (regcache, tdep->ppc_gp0_regnum + i, gprs32[i]);


@@ -1226,19 +1257,19 @@ fetch_regs_kernel_thread (struct regcache *regcache, int regno,
 
   /* Floating-point registers.  */
 
 
   /* Floating-point registers.  */
 

-  if (ppc_floating_point_unit_p (current_gdbarch)
+  if (ppc_floating_point_unit_p (gdbarch)

       && (regno == -1
           || (regno >= tdep->ppc_fp0_regnum
               && regno < tdep->ppc_fp0_regnum + ppc_num_fprs)))
     {
       && (regno == -1
           || (regno >= tdep->ppc_fp0_regnum
               && regno < tdep->ppc_fp0_regnum + ppc_num_fprs)))
     {

-      if (!ptrace32 (PTT_READ_FPRS, tid, (int *) fprs, 0, NULL))
+      if (!ptrace32 (PTT_READ_FPRS, tid, (uintptr_t) fprs, 0, NULL))

        memset (fprs, 0, sizeof (fprs));
       supply_fprs (regcache, fprs);
     }
 
   /* Special-purpose registers.  */
 
        memset (fprs, 0, sizeof (fprs));
       supply_fprs (regcache, fprs);
     }
 
   /* Special-purpose registers.  */
 

-  if (regno == -1 || special_register_p (regno))
+  if (regno == -1 || special_register_p (gdbarch, regno))

     {
       if (arch64)
        {
     {
       if (arch64)
        {


@@ -1251,9 +1282,9 @@ fetch_regs_kernel_thread (struct regcache *regcache, int regno,
        }
       else
        {
        }
       else
        {

-         struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+         struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);

 
 

-         if (!ptrace32 (PTT_READ_SPRS, tid, (int *) &sprs32, 0, NULL))
+         if (!ptrace32 (PTT_READ_SPRS, tid, (uintptr_t) &sprs32, 0, NULL))

            memset (&sprs32, 0, sizeof (sprs32));
          supply_sprs32 (regcache, sprs32.pt_iar, sprs32.pt_msr, sprs32.pt_cr,
                         sprs32.pt_lr, sprs32.pt_ctr, sprs32.pt_xer,
            memset (&sprs32, 0, sizeof (sprs32));
          supply_sprs32 (regcache, sprs32.pt_iar, sprs32.pt_msr, sprs32.pt_cr,
                         sprs32.pt_lr, sprs32.pt_ctr, sprs32.pt_xer,


@@ -1270,20 +1301,22 @@ fetch_regs_kernel_thread (struct regcache *regcache, int regno,
    thread/process specified by inferior_ptid.  */
 
 static void
    thread/process specified by inferior_ptid.  */
 
 static void

-aix_thread_fetch_registers (struct regcache *regcache, int regno)
+aix_thread_fetch_registers (struct target_ops *ops,
+                            struct regcache *regcache, int regno)

 {
   struct thread_info *thread;
   pthdb_tid_t tid;
 {
   struct thread_info *thread;
   pthdb_tid_t tid;

+  struct target_ops *beneath = find_target_beneath (ops);

 
   if (!PD_TID (inferior_ptid))
 
   if (!PD_TID (inferior_ptid))

-    base_target.to_fetch_registers (regcache, regno);
+    beneath->to_fetch_registers (beneath, regcache, regno);

   else
     {
   else
     {

-      thread = find_thread_pid (inferior_ptid);
-      tid = thread->private->tid;
+      thread = find_thread_ptid (inferior_ptid);
+      tid = thread->priv->tid;

 
       if (tid == PTHDB_INVALID_TID)
 
       if (tid == PTHDB_INVALID_TID)

-       fetch_regs_user_thread (regcache, thread->private->pdtid);
+       fetch_regs_user_thread (regcache, thread->priv->pdtid);

       else
        fetch_regs_kernel_thread (regcache, regno, tid);
     }
       else
        fetch_regs_kernel_thread (regcache, regno, tid);
     }


@@ -1294,11 +1327,12 @@ aix_thread_fetch_registers (struct regcache *regcache, int regno)
 static void
 fill_gprs64 (const struct regcache *regcache, uint64_t *vals)
 {
 static void
 fill_gprs64 (const struct regcache *regcache, uint64_t *vals)
 {

-  struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+  struct gdbarch_tdep *tdep = gdbarch_tdep (get_regcache_arch (regcache));

   int regno;
 
   for (regno = 0; regno < ppc_num_gprs; regno++)
   int regno;
 
   for (regno = 0; regno < ppc_num_gprs; regno++)

-    if (regcache_valid_p (regcache, tdep->ppc_gp0_regnum + regno))
+    if (REG_VALID == regcache_register_status (regcache,
+                                              tdep->ppc_gp0_regnum + regno))

       regcache_raw_collect (regcache, tdep->ppc_gp0_regnum + regno,
                            vals + regno);
 }
       regcache_raw_collect (regcache, tdep->ppc_gp0_regnum + regno,
                            vals + regno);
 }


@@ -1306,11 +1340,12 @@ fill_gprs64 (const struct regcache *regcache, uint64_t *vals)
 static void 
 fill_gprs32 (const struct regcache *regcache, uint32_t *vals)
 {
 static void 
 fill_gprs32 (const struct regcache *regcache, uint32_t *vals)
 {

-  struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+  struct gdbarch_tdep *tdep = gdbarch_tdep (get_regcache_arch (regcache));

   int regno;
 
   for (regno = 0; regno < ppc_num_gprs; regno++)
   int regno;
 
   for (regno = 0; regno < ppc_num_gprs; regno++)

-    if (regcache_valid_p (regcache, tdep->ppc_gp0_regnum + regno))
+    if (REG_VALID == regcache_register_status (regcache,
+                                              tdep->ppc_gp0_regnum + regno))

       regcache_raw_collect (regcache, tdep->ppc_gp0_regnum + regno,
                            vals + regno);
 }
       regcache_raw_collect (regcache, tdep->ppc_gp0_regnum + regno,
                            vals + regno);
 }


@@ -1319,18 +1354,20 @@ fill_gprs32 (const struct regcache *regcache, uint32_t *vals)
 static void
 fill_fprs (const struct regcache *regcache, double *vals)
 {
 static void
 fill_fprs (const struct regcache *regcache, double *vals)
 {

-  struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+  struct gdbarch *gdbarch = get_regcache_arch (regcache);
+  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);

   int regno;
 
   /* This function should never be called on architectures without
      floating-point registers.  */
   int regno;
 
   /* This function should never be called on architectures without
      floating-point registers.  */

-  gdb_assert (ppc_floating_point_unit_p (current_gdbarch));
+  gdb_assert (ppc_floating_point_unit_p (gdbarch));

 
   for (regno = tdep->ppc_fp0_regnum;
        regno < tdep->ppc_fp0_regnum + ppc_num_fprs;
        regno++)
 
   for (regno = tdep->ppc_fp0_regnum;
        regno < tdep->ppc_fp0_regnum + ppc_num_fprs;
        regno++)

-    if (regcache_valid_p (regcache, regno))
-      regcache_raw_collect (regcache, regno, vals + regno);
+    if (REG_VALID == regcache_register_status (regcache, regno))
+      regcache_raw_collect (regcache, regno,
+                           vals + regno - tdep->ppc_fp0_regnum);

 }
 
 /* Store the special registers into the specified 64-bit and 32-bit
 }
 
 /* Store the special registers into the specified 64-bit and 32-bit


@@ -1342,29 +1379,33 @@ fill_sprs64 (const struct regcache *regcache,
             uint64_t *lr, uint64_t *ctr, uint32_t *xer,
             uint32_t *fpscr)
 {
             uint64_t *lr, uint64_t *ctr, uint32_t *xer,
             uint32_t *fpscr)
 {

-  struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+  struct gdbarch *gdbarch = get_regcache_arch (regcache);
+  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);

 
   /* Verify that the size of the size of the IAR buffer is the
      same as the raw size of the PC (in the register cache).  If
      they're not, then either GDB has been built incorrectly, or
      there's some other kind of internal error.  To be really safe,
      we should check all of the sizes.   */
 
   /* Verify that the size of the size of the IAR buffer is the
      same as the raw size of the PC (in the register cache).  If
      they're not, then either GDB has been built incorrectly, or
      there's some other kind of internal error.  To be really safe,
      we should check all of the sizes.   */

-  gdb_assert (sizeof (*iar) == register_size (current_gdbarch, PC_REGNUM));
+  gdb_assert (sizeof (*iar) == register_size
+                                (gdbarch, gdbarch_pc_regnum (gdbarch)));

 
 

-  if (regcache_valid_p (regcache, PC_REGNUM))
-    regcache_raw_collect (regcache, PC_REGNUM, iar);
-  if (regcache_valid_p (regcache, tdep->ppc_ps_regnum))
+  if (REG_VALID == regcache_register_status (regcache,
+                                            gdbarch_pc_regnum (gdbarch)))
+    regcache_raw_collect (regcache, gdbarch_pc_regnum (gdbarch), iar);
+  if (REG_VALID == regcache_register_status (regcache, tdep->ppc_ps_regnum))

     regcache_raw_collect (regcache, tdep->ppc_ps_regnum, msr);
     regcache_raw_collect (regcache, tdep->ppc_ps_regnum, msr);

-  if (regcache_valid_p (regcache, tdep->ppc_cr_regnum))
+  if (REG_VALID == regcache_register_status (regcache, tdep->ppc_cr_regnum))

     regcache_raw_collect (regcache, tdep->ppc_cr_regnum, cr);
     regcache_raw_collect (regcache, tdep->ppc_cr_regnum, cr);

-  if (regcache_valid_p (regcache, tdep->ppc_lr_regnum))
+  if (REG_VALID == regcache_register_status (regcache, tdep->ppc_lr_regnum))

     regcache_raw_collect (regcache, tdep->ppc_lr_regnum, lr);
     regcache_raw_collect (regcache, tdep->ppc_lr_regnum, lr);

-  if (regcache_valid_p (regcache, tdep->ppc_ctr_regnum))
+  if (REG_VALID == regcache_register_status (regcache, tdep->ppc_ctr_regnum))

     regcache_raw_collect (regcache, tdep->ppc_ctr_regnum, ctr);
     regcache_raw_collect (regcache, tdep->ppc_ctr_regnum, ctr);

-  if (regcache_valid_p (regcache, tdep->ppc_xer_regnum))
+  if (REG_VALID == regcache_register_status (regcache, tdep->ppc_xer_regnum))

     regcache_raw_collect (regcache, tdep->ppc_xer_regnum, xer);
   if (tdep->ppc_fpscr_regnum >= 0
     regcache_raw_collect (regcache, tdep->ppc_xer_regnum, xer);
   if (tdep->ppc_fpscr_regnum >= 0

-      && regcache_valid_p (regcache, tdep->ppc_fpscr_regnum))
+      && REG_VALID == regcache_register_status (regcache,
+                                               tdep->ppc_fpscr_regnum))

     regcache_raw_collect (regcache, tdep->ppc_fpscr_regnum, fpscr);
 }
 
     regcache_raw_collect (regcache, tdep->ppc_fpscr_regnum, fpscr);
 }
 


@@ -1374,29 +1415,32 @@ fill_sprs32 (const struct regcache *regcache,
             uint32_t *lr, uint32_t *ctr, uint32_t *xer,
             uint32_t *fpscr)
 {
             uint32_t *lr, uint32_t *ctr, uint32_t *xer,
             uint32_t *fpscr)
 {

-  struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+  struct gdbarch *gdbarch = get_regcache_arch (regcache);
+  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);

 
   /* Verify that the size of the size of the IAR buffer is the
      same as the raw size of the PC (in the register cache).  If
      they're not, then either GDB has been built incorrectly, or
      there's some other kind of internal error.  To be really safe,
      we should check all of the sizes.  */
 
   /* Verify that the size of the size of the IAR buffer is the
      same as the raw size of the PC (in the register cache).  If
      they're not, then either GDB has been built incorrectly, or
      there's some other kind of internal error.  To be really safe,
      we should check all of the sizes.  */

-  gdb_assert (sizeof (*iar) == register_size (current_gdbarch, PC_REGNUM));
+  gdb_assert (sizeof (*iar) == register_size (gdbarch,
+                                             gdbarch_pc_regnum (gdbarch)));

 
 

-  if (regcache_valid_p (regcache, PC_REGNUM))
-    regcache_raw_collect (regcache, PC_REGNUM, iar);
-  if (regcache_valid_p (regcache, tdep->ppc_ps_regnum))
+  if (REG_VALID == regcache_register_status (regcache,
+                                            gdbarch_pc_regnum (gdbarch)))
+    regcache_raw_collect (regcache, gdbarch_pc_regnum (gdbarch), iar);
+  if (REG_VALID == regcache_register_status (regcache, tdep->ppc_ps_regnum))

     regcache_raw_collect (regcache, tdep->ppc_ps_regnum, msr);
     regcache_raw_collect (regcache, tdep->ppc_ps_regnum, msr);

-  if (regcache_valid_p (regcache, tdep->ppc_cr_regnum))
+  if (REG_VALID == regcache_register_status (regcache, tdep->ppc_cr_regnum))

     regcache_raw_collect (regcache, tdep->ppc_cr_regnum, cr);
     regcache_raw_collect (regcache, tdep->ppc_cr_regnum, cr);

-  if (regcache_valid_p (regcache, tdep->ppc_lr_regnum))
+  if (REG_VALID == regcache_register_status (regcache, tdep->ppc_lr_regnum))

     regcache_raw_collect (regcache, tdep->ppc_lr_regnum, lr);
     regcache_raw_collect (regcache, tdep->ppc_lr_regnum, lr);

-  if (regcache_valid_p (regcache, tdep->ppc_ctr_regnum))
+  if (REG_VALID == regcache_register_status (regcache, tdep->ppc_ctr_regnum))

     regcache_raw_collect (regcache, tdep->ppc_ctr_regnum, ctr);
     regcache_raw_collect (regcache, tdep->ppc_ctr_regnum, ctr);

-  if (regcache_valid_p (regcache, tdep->ppc_xer_regnum))
+  if (REG_VALID == regcache_register_status (regcache, tdep->ppc_xer_regnum))

     regcache_raw_collect (regcache, tdep->ppc_xer_regnum, xer);
   if (tdep->ppc_fpscr_regnum >= 0
     regcache_raw_collect (regcache, tdep->ppc_xer_regnum, xer);
   if (tdep->ppc_fpscr_regnum >= 0

-      && regcache_valid_p (regcache, tdep->ppc_fpscr_regnum))
+      && REG_VALID == regcache_register_status (regcache, tdep->ppc_fpscr_regnum))

     regcache_raw_collect (regcache, tdep->ppc_fpscr_regnum, fpscr);
 }
 
     regcache_raw_collect (regcache, tdep->ppc_fpscr_regnum, fpscr);
 }
 


@@ -1409,7 +1453,8 @@ fill_sprs32 (const struct regcache *regcache,
 static void
 store_regs_user_thread (const struct regcache *regcache, pthdb_pthread_t pdtid)
 {
 static void
 store_regs_user_thread (const struct regcache *regcache, pthdb_pthread_t pdtid)
 {

-  struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+  struct gdbarch *gdbarch = get_regcache_arch (regcache);
+  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);

   int status, i;
   pthdb_context_t ctx;
   uint32_t int32;
   int status, i;
   pthdb_context_t ctx;
   uint32_t int32;


@@ -1430,7 +1475,8 @@ store_regs_user_thread (const struct regcache *regcache, pthdb_pthread_t pdtid)
   /* Collect general-purpose register values from the regcache.  */
 
   for (i = 0; i < ppc_num_gprs; i++)
   /* Collect general-purpose register values from the regcache.  */
 
   for (i = 0; i < ppc_num_gprs; i++)

-    if (regcache_valid_p (regcache, tdep->ppc_gp0_regnum + i))
+    if (REG_VALID == regcache_register_status (regcache,
+                                              tdep->ppc_gp0_regnum + i))

       {
        if (arch64)
          {
       {
        if (arch64)
          {


@@ -1447,7 +1493,7 @@ store_regs_user_thread (const struct regcache *regcache, pthdb_pthread_t pdtid)
       }
 
   /* Collect floating-point register values from the regcache.  */
       }
 
   /* Collect floating-point register values from the regcache.  */

-  if (ppc_floating_point_unit_p (current_gdbarch))
+  if (ppc_floating_point_unit_p (gdbarch))

     fill_fprs (regcache, ctx.fpr);
 
   /* Special registers (always kept in ctx as 64 bits).  */
     fill_fprs (regcache, ctx.fpr);
 
   /* Special registers (always kept in ctx as 64 bits).  */


@@ -1465,25 +1511,30 @@ store_regs_user_thread (const struct regcache *regcache, pthdb_pthread_t pdtid)
 
       fill_sprs32 (regcache, &tmp_iar, &tmp_msr, &tmp_cr, &tmp_lr, &tmp_ctr,
                             &tmp_xer, &tmp_fpscr);
 
       fill_sprs32 (regcache, &tmp_iar, &tmp_msr, &tmp_cr, &tmp_lr, &tmp_ctr,
                             &tmp_xer, &tmp_fpscr);

-      if (regcache_valid_p (regcache, PC_REGNUM))
+      if (REG_VALID == regcache_register_status (regcache,
+                                                gdbarch_pc_regnum (gdbarch)))

        ctx.iar = tmp_iar;
        ctx.iar = tmp_iar;

-      if (regcache_valid_p (regcache, tdep->ppc_ps_regnum))
+      if (REG_VALID == regcache_register_status (regcache, tdep->ppc_ps_regnum))

        ctx.msr = tmp_msr;
        ctx.msr = tmp_msr;

-      if (regcache_valid_p (regcache, tdep->ppc_cr_regnum))
+      if (REG_VALID == regcache_register_status (regcache, tdep->ppc_cr_regnum))

        ctx.cr  = tmp_cr;
        ctx.cr  = tmp_cr;

-      if (regcache_valid_p (regcache, tdep->ppc_lr_regnum))
+      if (REG_VALID == regcache_register_status (regcache, tdep->ppc_lr_regnum))

        ctx.lr  = tmp_lr;
        ctx.lr  = tmp_lr;

-      if (regcache_valid_p (regcache, tdep->ppc_ctr_regnum))
+      if (REG_VALID == regcache_register_status (regcache,
+                                                tdep->ppc_ctr_regnum))

        ctx.ctr = tmp_ctr;
        ctx.ctr = tmp_ctr;

-      if (regcache_valid_p (regcache, tdep->ppc_xer_regnum))
+      if (REG_VALID == regcache_register_status (regcache,
+                                                tdep->ppc_xer_regnum))

        ctx.xer = tmp_xer;
        ctx.xer = tmp_xer;

-      if (regcache_valid_p (regcache, tdep->ppc_xer_regnum))
+      if (REG_VALID == regcache_register_status (regcache,
+                                                tdep->ppc_xer_regnum))

        ctx.fpscr = tmp_fpscr;
     }
 
   status = pthdb_pthread_setcontext (pd_session, pdtid, &ctx);
   if (status != PTHDB_SUCCESS)
        ctx.fpscr = tmp_fpscr;
     }
 
   status = pthdb_pthread_setcontext (pd_session, pdtid, &ctx);
   if (status != PTHDB_SUCCESS)

-    error (_("aix-thread: store_registers: pthdb_pthread_setcontext returned %s"),
+    error (_("aix-thread: store_registers: "
+            "pthdb_pthread_setcontext returned %s"),

            pd_status2str (status));
 }
 
            pd_status2str (status));
 }
 


@@ -1499,7 +1550,8 @@ static void
 store_regs_kernel_thread (const struct regcache *regcache, int regno,
                          pthdb_tid_t tid)
 {
 store_regs_kernel_thread (const struct regcache *regcache, int regno,
                          pthdb_tid_t tid)
 {

-  struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+  struct gdbarch *gdbarch = get_regcache_arch (regcache);
+  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);

   uint64_t gprs64[ppc_num_gprs];
   uint32_t gprs32[ppc_num_gprs];
   double fprs[ppc_num_fprs];
   uint64_t gprs64[ppc_num_gprs];
   uint32_t gprs32[ppc_num_gprs];
   double fprs[ppc_num_fprs];


@@ -1527,28 +1579,28 @@ store_regs_kernel_thread (const struct regcache *regcache, int regno,
       else
        {
          /* Pre-fetch: some regs may not be in the cache.  */
       else
        {
          /* Pre-fetch: some regs may not be in the cache.  */

-         ptrace32 (PTT_READ_GPRS, tid, gprs32, 0, NULL);
+         ptrace32 (PTT_READ_GPRS, tid, (uintptr_t) gprs32, 0, NULL);

          fill_gprs32 (regcache, gprs32);
          fill_gprs32 (regcache, gprs32);

-         ptrace32 (PTT_WRITE_GPRS, tid, gprs32, 0, NULL);
+         ptrace32 (PTT_WRITE_GPRS, tid, (uintptr_t) gprs32, 0, NULL);

        }
     }
 
   /* Floating-point registers.  */
 
        }
     }
 
   /* Floating-point registers.  */
 

-  if (ppc_floating_point_unit_p (current_gdbarch)
+  if (ppc_floating_point_unit_p (gdbarch)

       && (regno == -1
           || (regno >= tdep->ppc_fp0_regnum
               && regno < tdep->ppc_fp0_regnum + ppc_num_fprs)))
     {
       /* Pre-fetch: some regs may not be in the cache.  */
       && (regno == -1
           || (regno >= tdep->ppc_fp0_regnum
               && regno < tdep->ppc_fp0_regnum + ppc_num_fprs)))
     {
       /* Pre-fetch: some regs may not be in the cache.  */

-      ptrace32 (PTT_READ_FPRS, tid, (int *) fprs, 0, NULL);
+      ptrace32 (PTT_READ_FPRS, tid, (uintptr_t) fprs, 0, NULL);

       fill_fprs (regcache, fprs);
       fill_fprs (regcache, fprs);

-      ptrace32 (PTT_WRITE_FPRS, tid, (int *) fprs, 0, NULL);
+      ptrace32 (PTT_WRITE_FPRS, tid, (uintptr_t) fprs, 0, NULL);

     }
 
   /* Special-purpose registers.  */
 
     }
 
   /* Special-purpose registers.  */
 

-  if (regno == -1 || special_register_p (regno))
+  if (regno == -1 || special_register_p (gdbarch, regno))

     {
       if (arch64)
        {
     {
       if (arch64)
        {


@@ -1575,7 +1627,7 @@ store_regs_kernel_thread (const struct regcache *regcache, int regno,
          gdb_assert (sizeof (sprs32.pt_iar) == 4);
 
          /* Pre-fetch: some registers won't be in the cache.  */
          gdb_assert (sizeof (sprs32.pt_iar) == 4);
 
          /* Pre-fetch: some registers won't be in the cache.  */

-         ptrace32 (PTT_READ_SPRS, tid, (int *) &sprs32, 0, NULL);
+         ptrace32 (PTT_READ_SPRS, tid, (uintptr_t) &sprs32, 0, NULL);

 
          fill_sprs32 (regcache, &tmp_iar, &tmp_msr, &tmp_cr, &tmp_lr,
                       &tmp_ctr, &tmp_xer, &tmp_fpscr);
 
          fill_sprs32 (regcache, &tmp_iar, &tmp_msr, &tmp_cr, &tmp_lr,
                       &tmp_ctr, &tmp_xer, &tmp_fpscr);


@@ -1589,11 +1641,12 @@ store_regs_kernel_thread (const struct regcache *regcache, int regno,
          sprs32.pt_fpscr = tmp_fpscr;
 
          if (tdep->ppc_mq_regnum >= 0)
          sprs32.pt_fpscr = tmp_fpscr;
 
          if (tdep->ppc_mq_regnum >= 0)

-           if (regcache_valid_p (regcache, tdep->ppc_mq_regnum))
+           if (REG_VALID == regcache_register_status (regcache,
+                                                      tdep->ppc_mq_regnum))

              regcache_raw_collect (regcache, tdep->ppc_mq_regnum,
                                    &sprs32.pt_mq);
 
              regcache_raw_collect (regcache, tdep->ppc_mq_regnum,
                                    &sprs32.pt_mq);
 

-         ptrace32 (PTT_WRITE_SPRS, tid, (int *) &sprs32, 0, NULL);
+         ptrace32 (PTT_WRITE_SPRS, tid, (uintptr_t) &sprs32, 0, NULL);

        }
     }
 }
        }
     }
 }


@@ -1602,73 +1655,67 @@ store_regs_kernel_thread (const struct regcache *regcache, int regno,
    thread/process specified by inferior_ptid.  */
 
 static void
    thread/process specified by inferior_ptid.  */
 
 static void

-aix_thread_store_registers (struct regcache *regcache, int regno)
+aix_thread_store_registers (struct target_ops *ops,
+                            struct regcache *regcache, int regno)

 {
   struct thread_info *thread;
   pthdb_tid_t tid;
 {
   struct thread_info *thread;
   pthdb_tid_t tid;

+  struct target_ops *beneath = find_target_beneath (ops);

 
   if (!PD_TID (inferior_ptid))
 
   if (!PD_TID (inferior_ptid))

-    base_target.to_store_registers (regcache, regno);
+    beneath->to_store_registers (beneath, regcache, regno);

   else
     {
   else
     {

-      thread = find_thread_pid (inferior_ptid);
-      tid = thread->private->tid;
+      thread = find_thread_ptid (inferior_ptid);
+      tid = thread->priv->tid;

 
       if (tid == PTHDB_INVALID_TID)
 
       if (tid == PTHDB_INVALID_TID)

-       store_regs_user_thread (regcache, thread->private->pdtid);
+       store_regs_user_thread (regcache, thread->priv->pdtid);

       else
        store_regs_kernel_thread (regcache, regno, tid);
     }
 }
 
       else
        store_regs_kernel_thread (regcache, regno, tid);
     }
 }
 

-/* Attempt a transfer all LEN bytes starting at OFFSET between the
-   inferior's OBJECT:ANNEX space and GDB's READBUF/WRITEBUF buffer.
-   Return the number of bytes actually transferred.  */
+/* Implement the to_xfer_partial target_ops method.  */

 
 

-static LONGEST
+static enum target_xfer_status

 aix_thread_xfer_partial (struct target_ops *ops, enum target_object object,
                         const char *annex, gdb_byte *readbuf,
 aix_thread_xfer_partial (struct target_ops *ops, enum target_object object,
                         const char *annex, gdb_byte *readbuf,

-                        const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
+                        const gdb_byte *writebuf,
+                        ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)

 {
   struct cleanup *old_chain = save_inferior_ptid ();
 {
   struct cleanup *old_chain = save_inferior_ptid ();

-  LONGEST xfer;
+  enum target_xfer_status xfer;
+  struct target_ops *beneath = find_target_beneath (ops);

 
 

-  inferior_ptid = pid_to_ptid (PIDGET (inferior_ptid));
-  xfer = base_target.to_xfer_partial (ops, object, annex,
-                                     readbuf, writebuf, offset, len);
+  inferior_ptid = pid_to_ptid (ptid_get_pid (inferior_ptid));
+  xfer = beneath->to_xfer_partial (beneath, object, annex, readbuf,
+                                  writebuf, offset, len, xfered_len);

 
   do_cleanups (old_chain);
   return xfer;
 }
 
 
   do_cleanups (old_chain);
   return xfer;
 }
 

-/* Kill and forget about the inferior process.  */
-
-static void
-aix_thread_kill (void)
-{
-  struct cleanup *cleanup = save_inferior_ptid ();
-
-  inferior_ptid = pid_to_ptid (PIDGET (inferior_ptid));
-  base_target.to_kill ();
-  do_cleanups (cleanup);
-}
-

 /* Clean up after the inferior exits.  */
 
 static void
 /* Clean up after the inferior exits.  */
 
 static void

-aix_thread_mourn_inferior (void)
+aix_thread_mourn_inferior (struct target_ops *ops)

 {
 {

+  struct target_ops *beneath = find_target_beneath (ops);
+

   pd_deactivate ();
   pd_deactivate ();

-  base_target.to_mourn_inferior ();
+  beneath->to_mourn_inferior (beneath);

 }
 
 /* Return whether thread PID is still valid.  */
 
 static int
 }
 
 /* Return whether thread PID is still valid.  */
 
 static int

-aix_thread_thread_alive (ptid_t ptid)
+aix_thread_thread_alive (struct target_ops *ops, ptid_t ptid)

 {
 {

+  struct target_ops *beneath = find_target_beneath (ops);
+

   if (!PD_TID (ptid))
   if (!PD_TID (ptid))

-    return base_target.to_thread_alive (ptid);
+    return beneath->to_thread_alive (beneath, ptid);

 
   /* We update the thread list every time the child stops, so all
      valid threads should be in the thread list.  */
 
   /* We update the thread list every time the child stops, so all
      valid threads should be in the thread list.  */


@@ -1679,12 +1726,13 @@ aix_thread_thread_alive (ptid_t ptid)
    "info threads" output.  */
 
 static char *
    "info threads" output.  */
 
 static char *

-aix_thread_pid_to_str (ptid_t ptid)
+aix_thread_pid_to_str (struct target_ops *ops, ptid_t ptid)

 {
   static char *ret = NULL;
 {
   static char *ret = NULL;

+  struct target_ops *beneath = find_target_beneath (ops);

 
   if (!PD_TID (ptid))
 
   if (!PD_TID (ptid))

-    return base_target.to_pid_to_str (ptid);
+    return beneath->to_pid_to_str (beneath, ptid);

 
   /* Free previous return value; a new one will be allocated by
      xstrprintf().  */
 
   /* Free previous return value; a new one will be allocated by
      xstrprintf().  */


@@ -1698,7 +1746,8 @@ aix_thread_pid_to_str (ptid_t ptid)
    THREAD, for use in "info threads" output.  */
 
 static char *
    THREAD, for use in "info threads" output.  */
 
 static char *

-aix_thread_extra_thread_info (struct thread_info *thread)
+aix_thread_extra_thread_info (struct target_ops *self,
+                             struct thread_info *thread)

 {
   struct ui_file *buf;
   int status;
 {
   struct ui_file *buf;
   int status;


@@ -1708,7 +1757,6 @@ aix_thread_extra_thread_info (struct thread_info *thread)
   pthdb_suspendstate_t suspendstate;
   pthdb_detachstate_t detachstate;
   int cancelpend;
   pthdb_suspendstate_t suspendstate;
   pthdb_detachstate_t detachstate;
   int cancelpend;

-  long length;

   static char *ret = NULL;
 
   if (!PD_TID (thread->ptid))
   static char *ret = NULL;
 
   if (!PD_TID (thread->ptid))


@@ -1716,8 +1764,8 @@ aix_thread_extra_thread_info (struct thread_info *thread)
 
   buf = mem_fileopen ();
 
 
   buf = mem_fileopen ();
 

-  pdtid = thread->private->pdtid;
-  tid = thread->private->tid;
+  pdtid = thread->priv->pdtid;
+  tid = thread->priv->tid;

 
   if (tid != PTHDB_INVALID_TID)
     /* i18n: Like "thread-identifier %d, [state] running, suspended" */
 
   if (tid != PTHDB_INVALID_TID)
     /* i18n: Like "thread-identifier %d, [state] running, suspended" */


@@ -1749,56 +1797,66 @@ aix_thread_extra_thread_info (struct thread_info *thread)
 
   xfree (ret);                 /* Free old buffer.  */
 
 
   xfree (ret);                 /* Free old buffer.  */
 

-  ret = ui_file_xstrdup (buf, &length);
+  ret = ui_file_xstrdup (buf, NULL);

   ui_file_delete (buf);
 
   return ret;
 }
 
   ui_file_delete (buf);
 
   return ret;
 }
 

+static ptid_t
+aix_thread_get_ada_task_ptid (struct target_ops *self, long lwp, long thread)
+{
+  return ptid_build (ptid_get_pid (inferior_ptid), 0, thread);
+}
+

 /* Initialize target aix_thread_ops.  */
 
 static void
 init_aix_thread_ops (void)
 {
 /* Initialize target aix_thread_ops.  */
 
 static void
 init_aix_thread_ops (void)
 {

-  aix_thread_ops.to_shortname          = "aix-threads";
-  aix_thread_ops.to_longname           = _("AIX pthread support");
-  aix_thread_ops.to_doc                = _("AIX pthread support");
-
-  aix_thread_ops.to_attach             = aix_thread_attach;
-  aix_thread_ops.to_detach             = aix_thread_detach;
-  aix_thread_ops.to_resume             = aix_thread_resume;
-  aix_thread_ops.to_wait               = aix_thread_wait;
-  aix_thread_ops.to_fetch_registers    = aix_thread_fetch_registers;
-  aix_thread_ops.to_store_registers    = aix_thread_store_registers;
-  aix_thread_ops.to_xfer_partial       = aix_thread_xfer_partial;
-  /* No need for aix_thread_ops.to_create_inferior, because we activate thread
-     debugging when the inferior reaches pd_brk_addr.  */
-  aix_thread_ops.to_kill               = aix_thread_kill;
-  aix_thread_ops.to_mourn_inferior     = aix_thread_mourn_inferior;
-  aix_thread_ops.to_thread_alive       = aix_thread_thread_alive;
-  aix_thread_ops.to_pid_to_str         = aix_thread_pid_to_str;
-  aix_thread_ops.to_extra_thread_info  = aix_thread_extra_thread_info;
-  aix_thread_ops.to_stratum            = thread_stratum;
-  aix_thread_ops.to_magic              = OPS_MAGIC;
+  aix_thread_ops.to_shortname = "aix-threads";
+  aix_thread_ops.to_longname = _("AIX pthread support");
+  aix_thread_ops.to_doc = _("AIX pthread support");
+
+  aix_thread_ops.to_detach = aix_thread_detach;
+  aix_thread_ops.to_resume = aix_thread_resume;
+  aix_thread_ops.to_wait = aix_thread_wait;
+  aix_thread_ops.to_fetch_registers = aix_thread_fetch_registers;
+  aix_thread_ops.to_store_registers = aix_thread_store_registers;
+  aix_thread_ops.to_xfer_partial = aix_thread_xfer_partial;
+  aix_thread_ops.to_mourn_inferior = aix_thread_mourn_inferior;
+  aix_thread_ops.to_thread_alive = aix_thread_thread_alive;
+  aix_thread_ops.to_pid_to_str = aix_thread_pid_to_str;
+  aix_thread_ops.to_extra_thread_info = aix_thread_extra_thread_info;
+  aix_thread_ops.to_get_ada_task_ptid = aix_thread_get_ada_task_ptid;
+  aix_thread_ops.to_stratum = thread_stratum;
+  aix_thread_ops.to_magic = OPS_MAGIC;

 }
 
 /* Module startup initialization function, automagically called by
    init.c.  */
 
 }
 
 /* Module startup initialization function, automagically called by
    init.c.  */
 

+void _initialize_aix_thread (void);
+

 void
 _initialize_aix_thread (void)
 {
   init_aix_thread_ops ();
 void
 _initialize_aix_thread (void)
 {
   init_aix_thread_ops ();

-  add_target (&aix_thread_ops);
+  complete_target_initialization (&aix_thread_ops);

 
   /* Notice when object files get loaded and unloaded.  */
 
   /* Notice when object files get loaded and unloaded.  */

-  target_new_objfile_chain = deprecated_target_new_objfile_hook;
-  deprecated_target_new_objfile_hook = new_objfile;
+  observer_attach_new_objfile (new_objfile);
+
+  /* Add ourselves to inferior_created event chain.
+     This is needed to enable the thread target on "attach".  */
+  observer_attach_inferior_created (aix_thread_inferior_created);

 
   add_setshow_boolean_cmd ("aix-thread", class_maintenance, &debug_aix_thread,
 
   add_setshow_boolean_cmd ("aix-thread", class_maintenance, &debug_aix_thread,

-                           _("Set debugging of AIX thread module."),
-                           _("Show debugging of AIX thread module."),
-                           _("Enables debugging output (used to debug GDB)."),
-                           NULL, NULL, /* FIXME: i18n: Debugging of AIX thread module is \"%d\".  */
-                           &setdebuglist, &showdebuglist);
+                          _("Set debugging of AIX thread module."),
+                          _("Show debugging of AIX thread module."),
+                          _("Enables debugging output (used to debug GDB)."),
+                          NULL, NULL,
+                          /* FIXME: i18n: Debugging of AIX thread
+                             module is \"%d\".  */
+                          &setdebuglist, &showdebuglist);

 }
 }