2004-05-10 Randolph Chung <tausq@debian.org>

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

diff --git a/gdb/rs6000-nat.c b/gdb/rs6000-nat.c
index 6afb4cf76c0e9ed2168ce5ec5e6b48db2fd48940..5fbf33435085a454b1308ddc501e7c9e2863bbe4 100644 (file)
--- a/gdb/rs6000-nat.c
+++ b/gdb/rs6000-nat.c
@@ -1,6 +1,8 @@
 /* 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, 1994, 1995, 1996, 1997, 1998
-   Free Software Foundation, Inc.
+
+   Copyright 1986, 1987, 1989, 1991, 1992, 1993, 1994, 1995, 1996,
+   1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free Software
+   Foundation, Inc.

 
    This file is part of GDB.
 
 
    This file is part of GDB.
 


@@ -29,6 +31,11 @@
 #include "libbfd.h"            /* For bfd_cache_lookup (FIXME) */
 #include "bfd.h"
 #include "gdb-stabs.h"
 #include "libbfd.h"            /* For bfd_cache_lookup (FIXME) */
 #include "bfd.h"
 #include "gdb-stabs.h"

+#include "regcache.h"
+#include "arch-utils.h"
+#include "language.h"          /* for local_hex_string().  */
+#include "ppc-tdep.h"
+#include "exec.h"

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


@@ -66,7 +73,7 @@
 #ifndef ARCH3264
 # define ARCH64() 0
 #else
 #ifndef ARCH3264
 # define ARCH64() 0
 #else

-# define ARCH64() (REGISTER_RAW_SIZE (0) == 8)
+# define ARCH64() (DEPRECATED_REGISTER_RAW_SIZE (0) == 8)

 #endif
 
 /* Union of 32-bit and 64-bit ".reg" core file sections. */
 #endif
 
 /* Union of 32-bit and 64-bit ".reg" core file sections. */


@@ -122,8 +129,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 *);


@@ -138,30 +143,58 @@ 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 == PC_REGNUM)
+    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;


@@ -170,7 +203,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, int *buf)

 {
 #ifdef ARCH3264
   int ret = ptracex (req, id, addr, data, buf);
 {
 #ifdef ARCH3264
   int ret = ptracex (req, id, addr, data, buf);


@@ -178,7 +211,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,42 +222,40 @@ ptrace64 (int req, int id, long long addr, int data, int *buf)
 static void
 fetch_register (int regno)
 {
 static void
 fetch_register (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 >= NUM_REGS)
+       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, (int *)&buf);
+         if (DEPRECATED_REGISTER_RAW_SIZE (regno) == 8)

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


@@ -232,7 +263,7 @@ fetch_register (int regno)
     }
 
   if (!errno)
     }
 
   if (!errno)

-    register_valid[regno] = 1;
+    supply_register (regno, (char *) addr);

   else
     {
 #if 0
   else
     {
 #if 0


@@ -248,21 +279,23 @@ fetch_register (int regno)
 static void
 store_register (int regno)
 {
 static void
 store_register (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_collect (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)
        fprintf_unfiltered (gdb_stderr,
     {
       if (regno >= NUM_REGS)
        fprintf_unfiltered (gdb_stderr,


@@ -281,23 +314,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 (DEPRECATED_REGISTER_RAW_SIZE (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, (int *)&buf);

        }
     }
 
        }
     }
 


@@ -319,17 +350,32 @@ fetch_inferior_registers (int 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 (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 (tdep->ppc_fp0_regnum + regno);
+
+      /* 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);
+      if (tdep->ppc_fpscr_regnum >= 0)
+        fetch_register (tdep->ppc_fpscr_regnum);
+      if (tdep->ppc_mq_regnum >= 0)
+       fetch_register (tdep->ppc_mq_regnum);

     }
 }
 
     }
 }
 


@@ -345,18 +391,32 @@ store_inferior_registers (int 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 (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 (tdep->ppc_fp0_regnum + regno);
+
+      /* 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);
+      if (tdep->ppc_fpscr_regnum >= 0)
+        store_register (tdep->ppc_fpscr_regnum);
+      if (tdep->ppc_mq_regnum >= 0)
+       store_register (tdep->ppc_mq_regnum);

     }
 }
 
     }
 }
 


@@ -371,9 +431,10 @@ read_word (CORE_ADDR from, int *to, int arch64)
   errno = 0;
 
   if (arch64)
   errno = 0;
 
   if (arch64)

-    *to = ptrace64 (PT_READ_I, inferior_pid, from, 0, NULL);
+    *to = rs6000_ptrace64 (PT_READ_I, PIDGET (inferior_ptid), from, 0, NULL);

   else
   else

-    *to = ptrace32 (PT_READ_I, inferior_pid, (int *)(long) from, 0, NULL);
+    *to = rs6000_ptrace32 (PT_READ_I, PIDGET (inferior_ptid), (int *)(long) from,
+                    0, NULL);

 
   return !errno;
 }
 
   return !errno;
 }


@@ -389,7 +450,8 @@ read_word (CORE_ADDR from, int *to, int arch64)
 
 int
 child_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len,
 
 int
 child_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len,

-                  int write, struct target_ops *target)
+                  int write, struct mem_attrib *attrib,
+                  struct target_ops *target)

 {
   /* Round starting address down to 32-bit word boundary. */
   int mask = sizeof (int) - 1;
 {
   /* Round starting address down to 32-bit word boundary. */
   int mask = sizeof (int) - 1;


@@ -400,6 +462,9 @@ child_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len,
     / sizeof (int);
 
   /* Allocate word transfer buffer. */
     / sizeof (int);
 
   /* Allocate word transfer buffer. */

+  /* FIXME (alloca): This code, cloned from infptrace.c, is unsafe
+     because it uses alloca to allocate a buffer of arbitrary size.
+     For very large xfers, this could crash GDB's stack.  */

   int *buf = (int *) alloca (count * sizeof (int));
 
   int arch64 = ARCH64 ();
   int *buf = (int *) alloca (count * sizeof (int));
 
   int arch64 = ARCH64 ();


@@ -428,7 +493,8 @@ child_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len,
 
       /* Fetch trailing memory needed for alignment. */
       if (addr + count * sizeof (int) > memaddr + len)
 
       /* Fetch trailing memory needed for alignment. */
       if (addr + count * sizeof (int) > memaddr + len)

-       if (!read_word (addr, buf + count - 1, arch64))
+       if (!read_word (addr + (count - 1) * sizeof (int),
+                        buf + count - 1, arch64))

          return 0;
 
       /* Copy supplied data into memory buffer. */
          return 0;
 
       /* Copy supplied data into memory buffer. */


@@ -438,9 +504,9 @@ child_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len,
       for (i = 0, errno = 0; i < count; i++, addr += sizeof (int))
        {
          if (arch64)
       for (i = 0, errno = 0; i < count; i++, addr += sizeof (int))
        {
          if (arch64)

-           ptrace64 (PT_WRITE_D, inferior_pid, addr, buf[i], NULL);
+           rs6000_ptrace64 (PT_WRITE_D, PIDGET (inferior_ptid), addr, buf[i], NULL);

          else
          else

-           ptrace32 (PT_WRITE_D, inferior_pid, (int *)(long) addr,
+           rs6000_ptrace32 (PT_WRITE_D, PIDGET (inferior_ptid), (int *)(long) addr,

                      buf[i], NULL);
 
          if (errno)
                      buf[i], NULL);
 
          if (errno)


@@ -479,9 +545,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");


@@ -490,7 +556,7 @@ exec_one_dummy_insn (void)
     {
       pid = wait (&status);
     }
     {
       pid = wait (&status);
     }

-  while (pid != inferior_pid);
+  while (pid != PIDGET (inferior_ptid));

 
   write_pc (prev_pc);
   target_remove_breakpoint (DUMMY_INSN_ADDR, shadow_contents);
 
   write_pc (prev_pc);
   target_remove_breakpoint (DUMMY_INSN_ADDR, shadow_contents);


@@ -503,9 +569,8 @@ fetch_core_registers (char *core_reg_sect, unsigned core_reg_size,
                      int which, CORE_ADDR reg_addr)
 {
   CoreRegs *regs;
                      int which, CORE_ADDR reg_addr)
 {
   CoreRegs *regs;

-  double *fprs;
-  int arch64, i, size;
-  void *gprs, *sprs[7];
+  int regi;
+  struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); 

 
   if (which != 0)
     {
 
   if (which != 0)
     {


@@ -515,45 +580,49 @@ fetch_core_registers (char *core_reg_sect, unsigned core_reg_size,
       return;
     }
 
       return;
     }
 

-  arch64 = ARCH64 ();

   regs = (CoreRegs *) core_reg_sect;
 
   regs = (CoreRegs *) core_reg_sect;
 

-  /* Retrieve register pointers. */
+  /* Put the register values from the core file section in the regcache.  */

 
 

-  if (arch64)
+  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;
+      for (regi = 0; regi < 32; regi++)
+        supply_register (regi, (char *) &regs->r64.gpr[regi]);
+
+      if (tdep->ppc_fp0_regnum >= 0)
+        for (regi = 0; regi < 32; regi++)
+          supply_register (tdep->ppc_fp0_regnum + regi,
+                           (char *) &regs->r64.fpr[regi]);
+
+      supply_register (PC_REGNUM, (char *) &regs->r64.iar);
+      supply_register (tdep->ppc_ps_regnum, (char *) &regs->r64.msr);
+      supply_register (tdep->ppc_cr_regnum, (char *) &regs->r64.cr);
+      supply_register (tdep->ppc_lr_regnum, (char *) &regs->r64.lr);
+      supply_register (tdep->ppc_ctr_regnum, (char *) &regs->r64.ctr);
+      supply_register (tdep->ppc_xer_regnum, (char *) &regs->r64.xer);
+      if (tdep->ppc_fpscr_regnum >= 0)
+        supply_register (tdep->ppc_fpscr_regnum, (char *) &regs->r64.fpscr);

     }
   else
     {
     }
   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);
+      for (regi = 0; regi < 32; regi++)
+        supply_register (regi, (char *) &regs->r32.gpr[regi]);
+
+      if (tdep->ppc_fp0_regnum >= 0)
+        for (regi = 0; regi < 32; regi++)
+          supply_register (tdep->ppc_fp0_regnum + regi,
+                           (char *) &regs->r32.fpr[regi]);
+
+      supply_register (PC_REGNUM, (char *) &regs->r32.iar);
+      supply_register (tdep->ppc_ps_regnum, (char *) &regs->r32.msr);
+      supply_register (tdep->ppc_cr_regnum, (char *) &regs->r32.cr);
+      supply_register (tdep->ppc_lr_regnum, (char *) &regs->r32.lr);
+      supply_register (tdep->ppc_ctr_regnum, (char *) &regs->r32.ctr);
+      supply_register (tdep->ppc_xer_regnum, (char *) &regs->r32.xer);
+      if (tdep->ppc_fpscr_regnum >= 0)
+        supply_register (tdep->ppc_fpscr_regnum, (char *) &regs->r32.fpscr);
+      if (tdep->ppc_mq_regnum >= 0)
+       supply_register (tdep->ppc_mq_regnum, (char *) &regs->r32.mq);

     }
 }
 \f
     }
 }
 \f


@@ -591,7 +660,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;
 


@@ -605,17 +674,22 @@ vmap_symtab (struct vmap *vp)
        return;
       objfile = symfile_objfile;
     }
        return;
       objfile = symfile_objfile;
     }

+  else if (!vp->loaded)
+    /* 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)
 
   for (i = 0; i < objfile->num_sections; ++i)

-    ANOFFSET (new_offsets, i) = ANOFFSET (objfile->section_offsets, i);
+    new_offsets->offsets[i] = ANOFFSET (objfile->section_offsets, i);

 
   /* The symbols in the object file are linked to the VMA of the section,
      relocate them VMA relative.  */
 
   /* The symbols in the object file are linked to the VMA of the section,
      relocate them VMA relative.  */

-  ANOFFSET (new_offsets, SECT_OFF_TEXT (objfile)) = vp->tstart - vp->tvma;
-  ANOFFSET (new_offsets, SECT_OFF_DATA (objfile)) = vp->dstart - vp->dvma;
-  ANOFFSET (new_offsets, SECT_OFF_BSS (objfile)) = vp->dstart - vp->dvma;
+  new_offsets->offsets[SECT_OFF_TEXT (objfile)] = vp->tstart - vp->tvma;
+  new_offsets->offsets[SECT_OFF_DATA (objfile)] = vp->dstart - vp->dvma;
+  new_offsets->offsets[SECT_OFF_BSS (objfile)] = vp->dstart - vp->dvma;

 
   objfile_relocate (objfile, new_offsets);
 }
 
   objfile_relocate (objfile, new_offsets);
 }


@@ -627,11 +701,28 @@ 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;
 }
 

+/* Add symbols for a vmap. Return zero upon error.  */
+
+int
+vmap_add_symbols (struct vmap *vp)
+{
+  if (catch_errors (objfile_symbol_add, vp->objfile,
+                   "Error while reading shared library symbols:\n",
+                   RETURN_MASK_ALL))
+    {
+      /* Note this is only done if symbol reading was successful.  */
+      vp->loaded = 1;
+      vmap_symtab (vp);
+      return 1;
+    }
+  return 0;
+}
+

 /* Add a new vmap entry based on ldinfo() information.
 
    If ldi->ldinfo_fd is not valid (e.g. this struct ld_info is from a
 /* Add a new vmap entry based on ldinfo() information.
 
    If ldi->ldinfo_fd is not valid (e.g. this struct ld_info is from a


@@ -643,7 +734,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;


@@ -666,8 +757,11 @@ add_vmap (LdInfo *ldi)
   else
     abfd = bfd_fdopenr (objname, gnutarget, fd);
   if (!abfd)
   else
     abfd = bfd_fdopenr (objname, gnutarget, fd);
   if (!abfd)

-    error ("Could not open `%s' as an executable file: %s",
-          objname, bfd_errmsg (bfd_get_error ()));
+    {
+      warning ("Could not open `%s' as an executable file: %s",
+              objname, bfd_errmsg (bfd_get_error ()));
+      return NULL;
+    }

 
   /* make sure we have an object file */
 
 
   /* make sure we have an object file */
 


@@ -679,46 +773,40 @@ 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);

          bfd_close (abfd);
          bfd_close (abfd);

-         /* FIXME -- should be error */
-         warning ("\"%s\": member \"%s\" missing.", abfd->filename, mem);
-         return 0;
+         return NULL;

        }
 
       if (!bfd_check_format (last, bfd_object))
        {
        }
 
       if (!bfd_check_format (last, bfd_object))
        {

-         bfd_close (last);     /* XXX???       */
-         goto obj_err;
+         warning ("\"%s\": member \"%s\" not in executable format: %s.",
+                  objname, mem, bfd_errmsg (bfd_get_error ()));
+         bfd_close (last);
+         bfd_close (abfd);
+         return NULL;

        }
 
       vp = map_vmap (last, abfd);
     }
   else
     {
        }
 
       vp = map_vmap (last, abfd);
     }
   else
     {

-    obj_err:
+      warning ("\"%s\": not in executable format: %s.",
+              objname, bfd_errmsg (bfd_get_error ()));

       bfd_close (abfd);
       bfd_close (abfd);

-      error ("\"%s\": not in executable format: %s.",
-            objname, bfd_errmsg (bfd_get_error ()));
-      /*NOTREACHED */
+      return NULL;

     }
   obj = allocate_objfile (vp->bfd, 0);
   vp->objfile = obj;
 
     }
   obj = allocate_objfile (vp->bfd, 0);
   vp->objfile = obj;
 

-#ifndef SOLIB_SYMBOLS_MANUAL
-  if (catch_errors (objfile_symbol_add, obj,
-                   "Error while reading shared library symbols:\n",
-                   RETURN_MASK_ALL))
-    {
-      /* Note this is only done if symbol reading was successful.  */
-      vmap_symtab (vp);
-      vp->loaded = 1;
-    }
-#endif
+  /* Always add symbols for the main objfile.  */
+  if (vp == vmap || auto_solib_add)
+    vmap_add_symbols (vp);

   return vp;
 }
 \f
   return vp;
 }
 \f


@@ -729,7 +817,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;


@@ -769,8 +857,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.


@@ -804,6 +892,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 (deprecated_target_new_objfile_hook && vp->objfile)
+           deprecated_target_new_objfile_hook (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.  */
        }
 


@@ -824,14 +917,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;
     }


@@ -864,17 +955,17 @@ vmap_exec (void)
 
   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;


@@ -903,12 +994,35 @@ 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;

 
 

-  gdbarch_update (info);
+  if (!gdbarch_update_p (info))
+    {
+      internal_error (__FILE__, __LINE__,
+                     "set_host_arch: failed to select architecture");
+    }

 }
 
 \f
 }
 
 \f


@@ -928,7 +1042,7 @@ xcoff_relocate_symtab (unsigned int pid)
   do
     {
       size = load_segs * ldisize;
   do
     {
       size = load_segs * ldisize;

-      ldi = (void *) xrealloc (ldi, load_segs * size);
+      ldi = (void *) xrealloc (ldi, size);

 
 #if 0
       /* According to my humble theory, AIX has some timing problems and
 
 #if 0
       /* According to my humble theory, AIX has some timing problems and


@@ -939,9 +1053,9 @@ 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 (rc == -1)
         {


@@ -957,7 +1071,7 @@ xcoff_relocate_symtab (unsigned int pid)
        }
     } while (rc == -1);
   if (ldi)
        }
     } while (rc == -1);
   if (ldi)

-    free (ldi);
+    xfree (ldi);

 }
 \f
 /* Core file stuff.  */
 }
 \f
 /* Core file stuff.  */


@@ -968,7 +1082,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;


@@ -982,12 +1096,6 @@ xcoff_relocate_core (struct target_ops *target)
   char *buffer = xmalloc (buffer_size);
   struct cleanup *old = make_cleanup (free_current_contents, &buffer);
 
   char *buffer = xmalloc (buffer_size);
   struct cleanup *old = make_cleanup (free_current_contents, &buffer);
 

-  /* FIXME, this restriction should not exist.  For now, though I'll
-     avoid coredumps with error() pending a real fix.  */
-  if (vmap == NULL)
-    error
-      ("Can't debug a core file without an executable file (on the RS/6000)");
-

   ldinfo_sec = bfd_get_section_by_name (core_bfd, ".ldinfo");
   if (ldinfo_sec == NULL)
     {
   ldinfo_sec = bfd_get_section_by_name (core_bfd, ".ldinfo");
   if (ldinfo_sec == NULL)
     {


@@ -1033,12 +1141,16 @@ xcoff_relocate_core (struct target_ops *target)
        ldi->l32.ldinfo_fd = -1;
 
       /* The first ldinfo is for the exec file, allocated elsewhere.  */
        ldi->l32.ldinfo_fd = -1;
 
       /* The first ldinfo is for the exec file, allocated elsewhere.  */

-      if (offset == 0)
+      if (offset == 0 && vmap != NULL)

        vp = vmap;
       else
        vp = add_vmap (ldi);
 
        vp = vmap;
       else
        vp = add_vmap (ldi);
 

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

       offset += LDI_NEXT (ldi, arch64);
       offset += LDI_NEXT (ldi, arch64);

+      if (vp == NULL)
+       continue;
+

       vmap_secs (vp, ldi, arch64);
 
       /* Unless this is the exec file,
       vmap_secs (vp, ldi, arch64);
 
       /* Unless this is the exec file,


@@ -1063,6 +1175,9 @@ 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);

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


@@ -1097,7 +1212,7 @@ 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\n", local_hex_string (pc));

 }
 \f
 /* Register that we are able to handle rs6000 core file formats. */
 }
 \f
 /* Register that we are able to handle rs6000 core file formats. */


@@ -1122,9 +1237,5 @@ _initialize_core_rs6000 (void)
      starting a child process. */
   rs6000_set_host_arch_hook = set_host_arch;
 
      starting a child process. */
   rs6000_set_host_arch_hook = set_host_arch;
 

-  /* For native configurations, where this module is included, inform
-     the xcoffsolib module where it can find the function for symbol table
-     relocation at runtime. */
-  xcoff_relocate_symtab_hook = xcoff_relocate_symtab;
-  add_core_fns (&rs6000_core_fns);
+  deprecated_add_core_fns (&rs6000_core_fns);

 }
 }