Changes to support core files and linux threads.

2000-04-20  Scott Bambrough <scottb@netwinder.org>

	* arm-linux-nat.c (PIDGET, TIDGET): New.
	(get_thread_id, GET_THREAD_ID): New.
	(fetch_nwfpe_register, store_nwfpe_register): New.
	(fetch_register, store_register): New.
	(fetch_fpregister, store_fpregister): New.
	(fill_gregset, supply_gregset): New.
	(fill_fpregset, supply_fpregset): New.
	(fetch_fpregs): Modified to use thread id's.
	(store_fpregs): Modified to use thread id's and
	fetch_nwfpe_register.
	(fetch_regs): Modified to use thread id's.
	(store_regs): Modified to use thread id's.
	(fetch_inferior_registers): Modified to handle single register
	fetches.
	(store_inferior_registers): Modified to handle single register
	stores.
	(arm_linux_register_u_addr): Removed.

	* configure.tgt: Added gdbserver to configdirs for arm*-*-linux*.

	* config/arm/linux.mh
	(NATDEPFILES): Removed core-aout.o.  Added core-regset.o.
	(LOADLIBES): Define.

	* config/arm/nm-linux.h: Include config/nm-linux.h.
	(ATTACH_DETACH): Removed.  Defined in config/nm-linux.h.
	(REGISTER_U_ADDR): Removed.
	(SVR4_SHARED_LIBS): Removed.  Defined in config/nm-linux.h.
	(#include "solib.h"): Removed.  Included via config/nm-linux.h.

1 files changed, 380 insertions, 42 deletions

diff --git a/gdb/arm-linux-nat.c b/gdb/arm-linux-nat.c
index aa2eb285de1..466d1d10164 100644
--- a/gdb/arm-linux-nat.c
+++ b/gdb/arm-linux-nat.c
@@ -26,6 +26,7 @@
 #include <sys/user.h>
 #include <sys/ptrace.h>
 #include <sys/utsname.h>
+#include <sys/procfs.h>
 
 extern int arm_apcs_32;
 
@@ -71,6 +72,27 @@ FPA11;
 
 static unsigned int os_version, os_major, os_minor, os_release;
 
+/* On 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_pid will contain the main process ID and the
+   individual thread (process) ID mashed together.  These macros are
+   used to separate them out.  These definitions should be overridden
+   if thread support is included.  */
+
+#if !defined (PIDGET)	/* Default definition for PIDGET/TIDGET.  */
+#define PIDGET(PID)	PID
+#define TIDGET(PID)	0
+#endif
+
+int
+get_thread_id (int inferior_pid)
+{
+  int tid = TIDGET (inferior_pid);
+  if (0 == tid) tid = inferior_pid;
+  return tid;
+}
+#define GET_THREAD_ID(PID)	get_thread_id ((PID));
+
 static void
 fetch_nwfpe_single (unsigned int fn, FPA11 * fpa11)
 {
@@ -114,6 +136,30 @@ fetch_nwfpe_extended (unsigned int fn, FPA11 * fpa11)
 }
 
 static void
+fetch_nwfpe_register (int regno, FPA11 * fpa11)
+{
+   int fn = regno - 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];
@@ -146,20 +192,96 @@ store_nwfpe_extended (unsigned int fn, FPA11 * fpa11)
   fpa11->fType[fn] = typeDouble;
 }
 
-/* Get the whole floating point state of the process and store the
-   floating point stack into registers[].  */
+void
+store_nwfpe_register (int regno, FPA11 * fpa11)
+{
+  if (register_valid[regno])
+    {
+       unsigned int fn = regno - 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;
+	 }
+    }
+}
+
+
+/* Get the value of a particular register from the floating point
+   state of the process and store it into registers[].  */
+
+static void
+fetch_fpregister (int regno)
+{
+  int ret, tid;
+  FPA11 fp;
+  
+  /* Get the thread id for the ptrace call.  */
+  tid = GET_THREAD_ID (inferior_pid);
+
+  /* Read the floating point state.  */
+  ret = ptrace (PT_GETFPREGS, tid, 0, &fp);
+  if (ret < 0)
+    {
+      warning ("Unable to fetch floating point register.");
+      return;
+    }
+
+  /* Fetch fpsr.  */
+  if (FPS_REGNUM == regno)
+    supply_register (FPS_REGNUM, (char *) &fp.fpsr);
+
+  /* Fetch the floating point register.  */
+  if (regno >= F0_REGNUM && regno <= F7_REGNUM)
+    {
+      int fn = regno - 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);
+	}
+    }
+}
+
+/* Get the whole floating point state of the process and store it
+   into registers[].  */
 
 static void
 fetch_fpregs (void)
 {
-  int ret, regno;
+  int ret, regno, tid;
   FPA11 fp;
 
+  /* Get the thread id for the ptrace call.  */
+  tid = GET_THREAD_ID (inferior_pid);
+  
   /* Read the floating point state.  */
-  ret = ptrace (PT_GETFPREGS, inferior_pid, 0, &fp);
+  ret = ptrace (PT_GETFPREGS, tid, 0, &fp);
   if (ret < 0)
     {
-      warning ("Unable to fetch the floating point state.");
+      warning ("Unable to fetch the floating point registers.");
       return;
     }
 
@@ -191,15 +313,64 @@ fetch_fpregs (void)
     }
 }
 
+/* Save a particular register into the floating point state of the
+   process using the contents from registers[].  */
+
+static void
+store_fpregister (int regno)
+{
+  int ret, tid;
+  FPA11 fp;
+
+  /* Get the thread id for the ptrace call.  */
+  tid = GET_THREAD_ID (inferior_pid);
+  
+  /* Read the floating point state.  */
+  ret = ptrace (PT_GETFPREGS, tid, 0, &fp);
+  if (ret < 0)
+    {
+      warning ("Unable to fetch the floating point registers.");
+      return;
+    }
+
+  /* Store fpsr.  */
+  if (FPS_REGNUM == regno && register_valid[FPS_REGNUM])
+    read_register_gen (FPS_REGNUM, (char *) &fp.fpsr);
+
+  /* Store the floating point register.  */
+  if (regno >= F0_REGNUM && regno <= F7_REGNUM)
+    {
+      store_nwfpe_register (regno, &fp);
+    }
+
+  ret = ptrace (PTRACE_SETFPREGS, tid, 0, &fp);
+  if (ret < 0)
+    {
+      warning ("Unable to store floating point register.");
+      return;
+    }
+}
+
 /* Save the whole floating point state of the process using
    the contents from registers[].  */
 
 static void
 store_fpregs (void)
 {
-  int ret, regno;
+  int ret, regno, tid;
   FPA11 fp;
 
+  /* Get the thread id for the ptrace call.  */
+  tid = GET_THREAD_ID (inferior_pid);
+  
+  /* Read the floating point state.  */
+  ret = ptrace (PT_GETFPREGS, tid, 0, &fp);
+  if (ret < 0)
+    {
+      warning ("Unable to fetch the floating point registers.");
+      return;
+    }
+
   /* Store fpsr.  */
   if (register_valid[FPS_REGNUM])
     read_register_gen (FPS_REGNUM, (char *) &fp.fpsr);
@@ -207,44 +378,67 @@ store_fpregs (void)
   /* Store the floating point registers.  */
   for (regno = F0_REGNUM; regno <= F7_REGNUM; regno++)
     {
-      if (register_valid[regno])
-	{
-	  unsigned int fn = regno - F0_REGNUM;
-	  switch (fp.fType[fn])
-	    {
-	    case typeSingle:
-	      store_nwfpe_single (fn, &fp);
-	      break;
-
-	    case typeDouble:
-	      store_nwfpe_double (fn, &fp);
-	      break;
-
-	    case typeExtended:
-	      store_nwfpe_extended (fn, &fp);
-	      break;
-	    }
-	}
+      fetch_nwfpe_register (regno, &fp);
     }
 
-  ret = ptrace (PTRACE_SETFPREGS, inferior_pid, 0, &fp);
+  ret = ptrace (PTRACE_SETFPREGS, tid, 0, &fp);
   if (ret < 0)
     {
-      warning ("Unable to store floating point state.");
+      warning ("Unable to store floating point registers.");
       return;
     }
 }
 
+/* Fetch a general register of the process and store into
+   registers[].  */
+
+static void
+fetch_register (int regno)
+{
+  int ret, tid;
+  struct pt_regs regs;
+
+  /* Get the thread id for the ptrace call.  */
+  tid = GET_THREAD_ID (inferior_pid);
+  
+  ret = ptrace (PTRACE_GETREGS, tid, 0, &regs);
+  if (ret < 0)
+    {
+      warning ("Unable to fetch general register.");
+      return;
+    }
+
+  if (regno >= A1_REGNUM && regno < PC_REGNUM)
+    supply_register (regno, (char *) &regs.uregs[regno]);
+
+  if (PS_REGNUM == regno)
+    {
+      if (arm_apcs_32)
+        supply_register (PS_REGNUM, (char *) &regs.uregs[CPSR_REGNUM]);
+      else
+        supply_register (PS_REGNUM, (char *) &regs.uregs[PC_REGNUM]);
+    }
+    
+  if (PC_REGNUM == regno)
+    { 
+      regs.uregs[PC_REGNUM] = ADDR_BITS_REMOVE (regs.uregs[PC_REGNUM]);
+      supply_register (PC_REGNUM, (char *) &regs.uregs[PC_REGNUM]);
+    }
+}
+
 /* Fetch all general registers of the process and store into
    registers[].  */
 
 static void
 fetch_regs (void)
 {
-  int ret, regno;
+  int ret, regno, tid;
   struct pt_regs regs;
 
-  ret = ptrace (PTRACE_GETREGS, inferior_pid, 0, &regs);
+  /* Get the thread id for the ptrace call.  */
+  tid = GET_THREAD_ID (inferior_pid);
+  
+  ret = ptrace (PTRACE_GETREGS, tid, 0, &regs);
   if (ret < 0)
     {
       warning ("Unable to fetch general registers.");
@@ -267,12 +461,47 @@ fetch_regs (void)
    registers[].  */
 
 static void
+store_register (int regno)
+{
+  int ret, tid;
+  struct pt_regs regs;
+  
+  if (!register_valid[regno])
+    return;
+
+  /* Get the thread id for the ptrace call.  */
+  tid = GET_THREAD_ID (inferior_pid);
+  
+  /* Get the general registers from the process.  */
+  ret = ptrace (PTRACE_GETREGS, tid, 0, &regs);
+  if (ret < 0)
+    {
+      warning ("Unable to fetch general registers.");
+      return;
+    }
+
+  if (regno >= A1_REGNUM && regno <= PC_REGNUM)
+    read_register_gen (regno, (char *) &regs.uregs[regno]);
+
+  ret = ptrace (PTRACE_SETREGS, tid, 0, &regs);
+  if (ret < 0)
+    {
+      warning ("Unable to store general register.");
+      return;
+    }
+}
+
+static void
 store_regs (void)
 {
-  int ret, regno;
+  int ret, regno, tid;
   struct pt_regs regs;
 
-  ret = ptrace (PTRACE_GETREGS, inferior_pid, 0, &regs);
+  /* Get the thread id for the ptrace call.  */
+  tid = GET_THREAD_ID (inferior_pid);
+  
+  /* Fetch the general registers.  */
+  ret = ptrace (PTRACE_GETREGS, tid, 0, &regs);
   if (ret < 0)
     {
       warning ("Unable to fetch general registers.");
@@ -285,7 +514,7 @@ store_regs (void)
 	read_register_gen (regno, (char *) &regs.uregs[regno]);
     }
 
-  ret = ptrace (PTRACE_SETREGS, inferior_pid, 0, &regs);
+  ret = ptrace (PTRACE_SETREGS, tid, 0, &regs);
 
   if (ret < 0)
     {
@@ -301,11 +530,19 @@ store_regs (void)
 void
 fetch_inferior_registers (int regno)
 {
-  if ((regno < F0_REGNUM) || (regno > FPS_REGNUM))
-    fetch_regs ();
+  if (-1 == regno)
+    {
+      fetch_regs ();
+      fetch_fpregs ();
+    }
+  else 
+    {
+      if (regno < F0_REGNUM || regno > FPS_REGNUM)
+        fetch_register (regno);
 
-  if (((regno >= F0_REGNUM) && (regno <= FPS_REGNUM)) || (regno == -1))
-    fetch_fpregs ();
+      if (regno >= F0_REGNUM && regno <= FPS_REGNUM)
+        fetch_fpregister (regno);
+    }
 }
 
 /* Store registers back into the inferior.  Store all registers if
@@ -315,17 +552,118 @@ fetch_inferior_registers (int regno)
 void
 store_inferior_registers (int regno)
 {
-  if ((regno < F0_REGNUM) || (regno > FPS_REGNUM))
-    store_regs ();
+  if (-1 == regno)
+    {
+      store_regs ();
+      store_fpregs ();
+    }
+  else
+    {
+      if ((regno < F0_REGNUM) || (regno > FPS_REGNUM))
+        store_register (regno);
 
-  if (((regno >= F0_REGNUM) && (regno <= FPS_REGNUM)) || (regno == -1))
-    store_fpregs ();
+      if ((regno >= F0_REGNUM) && (regno <= FPS_REGNUM))
+        store_fpregister (regno);
+    }
 }
 
-int
-arm_linux_register_u_addr (int blockend, int regnum)
+/* 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.  */
+
+void
+fill_gregset (gregset_t *gregsetp, int regno)
+{
+  if (-1 == regno)
+    {
+      int regnum;
+      for (regnum = A1_REGNUM; regnum <= PC_REGNUM; regnum++) 
+        if (register_valid[regnum])
+	  read_register_gen (regnum, (char *) &(*gregsetp)[regnum]);
+    }
+  else if (regno >= A1_REGNUM && regno <= PC_REGNUM)
+    {
+      if (register_valid[regno])
+	read_register_gen (regno, (char *) &(*gregsetp)[regno]);
+    }
+
+  if (PS_REGNUM == regno || -1 == regno)
+    {
+      if (register_valid[regno] || -1 == regno)
+        {
+          if (arm_apcs_32)
+	    read_register_gen (PS_REGNUM, (char *) &(*gregsetp)[CPSR_REGNUM]);
+	  else
+	    read_register_gen (PC_REGNUM, (char *) &(*gregsetp)[PC_REGNUM]);
+	}
+    }
+        
+}
+
+/* Fill GDB's register array with the general-purpose register values
+   in *gregsetp.  */
+
+void
+supply_gregset (gregset_t *gregsetp)
+{
+  int regno, reg_pc;
+
+  for (regno = A1_REGNUM; regno < PC_REGNUM; regno++)
+    supply_register (regno, (char *) &(*gregsetp)[regno]);
+
+  if (arm_apcs_32)
+    supply_register (PS_REGNUM, (char *) &(*gregsetp)[CPSR_REGNUM]);
+  else
+    supply_register (PS_REGNUM, (char *) &(*gregsetp)[PC_REGNUM]);
+
+  reg_pc = ADDR_BITS_REMOVE ((CORE_ADDR)(*gregsetp)[PC_REGNUM]);
+  supply_register (PC_REGNUM, (char *) &reg_pc);
+}
+
+/* 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 (fpregset_t *fpregsetp, int regno)
+{
+  FPA11 *fp = (FPA11 *) fpregsetp;
+  
+  if (-1 == regno)
+    {
+       int regnum;
+       for (regnum = F0_REGNUM; regnum <= F7_REGNUM; regnum++)
+         store_nwfpe_register (regnum, fp);
+    }
+  else if (regno >= F0_REGNUM && regno <= F7_REGNUM)
+    {
+      store_nwfpe_register (regno, fp);
+      return;
+    }
+
+  /* Store fpsr.  */
+  if (register_valid[FPS_REGNUM])
+    if (FPS_REGNUM == regno || -1 == regno)
+      read_register_gen (FPS_REGNUM, (char *) &fp->fpsr);
+}
+
+/* Fill GDB's register array with the floating-point register values
+   in *fpregsetp.  */
+
+void
+supply_fpregset (fpregset_t *fpregsetp)
 {
-  return blockend + REGISTER_BYTE (regnum);
+  int regno;
+  FPA11 *fp = (FPA11 *) fpregsetp;
+
+  /* Fetch fpsr.  */
+  supply_register (FPS_REGNUM, (char *) &fp->fpsr);
+
+  /* Fetch the floating point registers.  */
+  for (regno = F0_REGNUM; regno <= F7_REGNUM; regno++)
+    {
+      fetch_nwfpe_register (regno, fp);
+    }
 }
 
 int