Implement '-target-detach pid'.

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

diff --git a/gdb/m68klinux-nat.c b/gdb/m68klinux-nat.c
index 96bf524cdbdb9d56ba0e307ac92a47fdbafc80b2..149a0b66a765fe1211a17b922cc0e95cea44e9f5 100644 (file)
--- a/gdb/m68klinux-nat.c
+++ b/gdb/m68klinux-nat.c
@@ -1,13 +1,13 @@
 /* Motorola m68k native support for GNU/Linux.
 
-   Copyright (C) 1996, 1998, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
-   Free Software Foundation, Inc.
+   Copyright (C) 1996, 1998, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
+   2008 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
-   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,
@@ -16,9 +16,7 @@
    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 "frame.h"
@@ -55,7 +53,7 @@
 /* Prototypes for supply_gregset etc. */
 #include "gregset.h"
 \f
-/* This table must line up with REGISTER_NAME in "m68k-tdep.c".  */
+/* This table must line up with gdbarch_register_name in "m68k-tdep.c".  */
 static const int regmap[] =
 {
   PT_D0, PT_D1, PT_D2, PT_D3, PT_D4, PT_D5, PT_D6, PT_D7,
@@ -81,7 +79,7 @@ getregs_supplies (int regno)
 int
 getfpregs_supplies (int regno)
 {
-  return FP0_REGNUM <= regno && regno <= M68K_FPI_REGNUM;
+  return M68K_FP0_REGNUM <= regno && regno <= M68K_FPI_REGNUM;
 }
 
 /* Does the current host support the GETREGS request?  */
@@ -116,6 +114,7 @@ int have_ptrace_getregs =
 static void
 fetch_register (struct regcache *regcache, int regno)
 {
+  struct gdbarch *gdbarch = get_regcache_arch (regcache);
   /* This isn't really an address.  But ptrace thinks of it as one.  */
   CORE_ADDR regaddr;
   char mess[128];              /* For messages */
@@ -123,9 +122,9 @@ fetch_register (struct regcache *regcache, int regno)
   char buf[MAX_REGISTER_SIZE];
   int tid;
 
-  if (CANNOT_FETCH_REGISTER (regno))
+  if (gdbarch_cannot_fetch_register (gdbarch, regno))
     {
-      memset (buf, '\0', register_size (current_gdbarch, regno));      /* Supply zeroes */
+      memset (buf, '\0', register_size (gdbarch, regno)); /* Supply zeroes */
       regcache_raw_supply (regcache, regno, buf);
       return;
     }
@@ -136,7 +135,7 @@ fetch_register (struct regcache *regcache, int regno)
     tid = PIDGET (inferior_ptid);      /* no thread id, just use process id */
 
   regaddr = 4 * regmap[regno];
-  for (i = 0; i < register_size (current_gdbarch, regno);
+  for (i = 0; i < register_size (gdbarch, regno);
        i += sizeof (PTRACE_TYPE_RET))
     {
       errno = 0;
@@ -146,7 +145,7 @@ fetch_register (struct regcache *regcache, int regno)
       if (errno != 0)
        {
          sprintf (mess, "reading register %s (#%d)", 
-                  REGISTER_NAME (regno), regno);
+                  gdbarch_register_name (gdbarch, regno), regno);
          perror_with_name (mess);
        }
     }
@@ -166,7 +165,9 @@ old_fetch_inferior_registers (struct regcache *regcache, int regno)
     }
   else
     {
-      for (regno = 0; regno < NUM_REGS; regno++)
+      for (regno = 0;
+          regno < gdbarch_num_regs (get_regcache_arch (regcache));
+          regno++)
        {
          fetch_register (regcache, regno);
        }
@@ -178,6 +179,7 @@ old_fetch_inferior_registers (struct regcache *regcache, int regno)
 static void
 store_register (const struct regcache *regcache, int regno)
 {
+  struct gdbarch *gdbarch = get_regcache_arch (regcache);
   /* This isn't really an address.  But ptrace thinks of it as one.  */
   CORE_ADDR regaddr;
   char mess[128];              /* For messages */
@@ -185,10 +187,8 @@ store_register (const struct regcache *regcache, int regno)
   int tid;
   char buf[MAX_REGISTER_SIZE];
 
-  if (CANNOT_STORE_REGISTER (regno))
-    {
-      return;
-    }
+  if (gdbarch_cannot_store_register (gdbarch, regno))
+    return;
 
   /* Overload thread id onto process id */
   tid = TIDGET (inferior_ptid);
@@ -201,7 +201,7 @@ store_register (const struct regcache *regcache, int regno)
   regcache_raw_collect (regcache, regno, buf);
 
   /* Store the local buffer into the inferior a chunk at the time. */
-  for (i = 0; i < register_size (current_gdbarch, regno);
+  for (i = 0; i < register_size (gdbarch, regno);
        i += sizeof (PTRACE_TYPE_RET))
     {
       errno = 0;
@@ -211,7 +211,7 @@ store_register (const struct regcache *regcache, int regno)
       if (errno != 0)
        {
          sprintf (mess, "writing register %s (#%d)", 
-                  REGISTER_NAME (regno), regno);
+                  gdbarch_register_name (gdbarch, regno), regno);
          perror_with_name (mess);
        }
     }
@@ -230,7 +230,9 @@ old_store_inferior_registers (const struct regcache *regcache, int regno)
     }
   else
     {
-      for (regno = 0; regno < NUM_REGS; regno++)
+      for (regno = 0;
+          regno < gdbarch_num_regs (get_regcache_arch (regcache));
+          regno++)
        {
          store_register (regcache, regno);
        }
@@ -244,13 +246,18 @@ old_store_inferior_registers (const struct regcache *regcache, int regno)
 void
 supply_gregset (struct regcache *regcache, const elf_gregset_t *gregsetp)
 {
+  struct gdbarch *gdbarch = get_regcache_arch (regcache);
   const elf_greg_t *regp = (const elf_greg_t *) gregsetp;
   int regi;
 
-  for (regi = M68K_D0_REGNUM; regi <= SP_REGNUM; regi++)
+  for (regi = M68K_D0_REGNUM;
+       regi <= gdbarch_sp_regnum (gdbarch);
+       regi++)
     regcache_raw_supply (regcache, regi, &regp[regmap[regi]]);
-  regcache_raw_supply (regcache, PS_REGNUM, &regp[PT_SR]);
-  regcache_raw_supply (regcache, PC_REGNUM, &regp[PT_PC]);
+  regcache_raw_supply (regcache, gdbarch_ps_regnum (gdbarch),
+                      &regp[PT_SR]);
+  regcache_raw_supply (regcache,
+                      gdbarch_pc_regnum (gdbarch), &regp[PT_PC]);
 }
 
 /* Fill register REGNO (if it is a general-purpose register) in
@@ -330,11 +337,14 @@ static void store_regs (const struct regcache *regcache, int tid, int regno) {}
 void
 supply_fpregset (struct regcache *regcache, const elf_fpregset_t *fpregsetp)
 {
+  struct gdbarch *gdbarch = get_regcache_arch (regcache);
   int regi;
 
-  for (regi = FP0_REGNUM; regi < FP0_REGNUM + 8; regi++)
+  for (regi = gdbarch_fp0_regnum (gdbarch);
+       regi < gdbarch_fp0_regnum (gdbarch) + 8; regi++)
     regcache_raw_supply (regcache, regi,
-                        FPREG_ADDR (fpregsetp, regi - FP0_REGNUM));
+                        FPREG_ADDR (fpregsetp,
+                                    regi - gdbarch_fp0_regnum (gdbarch)));
   regcache_raw_supply (regcache, M68K_FPC_REGNUM, &fpregsetp->fpcntl[0]);
   regcache_raw_supply (regcache, M68K_FPS_REGNUM, &fpregsetp->fpcntl[1]);
   regcache_raw_supply (regcache, M68K_FPI_REGNUM, &fpregsetp->fpcntl[2]);
@@ -348,13 +358,16 @@ void
 fill_fpregset (const struct regcache *regcache,
               elf_fpregset_t *fpregsetp, int regno)
 {
+  struct gdbarch *gdbarch = get_regcache_arch (regcache);
   int i;
 
   /* Fill in the floating-point registers.  */
-  for (i = FP0_REGNUM; i < FP0_REGNUM + 8; i++)
+  for (i = gdbarch_fp0_regnum (gdbarch);
+       i < gdbarch_fp0_regnum (gdbarch) + 8; i++)
     if (regno == -1 || regno == i)
       regcache_raw_collect (regcache, i,
-                           FPREG_ADDR (fpregsetp, i - FP0_REGNUM));
+                           FPREG_ADDR (fpregsetp,
+                                       i - gdbarch_fp0_regnum (gdbarch)));
 
   /* Fill in the floating-point control registers.  */
   for (i = M68K_FPC_REGNUM; i <= M68K_FPI_REGNUM; i++)