* configure.ac (AC_CHECK_FUNCS): Add check for setsid.

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

diff --git a/gdb/aix-thread.c b/gdb/aix-thread.c
index b53fa69712283e2e467431218aa211a034afdf80..c620ce3a4281572ab5c7fe6d597a19b5c845223f 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 1999, 2000, 2002 Free Software Foundation, Inc.
+   Copyright (C) 1999, 2000, 2002, 2007, 2008 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., 59 Temple Place - Suite 330,
-   Boston, MA 02111-1307, 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


@@ -48,19 +46,14 @@
 #include "inferior.h"
 #include "regcache.h"
 #include "gdbcmd.h"
 #include "inferior.h"
 #include "regcache.h"
 #include "gdbcmd.h"

-
-#if 0
-#include "coff/internal.h"     /* for libcoff.h */
-#include "bfd/libcoff.h"       /* for xcoff_data */
-#endif
+#include "ppc-tdep.h"
+#include "gdb_string.h"
+#include "observer.h"

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

-#if 0
-#include <pthread.h>
-#endif

 #include <sched.h>
 #include <sys/pthdebug.h>
 
 #include <sched.h>
 #include <sys/pthdebug.h>
 


@@ -109,13 +102,13 @@ struct pd_thread {
 
 /* This module's target-specific operations, active while pd_able is true.  */
 
 
 /* This module's target-specific operations, active while pd_able is true.  */
 

-static struct target_ops 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 child_ops or core_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.  */
 
    because they lack current_target's default callbacks.  */
 

-static struct target_ops base_ops;
+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.  */


@@ -135,10 +128,6 @@ static int pd_active = 0;
 
 static int arch64;
 
 
 static int arch64;
 

-/* Saved pointer to previous owner of 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);


@@ -239,13 +228,13 @@ ptrace_check (int req, int id, int ret)
        {
          if (debug_aix_thread)
            fprintf_unfiltered (gdb_stdlog, 
        {
          if (debug_aix_thread)
            fprintf_unfiltered (gdb_stdlog, 

-                               "ptrace (%d, %d) = %d (errno = %d)",
+                               "ptrace (%d, %d) = %d (errno = %d)\n",

                                req, id, ret, errno);
          return ret == -1 ? 0 : 1;
        }
       break;
     }
                                req, id, ret, errno);
          return ret == -1 ? 0 : 1;
        }
       break;
     }

-  error ("aix-thread: ptrace (%d, %d) returned %d (errno = %d %s)",
+  error (_("aix-thread: ptrace (%d, %d) returned %d (errno = %d %s)"),

         req, id, ret, errno, safe_strerror (errno));
   return 0;  /* Not reached.  */
 }
         req, id, ret, errno, safe_strerror (errno));
   return 0;  /* Not reached.  */
 }


@@ -266,7 +255,7 @@ ptrace32 (int req, int id, int *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, (int *) 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


@@ -294,7 +283,7 @@ pdc_symbol_addrs (pthdb_user_t user, pthdb_symbol_t *symbols, int count)
 
   if (debug_aix_thread)
     fprintf_unfiltered (gdb_stdlog,
 
   if (debug_aix_thread)
     fprintf_unfiltered (gdb_stdlog,

-      "pdc_symbol_addrs (user = %ld, symbols = 0x%lx, count = %d)",
+      "pdc_symbol_addrs (user = %ld, symbols = 0x%lx, count = %d)\n",

       user, (long) symbols, count);
 
   for (i = 0; i < count; i++)
       user, (long) symbols, count);
 
   for (i = 0; i < count; i++)


@@ -302,7 +291,7 @@ pdc_symbol_addrs (pthdb_user_t user, pthdb_symbol_t *symbols, int count)
       name = symbols[i].name;
       if (debug_aix_thread)
        fprintf_unfiltered (gdb_stdlog, 
       name = symbols[i].name;
       if (debug_aix_thread)
        fprintf_unfiltered (gdb_stdlog, 

-                           "  symbols[%d].name = \"%s\"", i, name);
+                           "  symbols[%d].name = \"%s\"\n", i, name);

 
       if (!*name)
        symbols[i].addr = 0;
 
       if (!*name)
        symbols[i].addr = 0;


@@ -311,17 +300,17 @@ pdc_symbol_addrs (pthdb_user_t user, pthdb_symbol_t *symbols, int count)
          if (!(ms = lookup_minimal_symbol (name, NULL, NULL)))
            {
              if (debug_aix_thread)
          if (!(ms = lookup_minimal_symbol (name, NULL, NULL)))
            {
              if (debug_aix_thread)

-               fprintf_unfiltered (gdb_stdlog, " returning PDC_FAILURE");
+               fprintf_unfiltered (gdb_stdlog, " returning PDC_FAILURE\n");

              return PDC_FAILURE;
            }
          symbols[i].addr = SYMBOL_VALUE_ADDRESS (ms);
        }
       if (debug_aix_thread)
              return PDC_FAILURE;
            }
          symbols[i].addr = SYMBOL_VALUE_ADDRESS (ms);
        }
       if (debug_aix_thread)

-       fprintf_unfiltered (gdb_stdlog, "  symbols[%d].addr = 0x%llx",
-                           i, symbols[i].addr);
+       fprintf_unfiltered (gdb_stdlog, "  symbols[%d].addr = %s\n",
+                           i, hex_string (symbols[i].addr));

     }
   if (debug_aix_thread)
     }
   if (debug_aix_thread)

-    fprintf_unfiltered (gdb_stdlog, " returning PDC_SUCCESS");
+    fprintf_unfiltered (gdb_stdlog, " returning PDC_SUCCESS\n");

   return PDC_SUCCESS;
 }
 
   return PDC_SUCCESS;
 }
 


@@ -343,15 +332,15 @@ pdc_read_regs (pthdb_user_t user,
    this is needed, I have implemented what I think it should do,
    however this code is untested.  */
 
    this is needed, I have implemented what I think it should do,
    however this code is untested.  */
 

-  uint64_t gprs64[32];
-  uint32_t gprs32[32];
-  double fprs[32];
+  uint64_t gprs64[ppc_num_gprs];
+  uint32_t gprs32[ppc_num_gprs];
+  double fprs[ppc_num_fprs];

   struct ptxsprs sprs64;
   struct ptsprs sprs32;
   
   if (debug_aix_thread)
   struct ptxsprs sprs64;
   struct ptsprs sprs32;
   
   if (debug_aix_thread)

-    fprintf_unfiltered (gdb_stdlog, "pdc_read_regs tid=%d flags=%llx\n",
-                        (int)tid, flags);
+    fprintf_unfiltered (gdb_stdlog, "pdc_read_regs tid=%d flags=%s\n",
+                        (int) tid, hex_string (flags));

 
   /* General-purpose registers.  */
   if (flags & PTHDB_FLAG_GPRS)
 
   /* General-purpose registers.  */
   if (flags & PTHDB_FLAG_GPRS)


@@ -416,23 +405,23 @@ pdc_write_regs (pthdb_user_t user,
      however this code is untested.  */
 
   if (debug_aix_thread)
      however this code is untested.  */
 
   if (debug_aix_thread)

-    fprintf_unfiltered (gdb_stdlog, "pdc_write_regs tid=%d flags=%llx\n",
-                        (int)tid, flags);
+    fprintf_unfiltered (gdb_stdlog, "pdc_write_regs tid=%d flags=%s\n",
+                        (int) tid, hex_string (flags));

 
   /* General-purpose registers.  */
   if (flags & PTHDB_FLAG_GPRS)
     {
       if (arch64)
        ptrace64aix (PTT_WRITE_GPRS, tid, 
 
   /* General-purpose registers.  */
   if (flags & PTHDB_FLAG_GPRS)
     {
       if (arch64)
        ptrace64aix (PTT_WRITE_GPRS, tid, 

-                    (unsigned long)context->gpr, 0, NULL);
+                    (unsigned long) context->gpr, 0, NULL);

       else
       else

-       ptrace32 (PTT_WRITE_GPRS, tid, (int *)context->gpr, 0, NULL);
+       ptrace32 (PTT_WRITE_GPRS, tid, (int *) 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, (int *) context->fpr, 0, NULL);

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


@@ -445,7 +434,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, (int *) &context->msr, 0, NULL);

        }
     }
   return 0;
        }
     }
   return 0;


@@ -461,14 +450,14 @@ pdc_read_data (pthdb_user_t user, void *buf,
 
   if (debug_aix_thread)
     fprintf_unfiltered (gdb_stdlog,
 
   if (debug_aix_thread)
     fprintf_unfiltered (gdb_stdlog,

-      "pdc_read_data (user = %ld, buf = 0x%lx, addr = 0x%llx, len = %ld)",
-      user, (long) buf, 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);
   ret = status == 0 ? PDC_SUCCESS : PDC_FAILURE;
 
   if (debug_aix_thread)
 
   status = target_read_memory (addr, buf, len);
   ret = status == 0 ? PDC_SUCCESS : PDC_FAILURE;
 
   if (debug_aix_thread)

-    fprintf_unfiltered (gdb_stdlog, "  status=%d, returning %s",
+    fprintf_unfiltered (gdb_stdlog, "  status=%d, returning %s\n",

                        status, pd_status2str (ret));
   return ret;
 }
                        status, pd_status2str (ret));
   return ret;
 }


@@ -483,14 +472,14 @@ pdc_write_data (pthdb_user_t user, void *buf,
 
   if (debug_aix_thread)
     fprintf_unfiltered (gdb_stdlog,
 
   if (debug_aix_thread)
     fprintf_unfiltered (gdb_stdlog,

-      "pdc_write_data (user = %ld, buf = 0x%lx, addr = 0x%llx, len = %ld)",
-      user, (long) buf, 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);
   ret = status == 0 ? PDC_SUCCESS : PDC_FAILURE;
 
   if (debug_aix_thread)
 
   status = target_write_memory (addr, buf, len);
   ret = status == 0 ? PDC_SUCCESS : PDC_FAILURE;
 
   if (debug_aix_thread)

-    fprintf_unfiltered (gdb_stdlog, "  status=%d, returning %s", status,
+    fprintf_unfiltered (gdb_stdlog, "  status=%d, returning %s\n", status,

                        pd_status2str (ret));
   return ret;
 }
                        pd_status2str (ret));
   return ret;
 }


@@ -503,12 +492,12 @@ pdc_alloc (pthdb_user_t user, size_t len, void **bufp)
 {
   if (debug_aix_thread)
     fprintf_unfiltered (gdb_stdlog,
 {
   if (debug_aix_thread)
     fprintf_unfiltered (gdb_stdlog,

-                        "pdc_alloc (user = %ld, len = %ld, bufp = 0x%lx)",
+                        "pdc_alloc (user = %ld, len = %ld, bufp = 0x%lx)\n",

                        user, len, (long) bufp);
   *bufp = xmalloc (len);
   if (debug_aix_thread)
     fprintf_unfiltered (gdb_stdlog, 
                        user, len, (long) bufp);
   *bufp = xmalloc (len);
   if (debug_aix_thread)
     fprintf_unfiltered (gdb_stdlog, 

-                       "  malloc returned 0x%lx", (long) *bufp);
+                       "  malloc returned 0x%lx\n", (long) *bufp);

 
   /* Note: xmalloc() can't return 0; therefore PDC_FAILURE will never
      be returned.  */
 
   /* Note: xmalloc() can't return 0; therefore PDC_FAILURE will never
      be returned.  */


@@ -525,12 +514,12 @@ pdc_realloc (pthdb_user_t user, void *buf, size_t len, void **bufp)
 {
   if (debug_aix_thread)
     fprintf_unfiltered (gdb_stdlog,
 {
   if (debug_aix_thread)
     fprintf_unfiltered (gdb_stdlog,

-      "pdc_realloc (user = %ld, buf = 0x%lx, len = %ld, bufp = 0x%lx)",
+      "pdc_realloc (user = %ld, buf = 0x%lx, len = %ld, bufp = 0x%lx)\n",

       user, (long) buf, len, (long) bufp);
   *bufp = xrealloc (buf, len);
   if (debug_aix_thread)
     fprintf_unfiltered (gdb_stdlog, 
       user, (long) buf, len, (long) bufp);
   *bufp = xrealloc (buf, len);
   if (debug_aix_thread)
     fprintf_unfiltered (gdb_stdlog, 

-                       "  realloc returned 0x%lx", (long) *bufp);
+                       "  realloc returned 0x%lx\n", (long) *bufp);

   return *bufp ? PDC_SUCCESS : PDC_FAILURE;
 }
 
   return *bufp ? PDC_SUCCESS : PDC_FAILURE;
 }
 


@@ -542,7 +531,7 @@ pdc_dealloc (pthdb_user_t user, void *buf)
 {
   if (debug_aix_thread)
     fprintf_unfiltered (gdb_stdlog, 
 {
   if (debug_aix_thread)
     fprintf_unfiltered (gdb_stdlog, 

-                       "pdc_free (user = %ld, buf = 0x%lx)", user,
+                       "pdc_free (user = %ld, buf = 0x%lx)\n", user,

                         (long) buf);
   xfree (buf);
   return PDC_SUCCESS;
                         (long) buf);
   xfree (buf);
   return PDC_SUCCESS;


@@ -555,12 +544,24 @@ state2str (pthdb_state_t state)
 {
   switch (state)
     {
 {
   switch (state)
     {

-    case PST_IDLE:     return "idle";          /* being created */
-    case PST_RUN:      return "running";       /* running */
-    case PST_SLEEP:    return "sleeping";      /* awaiting an event */
-    case PST_READY:    return "ready";         /* runnable */
-    case PST_TERM:     return "finished";      /* awaiting a join/detach */
-    default:           return "unknown";
+    case PST_IDLE:
+      /* i18n: Like "Thread-Id %d, [state] idle" */
+      return _("idle");      /* being created */
+    case PST_RUN:
+      /* i18n: Like "Thread-Id %d, [state] running" */
+      return _("running");   /* running */
+    case PST_SLEEP:
+      /* i18n: Like "Thread-Id %d, [state] sleeping" */
+      return _("sleeping");  /* awaiting an event */
+    case PST_READY:
+      /* i18n: Like "Thread-Id %d, [state] ready" */
+      return _("ready");     /* runnable */
+    case PST_TERM:
+      /* i18n: Like "Thread-Id %d, [state] finished" */
+      return _("finished");  /* awaiting a join/detach */
+    default:
+      /* i18n: Like "Thread-Id %d, [state] unknown" */
+      return _("unknown");

     }
 }
 
     }
 }
 


@@ -626,6 +627,35 @@ gcmp (const void *t1v, const void *t2v)
   return ptid_cmp (t1->ptid, t2->ptid);
 }
 
   return ptid_cmp (t1->ptid, t2->ptid);
 }
 

+/* Search through the list of all kernel threads for the thread
+   that has stopped on a SIGTRAP signal, and return its TID.
+   Return 0 if none found.  */
+
+static pthdb_tid_t
+get_signaled_thread (void)
+{
+  struct thrdsinfo64 thrinf;
+  pthdb_tid_t ktid = 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)
+  {
+    if (getthrds (PIDGET (inferior_ptid), &thrinf, 
+                 sizeof (thrinf), &ktid, 1) != 1)
+      break;
+
+    if (thrinf.ti_cursig == SIGTRAP)
+      return thrinf.ti_tid;
+  }
+
+  /* Didn't find any thread stopped on a SIGTRAP signal.  */
+  return 0;
+}
+

 /* Synchronize GDB's thread list with libpthdebug's.
 
    There are some benefits of doing this every time the inferior stops:
 /* Synchronize GDB's thread list with libpthdebug's.
 
    There are some benefits of doing this every time the inferior stops:


@@ -752,28 +782,15 @@ sync_threadlists (void)
   xfree (gbuf);
 }
 
   xfree (gbuf);
 }
 

-/* Iterate_over_threads() callback for locating a thread whose kernel
-   thread just received a trap signal.  */
+/* Iterate_over_threads() callback for locating a thread, using
+   the TID of its associated kernel thread.  */

 
 static int
 
 static int

-iter_trap (struct thread_info *thread, void *unused)
+iter_tid (struct thread_info *thread, void *tidp)

 {
 {

-  struct thrdsinfo64 thrinf;
-  pthdb_tid_t tid;
-
-  /* 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);
+  const pthdb_tid_t tid = *(pthdb_tid_t *)tidp;

 
 

-  tid = thread->private->tid;
-  if (tid == PTHDB_INVALID_TID)
-    return 0;
-
-  if (getthrds (PIDGET (inferior_ptid), &thrinf, 
-               sizeof (thrinf), &tid, 1) != 1)
-    return 0;
-
-  return thrinf.ti_cursig == SIGTRAP;
+  return (thread->private->tid == tid);

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


@@ -785,7 +802,8 @@ pd_update (int set_infpid)
 {
   int status;
   ptid_t ptid;
 {
   int status;
   ptid_t ptid;

-  struct thread_info *thread;
+  pthdb_tid_t tid;
+  struct thread_info *thread = NULL;

 
   if (!pd_active)
     return inferior_ptid;
 
   if (!pd_active)
     return inferior_ptid;


@@ -798,7 +816,9 @@ pd_update (int set_infpid)
 
   /* Define "current thread" as one that just received a trap signal.  */
 
 
   /* Define "current thread" as one that just received a trap signal.  */
 

-  thread = iterate_over_threads (iter_trap, NULL);
+  tid = get_signaled_thread ();
+  if (tid != 0)
+    thread = iterate_over_threads (iter_tid, &tid);

   if (!thread)
     ptid = inferior_ptid;
   else
   if (!thread)
     ptid = inferior_ptid;
   else


@@ -858,7 +878,7 @@ pd_enable (void)
     return;
 
   /* Check application word size.  */
     return;
 
   /* Check application word size.  */

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

 
   /* Check whether the application is pthreaded.  */
   stub_name = NULL;
 
   /* Check whether the application is pthreaded.  */
   stub_name = NULL;


@@ -876,8 +896,8 @@ pd_enable (void)
     return;
 
   /* Prepare for thread debugging.  */
     return;
 
   /* Prepare for thread debugging.  */

-  base_ops = current_target;
-  push_target (&ops);
+  base_target = current_target;
+  push_target (&aix_thread_ops);

   pd_able = 1;
 
   /* If we're debugging a core file or an attached inferior, the
   pd_able = 1;
 
   /* If we're debugging a core file or an attached inferior, the


@@ -896,10 +916,10 @@ pd_disable (void)
   if (pd_active)
     pd_deactivate ();
   pd_able = 0;
   if (pd_active)
     pd_deactivate ();
   pd_able = 0;

-  unpush_target (&ops);
+  unpush_target (&aix_thread_ops);

 }
 
 }
 

-/* 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.


@@ -913,34 +933,31 @@ 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

-ops_attach (char *args, int from_tty)
+aix_thread_attach (char *args, int from_tty)

 {
 {

-  base_ops.to_attach (args, from_tty);
+  base_target.to_attach (args, from_tty);

   pd_activate (1);
 }
 
   pd_activate (1);
 }
 

-/* Detach from the process attached to by ops_attach().  */
+/* Detach from the process attached to by aix_thread_attach().  */

 
 static void
 
 static void

-ops_detach (char *args, int from_tty)
+aix_thread_detach (char *args, int from_tty)

 {
 {

-  pd_deactivate ();
-  base_ops.to_detach (args, from_tty);
+  pd_disable ();
+  base_target.to_detach (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

-ops_resume (ptid_t ptid, int step, enum target_signal sig)
+aix_thread_resume (ptid_t ptid, int step, enum target_signal sig)

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


@@ -949,28 +966,28 @@ ops_resume (ptid_t ptid, int step, enum target_signal sig)
     {
       struct cleanup *cleanup = save_inferior_ptid ();
       inferior_ptid = pid_to_ptid (PIDGET (inferior_ptid));
     {
       struct cleanup *cleanup = save_inferior_ptid ();
       inferior_ptid = pid_to_ptid (PIDGET (inferior_ptid));

-      base_ops.to_resume (ptid, step, sig);
+      base_target.to_resume (ptid, step, sig);

       do_cleanups (cleanup);
     }
   else
     {
       thread = find_thread_pid (ptid);
       if (!thread)
       do_cleanups (cleanup);
     }
   else
     {
       thread = find_thread_pid (ptid);
       if (!thread)

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

               TIDGET (ptid));
 
       tid[0] = thread->private->tid;
       if (tid[0] == PTHDB_INVALID_TID)
               TIDGET (ptid));
 
       tid[0] = thread->private->tid;
       if (tid[0] == PTHDB_INVALID_TID)

-       error ("aix-thread resume: no tid for pthread %ld", 
+       error (_("aix-thread resume: no tid for pthread %ld"),

               TIDGET (ptid));
       tid[1] = 0;
 
       if (arch64)
        ptrace64aix (PTT_CONTINUE, tid[0], 1, 
               TIDGET (ptid));
       tid[1] = 0;
 
       if (arch64)
        ptrace64aix (PTT_CONTINUE, tid[0], 1, 

-                    target_signal_to_host (sig), (int *)tid);
+                    target_signal_to_host (sig), (int *) tid);

       else
        ptrace32 (PTT_CONTINUE, tid[0], (int *) 1,
       else
        ptrace32 (PTT_CONTINUE, tid[0], (int *) 1,

-                 target_signal_to_host (sig), (int *)tid);
+                 target_signal_to_host (sig), (int *) tid);

     }
 }
 
     }
 }
 


@@ -979,14 +996,14 @@ ops_resume (ptid_t ptid, int step, enum target_signal sig)
    thread.  */
 
 static ptid_t
    thread.  */
 
 static ptid_t

-ops_wait (ptid_t ptid, struct target_waitstatus *status)
+aix_thread_wait (ptid_t ptid, struct target_waitstatus *status)

 {
   struct cleanup *cleanup = save_inferior_ptid ();
 
   pid_to_prc (&ptid);
 
   inferior_ptid = pid_to_ptid (PIDGET (inferior_ptid));
 {
   struct cleanup *cleanup = save_inferior_ptid ();
 
   pid_to_prc (&ptid);
 
   inferior_ptid = pid_to_ptid (PIDGET (inferior_ptid));

-  ptid = base_ops.to_wait (ptid, status);
+  ptid = base_target.to_wait (ptid, status);

   do_cleanups (cleanup);
 
   if (PIDGET (ptid) == -1)
   do_cleanups (cleanup);
 
   if (PIDGET (ptid) == -1)


@@ -994,8 +1011,9 @@ ops_wait (ptid_t ptid, struct target_waitstatus *status)
 
   /* Check whether libpthdebug might be ready to be initialized.  */
   if (!pd_active && status->kind == TARGET_WAITKIND_STOPPED &&
 
   /* 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)
+      status->value.sig == TARGET_SIGNAL_TRAP
+      && read_pc_pid (ptid)
+        - gdbarch_decr_pc_after_break (current_gdbarch) == pd_brk_addr)

     return pd_activate (0);
 
   return pd_update (0);
     return pd_activate (0);
 
   return pd_update (0);


@@ -1004,65 +1022,105 @@ ops_wait (ptid_t ptid, struct target_waitstatus *status)
 /* Record that the 64-bit general-purpose registers contain VALS.  */
 
 static void
 /* Record that the 64-bit general-purpose registers contain VALS.  */
 
 static void

-supply_gprs64 (uint64_t *vals)
+supply_gprs64 (struct regcache *regcache, uint64_t *vals)

 {
 {

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

   int regno;
 
   int regno;
 

-  for (regno = 0; regno < 32; regno++)
-    supply_register (regno, (char *) (vals + regno));
+  for (regno = 0; regno < ppc_num_gprs; regno++)
+    regcache_raw_supply (regcache, tdep->ppc_gp0_regnum + regno,
+                        (char *) (vals + regno));

 }
 
 /* Record that 32-bit register REGNO contains VAL.  */
 
 static void
 }
 
 /* Record that 32-bit register REGNO contains VAL.  */
 
 static void

-supply_reg32 (int regno, uint32_t val)
+supply_reg32 (struct regcache *regcache, int regno, uint32_t val)

 {
 {

-  supply_register (regno, (char *) &val);
+  regcache_raw_supply (regcache, regno, (char *) &val);

 }
 
 /* Record that the floating-point registers contain VALS.  */
 
 static void
 }
 
 /* Record that the floating-point registers contain VALS.  */
 
 static void

-supply_fprs (double *vals)
+supply_fprs (struct regcache *regcache, double *vals)

 {
 {

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

   int regno;
 
   int regno;
 

-  for (regno = 0; regno < 32; regno++)
-    supply_register (regno + FP0_REGNUM, (char *) (vals + regno));
+  /* This function should never be called on architectures without
+     floating-point registers.  */
+  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));

 }
 
 }
 

+/* Predicate to test whether given register number is a "special" register.  */
+static int
+special_register_p (struct gdbarch *gdbarch, int regno)
+{
+  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
+
+  return regno == gdbarch_pc_regnum (gdbarch)
+      || regno == tdep->ppc_ps_regnum
+      || regno == tdep->ppc_cr_regnum
+      || regno == tdep->ppc_lr_regnum
+      || regno == tdep->ppc_ctr_regnum
+      || regno == tdep->ppc_xer_regnum
+      || (tdep->ppc_fpscr_regnum >= 0 && regno == tdep->ppc_fpscr_regnum)
+      || (tdep->ppc_mq_regnum >= 0 && regno == tdep->ppc_mq_regnum);
+}
+
+

 /* Record that the special registers contain the specified 64-bit and
    32-bit values.  */
 
 static void
 /* Record that the special registers contain the specified 64-bit and
    32-bit values.  */
 
 static void

-supply_sprs64 (uint64_t iar, uint64_t msr, uint32_t cr,
-              uint64_t lr, uint64_t ctr, uint32_t xer)
+supply_sprs64 (struct regcache *regcache,
+              uint64_t iar, uint64_t msr, uint32_t cr,
+              uint64_t lr, uint64_t ctr, uint32_t xer,
+              uint32_t fpscr)

 {
 {

-  int regno = FIRST_UISA_SP_REGNUM;
-
-  supply_register (regno,     (char *) &iar);
-  supply_register (regno + 1, (char *) &msr);
-  supply_register (regno + 2, (char *) &cr);
-  supply_register (regno + 3, (char *) &lr);
-  supply_register (regno + 4, (char *) &ctr);
-  supply_register (regno + 5, (char *) &xer);
+  struct gdbarch *gdbarch = get_regcache_arch (regcache);
+  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
+
+  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_ctr_regnum, (char *) &ctr);
+  regcache_raw_supply (regcache, tdep->ppc_xer_regnum, (char *) &xer);
+  if (tdep->ppc_fpscr_regnum >= 0)
+    regcache_raw_supply (regcache, tdep->ppc_fpscr_regnum,
+                        (char *) &fpscr);

 }
 
 /* Record that the special registers contain the specified 32-bit
    values.  */
 
 static void
 }
 
 /* Record that the special registers contain the specified 32-bit
    values.  */
 
 static void

-supply_sprs32 (uint32_t iar, uint32_t msr, uint32_t cr,
-              uint32_t lr, uint32_t ctr, uint32_t xer)
+supply_sprs32 (struct regcache *regcache,
+              uint32_t iar, uint32_t msr, uint32_t cr,
+              uint32_t lr, uint32_t ctr, uint32_t xer,
+              uint32_t fpscr)

 {
 {

-  int regno = FIRST_UISA_SP_REGNUM;
-
-  supply_register (regno,     (char *) &iar);
-  supply_register (regno + 1, (char *) &msr);
-  supply_register (regno + 2, (char *) &cr);
-  supply_register (regno + 3, (char *) &lr);
-  supply_register (regno + 4, (char *) &ctr);
-  supply_register (regno + 5, (char *) &xer);
+  struct gdbarch *gdbarch = get_regcache_arch (regcache);
+  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
+
+  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_ctr_regnum, (char *) &ctr);
+  regcache_raw_supply (regcache, tdep->ppc_xer_regnum, (char *) &xer);
+  if (tdep->ppc_fpscr_regnum >= 0)
+    regcache_raw_supply (regcache, tdep->ppc_fpscr_regnum,
+                        (char *) &fpscr);

 }
 
 /* Fetch all registers from pthread PDTID, which doesn't have a kernel
 }
 
 /* Fetch all registers from pthread PDTID, which doesn't have a kernel


@@ -1073,36 +1131,42 @@ supply_sprs32 (uint32_t iar, uint32_t msr, uint32_t cr,
    function.  */
 
 static void
    function.  */
 
 static void

-fetch_regs_lib (pthdb_pthread_t pdtid)
+fetch_regs_user_thread (struct regcache *regcache, pthdb_pthread_t pdtid)

 {
 {

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

   int status, i;
   pthdb_context_t ctx;
 
   if (debug_aix_thread)
   int status, i;
   pthdb_context_t ctx;
 
   if (debug_aix_thread)

-    fprintf_unfiltered (gdb_stdlog, "fetch_regs_lib %lx\n", (long)pdtid);
+    fprintf_unfiltered (gdb_stdlog, 
+                       "fetch_regs_user_thread %lx\n", (long) pdtid);

   status = pthdb_pthread_context (pd_session, pdtid, &ctx);
   if (status != PTHDB_SUCCESS)
   status = pthdb_pthread_context (pd_session, pdtid, &ctx);
   if (status != PTHDB_SUCCESS)

-    error ("aix-thread: fetch_registers: pthdb_pthread_context returned %s",
+    error (_("aix-thread: fetch_registers: pthdb_pthread_context returned %s"),

            pd_status2str (status));
 
   /* General-purpose registers.  */
 
   if (arch64)
            pd_status2str (status));
 
   /* General-purpose registers.  */
 
   if (arch64)

-    supply_gprs64 (ctx.gpr);
+    supply_gprs64 (regcache, ctx.gpr);

   else
   else

-    for (i = 0; i < 32; i++)
-      supply_reg32 (i, ctx.gpr[i]);
+    for (i = 0; i < ppc_num_gprs; i++)
+      supply_reg32 (regcache, tdep->ppc_gp0_regnum + i, ctx.gpr[i]);

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

-  supply_fprs (ctx.fpr);
+  if (ppc_floating_point_unit_p (gdbarch))
+    supply_fprs (regcache, ctx.fpr);

 
   /* Special registers.  */
 
   if (arch64)
 
   /* Special registers.  */
 
   if (arch64)

-    supply_sprs64 (ctx.iar, ctx.msr, ctx.cr, ctx.lr, ctx.ctr, ctx.xer);
+    supply_sprs64 (regcache, ctx.iar, ctx.msr, ctx.cr, ctx.lr, ctx.ctr,
+                            ctx.xer, ctx.fpscr);

   else
   else

-    supply_sprs32 (ctx.iar, ctx.msr, ctx.cr, ctx.lr, ctx.ctr, ctx.xer);
+    supply_sprs32 (regcache, ctx.iar, ctx.msr, ctx.cr, ctx.lr, ctx.ctr,
+                            ctx.xer, ctx.fpscr);

 }
 
 /* Fetch register REGNO if != -1 or all registers otherwise from
 }
 
 /* Fetch register REGNO if != -1 or all registers otherwise from


@@ -1121,70 +1185,82 @@ fetch_regs_lib (pthdb_pthread_t pdtid)
    be retrieved.  */
 
 static void
    be retrieved.  */
 
 static void

-fetch_regs_kern (int regno, pthdb_tid_t tid)
+fetch_regs_kernel_thread (struct regcache *regcache, int regno,
+                         pthdb_tid_t tid)

 {
 {

-  uint64_t gprs64[32];
-  uint32_t gprs32[32];
-  double fprs[32];
+  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];

   struct ptxsprs sprs64;
   struct ptsprs sprs32;
   int i;
 
   if (debug_aix_thread)
     fprintf_unfiltered (gdb_stdlog,
   struct ptxsprs sprs64;
   struct ptsprs sprs32;
   int i;
 
   if (debug_aix_thread)
     fprintf_unfiltered (gdb_stdlog,

-                       "fetch_regs_kern tid=%lx regno=%d arch64=%d\n",
-                       (long)tid, regno, arch64);
+       "fetch_regs_kernel_thread tid=%lx regno=%d arch64=%d\n",
+       (long) tid, regno, arch64);

 
   /* General-purpose registers.  */
 
   /* General-purpose registers.  */

-  if (regno == -1 || regno < FP0_REGNUM)
+  if (regno == -1
+      || (tdep->ppc_gp0_regnum <= regno
+          && regno < tdep->ppc_gp0_regnum + ppc_num_gprs))

     {
       if (arch64)
        {
          if (!ptrace64aix (PTT_READ_GPRS, tid, 
                            (unsigned long) gprs64, 0, NULL))
            memset (gprs64, 0, sizeof (gprs64));
     {
       if (arch64)
        {
          if (!ptrace64aix (PTT_READ_GPRS, tid, 
                            (unsigned long) gprs64, 0, NULL))
            memset (gprs64, 0, sizeof (gprs64));

-         supply_gprs64 (gprs64);
+         supply_gprs64 (regcache, gprs64);

        }
       else
        {
          if (!ptrace32 (PTT_READ_GPRS, tid, gprs32, 0, NULL))
            memset (gprs32, 0, sizeof (gprs32));
        }
       else
        {
          if (!ptrace32 (PTT_READ_GPRS, tid, gprs32, 0, NULL))
            memset (gprs32, 0, sizeof (gprs32));

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

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

-  if (regno == -1 || (regno >= FP0_REGNUM && regno <= FPLAST_REGNUM))
+  if (ppc_floating_point_unit_p (gdbarch)
+      && (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))
        memset (fprs, 0, sizeof (fprs));
     {
       if (!ptrace32 (PTT_READ_FPRS, tid, (int *) fprs, 0, NULL))
        memset (fprs, 0, sizeof (fprs));

-      supply_fprs (fprs);
+      supply_fprs (regcache, fprs);

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

-  if (regno == -1 || 
-      (regno > FPLAST_REGNUM && regno <= LAST_UISA_SP_REGNUM))
+  if (regno == -1 || special_register_p (gdbarch, regno))

     {
       if (arch64)
        {
          if (!ptrace64aix (PTT_READ_SPRS, tid, 
                            (unsigned long) &sprs64, 0, NULL))
            memset (&sprs64, 0, sizeof (sprs64));
     {
       if (arch64)
        {
          if (!ptrace64aix (PTT_READ_SPRS, tid, 
                            (unsigned long) &sprs64, 0, NULL))
            memset (&sprs64, 0, sizeof (sprs64));

-         supply_sprs64 (sprs64.pt_iar, sprs64.pt_msr, sprs64.pt_cr,
-                        sprs64.pt_lr, sprs64.pt_ctr, sprs64.pt_xer);
+         supply_sprs64 (regcache, sprs64.pt_iar, sprs64.pt_msr,
+                        sprs64.pt_cr, sprs64.pt_lr, sprs64.pt_ctr,
+                        sprs64.pt_xer, sprs64.pt_fpscr);

        }
       else
        {
        }
       else
        {

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

          if (!ptrace32 (PTT_READ_SPRS, tid, (int *) &sprs32, 0, NULL))
            memset (&sprs32, 0, sizeof (sprs32));
          if (!ptrace32 (PTT_READ_SPRS, tid, (int *) &sprs32, 0, NULL))
            memset (&sprs32, 0, sizeof (sprs32));

-         supply_sprs32 (sprs32.pt_iar, sprs32.pt_msr, sprs32.pt_cr,
-                        sprs32.pt_lr, sprs32.pt_ctr, sprs32.pt_xer);
+         supply_sprs32 (regcache, sprs32.pt_iar, sprs32.pt_msr, sprs32.pt_cr,
+                        sprs32.pt_lr, sprs32.pt_ctr, sprs32.pt_xer,
+                        sprs32.pt_fpscr);

 
 

-         if (REGISTER_RAW_SIZE (LAST_UISA_SP_REGNUM))
-           supply_register (LAST_UISA_SP_REGNUM, (char *) &sprs32.pt_mq);
+         if (tdep->ppc_mq_regnum >= 0)
+           regcache_raw_supply (regcache, tdep->ppc_mq_regnum,
+                                (char *) &sprs32.pt_mq);

        }
     }
 }
        }
     }
 }


@@ -1193,107 +1269,139 @@ fetch_regs_kern (int regno, pthdb_tid_t tid)
    thread/process specified by inferior_ptid.  */
 
 static void
    thread/process specified by inferior_ptid.  */
 
 static void

-ops_fetch_registers (int regno)
+aix_thread_fetch_registers (struct regcache *regcache, int regno)

 {
   struct thread_info *thread;
   pthdb_tid_t tid;
 
   if (!PD_TID (inferior_ptid))
 {
   struct thread_info *thread;
   pthdb_tid_t tid;
 
   if (!PD_TID (inferior_ptid))

-    base_ops.to_fetch_registers (regno);
+    base_target.to_fetch_registers (regcache, regno);

   else
     {
       thread = find_thread_pid (inferior_ptid);
       tid = thread->private->tid;
 
       if (tid == PTHDB_INVALID_TID)
   else
     {
       thread = find_thread_pid (inferior_ptid);
       tid = thread->private->tid;
 
       if (tid == PTHDB_INVALID_TID)

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

       else
       else

-       fetch_regs_kern (regno, tid);
+       fetch_regs_kernel_thread (regcache, regno, tid);

     }
 }
 
 /* Store the gp registers into an array of uint32_t or uint64_t.  */
 
 static void
     }
 }
 
 /* Store the gp registers into an array of uint32_t or uint64_t.  */
 
 static void

-fill_gprs64 (uint64_t *vals)
+fill_gprs64 (const struct regcache *regcache, uint64_t *vals)

 {
 {

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

   int regno;
 
   int regno;
 

-  for (regno = 0; regno < FP0_REGNUM; regno++)
-    if (register_cached (regno))
-      regcache_collect (regno, vals + regno);
+  for (regno = 0; regno < ppc_num_gprs; regno++)
+    if (regcache_valid_p (regcache, tdep->ppc_gp0_regnum + regno))
+      regcache_raw_collect (regcache, tdep->ppc_gp0_regnum + regno,
+                           vals + regno);

 }
 
 static void 
 }
 
 static void 

-fill_gprs32 (uint32_t *vals)
+fill_gprs32 (const struct regcache *regcache, uint32_t *vals)

 {
 {

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

   int regno;
 
   int regno;
 

-  for (regno = 0; regno < FP0_REGNUM; regno++)
-    if (register_cached (regno))
-      regcache_collect (regno, vals + regno);
+  for (regno = 0; regno < ppc_num_gprs; regno++)
+    if (regcache_valid_p (regcache, tdep->ppc_gp0_regnum + regno))
+      regcache_raw_collect (regcache, tdep->ppc_gp0_regnum + regno,
+                           vals + regno);

 }
 
 /* Store the floating point registers into a double array.  */
 static void
 }
 
 /* Store the floating point registers into a double array.  */
 static void

-fill_fprs (double *vals)
+fill_fprs (const struct regcache *regcache, double *vals)

 {
 {

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

   int regno;
 
   int regno;
 

-  for (regno = FP0_REGNUM; regno < FPLAST_REGNUM; regno++)
-    if (register_cached (regno))
-      regcache_collect (regno, vals + regno);
+  /* This function should never be called on architectures without
+     floating-point registers.  */
+  gdb_assert (ppc_floating_point_unit_p (gdbarch));
+
+  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);

 }
 
 /* Store the special registers into the specified 64-bit and 32-bit
    locations.  */
 
 static void
 }
 
 /* Store the special registers into the specified 64-bit and 32-bit
    locations.  */
 
 static void

-fill_sprs64 (uint64_t *iar, uint64_t *msr, uint32_t *cr,
-            uint64_t *lr, uint64_t *ctr, uint32_t *xer)
+fill_sprs64 (const struct regcache *regcache,
+            uint64_t *iar, uint64_t *msr, uint32_t *cr,
+            uint64_t *lr, uint64_t *ctr, uint32_t *xer,
+            uint32_t *fpscr)

 {
 {

-  int regno = FIRST_UISA_SP_REGNUM;
-
-  gdb_assert (sizeof (*iar) == REGISTER_RAW_SIZE (regno));
-
-  if (register_cached (regno))
-    regcache_collect (regno,     iar);
-  if (register_cached (regno + 1))
-    regcache_collect (regno + 1, msr);
-  if (register_cached (regno + 2))
-    regcache_collect (regno + 2, cr);
-  if (register_cached (regno + 3))
-    regcache_collect (regno + 3, lr);
-  if (register_cached (regno + 4))
-    regcache_collect (regno + 4, ctr);
-  if (register_cached (regno + 5))
-    regcache_collect (regno + 5, xer);
+  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.   */
+  gdb_assert (sizeof (*iar) == register_size
+                                (gdbarch, gdbarch_pc_regnum (gdbarch)));
+
+  if (regcache_valid_p (regcache, gdbarch_pc_regnum (gdbarch)))
+    regcache_raw_collect (regcache, gdbarch_pc_regnum (gdbarch), iar);
+  if (regcache_valid_p (regcache, tdep->ppc_ps_regnum))
+    regcache_raw_collect (regcache, tdep->ppc_ps_regnum, msr);
+  if (regcache_valid_p (regcache, tdep->ppc_cr_regnum))
+    regcache_raw_collect (regcache, tdep->ppc_cr_regnum, cr);
+  if (regcache_valid_p (regcache, tdep->ppc_lr_regnum))
+    regcache_raw_collect (regcache, tdep->ppc_lr_regnum, lr);
+  if (regcache_valid_p (regcache, tdep->ppc_ctr_regnum))
+    regcache_raw_collect (regcache, tdep->ppc_ctr_regnum, ctr);
+  if (regcache_valid_p (regcache, tdep->ppc_xer_regnum))
+    regcache_raw_collect (regcache, tdep->ppc_xer_regnum, xer);
+  if (tdep->ppc_fpscr_regnum >= 0
+      && regcache_valid_p (regcache, tdep->ppc_fpscr_regnum))
+    regcache_raw_collect (regcache, tdep->ppc_fpscr_regnum, fpscr);

 }
 
 static void
 }
 
 static void

-fill_sprs32 (unsigned long *iar, unsigned long *msr, unsigned long *cr,
-            unsigned long *lr,  unsigned long *ctr, unsigned long *xer)
+fill_sprs32 (const struct regcache *regcache,
+            uint32_t *iar, uint32_t *msr, uint32_t *cr,
+            uint32_t *lr, uint32_t *ctr, uint32_t *xer,
+            uint32_t *fpscr)

 {
 {

-  int regno = FIRST_UISA_SP_REGNUM;
-
-  /* If this assert() fails, the most likely reason is that GDB was
-     built incorrectly.  In order to make use of many of the header
-     files in /usr/include/sys, GDB needs to be configured so that
-     sizeof (long) == 4).  */
-  gdb_assert (sizeof (*iar) == REGISTER_RAW_SIZE (regno));
-
-  if (register_cached (regno))
-    regcache_collect (regno,     iar);
-  if (register_cached (regno + 1))
-    regcache_collect (regno + 1, msr);
-  if (register_cached (regno + 2))
-    regcache_collect (regno + 2, cr);
-  if (register_cached (regno + 3))
-    regcache_collect (regno + 3, lr);
-  if (register_cached (regno + 4))
-    regcache_collect (regno + 4, ctr);
-  if (register_cached (regno + 5))
-    regcache_collect (regno + 5, xer);
+  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.  */
+  gdb_assert (sizeof (*iar) == register_size (gdbarch,
+                                             gdbarch_pc_regnum (gdbarch)));
+
+  if (regcache_valid_p (regcache, gdbarch_pc_regnum (gdbarch)))
+    regcache_raw_collect (regcache, gdbarch_pc_regnum (gdbarch), iar);
+  if (regcache_valid_p (regcache, tdep->ppc_ps_regnum))
+    regcache_raw_collect (regcache, tdep->ppc_ps_regnum, msr);
+  if (regcache_valid_p (regcache, tdep->ppc_cr_regnum))
+    regcache_raw_collect (regcache, tdep->ppc_cr_regnum, cr);
+  if (regcache_valid_p (regcache, tdep->ppc_lr_regnum))
+    regcache_raw_collect (regcache, tdep->ppc_lr_regnum, lr);
+  if (regcache_valid_p (regcache, tdep->ppc_ctr_regnum))
+    regcache_raw_collect (regcache, tdep->ppc_ctr_regnum, ctr);
+  if (regcache_valid_p (regcache, tdep->ppc_xer_regnum))
+    regcache_raw_collect (regcache, tdep->ppc_xer_regnum, xer);
+  if (tdep->ppc_fpscr_regnum >= 0
+      && regcache_valid_p (regcache, tdep->ppc_fpscr_regnum))
+    regcache_raw_collect (regcache, tdep->ppc_fpscr_regnum, fpscr);

 }
 
 /* Store all registers into pthread PDTID, which doesn't have a kernel
 }
 
 /* Store all registers into pthread PDTID, which doesn't have a kernel


@@ -1303,8 +1411,10 @@ fill_sprs32 (unsigned long *iar, unsigned long *msr, unsigned long *cr,
    but I doubt it's worth the effort.  */
 
 static void
    but I doubt it's worth the effort.  */
 
 static void

-store_regs_lib (pthdb_pthread_t pdtid)
+store_regs_user_thread (const struct regcache *regcache, pthdb_pthread_t pdtid)

 {
 {

+  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;


@@ -1313,66 +1423,72 @@ store_regs_lib (pthdb_pthread_t pdtid)
 
   if (debug_aix_thread)
     fprintf_unfiltered (gdb_stdlog, 
 
   if (debug_aix_thread)
     fprintf_unfiltered (gdb_stdlog, 

-                       "store_regs_lib %lx\n", (long)pdtid);
+                       "store_regs_user_thread %lx\n", (long) pdtid);

 
   /* Retrieve the thread's current context for its non-register
      values.  */
   status = pthdb_pthread_context (pd_session, pdtid, &ctx);
   if (status != PTHDB_SUCCESS)
 
   /* Retrieve the thread's current context for its non-register
      values.  */
   status = pthdb_pthread_context (pd_session, pdtid, &ctx);
   if (status != PTHDB_SUCCESS)

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

            pd_status2str (status));
 
   /* Collect general-purpose register values from the regcache.  */
 
            pd_status2str (status));
 
   /* Collect general-purpose register values from the regcache.  */
 

-  for (i = 0; i < 32; i++)
-    if (register_cached (i))
+  for (i = 0; i < ppc_num_gprs; i++)
+    if (regcache_valid_p (regcache, tdep->ppc_gp0_regnum + i))

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

-           regcache_collect (i, (void *) &int64);
+           regcache_raw_collect (regcache, tdep->ppc_gp0_regnum + i,
+                                 (void *) &int64);

            ctx.gpr[i] = int64;
          }
        else
          {
            ctx.gpr[i] = int64;
          }
        else
          {

-           regcache_collect (i, (void *) &int32);
+           regcache_raw_collect (regcache, tdep->ppc_gp0_regnum + i,
+                                 (void *) &int32);

            ctx.gpr[i] = int32;
          }
       }
 
   /* Collect floating-point register values from the regcache.  */
            ctx.gpr[i] = int32;
          }
       }
 
   /* Collect floating-point register values from the regcache.  */

-  fill_fprs (ctx.fpr);
+  if (ppc_floating_point_unit_p (gdbarch))
+    fill_fprs (regcache, ctx.fpr);

 
   /* Special registers (always kept in ctx as 64 bits).  */
   if (arch64)
     {
 
   /* Special registers (always kept in ctx as 64 bits).  */
   if (arch64)
     {

-      fill_sprs64 (&ctx.iar, &ctx.msr, &ctx.cr, &ctx.lr, &ctx.ctr, &ctx.xer);
+      fill_sprs64 (regcache, &ctx.iar, &ctx.msr, &ctx.cr, &ctx.lr, &ctx.ctr,
+                            &ctx.xer, &ctx.fpscr);

     }
   else
     {
       /* Problem: ctx.iar etc. are 64 bits, but raw_registers are 32.
     }
   else
     {
       /* Problem: ctx.iar etc. are 64 bits, but raw_registers are 32.

-        Solution: use 32-bit temp variables.  (The assert() in fill_sprs32()
-        will fail if the size of an unsigned long is incorrect.  If this
-        happens, GDB needs to be reconfigured so that longs are 32-bits.)  */
-      unsigned long tmp_iar, tmp_msr, tmp_cr, tmp_lr, tmp_ctr, tmp_xer;
+        Solution: use 32-bit temp variables.  */
+      uint32_t tmp_iar, tmp_msr, tmp_cr, tmp_lr, tmp_ctr, tmp_xer,
+              tmp_fpscr;

 
 

-      fill_sprs32 (&tmp_iar, &tmp_msr, &tmp_cr, &tmp_lr, &tmp_ctr, &tmp_xer);
-      if (register_cached (FIRST_UISA_SP_REGNUM))
+      fill_sprs32 (regcache, &tmp_iar, &tmp_msr, &tmp_cr, &tmp_lr, &tmp_ctr,
+                            &tmp_xer, &tmp_fpscr);
+      if (regcache_valid_p (regcache, gdbarch_pc_regnum (gdbarch)))

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

-      if (register_cached (FIRST_UISA_SP_REGNUM + 1))
+      if (regcache_valid_p (regcache, tdep->ppc_ps_regnum))

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

-      if (register_cached (FIRST_UISA_SP_REGNUM + 2))
+      if (regcache_valid_p (regcache, tdep->ppc_cr_regnum))

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

-      if (register_cached (FIRST_UISA_SP_REGNUM + 3))
+      if (regcache_valid_p (regcache, tdep->ppc_lr_regnum))

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

-      if (register_cached (FIRST_UISA_SP_REGNUM + 4))
+      if (regcache_valid_p (regcache, tdep->ppc_ctr_regnum))

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

-      if (register_cached (FIRST_UISA_SP_REGNUM + 5))
+      if (regcache_valid_p (regcache, tdep->ppc_xer_regnum))

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

+      if (regcache_valid_p (regcache, tdep->ppc_xer_regnum))
+       ctx.fpscr = tmp_fpscr;

     }
 
   status = pthdb_pthread_setcontext (pd_session, pdtid, &ctx);
   if (status != PTHDB_SUCCESS)
     }
 
   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));
 }
 


@@ -1385,74 +1501,103 @@ store_regs_lib (pthdb_pthread_t pdtid)
    group.  */
 
 static void
    group.  */
 
 static void

-store_regs_kern (int regno, pthdb_tid_t tid)
+store_regs_kernel_thread (const struct regcache *regcache, int regno,
+                         pthdb_tid_t tid)

 {
 {

-  uint64_t gprs64[32];
-  uint32_t gprs32[32];
-  double fprs[32];
+  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];

   struct ptxsprs sprs64;
   struct ptsprs  sprs32;
   int i;
 
   if (debug_aix_thread)
   struct ptxsprs sprs64;
   struct ptsprs  sprs32;
   int i;
 
   if (debug_aix_thread)

-    fprintf_unfiltered (gdb_stdlog, "store_regs_kern tid=%lx regno=%d\n",
-                        (long)tid, regno);
+    fprintf_unfiltered (gdb_stdlog, 
+                       "store_regs_kernel_thread tid=%lx regno=%d\n",
+                        (long) tid, regno);

 
   /* General-purpose registers.  */
 
   /* General-purpose registers.  */

-  if (regno == -1 || regno < FP0_REGNUM)
+  if (regno == -1
+      || (tdep->ppc_gp0_regnum <= regno
+          && regno < tdep->ppc_gp0_regnum + ppc_num_fprs))

     {
       if (arch64)
        {
          /* Pre-fetch: some regs may not be in the cache.  */
          ptrace64aix (PTT_READ_GPRS, tid, (unsigned long) gprs64, 0, NULL);
     {
       if (arch64)
        {
          /* Pre-fetch: some regs may not be in the cache.  */
          ptrace64aix (PTT_READ_GPRS, tid, (unsigned long) gprs64, 0, NULL);

-         fill_gprs64 (gprs64);
+         fill_gprs64 (regcache, gprs64);

          ptrace64aix (PTT_WRITE_GPRS, tid, (unsigned long) gprs64, 0, NULL);
        }
       else
        {
          /* Pre-fetch: some regs may not be in the cache.  */
          ptrace32 (PTT_READ_GPRS, tid, gprs32, 0, NULL);
          ptrace64aix (PTT_WRITE_GPRS, tid, (unsigned long) gprs64, 0, NULL);
        }
       else
        {
          /* Pre-fetch: some regs may not be in the cache.  */
          ptrace32 (PTT_READ_GPRS, tid, gprs32, 0, NULL);

-         fill_gprs32 (gprs32);
+         fill_gprs32 (regcache, gprs32);

          ptrace32 (PTT_WRITE_GPRS, tid, gprs32, 0, NULL);
        }
     }
 
   /* Floating-point registers.  */
 
          ptrace32 (PTT_WRITE_GPRS, tid, gprs32, 0, NULL);
        }
     }
 
   /* Floating-point registers.  */
 

-  if (regno == -1 || (regno >= FP0_REGNUM && regno <= FPLAST_REGNUM))
+  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.  */
       ptrace32 (PTT_READ_FPRS, tid, (int *) fprs, 0, NULL);
     {
       /* Pre-fetch: some regs may not be in the cache.  */
       ptrace32 (PTT_READ_FPRS, tid, (int *) fprs, 0, NULL);

-      fill_fprs (fprs);
+      fill_fprs (regcache, fprs);

       ptrace32 (PTT_WRITE_FPRS, tid, (int *) fprs, 0, NULL);
     }
 
   /* Special-purpose registers.  */
 
       ptrace32 (PTT_WRITE_FPRS, tid, (int *) fprs, 0, NULL);
     }
 
   /* Special-purpose registers.  */
 

-  if (regno == -1 || 
-      (regno > FPLAST_REGNUM && regno <= LAST_UISA_SP_REGNUM))
+  if (regno == -1 || special_register_p (gdbarch, regno))

     {
       if (arch64)
        {
          /* Pre-fetch: some registers won't be in the cache.  */
          ptrace64aix (PTT_READ_SPRS, tid, 
                       (unsigned long) &sprs64, 0, NULL);
     {
       if (arch64)
        {
          /* Pre-fetch: some registers won't be in the cache.  */
          ptrace64aix (PTT_READ_SPRS, tid, 
                       (unsigned long) &sprs64, 0, NULL);

-         fill_sprs64 (&sprs64.pt_iar, &sprs64.pt_msr, &sprs64.pt_cr,
-                      &sprs64.pt_lr,  &sprs64.pt_ctr, &sprs64.pt_xer);
+         fill_sprs64 (regcache, &sprs64.pt_iar, &sprs64.pt_msr,
+                      &sprs64.pt_cr, &sprs64.pt_lr, &sprs64.pt_ctr,
+                      &sprs64.pt_xer, &sprs64.pt_fpscr);

          ptrace64aix (PTT_WRITE_SPRS, tid, 
                       (unsigned long) &sprs64, 0, NULL);
        }
       else
        {
          ptrace64aix (PTT_WRITE_SPRS, tid, 
                       (unsigned long) &sprs64, 0, NULL);
        }
       else
        {

+         /* The contents of "struct ptspr" were declared as "unsigned
+            long" up to AIX 5.2, but are "unsigned int" since 5.3.
+            Use temporaries to work around this problem.  Also, add an
+            assert here to make sure we fail if the system header files
+            use "unsigned long", and the size of that type is not what
+            the headers expect.  */
+         uint32_t tmp_iar, tmp_msr, tmp_cr, tmp_lr, tmp_ctr, tmp_xer,
+                  tmp_fpscr;
+
+         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);
 
          /* Pre-fetch: some registers won't be in the cache.  */
          ptrace32 (PTT_READ_SPRS, tid, (int *) &sprs32, 0, NULL);
 

-         fill_sprs32 (&sprs32.pt_iar, &sprs32.pt_msr, &sprs32.pt_cr,
-                      &sprs32.pt_lr,  &sprs32.pt_ctr, &sprs32.pt_xer);
+         fill_sprs32 (regcache, &tmp_iar, &tmp_msr, &tmp_cr, &tmp_lr,
+                      &tmp_ctr, &tmp_xer, &tmp_fpscr);
+
+         sprs32.pt_iar = tmp_iar;
+         sprs32.pt_msr = tmp_msr;
+         sprs32.pt_cr = tmp_cr;
+         sprs32.pt_lr = tmp_lr;
+         sprs32.pt_ctr = tmp_ctr;
+         sprs32.pt_xer = tmp_xer;
+         sprs32.pt_fpscr = tmp_fpscr;

 
 

-         if (REGISTER_RAW_SIZE (LAST_UISA_SP_REGNUM))
-           if (register_cached (LAST_UISA_SP_REGNUM))
-             regcache_collect (LAST_UISA_SP_REGNUM, &sprs32.pt_mq);
+         if (tdep->ppc_mq_regnum >= 0)
+           if (regcache_valid_p (regcache, tdep->ppc_mq_regnum))
+             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, (int *) &sprs32, 0, NULL);
        }


@@ -1463,72 +1608,73 @@ store_regs_kern (int regno, pthdb_tid_t tid)
    thread/process specified by inferior_ptid.  */
 
 static void
    thread/process specified by inferior_ptid.  */
 
 static void

-ops_store_registers (int regno)
+aix_thread_store_registers (struct regcache *regcache, int regno)

 {
   struct thread_info *thread;
   pthdb_tid_t tid;
 
   if (!PD_TID (inferior_ptid))
 {
   struct thread_info *thread;
   pthdb_tid_t tid;
 
   if (!PD_TID (inferior_ptid))

-    base_ops.to_store_registers (regno);
+    base_target.to_store_registers (regcache, regno);

   else
     {
       thread = find_thread_pid (inferior_ptid);
       tid = thread->private->tid;
 
       if (tid == PTHDB_INVALID_TID)
   else
     {
       thread = find_thread_pid (inferior_ptid);
       tid = thread->private->tid;
 
       if (tid == PTHDB_INVALID_TID)

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

       else
       else

-       store_regs_kern (regno, tid);
+       store_regs_kernel_thread (regcache, regno, tid);

     }
 }
 
     }
 }
 

-/* Transfer LEN bytes of memory from GDB address MYADDR to target
-   address MEMADDR if WRITE and vice versa otherwise.  */
+/* 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.  */

 
 

-static int
-ops_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
-                 struct mem_attrib *attrib,
-                struct target_ops *target)
+static LONGEST
+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)

 {
 {

-  int n;
-  struct cleanup *cleanup = save_inferior_ptid ();
+  struct cleanup *old_chain = save_inferior_ptid ();
+  LONGEST xfer;

 
   inferior_ptid = pid_to_ptid (PIDGET (inferior_ptid));
 
   inferior_ptid = pid_to_ptid (PIDGET (inferior_ptid));

-  n = base_ops.to_xfer_memory (memaddr, myaddr, len, 
-                              write, attrib, &base_ops);
-  do_cleanups (cleanup);
+  xfer = base_target.to_xfer_partial (ops, object, annex,
+                                     readbuf, writebuf, offset, len);

 
 

-  return n;
+  do_cleanups (old_chain);
+  return xfer;

 }
 
 /* Kill and forget about the inferior process.  */
 
 static void
 }
 
 /* Kill and forget about the inferior process.  */
 
 static void

-ops_kill (void)
+aix_thread_kill (void)

 {
   struct cleanup *cleanup = save_inferior_ptid ();
 
   inferior_ptid = pid_to_ptid (PIDGET (inferior_ptid));
 {
   struct cleanup *cleanup = save_inferior_ptid ();
 
   inferior_ptid = pid_to_ptid (PIDGET (inferior_ptid));

-  base_ops.to_kill ();
+  base_target.to_kill ();

   do_cleanups (cleanup);
 }
 
 /* Clean up after the inferior exits.  */
 
 static void
   do_cleanups (cleanup);
 }
 
 /* Clean up after the inferior exits.  */
 
 static void

-ops_mourn_inferior (void)
+aix_thread_mourn_inferior (void)

 {
   pd_deactivate ();
 {
   pd_deactivate ();

-  base_ops.to_mourn_inferior ();
+  base_target.to_mourn_inferior ();

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

-ops_thread_alive (ptid_t ptid)
+aix_thread_thread_alive (ptid_t ptid)

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

-    return base_ops.to_thread_alive (ptid);
+    return base_target.to_thread_alive (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.  */


@@ -1539,18 +1685,18 @@ ops_thread_alive (ptid_t ptid)
    "info threads" output.  */
 
 static char *
    "info threads" output.  */
 
 static char *

-ops_pid_to_str (ptid_t ptid)
+aix_thread_pid_to_str (ptid_t ptid)

 {
   static char *ret = NULL;
 
   if (!PD_TID (ptid))
 {
   static char *ret = NULL;
 
   if (!PD_TID (ptid))

-    return base_ops.to_pid_to_str (ptid);
+    return base_target.to_pid_to_str (ptid);

 
   /* Free previous return value; a new one will be allocated by
 
   /* Free previous return value; a new one will be allocated by

-     xasprintf().  */
+     xstrprintf().  */

   xfree (ret);
 
   xfree (ret);
 

-  xasprintf (&ret, "Thread %ld", ptid_get_tid (ptid));
+  ret = xstrprintf (_("Thread %ld"), ptid_get_tid (ptid));

   return ret;
 }
 
   return ret;
 }
 


@@ -1558,7 +1704,7 @@ ops_pid_to_str (ptid_t ptid)
    THREAD, for use in "info threads" output.  */
 
 static char *
    THREAD, for use in "info threads" output.  */
 
 static char *

-ops_extra_thread_info (struct thread_info *thread)
+aix_thread_extra_thread_info (struct thread_info *thread)

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


@@ -1580,7 +1726,8 @@ ops_extra_thread_info (struct thread_info *thread)
   tid = thread->private->tid;
 
   if (tid != PTHDB_INVALID_TID)
   tid = thread->private->tid;
 
   if (tid != PTHDB_INVALID_TID)

-    fprintf_unfiltered (buf, "tid %d", tid);
+    /* i18n: Like "thread-identifier %d, [state] running, suspended" */
+    fprintf_unfiltered (buf, _("tid %d"), (int)tid);

 
   status = pthdb_pthread_state (pd_session, pdtid, &state);
   if (status != PTHDB_SUCCESS)
 
   status = pthdb_pthread_state (pd_session, pdtid, &state);
   if (status != PTHDB_SUCCESS)


@@ -1590,16 +1737,19 @@ ops_extra_thread_info (struct thread_info *thread)
   status = pthdb_pthread_suspendstate (pd_session, pdtid, 
                                       &suspendstate);
   if (status == PTHDB_SUCCESS && suspendstate == PSS_SUSPENDED)
   status = pthdb_pthread_suspendstate (pd_session, pdtid, 
                                       &suspendstate);
   if (status == PTHDB_SUCCESS && suspendstate == PSS_SUSPENDED)

-    fprintf_unfiltered (buf, ", suspended");
+    /* i18n: Like "Thread-Id %d, [state] running, suspended" */
+    fprintf_unfiltered (buf, _(", suspended"));

 
   status = pthdb_pthread_detachstate (pd_session, pdtid, 
                                      &detachstate);
   if (status == PTHDB_SUCCESS && detachstate == PDS_DETACHED)
 
   status = pthdb_pthread_detachstate (pd_session, pdtid, 
                                      &detachstate);
   if (status == PTHDB_SUCCESS && detachstate == PDS_DETACHED)

-    fprintf_unfiltered (buf, ", detached");
+    /* i18n: Like "Thread-Id %d, [state] running, detached" */
+    fprintf_unfiltered (buf, _(", detached"));

 
   pthdb_pthread_cancelpend (pd_session, pdtid, &cancelpend);
   if (status == PTHDB_SUCCESS && cancelpend)
 
   pthdb_pthread_cancelpend (pd_session, pdtid, &cancelpend);
   if (status == PTHDB_SUCCESS && cancelpend)

-    fprintf_unfiltered (buf, ", cancel pending");
+    /* i18n: Like "Thread-Id %d, [state] running, cancel pending" */
+    fprintf_unfiltered (buf, _(", cancel pending"));

 
   ui_file_write (buf, "", 1);
 
 
   ui_file_write (buf, "", 1);
 


@@ -1611,31 +1761,31 @@ ops_extra_thread_info (struct thread_info *thread)
   return ret;
 }
 
   return ret;
 }
 

-/* Initialize target ops.  */
+/* Initialize target aix_thread_ops.  */

 
 static void
 
 static void

-init_ops (void)
+init_aix_thread_ops (void)

 {
 {

-  ops.to_shortname          = "aix-threads";
-  ops.to_longname           = "AIX pthread support";
-  ops.to_doc                = "AIX pthread support";
-
-  ops.to_attach             = ops_attach;
-  ops.to_detach             = ops_detach;
-  ops.to_resume             = ops_resume;
-  ops.to_wait               = ops_wait;
-  ops.to_fetch_registers    = ops_fetch_registers;
-  ops.to_store_registers    = ops_store_registers;
-  ops.to_xfer_memory        = ops_xfer_memory;
-  /* No need for ops.to_create_inferior, because we activate thread
+  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.  */
      debugging when the inferior reaches pd_brk_addr.  */

-  ops.to_kill               = ops_kill;
-  ops.to_mourn_inferior     = ops_mourn_inferior;
-  ops.to_thread_alive       = ops_thread_alive;
-  ops.to_pid_to_str         = ops_pid_to_str;
-  ops.to_extra_thread_info  = ops_extra_thread_info;
-  ops.to_stratum            = thread_stratum;
-  ops.to_magic              = OPS_MAGIC;
+  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;

 }
 
 /* Module startup initialization function, automagically called by
 }
 
 /* Module startup initialization function, automagically called by


@@ -1644,17 +1794,16 @@ init_ops (void)
 void
 _initialize_aix_thread (void)
 {
 void
 _initialize_aix_thread (void)
 {

-  init_ops ();
-  add_target (&ops);
+  init_aix_thread_ops ();
+  add_target (&aix_thread_ops);

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

-  target_new_objfile_chain = target_new_objfile_hook;
-  target_new_objfile_hook = new_objfile;
-
-  add_show_from_set (add_set_cmd ("aix-thread", no_class, var_zinteger,
-                                 (char *) &debug_aix_thread, 
-                                 "Set debugging of AIX thread module.\n"
-                                  "Enables printf debugging output.\n",
-                                 &setdebuglist),
-                                 &showdebuglist);
+  observer_attach_new_objfile (new_objfile);
+
+  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);

 }
 }