gdb/gdbserver/

[deliverable/binutils-gdb.git] / gdb / rs6000-nat.c

diff --git a/gdb/rs6000-nat.c b/gdb/rs6000-nat.c
index 365463a1ddc6b0f03d3f3aca8478d02cc72d1632..31ef64a9059ac8ae718dadf1d854e792901d8a23 100644 (file)
--- a/gdb/rs6000-nat.c
+++ b/gdb/rs6000-nat.c
@@ -1,14 +1,13 @@
 /* IBM RS/6000 native-dependent code for GDB, the GNU debugger.
 
 /* IBM RS/6000 native-dependent code for GDB, the GNU debugger.
 

-   Copyright (C) 1986, 1987, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
-   1998, 1999, 2000, 2001, 2002, 2003, 2004, 2007
-   Free Software Foundation, Inc.
+   Copyright (C) 1986-1987, 1989, 1991-2004, 2007-2012 Free Software
+   Foundation, Inc.

 
    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
 
    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,


@@ -17,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/>.  */

 
 #include "defs.h"
 #include "inferior.h"
 
 #include "defs.h"
 #include "inferior.h"


@@ -38,7 +35,8 @@
 #include "ppc-tdep.h"
 #include "rs6000-tdep.h"
 #include "exec.h"
 #include "ppc-tdep.h"
 #include "rs6000-tdep.h"
 #include "exec.h"

-#include "gdb_stdint.h"
+#include "observer.h"
+#include "xcoffread.h"

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


@@ -62,35 +60,24 @@
 
 /* On AIX4.3+, sys/ldr.h provides different versions of struct ld_info for
    debugging 32-bit and 64-bit processes.  Define a typedef and macros for
 
 /* On AIX4.3+, sys/ldr.h provides different versions of struct ld_info for
    debugging 32-bit and 64-bit processes.  Define a typedef and macros for

-   accessing fields in the appropriate structures. */
+   accessing fields in the appropriate structures.  */

 
 /* In 32-bit compilation mode (which is the only mode from which ptrace()
 
 /* In 32-bit compilation mode (which is the only mode from which ptrace()

-   works on 4.3), __ld_info32 is #defined as equivalent to ld_info. */
+   works on 4.3), __ld_info32 is #defined as equivalent to ld_info.  */

 
 #ifdef __ld_info32
 # define ARCH3264
 #endif
 
 
 #ifdef __ld_info32
 # define ARCH3264
 #endif
 

-/* Return whether the current architecture is 64-bit. */
+/* Return whether the current architecture is 64-bit.  */

 
 #ifndef ARCH3264
 # define ARCH64() 0
 #else
 
 #ifndef ARCH3264
 # define ARCH64() 0
 #else

-# define ARCH64() (register_size (current_gdbarch, 0) == 8)
+# define ARCH64() (register_size (target_gdbarch, 0) == 8)

 #endif
 
 #endif
 

-/* Union of 32-bit and 64-bit ".reg" core file sections. */
-
-typedef union {
-#ifdef ARCH3264
-  struct __context64 r64;
-#else
-  struct mstsave r64;
-#endif
-  struct mstsave r32;
-} CoreRegs;
-
-/* Union of 32-bit and 64-bit versions of ld_info. */
+/* Union of 32-bit and 64-bit versions of ld_info.  */

 
 typedef union {
 #ifndef ARCH3264
 
 typedef union {
 #ifndef ARCH3264


@@ -104,7 +91,7 @@ typedef union {
 
 /* If compiling with 32-bit and 64-bit debugging capability (e.g. AIX 4.x),
    declare and initialize a variable named VAR suitable for use as the arch64
 
 /* If compiling with 32-bit and 64-bit debugging capability (e.g. AIX 4.x),
    declare and initialize a variable named VAR suitable for use as the arch64

-   parameter to the various LDI_*() macros. */
+   parameter to the various LDI_*() macros.  */

 
 #ifndef ARCH3264
 # define ARCH64_DECL(var)
 
 #ifndef ARCH3264
 # define ARCH64_DECL(var)


@@ -114,7 +101,7 @@ typedef union {
 
 /* Return LDI's FIELD for a 64-bit process if ARCH64 and for a 32-bit process
    otherwise.  This technique only works for FIELDs with the same data type in
 
 /* Return LDI's FIELD for a 64-bit process if ARCH64 and for a 32-bit process
    otherwise.  This technique only works for FIELDs with the same data type in

-   32-bit and 64-bit versions of ld_info. */
+   32-bit and 64-bit versions of ld_info.  */

 
 #ifndef ARCH3264
 # define LDI_FIELD(ldi, arch64, field) (ldi)->l32.ldinfo_##field
 
 #ifndef ARCH3264
 # define LDI_FIELD(ldi, arch64, field) (ldi)->l32.ldinfo_##field


@@ -124,7 +111,7 @@ typedef union {
 #endif
 
 /* Return various LDI fields for a 64-bit process if ARCH64 and for a 32-bit
 #endif
 
 /* Return various LDI fields for a 64-bit process if ARCH64 and for a 32-bit

-   process otherwise. */
+   process otherwise.  */

 
 #define LDI_NEXT(ldi, arch64)          LDI_FIELD(ldi, arch64, next)
 #define LDI_FD(ldi, arch64)            LDI_FIELD(ldi, arch64, fd)
 
 #define LDI_NEXT(ldi, arch64)          LDI_FIELD(ldi, arch64, next)
 #define LDI_FD(ldi, arch64)            LDI_FIELD(ldi, arch64, fd)


@@ -142,9 +129,7 @@ static int objfile_symbol_add (void *);
 
 static void vmap_symtab (struct vmap *);
 
 
 static void vmap_symtab (struct vmap *);
 

-static void fetch_core_registers (char *, unsigned int, int, CORE_ADDR);
-
-static void exec_one_dummy_insn (void);
+static void exec_one_dummy_insn (struct regcache *);

 
 extern void fixup_breakpoints (CORE_ADDR low, CORE_ADDR high, CORE_ADDR delta);
 
 
 extern void fixup_breakpoints (CORE_ADDR low, CORE_ADDR high, CORE_ADDR delta);
 


@@ -154,9 +139,9 @@ extern void fixup_breakpoints (CORE_ADDR low, CORE_ADDR high, CORE_ADDR delta);
    ISFLOAT to indicate whether REGNO is a floating point register.  */
 
 static int
    ISFLOAT to indicate whether REGNO is a floating point register.  */
 
 static int

-regmap (int regno, int *isfloat)
+regmap (struct gdbarch *gdbarch, int regno, int *isfloat)

 {
 {

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

 
   *isfloat = 0;
   if (tdep->ppc_gp0_regnum <= regno
 
   *isfloat = 0;
   if (tdep->ppc_gp0_regnum <= regno


@@ -169,7 +154,7 @@ regmap (int regno, int *isfloat)
       *isfloat = 1;
       return regno - tdep->ppc_fp0_regnum + FPR0;
     }
       *isfloat = 1;
       return regno - tdep->ppc_fp0_regnum + FPR0;
     }

-  else if (regno == PC_REGNUM)
+  else if (regno == gdbarch_pc_regnum (gdbarch))

     return IAR;
   else if (regno == tdep->ppc_ps_regnum)
     return MSR;
     return IAR;
   else if (regno == tdep->ppc_ps_regnum)
     return MSR;


@@ -190,7 +175,7 @@ regmap (int regno, int *isfloat)
     return -1;
 }
 
     return -1;
 }
 

-/* Call ptrace(REQ, ID, ADDR, DATA, BUF). */
+/* Call ptrace(REQ, ID, ADDR, DATA, BUF).  */

 
 static int
 rs6000_ptrace32 (int req, int id, int *addr, int data, int *buf)
 
 static int
 rs6000_ptrace32 (int req, int id, int *addr, int data, int *buf)


@@ -203,7 +188,7 @@ rs6000_ptrace32 (int req, int id, int *addr, int data, int *buf)
   return ret;
 }
 
   return ret;
 }
 

-/* Call ptracex(REQ, ID, ADDR, DATA, BUF). */
+/* Call ptracex(REQ, ID, ADDR, DATA, BUF).  */

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


@@ -214,51 +199,53 @@ rs6000_ptrace64 (int req, int id, long long addr, int data, void *buf)
   int ret = 0;
 #endif
 #if 0
   int ret = 0;
 #endif
 #if 0

-  printf ("rs6000_ptrace64 (%d, %d, 0x%llx, %08x, 0x%x) = 0x%x\n",
-         req, id, addr, data, (unsigned int)buf, ret);
+  printf ("rs6000_ptrace64 (%d, %d, %s, %08x, 0x%x) = 0x%x\n",
+         req, id, hex_string (addr), data, (unsigned int)buf, ret);

 #endif
   return ret;
 }
 
 #endif
   return ret;
 }
 

-/* Fetch register REGNO from the inferior. */
+/* Fetch register REGNO from the inferior.  */

 
 static void
 
 static void

-fetch_register (int regno)
+fetch_register (struct regcache *regcache, int regno)

 {
 {

+  struct gdbarch *gdbarch = get_regcache_arch (regcache);

   int addr[MAX_REGISTER_SIZE];
   int nr, isfloat;
 
   int addr[MAX_REGISTER_SIZE];
   int nr, isfloat;
 

-  /* Retrieved values may be -1, so infer errors from errno. */
+  /* Retrieved values may be -1, so infer errors from errno.  */

   errno = 0;
 
   errno = 0;
 

-  nr = regmap (regno, &isfloat);
+  nr = regmap (gdbarch, regno, &isfloat);

 
 

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

   if (isfloat)
     rs6000_ptrace32 (PT_READ_FPR, PIDGET (inferior_ptid), addr, nr, 0);
 
   if (isfloat)
     rs6000_ptrace32 (PT_READ_FPR, PIDGET (inferior_ptid), addr, nr, 0);
 

-  /* Bogus register number. */
+  /* Bogus register number.  */

   else if (nr < 0)
     {
   else if (nr < 0)
     {

-      if (regno >= NUM_REGS)
+      if (regno >= gdbarch_num_regs (gdbarch))

        fprintf_unfiltered (gdb_stderr,
                            "gdb error: register no %d not implemented.\n",
                            regno);
       return;
     }
 
        fprintf_unfiltered (gdb_stderr,
                            "gdb error: register no %d not implemented.\n",
                            regno);
       return;
     }
 

-  /* Fixed-point registers. */
+  /* Fixed-point registers.  */

   else
     {
       if (!ARCH64 ())
   else
     {
       if (!ARCH64 ())

-       *addr = rs6000_ptrace32 (PT_READ_GPR, PIDGET (inferior_ptid), (int *)nr, 0, 0);
+       *addr = rs6000_ptrace32 (PT_READ_GPR, PIDGET (inferior_ptid),
+                                (int *) nr, 0, 0);

       else
        {
          /* PT_READ_GPR requires the buffer parameter to point to long long,
       else
        {
          /* PT_READ_GPR requires the buffer parameter to point to long long,

-            even if the register is really only 32 bits. */
+            even if the register is really only 32 bits.  */

          long long buf;
          rs6000_ptrace64 (PT_READ_GPR, PIDGET (inferior_ptid), nr, 0, &buf);
          long long buf;
          rs6000_ptrace64 (PT_READ_GPR, PIDGET (inferior_ptid), nr, 0, &buf);

-         if (register_size (current_gdbarch, regno) == 8)
+         if (register_size (gdbarch, regno) == 8)

            memcpy (addr, &buf, 8);
          else
            *addr = buf;
            memcpy (addr, &buf, 8);
          else
            *addr = buf;


@@ -266,68 +253,70 @@ fetch_register (int regno)
     }
 
   if (!errno)
     }
 
   if (!errno)

-    regcache_raw_supply (current_regcache, regno, (char *) addr);
+    regcache_raw_supply (regcache, regno, (char *) addr);

   else
     {
 #if 0
   else
     {
 #if 0

-      /* FIXME: this happens 3 times at the start of each 64-bit program. */
-      perror ("ptrace read");
+      /* FIXME: this happens 3 times at the start of each 64-bit program.  */
+      perror (_("ptrace read"));

 #endif
       errno = 0;
     }
 }
 
 #endif
       errno = 0;
     }
 }
 

-/* Store register REGNO back into the inferior. */
+/* Store register REGNO back into the inferior.  */

 
 static void
 
 static void

-store_register (int regno)
+store_register (struct regcache *regcache, int regno)

 {
 {

+  struct gdbarch *gdbarch = get_regcache_arch (regcache);

   int addr[MAX_REGISTER_SIZE];
   int nr, isfloat;
 
   /* Fetch the register's value from the register cache.  */
   int addr[MAX_REGISTER_SIZE];
   int nr, isfloat;
 
   /* Fetch the register's value from the register cache.  */

-  regcache_raw_collect (current_regcache, regno, addr);
+  regcache_raw_collect (regcache, regno, addr);

 
 

-  /* -1 can be a successful return value, so infer errors from errno. */
+  /* -1 can be a successful return value, so infer errors from errno.  */

   errno = 0;
 
   errno = 0;
 

-  nr = regmap (regno, &isfloat);
+  nr = regmap (gdbarch, regno, &isfloat);

 
 

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

   if (isfloat)
     rs6000_ptrace32 (PT_WRITE_FPR, PIDGET (inferior_ptid), addr, nr, 0);
 
   if (isfloat)
     rs6000_ptrace32 (PT_WRITE_FPR, PIDGET (inferior_ptid), addr, nr, 0);
 

-  /* Bogus register number. */
+  /* Bogus register number.  */

   else if (nr < 0)
     {
   else if (nr < 0)
     {

-      if (regno >= NUM_REGS)
+      if (regno >= gdbarch_num_regs (gdbarch))

        fprintf_unfiltered (gdb_stderr,
                            "gdb error: register no %d not implemented.\n",
                            regno);
     }
 
        fprintf_unfiltered (gdb_stderr,
                            "gdb error: register no %d not implemented.\n",
                            regno);
     }
 

-  /* Fixed-point registers. */
+  /* Fixed-point registers.  */

   else
     {
   else
     {

-      if (regno == SP_REGNUM)
+      if (regno == gdbarch_sp_regnum (gdbarch))

        /* Execute one dummy instruction (which is a breakpoint) in inferior
           process to give kernel a chance to do internal housekeeping.
           Otherwise the following ptrace(2) calls will mess up user stack
           since kernel will get confused about the bottom of the stack
        /* Execute one dummy instruction (which is a breakpoint) in inferior
           process to give kernel a chance to do internal housekeeping.
           Otherwise the following ptrace(2) calls will mess up user stack
           since kernel will get confused about the bottom of the stack

-          (%sp). */
-       exec_one_dummy_insn ();
+          (%sp).  */
+       exec_one_dummy_insn (regcache);

 
       /* The PT_WRITE_GPR operation is rather odd.  For 32-bit inferiors,
          the register's value is passed by value, but for 64-bit inferiors,
         the address of a buffer containing the value is passed.  */
       if (!ARCH64 ())
 
       /* The PT_WRITE_GPR operation is rather odd.  For 32-bit inferiors,
          the register's value is passed by value, but for 64-bit inferiors,
         the address of a buffer containing the value is passed.  */
       if (!ARCH64 ())

-       rs6000_ptrace32 (PT_WRITE_GPR, PIDGET (inferior_ptid), (int *)nr, *addr, 0);
+       rs6000_ptrace32 (PT_WRITE_GPR, PIDGET (inferior_ptid),
+                        (int *) nr, *addr, 0);

       else
        {
          /* PT_WRITE_GPR requires the buffer parameter to point to an 8-byte
       else
        {
          /* PT_WRITE_GPR requires the buffer parameter to point to an 8-byte

-            area, even if the register is really only 32 bits. */
+            area, even if the register is really only 32 bits.  */

          long long buf;
          long long buf;

-         if (register_size (current_gdbarch, regno) == 8)
+         if (register_size (gdbarch, regno) == 8)

            memcpy (&buf, addr, 8);
          else
            buf = *addr;
            memcpy (&buf, addr, 8);
          else
            buf = *addr;


@@ -337,48 +326,50 @@ store_register (int regno)
 
   if (errno)
     {
 
   if (errno)
     {

-      perror ("ptrace write");
+      perror (_("ptrace write"));

       errno = 0;
     }
 }
 
 /* Read from the inferior all registers if REGNO == -1 and just register
       errno = 0;
     }
 }
 
 /* Read from the inferior all registers if REGNO == -1 and just register

-   REGNO otherwise. */
+   REGNO otherwise.  */

 
 static void
 
 static void

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

 {
 {

+  struct gdbarch *gdbarch = get_regcache_arch (regcache);

   if (regno != -1)
   if (regno != -1)

-    fetch_register (regno);
+    fetch_register (regcache, regno);

 
   else
     {
 
   else
     {

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

 
       /* Read 32 general purpose registers.  */
       for (regno = tdep->ppc_gp0_regnum;
            regno < tdep->ppc_gp0_regnum + ppc_num_gprs;
           regno++)
        {
 
       /* Read 32 general purpose registers.  */
       for (regno = tdep->ppc_gp0_regnum;
            regno < tdep->ppc_gp0_regnum + ppc_num_gprs;
           regno++)
        {

-         fetch_register (regno);
+         fetch_register (regcache, regno);

        }
 
       /* Read general purpose floating point registers.  */
       if (tdep->ppc_fp0_regnum >= 0)
         for (regno = 0; regno < ppc_num_fprs; regno++)
        }
 
       /* Read general purpose floating point registers.  */
       if (tdep->ppc_fp0_regnum >= 0)
         for (regno = 0; regno < ppc_num_fprs; regno++)

-          fetch_register (tdep->ppc_fp0_regnum + regno);
+          fetch_register (regcache, tdep->ppc_fp0_regnum + regno);

 
       /* Read special registers.  */
 
       /* Read special registers.  */

-      fetch_register (PC_REGNUM);
-      fetch_register (tdep->ppc_ps_regnum);
-      fetch_register (tdep->ppc_cr_regnum);
-      fetch_register (tdep->ppc_lr_regnum);
-      fetch_register (tdep->ppc_ctr_regnum);
-      fetch_register (tdep->ppc_xer_regnum);
+      fetch_register (regcache, gdbarch_pc_regnum (gdbarch));
+      fetch_register (regcache, tdep->ppc_ps_regnum);
+      fetch_register (regcache, tdep->ppc_cr_regnum);
+      fetch_register (regcache, tdep->ppc_lr_regnum);
+      fetch_register (regcache, tdep->ppc_ctr_regnum);
+      fetch_register (regcache, tdep->ppc_xer_regnum);

       if (tdep->ppc_fpscr_regnum >= 0)
       if (tdep->ppc_fpscr_regnum >= 0)

-        fetch_register (tdep->ppc_fpscr_regnum);
+        fetch_register (regcache, tdep->ppc_fpscr_regnum);

       if (tdep->ppc_mq_regnum >= 0)
       if (tdep->ppc_mq_regnum >= 0)

-       fetch_register (tdep->ppc_mq_regnum);
+       fetch_register (regcache, tdep->ppc_mq_regnum);

     }
 }
 
     }
 }
 


@@ -387,39 +378,41 @@ rs6000_fetch_inferior_registers (int regno)
    Otherwise, REGNO specifies which register (so we can save time).  */
 
 static void
    Otherwise, REGNO specifies which register (so we can save time).  */
 
 static void

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

 {
 {

+  struct gdbarch *gdbarch = get_regcache_arch (regcache);

   if (regno != -1)
   if (regno != -1)

-    store_register (regno);
+    store_register (regcache, regno);

 
   else
     {
 
   else
     {

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

 
       /* Write general purpose registers first.  */
       for (regno = tdep->ppc_gp0_regnum;
            regno < tdep->ppc_gp0_regnum + ppc_num_gprs;
           regno++)
        {
 
       /* Write general purpose registers first.  */
       for (regno = tdep->ppc_gp0_regnum;
            regno < tdep->ppc_gp0_regnum + ppc_num_gprs;
           regno++)
        {

-         store_register (regno);
+         store_register (regcache, regno);

        }
 
       /* Write floating point registers.  */
       if (tdep->ppc_fp0_regnum >= 0)
         for (regno = 0; regno < ppc_num_fprs; regno++)
        }
 
       /* Write floating point registers.  */
       if (tdep->ppc_fp0_regnum >= 0)
         for (regno = 0; regno < ppc_num_fprs; regno++)

-          store_register (tdep->ppc_fp0_regnum + regno);
+          store_register (regcache, tdep->ppc_fp0_regnum + regno);

 
       /* Write special registers.  */
 
       /* Write special registers.  */

-      store_register (PC_REGNUM);
-      store_register (tdep->ppc_ps_regnum);
-      store_register (tdep->ppc_cr_regnum);
-      store_register (tdep->ppc_lr_regnum);
-      store_register (tdep->ppc_ctr_regnum);
-      store_register (tdep->ppc_xer_regnum);
+      store_register (regcache, gdbarch_pc_regnum (gdbarch));
+      store_register (regcache, tdep->ppc_ps_regnum);
+      store_register (regcache, tdep->ppc_cr_regnum);
+      store_register (regcache, tdep->ppc_lr_regnum);
+      store_register (regcache, tdep->ppc_ctr_regnum);
+      store_register (regcache, tdep->ppc_xer_regnum);

       if (tdep->ppc_fpscr_regnum >= 0)
       if (tdep->ppc_fpscr_regnum >= 0)

-        store_register (tdep->ppc_fpscr_regnum);
+        store_register (regcache, tdep->ppc_fpscr_regnum);

       if (tdep->ppc_mq_regnum >= 0)
       if (tdep->ppc_mq_regnum >= 0)

-       store_register (tdep->ppc_mq_regnum);
+       store_register (regcache, tdep->ppc_mq_regnum);

     }
 }
 
     }
 }
 


@@ -477,7 +470,8 @@ rs6000_xfer_partial (struct target_ops *ops, enum target_object object,
                                                 rounded_offset, 0, NULL);
                else
                  buffer.word = rs6000_ptrace32 (PT_READ_I, pid,
                                                 rounded_offset, 0, NULL);
                else
                  buffer.word = rs6000_ptrace32 (PT_READ_I, pid,

-                                                (int *)(uintptr_t)rounded_offset,
+                                                (int *) (uintptr_t)
+                                                rounded_offset,

                                                 0, NULL);
              }
 
                                                 0, NULL);
              }
 


@@ -492,7 +486,8 @@ rs6000_xfer_partial (struct target_ops *ops, enum target_object object,
                               rounded_offset, buffer.word, NULL);
            else
              rs6000_ptrace32 (PT_WRITE_D, pid,
                               rounded_offset, buffer.word, NULL);
            else
              rs6000_ptrace32 (PT_WRITE_D, pid,

-                              (int *)(uintptr_t)rounded_offset, buffer.word, NULL);
+                              (int *) (uintptr_t) rounded_offset,
+                              buffer.word, NULL);

            if (errno)
              return 0;
          }
            if (errno)
              return 0;
          }


@@ -523,135 +518,112 @@ rs6000_xfer_partial (struct target_ops *ops, enum target_object object,
     }
 }
 
     }
 }
 

+/* Wait for the child specified by PTID to do something.  Return the
+   process ID of the child, or MINUS_ONE_PTID in case of error; store
+   the status in *OURSTATUS.  */
+
+static ptid_t
+rs6000_wait (struct target_ops *ops,
+            ptid_t ptid, struct target_waitstatus *ourstatus, int options)
+{
+  pid_t pid;
+  int status, save_errno;
+
+  do
+    {
+      set_sigint_trap ();
+
+      do
+       {
+         pid = waitpid (ptid_get_pid (ptid), &status, 0);
+         save_errno = errno;
+       }
+      while (pid == -1 && errno == EINTR);
+
+      clear_sigint_trap ();
+
+      if (pid == -1)
+       {
+         fprintf_unfiltered (gdb_stderr,
+                             _("Child process unexpectedly missing: %s.\n"),
+                             safe_strerror (save_errno));
+
+         /* Claim it exited with unknown signal.  */
+         ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
+         ourstatus->value.sig = TARGET_SIGNAL_UNKNOWN;
+         return inferior_ptid;
+       }
+
+      /* Ignore terminated detached child processes.  */
+      if (!WIFSTOPPED (status) && pid != ptid_get_pid (inferior_ptid))
+       pid = -1;
+    }
+  while (pid == -1);
+
+  /* AIX has a couple of strange returns from wait().  */
+
+  /* stop after load" status.  */
+  if (status == 0x57c)
+    ourstatus->kind = TARGET_WAITKIND_LOADED;
+  /* signal 0.  I have no idea why wait(2) returns with this status word.  */
+  else if (status == 0x7f)
+    ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
+  /* A normal waitstatus.  Let the usual macros deal with it.  */
+  else
+    store_waitstatus (ourstatus, status);
+
+  return pid_to_ptid (pid);
+}

 
 /* Execute one dummy breakpoint instruction.  This way we give the kernel
    a chance to do some housekeeping and update inferior's internal data,
 
 /* Execute one dummy breakpoint instruction.  This way we give the kernel
    a chance to do some housekeeping and update inferior's internal data,

-   including u_area. */
+   including u_area.  */

 
 static void
 
 static void

-exec_one_dummy_insn (void)
+exec_one_dummy_insn (struct regcache *regcache)

 {
 {

-#define        DUMMY_INSN_ADDR gdbarch_tdep (current_gdbarch)->text_segment_base+0x200
+#define        DUMMY_INSN_ADDR AIX_TEXT_SEGMENT_BASE+0x200

 
 

+  struct gdbarch *gdbarch = get_regcache_arch (regcache);

   int ret, status, pid;
   CORE_ADDR prev_pc;
   void *bp;
 
   int ret, status, pid;
   CORE_ADDR prev_pc;
   void *bp;
 

-  /* We plant one dummy breakpoint into DUMMY_INSN_ADDR address. We
+  /* We plant one dummy breakpoint into DUMMY_INSN_ADDR address.  We

      assume that this address will never be executed again by the real
      assume that this address will never be executed again by the real

-     code. */
+     code.  */

 
 

-  bp = deprecated_insert_raw_breakpoint (DUMMY_INSN_ADDR);
+  bp = deprecated_insert_raw_breakpoint (gdbarch, NULL, DUMMY_INSN_ADDR);

 
   /* You might think this could be done with a single ptrace call, and
      you'd be correct for just about every platform I've ever worked
      on.  However, rs6000-ibm-aix4.1.3 seems to have screwed this up --
      the inferior never hits the breakpoint (it's also worth noting
      powerpc-ibm-aix4.1.3 works correctly).  */
 
   /* You might think this could be done with a single ptrace call, and
      you'd be correct for just about every platform I've ever worked
      on.  However, rs6000-ibm-aix4.1.3 seems to have screwed this up --
      the inferior never hits the breakpoint (it's also worth noting
      powerpc-ibm-aix4.1.3 works correctly).  */

-  prev_pc = read_pc ();
-  write_pc (DUMMY_INSN_ADDR);
+  prev_pc = regcache_read_pc (regcache);
+  regcache_write_pc (regcache, DUMMY_INSN_ADDR);

   if (ARCH64 ())
     ret = rs6000_ptrace64 (PT_CONTINUE, PIDGET (inferior_ptid), 1, 0, NULL);
   else
   if (ARCH64 ())
     ret = rs6000_ptrace64 (PT_CONTINUE, PIDGET (inferior_ptid), 1, 0, NULL);
   else

-    ret = rs6000_ptrace32 (PT_CONTINUE, PIDGET (inferior_ptid), (int *)1, 0, NULL);
+    ret = rs6000_ptrace32 (PT_CONTINUE, PIDGET (inferior_ptid),
+                          (int *) 1, 0, NULL);

 
   if (ret != 0)
 
   if (ret != 0)

-    perror ("pt_continue");
+    perror (_("pt_continue"));

 
   do
     {
 
   do
     {

-      pid = wait (&status);
+      pid = waitpid (PIDGET (inferior_ptid), &status, 0);

     }
   while (pid != PIDGET (inferior_ptid));
 
     }
   while (pid != PIDGET (inferior_ptid));
 

-  write_pc (prev_pc);
-  deprecated_remove_raw_breakpoint (bp);
-}
-
-/* Fetch registers from the register section in core bfd. */
-
-static void
-fetch_core_registers (char *core_reg_sect, unsigned core_reg_size,
-                     int which, CORE_ADDR reg_addr)
-{
-  CoreRegs *regs;
-  int regi;
-  struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); 
-
-  if (which != 0)
-    {
-      fprintf_unfiltered
-       (gdb_stderr,
-        "Gdb error: unknown parameter to fetch_core_registers().\n");
-      return;
-    }
-
-  regs = (CoreRegs *) core_reg_sect;
-
-  /* Put the register values from the core file section in the regcache.  */
-
-  if (ARCH64 ())
-    {
-      for (regi = 0; regi < ppc_num_gprs; regi++)
-        regcache_raw_supply (current_regcache, tdep->ppc_gp0_regnum + regi,
-                            (char *) &regs->r64.gpr[regi]);
-
-      if (tdep->ppc_fp0_regnum >= 0)
-        for (regi = 0; regi < ppc_num_fprs; regi++)
-          regcache_raw_supply (current_regcache, tdep->ppc_fp0_regnum + regi,
-                              (char *) &regs->r64.fpr[regi]);
-
-      regcache_raw_supply (current_regcache, PC_REGNUM,
-                          (char *) &regs->r64.iar);
-      regcache_raw_supply (current_regcache, tdep->ppc_ps_regnum,
-                          (char *) &regs->r64.msr);
-      regcache_raw_supply (current_regcache, tdep->ppc_cr_regnum,
-                          (char *) &regs->r64.cr);
-      regcache_raw_supply (current_regcache, tdep->ppc_lr_regnum,
-                          (char *) &regs->r64.lr);
-      regcache_raw_supply (current_regcache, tdep->ppc_ctr_regnum,
-                          (char *) &regs->r64.ctr);
-      regcache_raw_supply (current_regcache, tdep->ppc_xer_regnum,
-                          (char *) &regs->r64.xer);
-      if (tdep->ppc_fpscr_regnum >= 0)
-        regcache_raw_supply (current_regcache, tdep->ppc_fpscr_regnum,
-                            (char *) &regs->r64.fpscr);
-    }
-  else
-    {
-      for (regi = 0; regi < ppc_num_gprs; regi++)
-        regcache_raw_supply (current_regcache, tdep->ppc_gp0_regnum + regi,
-                            (char *) &regs->r32.gpr[regi]);
-
-      if (tdep->ppc_fp0_regnum >= 0)
-        for (regi = 0; regi < ppc_num_fprs; regi++)
-          regcache_raw_supply (current_regcache, tdep->ppc_fp0_regnum + regi,
-                              (char *) &regs->r32.fpr[regi]);
-
-      regcache_raw_supply (current_regcache, PC_REGNUM,
-                          (char *) &regs->r32.iar);
-      regcache_raw_supply (current_regcache, tdep->ppc_ps_regnum,
-                          (char *) &regs->r32.msr);
-      regcache_raw_supply (current_regcache, tdep->ppc_cr_regnum,
-                          (char *) &regs->r32.cr);
-      regcache_raw_supply (current_regcache, tdep->ppc_lr_regnum,
-                          (char *) &regs->r32.lr);
-      regcache_raw_supply (current_regcache, tdep->ppc_ctr_regnum,
-                          (char *) &regs->r32.ctr);
-      regcache_raw_supply (current_regcache, tdep->ppc_xer_regnum,
-                          (char *) &regs->r32.xer);
-      if (tdep->ppc_fpscr_regnum >= 0)
-        regcache_raw_supply (current_regcache, tdep->ppc_fpscr_regnum,
-                            (char *) &regs->r32.fpscr);
-      if (tdep->ppc_mq_regnum >= 0)
-       regcache_raw_supply (current_regcache, tdep->ppc_mq_regnum,
-                            (char *) &regs->r32.mq);
-    }
+  regcache_write_pc (regcache, prev_pc);
+  deprecated_remove_raw_breakpoint (gdbarch, bp);

 }
 \f
 
 /* Copy information about text and data sections from LDI to VP for a 64-bit
 }
 \f
 
 /* Copy information about text and data sections from LDI to VP for a 64-bit

-   process if ARCH64 and for a 32-bit process otherwise. */
+   process if ARCH64 and for a 32-bit process otherwise.  */

 
 static void
 vmap_secs (struct vmap *vp, LdInfo *ldi, int arch64)
 
 static void
 vmap_secs (struct vmap *vp, LdInfo *ldi, int arch64)


@@ -678,7 +650,7 @@ vmap_secs (struct vmap *vp, LdInfo *ldi, int arch64)
   vp->tstart += vp->toffs;
 }
 
   vp->tstart += vp->toffs;
 }
 

-/* handle symbol translation on vmapping */
+/* Handle symbol translation on vmapping.  */

 
 static void
 vmap_symtab (struct vmap *vp)
 
 static void
 vmap_symtab (struct vmap *vp)


@@ -698,7 +670,7 @@ vmap_symtab (struct vmap *vp)
       objfile = symfile_objfile;
     }
   else if (!vp->loaded)
       objfile = symfile_objfile;
     }
   else if (!vp->loaded)

-    /* If symbols are not yet loaded, offsets are not yet valid. */
+    /* If symbols are not yet loaded, offsets are not yet valid.  */

     return;
 
   new_offsets =
     return;
 
   new_offsets =


@@ -724,8 +696,8 @@ objfile_symbol_add (void *arg)
 {
   struct objfile *obj = (struct objfile *) arg;
 
 {
   struct objfile *obj = (struct objfile *) arg;
 

-  syms_from_objfile (obj, NULL, 0, 0, 0, 0);
-  new_symfile_objfile (obj, 0, 0);
+  syms_from_objfile (obj, NULL, 0, 0, 0);
+  new_symfile_objfile (obj, 0);

   return 1;
 }
 
   return 1;
 }
 


@@ -764,13 +736,13 @@ add_vmap (LdInfo *ldi)
   ARCH64_DECL (arch64);
 
   /* This ldi structure was allocated using alloca() in 
   ARCH64_DECL (arch64);
 
   /* This ldi structure was allocated using alloca() in 

-     xcoff_relocate_symtab(). Now we need to have persistent object 
-     and member names, so we should save them. */
+     xcoff_relocate_symtab().  Now we need to have persistent object 
+     and member names, so we should save them.  */

 
   filename = LDI_FILENAME (ldi, arch64);
   mem = filename + strlen (filename) + 1;
 
   filename = LDI_FILENAME (ldi, arch64);
   mem = filename + strlen (filename) + 1;

-  mem = savestring (mem, strlen (mem));
-  objname = savestring (filename, strlen (filename));
+  mem = xstrdup (mem);
+  objname = xstrdup (filename);

 
   fd = LDI_FD (ldi, arch64);
   if (fd < 0)
 
   fd = LDI_FD (ldi, arch64);
   if (fd < 0)


@@ -786,7 +758,7 @@ add_vmap (LdInfo *ldi)
       return NULL;
     }
 
       return NULL;
     }
 

-  /* make sure we have an object file */
+  /* Make sure we have an object file.  */

 
   if (bfd_check_format (abfd, bfd_object))
     vp = map_vmap (abfd, 0);
 
   if (bfd_check_format (abfd, bfd_object))
     vp = map_vmap (abfd, 0);


@@ -794,9 +766,9 @@ add_vmap (LdInfo *ldi)
   else if (bfd_check_format (abfd, bfd_archive))
     {
       last = 0;
   else if (bfd_check_format (abfd, bfd_archive))
     {
       last = 0;

-      /* FIXME??? am I tossing BFDs?  bfd? */
+      /* FIXME??? am I tossing BFDs?  bfd?  */

       while ((last = bfd_openr_next_archived_file (abfd, last)))
       while ((last = bfd_openr_next_archived_file (abfd, last)))

-       if (DEPRECATED_STREQ (mem, last->filename))
+       if (strcmp (mem, last->filename) == 0)

          break;
 
       if (!last)
          break;
 
       if (!last)


@@ -861,7 +833,7 @@ vmap_ldinfo (LdInfo *ldi)
       if (fstat (fd, &ii) < 0)
        {
          /* The kernel sets ld_info to -1, if the process is still using the
       if (fstat (fd, &ii) < 0)
        {
          /* The kernel sets ld_info to -1, if the process is still using the

-            object, and the object is removed. Keep the symbol info for the
+            object, and the object is removed.  Keep the symbol info for the

             removed object and issue a warning.  */
          warning (_("%s (fd=%d) has disappeared, keeping its symbols"),
                   name, fd);
             removed object and issue a warning.  */
          warning (_("%s (fd=%d) has disappeared, keeping its symbols"),
                   name, fd);


@@ -873,15 +845,15 @@ vmap_ldinfo (LdInfo *ldi)
          struct objfile *objfile;
 
          /* First try to find a `vp', which is the same as in ldinfo.
          struct objfile *objfile;
 
          /* First try to find a `vp', which is the same as in ldinfo.

-            If not the same, just continue and grep the next `vp'. If same,
-            relocate its tstart, tend, dstart, dend values. If no such `vp'
+            If not the same, just continue and grep the next `vp'.  If same,
+            relocate its tstart, tend, dstart, dend values.  If no such `vp'

             found, get out of this for loop, add this ldi entry as a new vmap
             found, get out of this for loop, add this ldi entry as a new vmap

-            (add_vmap) and come back, find its `vp' and so on... */
+            (add_vmap) and come back, find its `vp' and so on...  */

 
 

-         /* The filenames are not always sufficient to match on. */
+         /* The filenames are not always sufficient to match on.  */

 
 

-         if ((name[0] == '/' && !DEPRECATED_STREQ (name, vp->name))
-             || (memb[0] && !DEPRECATED_STREQ (memb, vp->member)))
+         if ((name[0] == '/' && strcmp (name, vp->name) != 0)
+             || (memb[0] && strcmp (memb, vp->member) != 0))

            continue;
 
          /* See if we are referring to the same file.
            continue;
 
          /* See if we are referring to the same file.


@@ -912,18 +884,19 @@ vmap_ldinfo (LdInfo *ldi)
          if (vp->objfile == NULL)
            got_exec_file = 1;
 
          if (vp->objfile == NULL)
            got_exec_file = 1;
 

-         /* relocate symbol table(s). */
+         /* relocate symbol table(s).  */

          vmap_symtab (vp);
 
          /* Announce new object files.  Doing this after symbol relocation
             makes aix-thread.c's job easier.  */
          vmap_symtab (vp);
 
          /* Announce new object files.  Doing this after symbol relocation
             makes aix-thread.c's job easier.  */

-         if (deprecated_target_new_objfile_hook && vp->objfile)
-           deprecated_target_new_objfile_hook (vp->objfile);
+         if (vp->objfile)
+           observer_notify_new_objfile (vp->objfile);

 
          /* There may be more, so we don't break out of the loop.  */
        }
 
 
          /* There may be more, so we don't break out of the loop.  */
        }
 

-      /* if there was no matching *vp, we must perforce create the sucker(s) */
+      /* If there was no matching *vp, we must perforce create the
+        sucker(s). */

       if (!got_one && !retried)
        {
          add_vmap (ldi);
       if (!got_one && !retried)
        {
          add_vmap (ldi);


@@ -947,69 +920,70 @@ If in fact that file has symbols which the mapped files listed by\n\
 symbols to the proper address)."),
               symfile_objfile->name);
       free_objfile (symfile_objfile);
 symbols to the proper address)."),
               symfile_objfile->name);
       free_objfile (symfile_objfile);

-      symfile_objfile = NULL;
+      gdb_assert (symfile_objfile == NULL);

     }
   breakpoint_re_set ();
 }
 \f
     }
   breakpoint_re_set ();
 }
 \f

-/* As well as symbol tables, exec_sections need relocation. After
+/* As well as symbol tables, exec_sections need relocation.  After

    the inferior process' termination, there will be a relocated symbol
    the inferior process' termination, there will be a relocated symbol

-   table exist with no corresponding inferior process. At that time, we
+   table exist with no corresponding inferior process.  At that time, we

    need to use `exec' bfd, rather than the inferior process's memory space
    to look up symbols.
 
    `exec_sections' need to be relocated only once, as long as the exec
    need to use `exec' bfd, rather than the inferior process's memory space
    to look up symbols.
 
    `exec_sections' need to be relocated only once, as long as the exec

-   file remains unchanged.
- */
+   file remains unchanged.  */

 
 static void
 vmap_exec (void)
 {
   static bfd *execbfd;
   int i;
 
 static void
 vmap_exec (void)
 {
   static bfd *execbfd;
   int i;

+  struct target_section_table *table = target_get_section_table (&exec_ops);

 
   if (execbfd == exec_bfd)
     return;
 
   execbfd = exec_bfd;
 
 
   if (execbfd == exec_bfd)
     return;
 
   execbfd = exec_bfd;
 

-  if (!vmap || !exec_ops.to_sections)
-    error (_("vmap_exec: vmap or exec_ops.to_sections == 0."));
+  if (!vmap || !table->sections)
+    error (_("vmap_exec: vmap or table->sections == 0."));

 
 

-  for (i = 0; &exec_ops.to_sections[i] < exec_ops.to_sections_end; i++)
+  for (i = 0; &table->sections[i] < table->sections_end; i++)

     {
     {

-      if (DEPRECATED_STREQ (".text", exec_ops.to_sections[i].the_bfd_section->name))
+      if (strcmp (".text", table->sections[i].the_bfd_section->name) == 0)

        {
        {

-         exec_ops.to_sections[i].addr += vmap->tstart - vmap->tvma;
-         exec_ops.to_sections[i].endaddr += vmap->tstart - vmap->tvma;
+         table->sections[i].addr += vmap->tstart - vmap->tvma;
+         table->sections[i].endaddr += vmap->tstart - vmap->tvma;

        }
        }

-      else if (DEPRECATED_STREQ (".data", exec_ops.to_sections[i].the_bfd_section->name))
+      else if (strcmp (".data", table->sections[i].the_bfd_section->name) == 0)

        {
        {

-         exec_ops.to_sections[i].addr += vmap->dstart - vmap->dvma;
-         exec_ops.to_sections[i].endaddr += vmap->dstart - vmap->dvma;
+         table->sections[i].addr += vmap->dstart - vmap->dvma;
+         table->sections[i].endaddr += vmap->dstart - vmap->dvma;

        }
        }

-      else if (DEPRECATED_STREQ (".bss", exec_ops.to_sections[i].the_bfd_section->name))
+      else if (strcmp (".bss", table->sections[i].the_bfd_section->name) == 0)

        {
        {

-         exec_ops.to_sections[i].addr += vmap->dstart - vmap->dvma;
-         exec_ops.to_sections[i].endaddr += vmap->dstart - vmap->dvma;
+         table->sections[i].addr += vmap->dstart - vmap->dvma;
+         table->sections[i].endaddr += vmap->dstart - vmap->dvma;

        }
     }
 }
 
 /* Set the current architecture from the host running GDB.  Called when
        }
     }
 }
 
 /* Set the current architecture from the host running GDB.  Called when

-   starting a child process. */
+   starting a child process.  */

 
 

-static void (*super_create_inferior) (char *exec_file, char *allargs,
-                                     char **env, int from_tty);
+static void (*super_create_inferior) (struct target_ops *,char *exec_file, 
+                                     char *allargs, char **env, int from_tty);

 static void
 static void

-rs6000_create_inferior (char *exec_file, char *allargs, char **env, int from_tty)
+rs6000_create_inferior (struct target_ops * ops, char *exec_file,
+                       char *allargs, char **env, int from_tty)

 {
   enum bfd_architecture arch;
   unsigned long mach;
   bfd abfd;
   struct gdbarch_info info;
 
 {
   enum bfd_architecture arch;
   unsigned long mach;
   bfd abfd;
   struct gdbarch_info info;
 

-  super_create_inferior (exec_file, allargs, env, from_tty);
+  super_create_inferior (ops, exec_file, allargs, env, from_tty);

 
   if (__power_rs ())
     {
 
   if (__power_rs ())
     {


@@ -1047,12 +1021,15 @@ rs6000_create_inferior (char *exec_file, char *allargs, char **env, int from_tty
 
   if (!gdbarch_update_p (info))
     internal_error (__FILE__, __LINE__,
 
   if (!gdbarch_update_p (info))
     internal_error (__FILE__, __LINE__,

-                   _("rs6000_create_inferior: failed to select architecture"));
+                   _("rs6000_create_inferior: failed "
+                     "to select architecture"));

 }
 
 \f
 /* xcoff_relocate_symtab -      hook for symbol table relocation.
 }
 
 \f
 /* xcoff_relocate_symtab -      hook for symbol table relocation.

-   also reads shared libraries.  */
+   
+   This is only applicable to live processes, and is a no-op when
+   debugging a core file.  */

 
 void
 xcoff_relocate_symtab (unsigned int pid)
 
 void
 xcoff_relocate_symtab (unsigned int pid)


@@ -1064,6 +1041,10 @@ xcoff_relocate_symtab (unsigned int pid)
   int ldisize = arch64 ? sizeof (ldi->l64) : sizeof (ldi->l32);
   int size;
 
   int ldisize = arch64 ? sizeof (ldi->l64) : sizeof (ldi->l32);
   int size;
 

+  /* Nothing to do if we are debugging a core file.  */
+  if (!target_has_execution)
+    return;
+

   do
     {
       size = load_segs * ldisize;
   do
     {
       size = load_segs * ldisize;


@@ -1072,8 +1053,8 @@ xcoff_relocate_symtab (unsigned int pid)
 #if 0
       /* According to my humble theory, AIX has some timing problems and
          when the user stack grows, kernel doesn't update stack info in time
 #if 0
       /* According to my humble theory, AIX has some timing problems and
          when the user stack grows, kernel doesn't update stack info in time

-         and ptrace calls step on user stack. That is why we sleep here a
-         little, and give kernel to update its internals. */
+         and ptrace calls step on user stack.  That is why we sleep here a
+         little, and give kernel to update its internals.  */

       usleep (36000);
 #endif
 
       usleep (36000);
 #endif
 


@@ -1092,7 +1073,7 @@ xcoff_relocate_symtab (unsigned int pid)
       else
        {
           vmap_ldinfo (ldi);
       else
        {
           vmap_ldinfo (ldi);

-          vmap_exec (); /* relocate the exec and core sections as well. */
+          vmap_exec (); /* relocate the exec and core sections as well.  */

        }
     } while (rc == -1);
   if (ldi)
        }
     } while (rc == -1);
   if (ldi)


@@ -1113,7 +1094,7 @@ xcoff_relocate_core (struct target_ops *target)
   struct vmap *vp;
   int arch64 = ARCH64 ();
 
   struct vmap *vp;
   int arch64 = ARCH64 ();
 

-  /* Size of a struct ld_info except for the variable-length filename. */
+  /* Size of a struct ld_info except for the variable-length filename.  */

   int nonfilesz = (int)LDI_FILENAME ((LdInfo *)0, arch64);
 
   /* Allocated size of buffer.  */
   int nonfilesz = (int)LDI_FILENAME ((LdInfo *)0, arch64);
 
   /* Allocated size of buffer.  */


@@ -1171,7 +1152,7 @@ xcoff_relocate_core (struct target_ops *target)
       else
        vp = add_vmap (ldi);
 
       else
        vp = add_vmap (ldi);
 

-      /* Process next shared library upon error. */
+      /* Process next shared library upon error.  */

       offset += LDI_NEXT (ldi, arch64);
       if (vp == NULL)
        continue;
       offset += LDI_NEXT (ldi, arch64);
       if (vp == NULL)
        continue;


@@ -1182,10 +1163,9 @@ xcoff_relocate_core (struct target_ops *target)
          add our sections to the section table for the core target.  */
       if (vp != vmap)
        {
          add our sections to the section table for the core target.  */
       if (vp != vmap)
        {

-         struct section_table *stp;
+         struct target_section *stp;

 
 

-         target_resize_to_sections (target, 2);
-         stp = target->to_sections_end - 2;
+         stp = deprecated_core_resize_section_table (2);

 
          stp->bfd = vp->bfd;
          stp->the_bfd_section = bfd_get_section_by_name (stp->bfd, ".text");
 
          stp->bfd = vp->bfd;
          stp->the_bfd_section = bfd_get_section_by_name (stp->bfd, ".text");


@@ -1201,8 +1181,8 @@ xcoff_relocate_core (struct target_ops *target)
 
       vmap_symtab (vp);
 
 
       vmap_symtab (vp);
 

-      if (deprecated_target_new_objfile_hook && vp != vmap && vp->objfile)
-       deprecated_target_new_objfile_hook (vp->objfile);
+      if (vp != vmap && vp->objfile)
+       observer_notify_new_objfile (vp->objfile);

     }
   while (LDI_NEXT (ldi, arch64) != 0);
   vmap_exec ();
     }
   while (LDI_NEXT (ldi, arch64) != 0);
   vmap_exec ();


@@ -1219,34 +1199,23 @@ static CORE_ADDR
 find_toc_address (CORE_ADDR pc)
 {
   struct vmap *vp;
 find_toc_address (CORE_ADDR pc)
 {
   struct vmap *vp;

-  extern CORE_ADDR get_toc_offset (struct objfile *);  /* xcoffread.c */

 
   for (vp = vmap; vp; vp = vp->nxt)
     {
       if (pc >= vp->tstart && pc < vp->tend)
        {
          /* vp->objfile is only NULL for the exec file.  */
 
   for (vp = vmap; vp; vp = vp->nxt)
     {
       if (pc >= vp->tstart && pc < vp->tend)
        {
          /* vp->objfile is only NULL for the exec file.  */

-         return vp->dstart + get_toc_offset (vp->objfile == NULL
-                                             ? symfile_objfile
-                                             : vp->objfile);
+         return vp->dstart + xcoff_get_toc_offset (vp->objfile == NULL
+                                                   ? symfile_objfile
+                                                   : vp->objfile);

        }
     }
   error (_("Unable to find TOC entry for pc %s."), hex_string (pc));
 }
 \f
        }
     }
   error (_("Unable to find TOC entry for pc %s."), hex_string (pc));
 }
 \f

-/* Register that we are able to handle rs6000 core file formats. */
-
-static struct core_fns rs6000_core_fns =
-{
-  bfd_target_xcoff_flavour,            /* core_flavour */
-  default_check_format,                        /* check_format */
-  default_core_sniffer,                        /* core_sniffer */
-  fetch_core_registers,                        /* core_read_registers */
-  NULL                                 /* next */
-};

 
 void
 
 void

-_initialize_core_rs6000 (void)
+_initialize_rs6000_nat (void)

 {
   struct target_ops *t;
 
 {
   struct target_ops *t;
 


@@ -1258,11 +1227,11 @@ _initialize_core_rs6000 (void)
   super_create_inferior = t->to_create_inferior;
   t->to_create_inferior = rs6000_create_inferior;
 
   super_create_inferior = t->to_create_inferior;
   t->to_create_inferior = rs6000_create_inferior;
 

+  t->to_wait = rs6000_wait;
+

   add_target (t);
 
   /* Initialize hook in rs6000-tdep.c for determining the TOC address
      when calling functions in the inferior.  */
   rs6000_find_toc_address_hook = find_toc_address;
   add_target (t);
 
   /* Initialize hook in rs6000-tdep.c for determining the TOC address
      when calling functions in the inferior.  */
   rs6000_find_toc_address_hook = find_toc_address;

-
-  deprecated_add_core_fns (&rs6000_core_fns);

 }
 }