* core-aout.c: Delete file.
[deliverable/binutils-gdb.git] / gdb / arm-linux-nat.c
index 115e960cf7b922229199a22bc039660ff27ccd52..b50f8969a184331bcb0a7961364bf677875ee4b1 100644 (file)
@@ -1,5 +1,6 @@
 /* GNU/Linux on ARM native support.
-   Copyright 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
+   Copyright (C) 1999, 2000, 2001, 2002, 2004, 2005, 2006, 2007
+   Free Software Foundation, Inc.
 
    This file is part of GDB.
 
 
    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 "gdbcore.h"
 #include "gdb_string.h"
 #include "regcache.h"
+#include "target.h"
+#include "linux-nat.h"
+#include "target-descriptions.h"
+#include "xml-support.h"
+
+#include "arm-tdep.h"
+#include "arm-linux-tdep.h"
 
 #include <sys/user.h>
 #include <sys/ptrace.h>
 /* Prototypes for supply_gregset etc. */
 #include "gregset.h"
 
-extern int arm_apcs_32;
+/* Defines ps_err_e, struct ps_prochandle.  */
+#include "gdb_proc_service.h"
+
+#ifndef PTRACE_GET_THREAD_AREA
+#define PTRACE_GET_THREAD_AREA 22
+#endif
 
-#define                typeNone                0x00
-#define                typeSingle              0x01
-#define                typeDouble              0x02
-#define                typeExtended            0x03
-#define        FPWORDS                 28
-#define                ARM_CPSR_REGNUM         16
-
-typedef union tagFPREG
-  {
-    unsigned int fSingle;
-    unsigned int fDouble[2];
-    unsigned int fExtended[3];
-  }
-FPREG;
-
-typedef struct tagFPA11
-  {
-    FPREG fpreg[8];            /* 8 floating point registers */
-    unsigned int fpsr;         /* floating point status register */
-    unsigned int fpcr;         /* floating point control register */
-    unsigned char fType[8];    /* type of floating point value held in
-                                  floating point registers.  */
-    int initflag;              /* NWFPE initialization flag.  */
-  }
-FPA11;
+#ifndef PTRACE_GETWMMXREGS
+#define PTRACE_GETWMMXREGS 18
+#define PTRACE_SETWMMXREGS 19
+#endif
+
+/* A flag for whether the WMMX registers are available.  */
+static int arm_linux_has_wmmx_registers;
+
+extern int arm_apcs_32;
 
 /* The following variables are used to determine the version of the
-   underlying Linux operating system.  Examples:
+   underlying GNU/Linux operating system.  Examples:
 
-   Linux 2.0.35                 Linux 2.2.12
+   GNU/Linux 2.0.35             GNU/Linux 2.2.12
    os_version = 0x00020023      os_version = 0x0002020c
    os_major = 2                 os_major = 2
    os_minor = 0                 os_minor = 2
@@ -76,11 +73,11 @@ FPA11;
 
 static unsigned int os_version, os_major, os_minor, os_release;
 
-/* On Linux, threads are implemented as pseudo-processes, in which
+/* On GNU/Linux, threads are implemented as pseudo-processes, in which
    case we may be tracing more than one process at a time.  In that
    case, inferior_ptid will contain the main process ID and the
-   individual thread (process) ID.  get_thread_id () is used to
-   get the thread id if it's available, and the process id otherwise. */
+   individual thread (process) ID.  get_thread_id () is used to get
+   the thread id if it's available, and the process id otherwise.  */
 
 int
 get_thread_id (ptid_t ptid)
@@ -90,130 +87,7 @@ get_thread_id (ptid_t ptid)
     tid = PIDGET (ptid);
   return tid;
 }
-#define GET_THREAD_ID(PTID)    get_thread_id ((PTID));
-
-static void
-fetch_nwfpe_single (unsigned int fn, FPA11 * fpa11)
-{
-  unsigned int mem[3];
-
-  mem[0] = fpa11->fpreg[fn].fSingle;
-  mem[1] = 0;
-  mem[2] = 0;
-  supply_register (ARM_F0_REGNUM + fn, (char *) &mem[0]);
-}
-
-static void
-fetch_nwfpe_double (unsigned int fn, FPA11 * fpa11)
-{
-  unsigned int mem[3];
-
-  mem[0] = fpa11->fpreg[fn].fDouble[1];
-  mem[1] = fpa11->fpreg[fn].fDouble[0];
-  mem[2] = 0;
-  supply_register (ARM_F0_REGNUM + fn, (char *) &mem[0]);
-}
-
-static void
-fetch_nwfpe_none (unsigned int fn)
-{
-  unsigned int mem[3] =
-  {0, 0, 0};
-
-  supply_register (ARM_F0_REGNUM + fn, (char *) &mem[0]);
-}
-
-static void
-fetch_nwfpe_extended (unsigned int fn, FPA11 * fpa11)
-{
-  unsigned int mem[3];
-
-  mem[0] = fpa11->fpreg[fn].fExtended[0];      /* sign & exponent */
-  mem[1] = fpa11->fpreg[fn].fExtended[2];      /* ls bits */
-  mem[2] = fpa11->fpreg[fn].fExtended[1];      /* ms bits */
-  supply_register (ARM_F0_REGNUM + fn, (char *) &mem[0]);
-}
-
-static void
-fetch_nwfpe_register (int regno, FPA11 * fpa11)
-{
-   int fn = regno - ARM_F0_REGNUM;
-
-   switch (fpa11->fType[fn])
-     {
-     case typeSingle:
-       fetch_nwfpe_single (fn, fpa11);
-       break;
-
-     case typeDouble:
-       fetch_nwfpe_double (fn, fpa11);
-       break;
-
-     case typeExtended:
-       fetch_nwfpe_extended (fn, fpa11);
-       break;
-
-     default:
-       fetch_nwfpe_none (fn);
-     }
-}
-
-static void
-store_nwfpe_single (unsigned int fn, FPA11 * fpa11)
-{
-  unsigned int mem[3];
-
-  read_register_gen (ARM_F0_REGNUM + fn, (char *) &mem[0]);
-  fpa11->fpreg[fn].fSingle = mem[0];
-  fpa11->fType[fn] = typeSingle;
-}
-
-static void
-store_nwfpe_double (unsigned int fn, FPA11 * fpa11)
-{
-  unsigned int mem[3];
-
-  read_register_gen (ARM_F0_REGNUM + fn, (char *) &mem[0]);
-  fpa11->fpreg[fn].fDouble[1] = mem[0];
-  fpa11->fpreg[fn].fDouble[0] = mem[1];
-  fpa11->fType[fn] = typeDouble;
-}
-
-void
-store_nwfpe_extended (unsigned int fn, FPA11 * fpa11)
-{
-  unsigned int mem[3];
-
-  read_register_gen (ARM_F0_REGNUM + fn, (char *) &mem[0]);
-  fpa11->fpreg[fn].fExtended[0] = mem[0];      /* sign & exponent */
-  fpa11->fpreg[fn].fExtended[2] = mem[1];      /* ls bits */
-  fpa11->fpreg[fn].fExtended[1] = mem[2];      /* ms bits */
-  fpa11->fType[fn] = typeDouble;
-}
-
-void
-store_nwfpe_register (int regno, FPA11 * fpa11)
-{
-  if (register_cached (regno))
-    {
-       unsigned int fn = regno - ARM_F0_REGNUM;
-       switch (fpa11->fType[fn])
-         {
-        case typeSingle:
-          store_nwfpe_single (fn, fpa11);
-          break;
-
-        case typeDouble:
-          store_nwfpe_double (fn, fpa11);
-          break;
-
-        case typeExtended:
-          store_nwfpe_extended (fn, fpa11);
-          break;
-        }
-    }
-}
-
+#define GET_THREAD_ID(PTID)    get_thread_id (PTID)
 
 /* Get the value of a particular register from the floating point
    state of the process and store it into regcache.  */
@@ -222,46 +96,27 @@ static void
 fetch_fpregister (int regno)
 {
   int ret, tid;
-  FPA11 fp;
+  gdb_byte fp[ARM_LINUX_SIZEOF_NWFPE];
   
   /* Get the thread id for the ptrace call.  */
   tid = GET_THREAD_ID (inferior_ptid);
 
   /* Read the floating point state.  */
-  ret = ptrace (PT_GETFPREGS, tid, 0, &fp);
+  ret = ptrace (PT_GETFPREGS, tid, 0, fp);
   if (ret < 0)
     {
-      warning ("Unable to fetch floating point register.");
+      warning (_("Unable to fetch floating point register."));
       return;
     }
 
   /* Fetch fpsr.  */
   if (ARM_FPS_REGNUM == regno)
-    supply_register (ARM_FPS_REGNUM, (char *) &fp.fpsr);
+    regcache_raw_supply (current_regcache, ARM_FPS_REGNUM,
+                        fp + NWFPE_FPSR_OFFSET);
 
   /* Fetch the floating point register.  */
   if (regno >= ARM_F0_REGNUM && regno <= ARM_F7_REGNUM)
-    {
-      int fn = regno - ARM_F0_REGNUM;
-
-      switch (fp.fType[fn])
-       {
-       case typeSingle:
-         fetch_nwfpe_single (fn, &fp);
-         break;
-
-       case typeDouble:
-           fetch_nwfpe_double (fn, &fp);
-         break;
-
-       case typeExtended:
-           fetch_nwfpe_extended (fn, &fp);
-         break;
-
-       default:
-           fetch_nwfpe_none (fn);
-       }
-    }
+    supply_nwfpe_register (current_regcache, regno, fp);
 }
 
 /* Get the whole floating point state of the process and store it
@@ -271,45 +126,26 @@ static void
 fetch_fpregs (void)
 {
   int ret, regno, tid;
-  FPA11 fp;
+  gdb_byte fp[ARM_LINUX_SIZEOF_NWFPE];
 
   /* Get the thread id for the ptrace call.  */
   tid = GET_THREAD_ID (inferior_ptid);
   
   /* Read the floating point state.  */
-  ret = ptrace (PT_GETFPREGS, tid, 0, &fp);
+  ret = ptrace (PT_GETFPREGS, tid, 0, fp);
   if (ret < 0)
     {
-      warning ("Unable to fetch the floating point registers.");
+      warning (_("Unable to fetch the floating point registers."));
       return;
     }
 
   /* Fetch fpsr.  */
-  supply_register (ARM_FPS_REGNUM, (char *) &fp.fpsr);
+  regcache_raw_supply (current_regcache, ARM_FPS_REGNUM,
+                      fp + NWFPE_FPSR_OFFSET);
 
   /* Fetch the floating point registers.  */
   for (regno = ARM_F0_REGNUM; regno <= ARM_F7_REGNUM; regno++)
-    {
-      int fn = regno - ARM_F0_REGNUM;
-
-      switch (fp.fType[fn])
-       {
-       case typeSingle:
-         fetch_nwfpe_single (fn, &fp);
-         break;
-
-       case typeDouble:
-         fetch_nwfpe_double (fn, &fp);
-         break;
-
-       case typeExtended:
-         fetch_nwfpe_extended (fn, &fp);
-         break;
-
-       default:
-         fetch_nwfpe_none (fn);
-       }
-    }
+    supply_nwfpe_register (current_regcache, regno, fp);
 }
 
 /* Save a particular register into the floating point state of the
@@ -319,33 +155,32 @@ static void
 store_fpregister (int regno)
 {
   int ret, tid;
-  FPA11 fp;
+  gdb_byte fp[ARM_LINUX_SIZEOF_NWFPE];
 
   /* Get the thread id for the ptrace call.  */
   tid = GET_THREAD_ID (inferior_ptid);
   
   /* Read the floating point state.  */
-  ret = ptrace (PT_GETFPREGS, tid, 0, &fp);
+  ret = ptrace (PT_GETFPREGS, tid, 0, fp);
   if (ret < 0)
     {
-      warning ("Unable to fetch the floating point registers.");
+      warning (_("Unable to fetch the floating point registers."));
       return;
     }
 
   /* Store fpsr.  */
   if (ARM_FPS_REGNUM == regno && register_cached (ARM_FPS_REGNUM))
-    read_register_gen (ARM_FPS_REGNUM, (char *) &fp.fpsr);
+    regcache_raw_collect (current_regcache, ARM_FPS_REGNUM,
+                         fp + NWFPE_FPSR_OFFSET);
 
   /* Store the floating point register.  */
   if (regno >= ARM_F0_REGNUM && regno <= ARM_F7_REGNUM)
-    {
-      store_nwfpe_register (regno, &fp);
-    }
+    collect_nwfpe_register (current_regcache, regno, fp);
 
-  ret = ptrace (PTRACE_SETFPREGS, tid, 0, &fp);
+  ret = ptrace (PTRACE_SETFPREGS, tid, 0, fp);
   if (ret < 0)
     {
-      warning ("Unable to store floating point register.");
+      warning (_("Unable to store floating point register."));
       return;
     }
 }
@@ -357,33 +192,33 @@ static void
 store_fpregs (void)
 {
   int ret, regno, tid;
-  FPA11 fp;
+  gdb_byte fp[ARM_LINUX_SIZEOF_NWFPE];
 
   /* Get the thread id for the ptrace call.  */
   tid = GET_THREAD_ID (inferior_ptid);
   
   /* Read the floating point state.  */
-  ret = ptrace (PT_GETFPREGS, tid, 0, &fp);
+  ret = ptrace (PT_GETFPREGS, tid, 0, fp);
   if (ret < 0)
     {
-      warning ("Unable to fetch the floating point registers.");
+      warning (_("Unable to fetch the floating point registers."));
       return;
     }
 
   /* Store fpsr.  */
   if (register_cached (ARM_FPS_REGNUM))
-    read_register_gen (ARM_FPS_REGNUM, (char *) &fp.fpsr);
+    regcache_raw_collect (current_regcache, ARM_FPS_REGNUM,
+                         fp + NWFPE_FPSR_OFFSET);
 
   /* Store the floating point registers.  */
   for (regno = ARM_F0_REGNUM; regno <= ARM_F7_REGNUM; regno++)
-    {
-      fetch_nwfpe_register (regno, &fp);
-    }
+    if (register_cached (regno))
+      collect_nwfpe_register (current_regcache, regno, fp);
 
-  ret = ptrace (PTRACE_SETFPREGS, tid, 0, &fp);
+  ret = ptrace (PTRACE_SETFPREGS, tid, 0, fp);
   if (ret < 0)
     {
-      warning ("Unable to store floating point registers.");
+      warning (_("Unable to store floating point registers."));
       return;
     }
 }
@@ -403,25 +238,28 @@ fetch_register (int regno)
   ret = ptrace (PTRACE_GETREGS, tid, 0, &regs);
   if (ret < 0)
     {
-      warning ("Unable to fetch general register.");
+      warning (_("Unable to fetch general register."));
       return;
     }
 
   if (regno >= ARM_A1_REGNUM && regno < ARM_PC_REGNUM)
-    supply_register (regno, (char *) &regs[regno]);
+    regcache_raw_supply (current_regcache, regno, (char *) &regs[regno]);
 
   if (ARM_PS_REGNUM == regno)
     {
       if (arm_apcs_32)
-        supply_register (ARM_PS_REGNUM, (char *) &regs[ARM_CPSR_REGNUM]);
+        regcache_raw_supply (current_regcache, ARM_PS_REGNUM,
+                            (char *) &regs[ARM_CPSR_REGNUM]);
       else
-        supply_register (ARM_PS_REGNUM, (char *) &regs[ARM_PC_REGNUM]);
+        regcache_raw_supply (current_regcache, ARM_PS_REGNUM,
+                            (char *) &regs[ARM_PC_REGNUM]);
     }
     
   if (ARM_PC_REGNUM == regno)
     { 
       regs[ARM_PC_REGNUM] = ADDR_BITS_REMOVE (regs[ARM_PC_REGNUM]);
-      supply_register (ARM_PC_REGNUM, (char *) &regs[ARM_PC_REGNUM]);
+      regcache_raw_supply (current_regcache, ARM_PC_REGNUM,
+                          (char *) &regs[ARM_PC_REGNUM]);
     }
 }
 
@@ -440,20 +278,23 @@ fetch_regs (void)
   ret = ptrace (PTRACE_GETREGS, tid, 0, &regs);
   if (ret < 0)
     {
-      warning ("Unable to fetch general registers.");
+      warning (_("Unable to fetch general registers."));
       return;
     }
 
   for (regno = ARM_A1_REGNUM; regno < ARM_PC_REGNUM; regno++)
-    supply_register (regno, (char *) &regs[regno]);
+    regcache_raw_supply (current_regcache, regno, (char *) &regs[regno]);
 
   if (arm_apcs_32)
-    supply_register (ARM_PS_REGNUM, (char *) &regs[ARM_CPSR_REGNUM]);
+    regcache_raw_supply (current_regcache, ARM_PS_REGNUM,
+                        (char *) &regs[ARM_CPSR_REGNUM]);
   else
-    supply_register (ARM_PS_REGNUM, (char *) &regs[ARM_PC_REGNUM]);
+    regcache_raw_supply (current_regcache, ARM_PS_REGNUM,
+                        (char *) &regs[ARM_PC_REGNUM]);
 
   regs[ARM_PC_REGNUM] = ADDR_BITS_REMOVE (regs[ARM_PC_REGNUM]);
-  supply_register (ARM_PC_REGNUM, (char *) &regs[ARM_PC_REGNUM]);
+  regcache_raw_supply (current_regcache, ARM_PC_REGNUM,
+                      (char *) &regs[ARM_PC_REGNUM]);
 }
 
 /* Store all general registers of the process from the values in
@@ -475,17 +316,23 @@ store_register (int regno)
   ret = ptrace (PTRACE_GETREGS, tid, 0, &regs);
   if (ret < 0)
     {
-      warning ("Unable to fetch general registers.");
+      warning (_("Unable to fetch general registers."));
       return;
     }
 
   if (regno >= ARM_A1_REGNUM && regno <= ARM_PC_REGNUM)
-    read_register_gen (regno, (char *) &regs[regno]);
+    regcache_raw_collect (current_regcache, regno, (char *) &regs[regno]);
+  else if (arm_apcs_32 && regno == ARM_PS_REGNUM)
+    regcache_raw_collect (current_regcache, regno,
+                        (char *) &regs[ARM_CPSR_REGNUM]);
+  else if (!arm_apcs_32 && regno == ARM_PS_REGNUM)
+    regcache_raw_collect (current_regcache, ARM_PC_REGNUM,
+                        (char *) &regs[ARM_PC_REGNUM]);
 
   ret = ptrace (PTRACE_SETREGS, tid, 0, &regs);
   if (ret < 0)
     {
-      warning ("Unable to store general register.");
+      warning (_("Unable to store general register."));
       return;
     }
 }
@@ -503,21 +350,99 @@ store_regs (void)
   ret = ptrace (PTRACE_GETREGS, tid, 0, &regs);
   if (ret < 0)
     {
-      warning ("Unable to fetch general registers.");
+      warning (_("Unable to fetch general registers."));
       return;
     }
 
   for (regno = ARM_A1_REGNUM; regno <= ARM_PC_REGNUM; regno++)
     {
       if (register_cached (regno))
-       read_register_gen (regno, (char *) &regs[regno]);
+       regcache_raw_collect (current_regcache, regno, (char *) &regs[regno]);
     }
 
+  if (arm_apcs_32 && register_cached (ARM_PS_REGNUM))
+    regcache_raw_collect (current_regcache, ARM_PS_REGNUM,
+                        (char *) &regs[ARM_CPSR_REGNUM]);
+
   ret = ptrace (PTRACE_SETREGS, tid, 0, &regs);
 
   if (ret < 0)
     {
-      warning ("Unable to store general registers.");
+      warning (_("Unable to store general registers."));
+      return;
+    }
+}
+
+/* Fetch all WMMX registers of the process and store into
+   regcache.  */
+
+#define IWMMXT_REGS_SIZE (16 * 8 + 6 * 4)
+
+static void
+fetch_wmmx_regs (void)
+{
+  char regbuf[IWMMXT_REGS_SIZE];
+  int ret, regno, tid;
+
+  /* Get the thread id for the ptrace call.  */
+  tid = GET_THREAD_ID (inferior_ptid);
+
+  ret = ptrace (PTRACE_GETWMMXREGS, tid, 0, regbuf);
+  if (ret < 0)
+    {
+      warning (_("Unable to fetch WMMX registers."));
+      return;
+    }
+
+  for (regno = 0; regno < 16; regno++)
+    regcache_raw_supply (current_regcache, regno + ARM_WR0_REGNUM,
+                        &regbuf[regno * 8]);
+
+  for (regno = 0; regno < 2; regno++)
+    regcache_raw_supply (current_regcache, regno + ARM_WCSSF_REGNUM,
+                        &regbuf[16 * 8 + regno * 4]);
+
+  for (regno = 0; regno < 4; regno++)
+    regcache_raw_supply (current_regcache, regno + ARM_WCGR0_REGNUM,
+                        &regbuf[16 * 8 + 2 * 4 + regno * 4]);
+}
+
+static void
+store_wmmx_regs (void)
+{
+  char regbuf[IWMMXT_REGS_SIZE];
+  int ret, regno, tid;
+
+  /* Get the thread id for the ptrace call.  */
+  tid = GET_THREAD_ID (inferior_ptid);
+
+  ret = ptrace (PTRACE_GETWMMXREGS, tid, 0, regbuf);
+  if (ret < 0)
+    {
+      warning (_("Unable to fetch WMMX registers."));
+      return;
+    }
+
+  for (regno = 0; regno < 16; regno++)
+    if (register_cached (regno + ARM_WR0_REGNUM))
+      regcache_raw_collect (current_regcache, regno + ARM_WR0_REGNUM,
+                           &regbuf[regno * 8]);
+
+  for (regno = 0; regno < 2; regno++)
+    if (register_cached (regno + ARM_WCSSF_REGNUM))
+      regcache_raw_collect (current_regcache, regno + ARM_WCSSF_REGNUM,
+                           &regbuf[16 * 8 + regno * 4]);
+
+  for (regno = 0; regno < 4; regno++)
+    if (register_cached (regno + ARM_WCGR0_REGNUM))
+      regcache_raw_collect (current_regcache, regno + ARM_WCGR0_REGNUM,
+                           &regbuf[16 * 8 + 2 * 4 + regno * 4]);
+
+  ret = ptrace (PTRACE_SETWMMXREGS, tid, 0, regbuf);
+
+  if (ret < 0)
+    {
+      warning (_("Unable to store WMMX registers."));
       return;
     }
 }
@@ -526,21 +451,25 @@ store_regs (void)
    regno == -1, otherwise fetch all general registers or all floating
    point registers depending upon the value of regno.  */
 
-void
-fetch_inferior_registers (int regno)
+static void
+arm_linux_fetch_inferior_registers (int regno)
 {
   if (-1 == regno)
     {
       fetch_regs ();
       fetch_fpregs ();
+      if (arm_linux_has_wmmx_registers)
+       fetch_wmmx_regs ();
     }
   else 
     {
-      if (regno < ARM_F0_REGNUM || regno > ARM_FPS_REGNUM)
+      if (regno < ARM_F0_REGNUM || regno == ARM_PS_REGNUM)
         fetch_register (regno);
-
-      if (regno >= ARM_F0_REGNUM && regno <= ARM_FPS_REGNUM)
+      else if (regno >= ARM_F0_REGNUM && regno <= ARM_FPS_REGNUM)
         fetch_fpregister (regno);
+      else if (arm_linux_has_wmmx_registers
+              && regno >= ARM_WR0_REGNUM && regno <= ARM_WCGR7_REGNUM)
+       fetch_wmmx_regs ();
     }
 }
 
@@ -548,95 +477,47 @@ fetch_inferior_registers (int regno)
    regno == -1, otherwise store all general registers or all floating
    point registers depending upon the value of regno.  */
 
-void
-store_inferior_registers (int regno)
+static void
+arm_linux_store_inferior_registers (int regno)
 {
   if (-1 == regno)
     {
       store_regs ();
       store_fpregs ();
+      if (arm_linux_has_wmmx_registers)
+       store_wmmx_regs ();
     }
   else
     {
-      if ((regno < ARM_F0_REGNUM) || (regno > ARM_FPS_REGNUM))
+      if (regno < ARM_F0_REGNUM || regno == ARM_PS_REGNUM)
         store_register (regno);
-
-      if ((regno >= ARM_F0_REGNUM) && (regno <= ARM_FPS_REGNUM))
+      else if ((regno >= ARM_F0_REGNUM) && (regno <= ARM_FPS_REGNUM))
         store_fpregister (regno);
+      else if (arm_linux_has_wmmx_registers
+              && regno >= ARM_WR0_REGNUM && regno <= ARM_WCGR7_REGNUM)
+       store_wmmx_regs ();
     }
 }
 
-/* Fill register regno (if it is a general-purpose register) in
-   *gregsetp with the appropriate value from GDB's register array.
-   If regno is -1, do this for all registers.  */
+/* Wrapper functions for the standard regset handling, used by
+   thread debugging.  */
 
 void
 fill_gregset (gdb_gregset_t *gregsetp, int regno)
 {
-  if (-1 == regno)
-    {
-      int regnum;
-      for (regnum = ARM_A1_REGNUM; regnum <= ARM_PC_REGNUM; regnum++) 
-       read_register_gen (regnum, (char *) &(*gregsetp)[regnum]);
-    }
-  else if (regno >= ARM_A1_REGNUM && regno <= ARM_PC_REGNUM)
-    read_register_gen (regno, (char *) &(*gregsetp)[regno]);
-
-  if (ARM_PS_REGNUM == regno || -1 == regno)
-    {
-      if (arm_apcs_32)
-       read_register_gen (ARM_PS_REGNUM,
-                          (char *) &(*gregsetp)[ARM_CPSR_REGNUM]);
-      else
-       read_register_gen (ARM_PC_REGNUM,
-                          (char *) &(*gregsetp)[ARM_PC_REGNUM]);
-    }
+  arm_linux_collect_gregset (NULL, current_regcache, regno, gregsetp, 0);
 }
 
-/* Fill GDB's register array with the general-purpose register values
-   in *gregsetp.  */
-
 void
 supply_gregset (gdb_gregset_t *gregsetp)
 {
-  int regno, reg_pc;
-
-  for (regno = ARM_A1_REGNUM; regno < ARM_PC_REGNUM; regno++)
-    supply_register (regno, (char *) &(*gregsetp)[regno]);
-
-  if (arm_apcs_32)
-    supply_register (ARM_PS_REGNUM, (char *) &(*gregsetp)[ARM_CPSR_REGNUM]);
-  else
-    supply_register (ARM_PS_REGNUM, (char *) &(*gregsetp)[ARM_PC_REGNUM]);
-
-  reg_pc = ADDR_BITS_REMOVE ((CORE_ADDR)(*gregsetp)[ARM_PC_REGNUM]);
-  supply_register (ARM_PC_REGNUM, (char *) &reg_pc);
+  arm_linux_supply_gregset (NULL, current_regcache, -1, gregsetp, 0);
 }
 
-/* Fill register regno (if it is a floating-point register) in
-   *fpregsetp with the appropriate value from GDB's register array.
-   If regno is -1, do this for all registers.  */
-
 void
 fill_fpregset (gdb_fpregset_t *fpregsetp, int regno)
 {
-  FPA11 *fp = (FPA11 *) fpregsetp;
-  
-  if (-1 == regno)
-    {
-       int regnum;
-       for (regnum = ARM_F0_REGNUM; regnum <= ARM_F7_REGNUM; regnum++)
-         store_nwfpe_register (regnum, fp);
-    }
-  else if (regno >= ARM_F0_REGNUM && regno <= ARM_F7_REGNUM)
-    {
-      store_nwfpe_register (regno, fp);
-      return;
-    }
-
-  /* Store fpsr.  */
-  if (ARM_FPS_REGNUM == regno || -1 == regno)
-    read_register_gen (ARM_FPS_REGNUM, (char *) &fp->fpsr);
+  arm_linux_collect_nwfpe (NULL, current_regcache, regno, fpregsetp, 0);
 }
 
 /* Fill GDB's register array with the floating-point register values
@@ -645,23 +526,24 @@ fill_fpregset (gdb_fpregset_t *fpregsetp, int regno)
 void
 supply_fpregset (gdb_fpregset_t *fpregsetp)
 {
-  int regno;
-  FPA11 *fp = (FPA11 *) fpregsetp;
-
-  /* Fetch fpsr.  */
-  supply_register (ARM_FPS_REGNUM, (char *) &fp->fpsr);
-
-  /* Fetch the floating point registers.  */
-  for (regno = ARM_F0_REGNUM; regno <= ARM_F7_REGNUM; regno++)
-    {
-      fetch_nwfpe_register (regno, fp);
-    }
+  arm_linux_supply_nwfpe (NULL, current_regcache, -1, fpregsetp, 0);
 }
 
-int
-arm_linux_kernel_u_size (void)
+/* Fetch the thread-local storage pointer for libthread_db.  */
+
+ps_err_e
+ps_get_thread_area (const struct ps_prochandle *ph,
+                    lwpid_t lwpid, int idx, void **base)
 {
-  return (sizeof (struct user));
+  if (ptrace (PTRACE_GET_THREAD_AREA, lwpid, NULL, base) != 0)
+    return PS_ERR;
+
+  /* IDX is the bias from the thread pointer to the beginning of the
+     thread descriptor.  It has to be subtracted due to implementation
+     quirks in libthread_db.  */
+  *base = (void *) ((char *)*base - idx);
+
+  return PS_OK;
 }
 
 static unsigned int
@@ -674,7 +556,7 @@ get_linux_version (unsigned int *vmajor,
 
   if (-1 == uname (&info))
     {
-      warning ("Unable to determine Linux version.");
+      warning (_("Unable to determine GNU/Linux version."));
       return -1;
     }
 
@@ -689,8 +571,64 @@ get_linux_version (unsigned int *vmajor,
   return ((*vmajor << 16) | (*vminor << 8) | *vrelease);
 }
 
+static LONGEST (*super_xfer_partial) (struct target_ops *, enum target_object,
+                                     const char *, gdb_byte *, const gdb_byte *,
+                                     ULONGEST, LONGEST);
+
+static LONGEST
+arm_linux_xfer_partial (struct target_ops *ops,
+                        enum target_object object,
+                        const char *annex,
+                        gdb_byte *readbuf, const gdb_byte *writebuf,
+                        ULONGEST offset, LONGEST len)
+{
+  if (object == TARGET_OBJECT_AVAILABLE_FEATURES)
+    {
+      if (annex != NULL && strcmp (annex, "target.xml") == 0)
+       {
+         int ret;
+         char regbuf[IWMMXT_REGS_SIZE];
+
+         ret = ptrace (PTRACE_GETWMMXREGS, GET_THREAD_ID (inferior_ptid),
+                       0, regbuf);
+         if (ret < 0)
+           arm_linux_has_wmmx_registers = 0;
+         else
+           arm_linux_has_wmmx_registers = 1;
+
+         if (arm_linux_has_wmmx_registers)
+           annex = "arm-with-iwmmxt.xml";
+         else
+           return -1;
+       }
+
+      return xml_builtin_xfer_partial (annex, readbuf, writebuf, offset, len);
+    }
+
+  return super_xfer_partial (ops, object, annex, readbuf, writebuf,
+                            offset, len);
+}
+
+void _initialize_arm_linux_nat (void);
+
 void
 _initialize_arm_linux_nat (void)
 {
+  struct target_ops *t;
+
   os_version = get_linux_version (&os_major, &os_minor, &os_release);
+
+  /* Fill in the generic GNU/Linux methods.  */
+  t = linux_target ();
+
+  /* Add our register access methods.  */
+  t->to_fetch_registers = arm_linux_fetch_inferior_registers;
+  t->to_store_registers = arm_linux_store_inferior_registers;
+
+  /* Override the default to_xfer_partial.  */
+  super_xfer_partial = t->to_xfer_partial;
+  t->to_xfer_partial = arm_linux_xfer_partial;
+
+  /* Register the target.  */
+  linux_nat_add_target (t);
 }
This page took 0.060429 seconds and 4 git commands to generate.