2007-06-18 Markus Deuling <deuling@de.ibm.com>
[deliverable/binutils-gdb.git] / gdb / rs6000-nat.c
index 7db0ba0f8d813cf40c0ca0282916f97c573deade..f8866aa0d22d37f0284a24cc08b753c6c801c74c 100644 (file)
@@ -1,6 +1,7 @@
 /* IBM RS/6000 native-dependent code for GDB, the GNU debugger.
 /* IBM RS/6000 native-dependent code for GDB, the GNU debugger.
-   Copyright 1986, 1987, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
-   1998, 1999, 2000, 2001
+
+   Copyright (C) 1986, 1987, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
+   1998, 1999, 2000, 2001, 2002, 2003, 2004, 2007
    Free Software Foundation, Inc.
 
    This file is part of GDB.
    Free Software Foundation, Inc.
 
    This file is part of GDB.
@@ -17,8 +18,8 @@
 
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
 
    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.  */
+   Foundation, Inc., 51 Franklin Street, Fifth Floor,
+   Boston, MA 02110-1301, USA.  */
 
 #include "defs.h"
 #include "inferior.h"
 
 #include "defs.h"
 #include "inferior.h"
 #include "xcoffsolib.h"
 #include "symfile.h"
 #include "objfiles.h"
 #include "xcoffsolib.h"
 #include "symfile.h"
 #include "objfiles.h"
-#include "libbfd.h"            /* For bfd_cache_lookup (FIXME) */
+#include "libbfd.h"            /* For bfd_default_set_arch_mach (FIXME) */
 #include "bfd.h"
 #include "bfd.h"
+#include "exceptions.h"
 #include "gdb-stabs.h"
 #include "regcache.h"
 #include "gdb-stabs.h"
 #include "regcache.h"
+#include "arch-utils.h"
+#include "inf-ptrace.h"
+#include "ppc-tdep.h"
+#include "rs6000-tdep.h"
+#include "exec.h"
+#include "gdb_stdint.h"
+#include "observer.h"
 
 #include <sys/ptrace.h>
 #include <sys/reg.h>
 
 #include <sys/ptrace.h>
 #include <sys/reg.h>
 #ifndef ARCH3264
 # define ARCH64() 0
 #else
 #ifndef ARCH3264
 # define ARCH64() 0
 #else
-# define ARCH64() (REGISTER_RAW_SIZE (0) == 8)
-#endif
-
-/* Union of 32-bit and 64-bit ".reg" core file sections. */
-
-typedef union {
-#ifdef ARCH3264
-  struct __context64 r64;
-#else
-  struct mstsave r64;
+# define ARCH64() (register_size (current_gdbarch, 0) == 8)
 #endif
 #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. */
 
@@ -124,8 +122,6 @@ typedef union {
 
 extern struct vmap *map_vmap (bfd * bf, bfd * arch);
 
 
 extern struct vmap *map_vmap (bfd * bf, bfd * arch);
 
-extern struct target_ops exec_ops;
-
 static void vmap_exec (void);
 
 static void vmap_ldinfo (LdInfo *);
 static void vmap_exec (void);
 
 static void vmap_ldinfo (LdInfo *);
@@ -136,34 +132,60 @@ 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 (void);
 
-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);
 
 
-/* Conversion from gdb-to-system special purpose register numbers. */
+/* Given REGNO, a gdb register number, return the corresponding
+   number suitable for use as a ptrace() parameter.  Return -1 if
+   there's no suitable mapping.  Also, set the int pointed to by
+   ISFLOAT to indicate whether REGNO is a floating point register.  */
 
 
-static int special_regs[] =
+static int
+regmap (int regno, int *isfloat)
 {
 {
-  IAR,                         /* PC_REGNUM    */
-  MSR,                         /* PS_REGNUM    */
-  CR,                          /* CR_REGNUM    */
-  LR,                          /* LR_REGNUM    */
-  CTR,                         /* CTR_REGNUM   */
-  XER,                         /* XER_REGNUM   */
-  MQ                           /* MQ_REGNUM    */
-};
+  struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+
+  *isfloat = 0;
+  if (tdep->ppc_gp0_regnum <= regno
+      && regno < tdep->ppc_gp0_regnum + ppc_num_gprs)
+    return regno;
+  else if (tdep->ppc_fp0_regnum >= 0
+           && tdep->ppc_fp0_regnum <= regno
+           && regno < tdep->ppc_fp0_regnum + ppc_num_fprs)
+    {
+      *isfloat = 1;
+      return regno - tdep->ppc_fp0_regnum + FPR0;
+    }
+  else if (regno == gdbarch_pc_regnum (current_gdbarch))
+    return IAR;
+  else if (regno == tdep->ppc_ps_regnum)
+    return MSR;
+  else if (regno == tdep->ppc_cr_regnum)
+    return CR;
+  else if (regno == tdep->ppc_lr_regnum)
+    return LR;
+  else if (regno == tdep->ppc_ctr_regnum)
+    return CTR;
+  else if (regno == tdep->ppc_xer_regnum)
+    return XER;
+  else if (tdep->ppc_fpscr_regnum >= 0
+           && regno == tdep->ppc_fpscr_regnum)
+    return FPSCR;
+  else if (tdep->ppc_mq_regnum >= 0 && regno == tdep->ppc_mq_regnum)
+    return MQ;
+  else
+    return -1;
+}
 
 /* Call ptrace(REQ, ID, ADDR, DATA, BUF). */
 
 static int
 
 /* Call ptrace(REQ, ID, ADDR, DATA, BUF). */
 
 static int
-ptrace32 (int req, int id, int *addr, int data, int *buf)
+rs6000_ptrace32 (int req, int id, int *addr, int data, int *buf)
 {
   int ret = ptrace (req, id, (int *)addr, data, buf);
 #if 0
 {
   int ret = ptrace (req, id, (int *)addr, data, buf);
 #if 0
-  printf ("ptrace32 (%d, %d, 0x%x, %08x, 0x%x) = 0x%x\n",
+  printf ("rs6000_ptrace32 (%d, %d, 0x%x, %08x, 0x%x) = 0x%x\n",
          req, id, (unsigned int)addr, data, (unsigned int)buf, ret);
 #endif
   return ret;
          req, id, (unsigned int)addr, data, (unsigned int)buf, ret);
 #endif
   return ret;
@@ -172,7 +194,7 @@ ptrace32 (int req, int id, int *addr, int data, int *buf)
 /* Call ptracex(REQ, ID, ADDR, DATA, BUF). */
 
 static int
 /* Call ptracex(REQ, ID, ADDR, DATA, BUF). */
 
 static int
-ptrace64 (int req, int id, long long addr, int data, int *buf)
+rs6000_ptrace64 (int req, int id, long long addr, int data, void *buf)
 {
 #ifdef ARCH3264
   int ret = ptracex (req, id, addr, data, buf);
 {
 #ifdef ARCH3264
   int ret = ptracex (req, id, addr, data, buf);
@@ -180,7 +202,7 @@ ptrace64 (int req, int id, long long addr, int data, int *buf)
   int ret = 0;
 #endif
 #if 0
   int ret = 0;
 #endif
 #if 0
-  printf ("ptrace64 (%d, %d, 0x%llx, %08x, 0x%x) = 0x%x\n",
+  printf ("rs6000_ptrace64 (%d, %d, 0x%llx, %08x, 0x%x) = 0x%x\n",
          req, id, addr, data, (unsigned int)buf, ret);
 #endif
   return ret;
          req, id, addr, data, (unsigned int)buf, ret);
 #endif
   return ret;
@@ -189,44 +211,42 @@ ptrace64 (int req, int id, long long addr, int data, int *buf)
 /* Fetch register REGNO from the inferior. */
 
 static void
 /* Fetch register REGNO from the inferior. */
 
 static void
-fetch_register (int regno)
+fetch_register (struct regcache *regcache, int regno)
 {
 {
-  int *addr = (int *) &registers[REGISTER_BYTE (regno)];
-  int nr;
+  int addr[MAX_REGISTER_SIZE];
+  int nr, isfloat;
 
   /* Retrieved values may be -1, so infer errors from errno. */
   errno = 0;
 
 
   /* Retrieved values may be -1, so infer errors from errno. */
   errno = 0;
 
+  nr = regmap (regno, &isfloat);
+
   /* Floating-point registers. */
   /* Floating-point registers. */
-  if (regno >= FP0_REGNUM && regno <= FPLAST_REGNUM)
-    {
-      nr = regno - FP0_REGNUM + FPR0;
-      ptrace32 (PT_READ_FPR, inferior_pid, addr, nr, 0);
-    }
+  if (isfloat)
+    rs6000_ptrace32 (PT_READ_FPR, PIDGET (inferior_ptid), addr, nr, 0);
 
   /* Bogus register number. */
 
   /* Bogus register number. */
-  else if (regno > LAST_UISA_SP_REGNUM)
-    fprintf_unfiltered (gdb_stderr,
-                       "gdb error: register no %d not implemented.\n",
-                       regno);
+  else if (nr < 0)
+    {
+      if (regno >= gdbarch_num_regs (current_gdbarch))
+       fprintf_unfiltered (gdb_stderr,
+                           "gdb error: register no %d not implemented.\n",
+                           regno);
+      return;
+    }
 
   /* Fixed-point registers. */
   else
     {
 
   /* Fixed-point registers. */
   else
     {
-      if (regno >= FIRST_UISA_SP_REGNUM)
-       nr = special_regs[regno - FIRST_UISA_SP_REGNUM];
-      else
-       nr = regno;
-
       if (!ARCH64 ())
       if (!ARCH64 ())
-       *addr = ptrace32 (PT_READ_GPR, inferior_pid, (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,
             even if the register is really only 32 bits. */
          long long buf;
       else
        {
          /* PT_READ_GPR requires the buffer parameter to point to long long,
             even if the register is really only 32 bits. */
          long long buf;
-         ptrace64 (PT_READ_GPR, inferior_pid, nr, 0, (int *)&buf);
-         if (REGISTER_RAW_SIZE (regno) == 8)
+         rs6000_ptrace64 (PT_READ_GPR, PIDGET (inferior_ptid), nr, 0, &buf);
+         if (register_size (current_gdbarch, regno) == 8)
            memcpy (addr, &buf, 8);
          else
            *addr = buf;
            memcpy (addr, &buf, 8);
          else
            *addr = buf;
@@ -234,7 +254,7 @@ fetch_register (int regno)
     }
 
   if (!errno)
     }
 
   if (!errno)
-    register_valid[regno] = 1;
+    regcache_raw_supply (regcache, regno, (char *) addr);
   else
     {
 #if 0
   else
     {
 #if 0
@@ -248,25 +268,27 @@ fetch_register (int regno)
 /* Store register REGNO back into the inferior. */
 
 static void
 /* Store register REGNO back into the inferior. */
 
 static void
-store_register (int regno)
+store_register (const struct regcache *regcache, int regno)
 {
 {
-  int *addr = (int *) &registers[REGISTER_BYTE (regno)];
-  int nr;
+  int addr[MAX_REGISTER_SIZE];
+  int nr, isfloat;
+
+  /* Fetch the register's value from the register cache.  */
+  regcache_raw_collect (regcache, regno, addr);
 
   /* -1 can be a successful return value, so infer errors from errno. */
   errno = 0;
 
 
   /* -1 can be a successful return value, so infer errors from errno. */
   errno = 0;
 
+  nr = regmap (regno, &isfloat);
+
   /* Floating-point registers. */
   /* Floating-point registers. */
-  if (regno >= FP0_REGNUM && regno <= FPLAST_REGNUM)
-    {
-      nr = regno - FP0_REGNUM + FPR0;
-      ptrace32 (PT_WRITE_FPR, inferior_pid, addr, nr, 0);
-    }
+  if (isfloat)
+    rs6000_ptrace32 (PT_WRITE_FPR, PIDGET (inferior_ptid), addr, nr, 0);
 
   /* Bogus register number. */
 
   /* Bogus register number. */
-  else if (regno > LAST_UISA_SP_REGNUM)
+  else if (nr < 0)
     {
     {
-      if (regno >= NUM_REGS)
+      if (regno >= gdbarch_num_regs (current_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);
@@ -275,7 +297,7 @@ store_register (int regno)
   /* Fixed-point registers. */
   else
     {
   /* Fixed-point registers. */
   else
     {
-      if (regno == SP_REGNUM)
+      if (regno == gdbarch_sp_regnum (current_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
        /* 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
@@ -283,23 +305,21 @@ store_register (int regno)
           (%sp). */
        exec_one_dummy_insn ();
 
           (%sp). */
        exec_one_dummy_insn ();
 
-      if (regno >= FIRST_UISA_SP_REGNUM)
-       nr = special_regs[regno - FIRST_UISA_SP_REGNUM];
-      else
-       nr = regno;
-
+      /* 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 ())
       if (!ARCH64 ())
-       ptrace32 (PT_WRITE_GPR, inferior_pid, (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
             area, even if the register is really only 32 bits. */
          long long buf;
       else
        {
          /* PT_WRITE_GPR requires the buffer parameter to point to an 8-byte
             area, even if the register is really only 32 bits. */
          long long buf;
-         if (REGISTER_RAW_SIZE (regno) == 8)
+         if (register_size (current_gdbarch, regno) == 8)
            memcpy (&buf, addr, 8);
          else
            buf = *addr;
            memcpy (&buf, addr, 8);
          else
            buf = *addr;
-         ptrace64 (PT_WRITE_GPR, inferior_pid, nr, 0, (int *)&buf);
+         rs6000_ptrace64 (PT_WRITE_GPR, PIDGET (inferior_ptid), nr, 0, &buf);
        }
     }
 
        }
     }
 
@@ -313,25 +333,40 @@ store_register (int regno)
 /* Read from the inferior all registers if REGNO == -1 and just register
    REGNO otherwise. */
 
 /* Read from the inferior all registers if REGNO == -1 and just register
    REGNO otherwise. */
 
-void
-fetch_inferior_registers (int regno)
+static void
+rs6000_fetch_inferior_registers (struct regcache *regcache, int regno)
 {
   if (regno != -1)
 {
   if (regno != -1)
-    fetch_register (regno);
+    fetch_register (regcache, regno);
 
   else
     {
 
   else
     {
-      /* read 32 general purpose registers. */
-      for (regno = 0; regno < 32; regno++)
-       fetch_register (regno);
+      struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
 
 
-      /* read general purpose floating point registers. */
-      for (regno = FP0_REGNUM; regno <= FPLAST_REGNUM; regno++)
-       fetch_register (regno);
+      /* Read 32 general purpose registers.  */
+      for (regno = tdep->ppc_gp0_regnum;
+           regno < tdep->ppc_gp0_regnum + ppc_num_gprs;
+          regno++)
+       {
+         fetch_register (regcache, regno);
+       }
 
 
-      /* read special registers. */
-      for (regno = FIRST_UISA_SP_REGNUM; regno <= LAST_UISA_SP_REGNUM; regno++)
-       fetch_register (regno);
+      /* Read general purpose floating point registers.  */
+      if (tdep->ppc_fp0_regnum >= 0)
+        for (regno = 0; regno < ppc_num_fprs; regno++)
+          fetch_register (regcache, tdep->ppc_fp0_regnum + regno);
+
+      /* Read special registers.  */
+      fetch_register (regcache, gdbarch_pc_regnum (current_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)
+        fetch_register (regcache, tdep->ppc_fpscr_regnum);
+      if (tdep->ppc_mq_regnum >= 0)
+       fetch_register (regcache, tdep->ppc_mq_regnum);
     }
 }
 
     }
 }
 
@@ -339,120 +374,199 @@ fetch_inferior_registers (int regno)
    If REGNO is -1, do this for all registers.
    Otherwise, REGNO specifies which register (so we can save time).  */
 
    If REGNO is -1, do this for all registers.
    Otherwise, REGNO specifies which register (so we can save time).  */
 
-void
-store_inferior_registers (int regno)
+static void
+rs6000_store_inferior_registers (struct regcache *regcache, int regno)
 {
   if (regno != -1)
 {
   if (regno != -1)
-    store_register (regno);
+    store_register (regcache, regno);
 
   else
     {
 
   else
     {
-      /* write general purpose registers first! */
-      for (regno = GPR0; regno <= GPR31; regno++)
-       store_register (regno);
-
-      /* write floating point registers now. */
-      for (regno = FP0_REGNUM; regno <= FPLAST_REGNUM; regno++)
-       store_register (regno);
+      struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
 
 
-      /* write special registers. */
+      /* Write general purpose registers first.  */
+      for (regno = tdep->ppc_gp0_regnum;
+           regno < tdep->ppc_gp0_regnum + ppc_num_gprs;
+          regno++)
+       {
+         store_register (regcache, regno);
+       }
 
 
-      for (regno = FIRST_UISA_SP_REGNUM; regno <= LAST_UISA_SP_REGNUM; regno++)
-       store_register (regno);
+      /* Write floating point registers.  */
+      if (tdep->ppc_fp0_regnum >= 0)
+        for (regno = 0; regno < ppc_num_fprs; regno++)
+          store_register (regcache, tdep->ppc_fp0_regnum + regno);
+
+      /* Write special registers.  */
+      store_register (regcache, gdbarch_pc_regnum (current_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)
+        store_register (regcache, tdep->ppc_fpscr_regnum);
+      if (tdep->ppc_mq_regnum >= 0)
+       store_register (regcache, tdep->ppc_mq_regnum);
     }
 }
 
     }
 }
 
-/* Store in *TO the 32-bit word at 32-bit-aligned ADDR in the child
-   process, which is 64-bit if ARCH64 and 32-bit otherwise.  Return
-   success. */
 
 
-static int
-read_word (CORE_ADDR from, int *to, int arch64)
-{
-  /* Retrieved values may be -1, so infer errors from errno. */
-  errno = 0;
+/* 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.  */
 
 
-  if (arch64)
-    *to = ptrace64 (PT_READ_I, inferior_pid, from, 0, NULL);
-  else
-    *to = ptrace32 (PT_READ_I, inferior_pid, (int *)(long) from, 0, NULL);
+static LONGEST
+rs6000_xfer_partial (struct target_ops *ops, enum target_object object,
+                    const char *annex, gdb_byte *readbuf,
+                    const gdb_byte *writebuf,
+                    ULONGEST offset, LONGEST len)
+{
+  pid_t pid = ptid_get_pid (inferior_ptid);
+  int arch64 = ARCH64 ();
 
 
-  return !errno;
+  switch (object)
+    {
+    case TARGET_OBJECT_MEMORY:
+      {
+       union
+       {
+         PTRACE_TYPE_RET word;
+         gdb_byte byte[sizeof (PTRACE_TYPE_RET)];
+       } buffer;
+       ULONGEST rounded_offset;
+       LONGEST partial_len;
+
+       /* Round the start offset down to the next long word
+          boundary.  */
+       rounded_offset = offset & -(ULONGEST) sizeof (PTRACE_TYPE_RET);
+
+       /* Since ptrace will transfer a single word starting at that
+          rounded_offset the partial_len needs to be adjusted down to
+          that (remember this function only does a single transfer).
+          Should the required length be even less, adjust it down
+          again.  */
+       partial_len = (rounded_offset + sizeof (PTRACE_TYPE_RET)) - offset;
+       if (partial_len > len)
+         partial_len = len;
+
+       if (writebuf)
+         {
+           /* If OFFSET:PARTIAL_LEN is smaller than
+              ROUNDED_OFFSET:WORDSIZE then a read/modify write will
+              be needed.  Read in the entire word.  */
+           if (rounded_offset < offset
+               || (offset + partial_len
+                   < rounded_offset + sizeof (PTRACE_TYPE_RET)))
+             {
+               /* Need part of initial word -- fetch it.  */
+               if (arch64)
+                 buffer.word = rs6000_ptrace64 (PT_READ_I, pid,
+                                                rounded_offset, 0, NULL);
+               else
+                 buffer.word = rs6000_ptrace32 (PT_READ_I, pid,
+                                                (int *)(uintptr_t)rounded_offset,
+                                                0, NULL);
+             }
+
+           /* Copy data to be written over corresponding part of
+              buffer.  */
+           memcpy (buffer.byte + (offset - rounded_offset),
+                   writebuf, partial_len);
+
+           errno = 0;
+           if (arch64)
+             rs6000_ptrace64 (PT_WRITE_D, pid,
+                              rounded_offset, buffer.word, NULL);
+           else
+             rs6000_ptrace32 (PT_WRITE_D, pid,
+                              (int *)(uintptr_t)rounded_offset, buffer.word, NULL);
+           if (errno)
+             return 0;
+         }
+
+       if (readbuf)
+         {
+           errno = 0;
+           if (arch64)
+             buffer.word = rs6000_ptrace64 (PT_READ_I, pid,
+                                            rounded_offset, 0, NULL);
+           else
+             buffer.word = rs6000_ptrace32 (PT_READ_I, pid,
+                                            (int *)(uintptr_t)rounded_offset,
+                                            0, NULL);
+           if (errno)
+             return 0;
+
+           /* Copy appropriate bytes out of the buffer.  */
+           memcpy (readbuf, buffer.byte + (offset - rounded_offset),
+                   partial_len);
+         }
+
+       return partial_len;
+      }
+
+    default:
+      return -1;
+    }
 }
 
 }
 
-/* Copy LEN bytes to or from inferior's memory starting at MEMADDR
-   to debugger memory starting at MYADDR.  Copy to inferior if
-   WRITE is nonzero.
-
-   Returns the length copied, which is either the LEN argument or zero.
-   This xfer function does not do partial moves, since child_ops
-   doesn't allow memory operations to cross below us in the target stack
-   anyway.  */
+/* 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.  */
 
 
-int
-child_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len,
-                  int write, struct mem_attrib *attrib,
-                  struct target_ops *target)
+static ptid_t
+rs6000_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
 {
 {
-  /* Round starting address down to 32-bit word boundary. */
-  int mask = sizeof (int) - 1;
-  CORE_ADDR addr = memaddr & ~(CORE_ADDR)mask;
+  pid_t pid;
+  int status, save_errno;
 
 
-  /* Round ending address up to 32-bit word boundary. */
-  int count = ((memaddr + len - addr + mask) & ~(CORE_ADDR)mask)
-    / sizeof (int);
+  do
+    {
+      set_sigint_trap ();
+      set_sigio_trap ();
 
 
-  /* Allocate word transfer buffer. */
-  int *buf = (int *) alloca (count * sizeof (int));
+      do
+       {
+         pid = waitpid (ptid_get_pid (ptid), &status, 0);
+         save_errno = errno;
+       }
+      while (pid == -1 && errno == EINTR);
 
 
-  int arch64 = ARCH64 ();
-  int i;
+      clear_sigio_trap ();
+      clear_sigint_trap ();
 
 
-  if (!write)
-    {
-      /* Retrieve memory a word at a time. */
-      for (i = 0; i < count; i++, addr += sizeof (int))
+      if (pid == -1)
        {
        {
-         if (!read_word (addr, buf + i, arch64))
-           return 0;
-         QUIT;
+         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 minus_one_ptid;
        }
 
        }
 
-      /* Copy memory to supplied buffer. */
-      addr -= count * sizeof (int);
-      memcpy (myaddr, (char *)buf + (memaddr - addr), len);
+      /* Ignore terminated detached child processes.  */
+      if (!WIFSTOPPED (status) && pid != ptid_get_pid (inferior_ptid))
+       pid = -1;
     }
     }
-  else
-    {
-      /* Fetch leading memory needed for alignment. */
-      if (addr < memaddr)
-       if (!read_word (addr, buf, arch64))
-         return 0;
+  while (pid == -1);
 
 
-      /* Fetch trailing memory needed for alignment. */
-      if (addr + count * sizeof (int) > memaddr + len)
-       if (!read_word (addr, buf + count - 1, arch64))
-         return 0;
-
-      /* Copy supplied data into memory buffer. */
-      memcpy ((char *)buf + (memaddr - addr), myaddr, len);
-
-      /* Store memory one word at a time. */
-      for (i = 0, errno = 0; i < count; i++, addr += sizeof (int))
-       {
-         if (arch64)
-           ptrace64 (PT_WRITE_D, inferior_pid, addr, buf[i], NULL);
-         else
-           ptrace32 (PT_WRITE_D, inferior_pid, (int *)(long) addr,
-                     buf[i], NULL);
+  /* AIX has a couple of strange returns from wait().  */
 
 
-         if (errno)
-           return 0;
-         QUIT;
-       }
-    }
+  /* 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 len;
+  return pid_to_ptid (pid);
 }
 
 /* Execute one dummy breakpoint instruction.  This way we give the kernel
 }
 
 /* Execute one dummy breakpoint instruction.  This way we give the kernel
@@ -462,17 +576,17 @@ child_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len,
 static void
 exec_one_dummy_insn (void)
 {
 static void
 exec_one_dummy_insn (void)
 {
-#define        DUMMY_INSN_ADDR (TEXT_SEGMENT_BASE)+0x200
+#define        DUMMY_INSN_ADDR gdbarch_tdep (current_gdbarch)->text_segment_base+0x200
 
 
-  char shadow_contents[BREAKPOINT_MAX];                /* Stash old bkpt addr contents */
   int ret, status, pid;
   CORE_ADDR prev_pc;
   int ret, status, pid;
   CORE_ADDR prev_pc;
+  void *bp;
 
   /* We plant one dummy breakpoint into DUMMY_INSN_ADDR address. We
      assume that this address will never be executed again by the real
      code. */
 
 
   /* We plant one dummy breakpoint into DUMMY_INSN_ADDR address. We
      assume that this address will never be executed again by the real
      code. */
 
-  target_insert_breakpoint (DUMMY_INSN_ADDR, shadow_contents);
+  bp = deprecated_insert_raw_breakpoint (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
 
   /* 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
@@ -482,9 +596,9 @@ exec_one_dummy_insn (void)
   prev_pc = read_pc ();
   write_pc (DUMMY_INSN_ADDR);
   if (ARCH64 ())
   prev_pc = read_pc ();
   write_pc (DUMMY_INSN_ADDR);
   if (ARCH64 ())
-    ret = ptrace64 (PT_CONTINUE, inferior_pid, 1, 0, NULL);
+    ret = rs6000_ptrace64 (PT_CONTINUE, PIDGET (inferior_ptid), 1, 0, NULL);
   else
   else
-    ret = ptrace32 (PT_CONTINUE, inferior_pid, (int *)1, 0, NULL);
+    ret = rs6000_ptrace32 (PT_CONTINUE, PIDGET (inferior_ptid), (int *)1, 0, NULL);
 
   if (ret != 0)
     perror ("pt_continue");
 
   if (ret != 0)
     perror ("pt_continue");
@@ -493,71 +607,10 @@ exec_one_dummy_insn (void)
     {
       pid = wait (&status);
     }
     {
       pid = wait (&status);
     }
-  while (pid != inferior_pid);
+  while (pid != PIDGET (inferior_ptid));
 
   write_pc (prev_pc);
 
   write_pc (prev_pc);
-  target_remove_breakpoint (DUMMY_INSN_ADDR, shadow_contents);
-}
-
-/* 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;
-  double *fprs;
-  int arch64, i, size;
-  void *gprs, *sprs[7];
-
-  if (which != 0)
-    {
-      fprintf_unfiltered
-       (gdb_stderr,
-        "Gdb error: unknown parameter to fetch_core_registers().\n");
-      return;
-    }
-
-  arch64 = ARCH64 ();
-  regs = (CoreRegs *) core_reg_sect;
-
-  /* Retrieve register pointers. */
-
-  if (arch64)
-    {
-      gprs = regs->r64.gpr;
-      fprs = regs->r64.fpr;
-      sprs[0] = &regs->r64.iar;
-      sprs[1] = &regs->r64.msr;
-      sprs[2] = &regs->r64.cr;
-      sprs[3] = &regs->r64.lr;
-      sprs[4] = &regs->r64.ctr;
-      sprs[5] = &regs->r64.xer;
-    }
-  else
-    {
-      gprs = regs->r32.gpr;
-      fprs = regs->r32.fpr;
-      sprs[0] = &regs->r32.iar;
-      sprs[1] = &regs->r32.msr;
-      sprs[2] = &regs->r32.cr;
-      sprs[3] = &regs->r32.lr;
-      sprs[4] = &regs->r32.ctr;
-      sprs[5] = &regs->r32.xer;
-      sprs[6] = &regs->r32.mq;
-    }
-
-  /* Copy from pointers to registers[]. */
-
-  memcpy (registers, gprs, 32 * (arch64 ? 8 : 4));
-  memcpy (registers + REGISTER_BYTE (FP0_REGNUM), fprs, 32 * 8);
-  for (i = FIRST_UISA_SP_REGNUM; i <= LAST_UISA_SP_REGNUM; i++)
-    {
-      size = REGISTER_RAW_SIZE (i);
-      if (size)
-       memcpy (registers + REGISTER_BYTE (i),
-               sprs[i - FIRST_UISA_SP_REGNUM], size);
-    }
+  deprecated_remove_raw_breakpoint (bp);
 }
 \f
 
 }
 \f
 
@@ -594,7 +647,7 @@ vmap_secs (struct vmap *vp, LdInfo *ldi, int arch64)
 static void
 vmap_symtab (struct vmap *vp)
 {
 static void
 vmap_symtab (struct vmap *vp)
 {
-  register struct objfile *objfile;
+  struct objfile *objfile;
   struct section_offsets *new_offsets;
   int i;
 
   struct section_offsets *new_offsets;
   int i;
 
@@ -612,7 +665,9 @@ vmap_symtab (struct vmap *vp)
     /* If symbols are not yet loaded, offsets are not yet valid. */
     return;
 
     /* If symbols are not yet loaded, offsets are not yet valid. */
     return;
 
-  new_offsets = (struct section_offsets *) alloca (SIZEOF_SECTION_OFFSETS);
+  new_offsets =
+    (struct section_offsets *)
+    alloca (SIZEOF_N_SECTION_OFFSETS (objfile->num_sections));
 
   for (i = 0; i < objfile->num_sections; ++i)
     new_offsets->offsets[i] = ANOFFSET (objfile->section_offsets, i);
 
   for (i = 0; i < objfile->num_sections; ++i)
     new_offsets->offsets[i] = ANOFFSET (objfile->section_offsets, i);
@@ -633,7 +688,7 @@ objfile_symbol_add (void *arg)
 {
   struct objfile *obj = (struct objfile *) arg;
 
 {
   struct objfile *obj = (struct objfile *) arg;
 
-  syms_from_objfile (obj, NULL, 0, 0);
+  syms_from_objfile (obj, NULL, 0, 0, 0, 0);
   new_symfile_objfile (obj, 0, 0);
   return 1;
 }
   new_symfile_objfile (obj, 0, 0);
   return 1;
 }
@@ -666,7 +721,7 @@ static struct vmap *
 add_vmap (LdInfo *ldi)
 {
   bfd *abfd, *last;
 add_vmap (LdInfo *ldi)
 {
   bfd *abfd, *last;
-  register char *mem, *objname, *filename;
+  char *mem, *objname, *filename;
   struct objfile *obj;
   struct vmap *vp;
   int fd;
   struct objfile *obj;
   struct vmap *vp;
   int fd;
@@ -690,7 +745,7 @@ add_vmap (LdInfo *ldi)
     abfd = bfd_fdopenr (objname, gnutarget, fd);
   if (!abfd)
     {
     abfd = bfd_fdopenr (objname, gnutarget, fd);
   if (!abfd)
     {
-      warning ("Could not open `%s' as an executable file: %s",
+      warning (_("Could not open `%s' as an executable file: %s"),
               objname, bfd_errmsg (bfd_get_error ()));
       return NULL;
     }
               objname, bfd_errmsg (bfd_get_error ()));
       return NULL;
     }
@@ -705,19 +760,19 @@ add_vmap (LdInfo *ldi)
       last = 0;
       /* FIXME??? am I tossing BFDs?  bfd? */
       while ((last = bfd_openr_next_archived_file (abfd, last)))
       last = 0;
       /* FIXME??? am I tossing BFDs?  bfd? */
       while ((last = bfd_openr_next_archived_file (abfd, last)))
-       if (STREQ (mem, last->filename))
+       if (DEPRECATED_STREQ (mem, last->filename))
          break;
 
       if (!last)
        {
          break;
 
       if (!last)
        {
-         warning ("\"%s\": member \"%s\" missing.", objname, mem);
+         warning (_("\"%s\": member \"%s\" missing."), objname, mem);
          bfd_close (abfd);
          return NULL;
        }
 
       if (!bfd_check_format (last, bfd_object))
        {
          bfd_close (abfd);
          return NULL;
        }
 
       if (!bfd_check_format (last, bfd_object))
        {
-         warning ("\"%s\": member \"%s\" not in executable format: %s.",
+         warning (_("\"%s\": member \"%s\" not in executable format: %s."),
                   objname, mem, bfd_errmsg (bfd_get_error ()));
          bfd_close (last);
          bfd_close (abfd);
                   objname, mem, bfd_errmsg (bfd_get_error ()));
          bfd_close (last);
          bfd_close (abfd);
@@ -728,7 +783,7 @@ add_vmap (LdInfo *ldi)
     }
   else
     {
     }
   else
     {
-      warning ("\"%s\": not in executable format: %s.",
+      warning (_("\"%s\": not in executable format: %s."),
               objname, bfd_errmsg (bfd_get_error ()));
       bfd_close (abfd);
       return NULL;
               objname, bfd_errmsg (bfd_get_error ()));
       bfd_close (abfd);
       return NULL;
@@ -749,7 +804,7 @@ static void
 vmap_ldinfo (LdInfo *ldi)
 {
   struct stat ii, vi;
 vmap_ldinfo (LdInfo *ldi)
 {
   struct stat ii, vi;
-  register struct vmap *vp;
+  struct vmap *vp;
   int got_one, retried;
   int got_exec_file = 0;
   uint next;
   int got_one, retried;
   int got_exec_file = 0;
   uint next;
@@ -772,7 +827,7 @@ vmap_ldinfo (LdInfo *ldi)
          /* 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
             removed object and issue a warning.  */
          /* 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
             removed object and issue a warning.  */
-         warning ("%s (fd=%d) has disappeared, keeping its symbols",
+         warning (_("%s (fd=%d) has disappeared, keeping its symbols"),
                   name, fd);
          continue;
        }
                   name, fd);
          continue;
        }
@@ -789,8 +844,8 @@ vmap_ldinfo (LdInfo *ldi)
 
          /* The filenames are not always sufficient to match on. */
 
 
          /* The filenames are not always sufficient to match on. */
 
-         if ((name[0] == '/' && !STREQ (name, vp->name))
-             || (memb[0] && !STREQ (memb, vp->member)))
+         if ((name[0] == '/' && !DEPRECATED_STREQ (name, vp->name))
+             || (memb[0] && !DEPRECATED_STREQ (memb, vp->member)))
            continue;
 
          /* See if we are referring to the same file.
            continue;
 
          /* See if we are referring to the same file.
@@ -801,7 +856,7 @@ vmap_ldinfo (LdInfo *ldi)
              || objfile->obfd == NULL
              || bfd_stat (objfile->obfd, &vi) < 0)
            {
              || objfile->obfd == NULL
              || bfd_stat (objfile->obfd, &vi) < 0)
            {
-             warning ("Unable to stat %s, keeping its symbols", name);
+             warning (_("Unable to stat %s, keeping its symbols"), name);
              continue;
            }
 
              continue;
            }
 
@@ -824,6 +879,11 @@ vmap_ldinfo (LdInfo *ldi)
          /* relocate symbol table(s). */
          vmap_symtab (vp);
 
          /* relocate symbol table(s). */
          vmap_symtab (vp);
 
+         /* Announce new object files.  Doing this after symbol relocation
+            makes aix-thread.c's job easier.  */
+         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.  */
        }
 
@@ -844,14 +904,12 @@ vmap_ldinfo (LdInfo *ldi)
      running a different copy of the same executable.  */
   if (symfile_objfile != NULL && !got_exec_file)
     {
      running a different copy of the same executable.  */
   if (symfile_objfile != NULL && !got_exec_file)
     {
-      warning_begin ();
-      fputs_unfiltered ("Symbol file ", gdb_stderr);
-      fputs_unfiltered (symfile_objfile->name, gdb_stderr);
-      fputs_unfiltered ("\nis not mapped; discarding it.\n\
+      warning (_("Symbol file %s\nis not mapped; discarding it.\n\
 If in fact that file has symbols which the mapped files listed by\n\
 \"info files\" lack, you can load symbols with the \"symbol-file\" or\n\
 \"add-symbol-file\" commands (note that you must take care of relocating\n\
 If in fact that file has symbols which the mapped files listed by\n\
 \"info files\" lack, you can load symbols with the \"symbol-file\" or\n\
 \"add-symbol-file\" commands (note that you must take care of relocating\n\
-symbols to the proper address).\n", gdb_stderr);
+symbols to the proper address)."),
+              symfile_objfile->name);
       free_objfile (symfile_objfile);
       symfile_objfile = NULL;
     }
       free_objfile (symfile_objfile);
       symfile_objfile = NULL;
     }
@@ -880,21 +938,21 @@ vmap_exec (void)
   execbfd = exec_bfd;
 
   if (!vmap || !exec_ops.to_sections)
   execbfd = exec_bfd;
 
   if (!vmap || !exec_ops.to_sections)
-    error ("vmap_exec: vmap or exec_ops.to_sections == 0\n");
+    error (_("vmap_exec: vmap or exec_ops.to_sections == 0."));
 
   for (i = 0; &exec_ops.to_sections[i] < exec_ops.to_sections_end; i++)
     {
 
   for (i = 0; &exec_ops.to_sections[i] < exec_ops.to_sections_end; i++)
     {
-      if (STREQ (".text", exec_ops.to_sections[i].the_bfd_section->name))
+      if (DEPRECATED_STREQ (".text", exec_ops.to_sections[i].the_bfd_section->name))
        {
          exec_ops.to_sections[i].addr += vmap->tstart - vmap->tvma;
          exec_ops.to_sections[i].endaddr += vmap->tstart - vmap->tvma;
        }
        {
          exec_ops.to_sections[i].addr += vmap->tstart - vmap->tvma;
          exec_ops.to_sections[i].endaddr += vmap->tstart - vmap->tvma;
        }
-      else if (STREQ (".data", exec_ops.to_sections[i].the_bfd_section->name))
+      else if (DEPRECATED_STREQ (".data", exec_ops.to_sections[i].the_bfd_section->name))
        {
          exec_ops.to_sections[i].addr += vmap->dstart - vmap->dvma;
          exec_ops.to_sections[i].endaddr += vmap->dstart - vmap->dvma;
        }
        {
          exec_ops.to_sections[i].addr += vmap->dstart - vmap->dvma;
          exec_ops.to_sections[i].endaddr += vmap->dstart - vmap->dvma;
        }
-      else if (STREQ (".bss", exec_ops.to_sections[i].the_bfd_section->name))
+      else if (DEPRECATED_STREQ (".bss", exec_ops.to_sections[i].the_bfd_section->name))
        {
          exec_ops.to_sections[i].addr += vmap->dstart - vmap->dvma;
          exec_ops.to_sections[i].endaddr += vmap->dstart - vmap->dvma;
        {
          exec_ops.to_sections[i].addr += vmap->dstart - vmap->dvma;
          exec_ops.to_sections[i].endaddr += vmap->dstart - vmap->dvma;
@@ -905,14 +963,18 @@ vmap_exec (void)
 /* Set the current architecture from the host running GDB.  Called when
    starting a child process. */
 
 /* Set the current architecture from the host running GDB.  Called when
    starting a child process. */
 
+static void (*super_create_inferior) (char *exec_file, char *allargs,
+                                     char **env, int from_tty);
 static void
 static void
-set_host_arch (int pid)
+rs6000_create_inferior (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);
+
   if (__power_rs ())
     {
       arch = bfd_arch_rs6000;
   if (__power_rs ())
     {
       arch = bfd_arch_rs6000;
@@ -923,21 +985,40 @@ set_host_arch (int pid)
       arch = bfd_arch_powerpc;
       mach = bfd_mach_ppc;
     }
       arch = bfd_arch_powerpc;
       mach = bfd_mach_ppc;
     }
+
+  /* FIXME: schauer/2002-02-25:
+     We don't know if we are executing a 32 or 64 bit executable,
+     and have no way to pass the proper word size to rs6000_gdbarch_init.
+     So we have to avoid switching to a new architecture, if the architecture
+     matches already.
+     Blindly calling rs6000_gdbarch_init used to work in older versions of
+     GDB, as rs6000_gdbarch_init incorrectly used the previous tdep to
+     determine the wordsize.  */
+  if (exec_bfd)
+    {
+      const struct bfd_arch_info *exec_bfd_arch_info;
+
+      exec_bfd_arch_info = bfd_get_arch_info (exec_bfd);
+      if (arch == exec_bfd_arch_info->arch)
+       return;
+    }
+
   bfd_default_set_arch_mach (&abfd, arch, mach);
 
   bfd_default_set_arch_mach (&abfd, arch, mach);
 
-  memset (&info, 0, sizeof info);
+  gdbarch_info_init (&info);
   info.bfd_arch_info = bfd_get_arch_info (&abfd);
   info.bfd_arch_info = bfd_get_arch_info (&abfd);
+  info.abfd = exec_bfd;
 
   if (!gdbarch_update_p (info))
 
   if (!gdbarch_update_p (info))
-    {
-      internal_error (__FILE__, __LINE__,
-                     "set_host_arch: failed to select architecture");
-    }
+    internal_error (__FILE__, __LINE__,
+                   _("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)
@@ -949,6 +1030,9 @@ 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;
 
+  if (ptid_equal (inferior_ptid, null_ptid))
+    return;
+
   do
     {
       size = load_segs * ldisize;
   do
     {
       size = load_segs * ldisize;
@@ -963,16 +1047,16 @@ xcoff_relocate_symtab (unsigned int pid)
 #endif
 
       if (arch64)
 #endif
 
       if (arch64)
-       rc = ptrace64 (PT_LDINFO, pid, (unsigned long) ldi, size, NULL);
+       rc = rs6000_ptrace64 (PT_LDINFO, pid, (unsigned long) ldi, size, NULL);
       else
       else
-       rc = ptrace32 (PT_LDINFO, pid, (int *) ldi, size, NULL);
+       rc = rs6000_ptrace32 (PT_LDINFO, pid, (int *) ldi, size, NULL);
 
       if (rc == -1)
         {
           if (errno == ENOMEM)
             load_segs *= 2;
           else
 
       if (rc == -1)
         {
           if (errno == ENOMEM)
             load_segs *= 2;
           else
-            perror_with_name ("ptrace ldinfo");
+            perror_with_name (_("ptrace ldinfo"));
         }
       else
        {
         }
       else
        {
@@ -992,7 +1076,7 @@ xcoff_relocate_symtab (unsigned int pid)
 void
 xcoff_relocate_core (struct target_ops *target)
 {
 void
 xcoff_relocate_core (struct target_ops *target)
 {
-  sec_ptr ldinfo_sec;
+  struct bfd_section *ldinfo_sec;
   int offset = 0;
   LdInfo *ldi;
   struct vmap *vp;
   int offset = 0;
   LdInfo *ldi;
   struct vmap *vp;
@@ -1085,18 +1169,15 @@ xcoff_relocate_core (struct target_ops *target)
        }
 
       vmap_symtab (vp);
        }
 
       vmap_symtab (vp);
+
+      if (vp != vmap && vp->objfile)
+       observer_notify_new_objfile (vp->objfile);
     }
   while (LDI_NEXT (ldi, arch64) != 0);
   vmap_exec ();
   breakpoint_re_set ();
   do_cleanups (old);
 }
     }
   while (LDI_NEXT (ldi, arch64) != 0);
   vmap_exec ();
   breakpoint_re_set ();
   do_cleanups (old);
 }
-
-int
-kernel_u_size (void)
-{
-  return (sizeof (struct user));
-}
 \f
 /* Under AIX, we have to pass the correct TOC pointer to a function
    when calling functions in the inferior.
 \f
 /* Under AIX, we have to pass the correct TOC pointer to a function
    when calling functions in the inferior.
@@ -1119,30 +1200,28 @@ find_toc_address (CORE_ADDR pc)
                                              : vp->objfile);
        }
     }
                                              : vp->objfile);
        }
     }
-  error ("Unable to find TOC entry for pc 0x%x\n", pc);
+  error (_("Unable to find TOC entry for pc %s."), hex_string (pc));
 }
 \f
 }
 \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)
 {
 {
-  /* 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;
+  struct target_ops *t;
+
+  t = inf_ptrace_target ();
+  t->to_fetch_registers = rs6000_fetch_inferior_registers;
+  t->to_store_registers = rs6000_store_inferior_registers;
+  t->to_xfer_partial = rs6000_xfer_partial;
 
 
-  /* Initialize hook in rs6000-tdep.c to set the current architecture when
-     starting a child process. */
-  rs6000_set_host_arch_hook = set_host_arch;
+  super_create_inferior = t->to_create_inferior;
+  t->to_create_inferior = rs6000_create_inferior;
 
 
-  add_core_fns (&rs6000_core_fns);
+  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;
 }
 }
This page took 0.093458 seconds and 4 git commands to generate.