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.

gdb/ChangeLog

@@ -1,3 +1,35 @@
+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.
+
 Thu Apr 20 18:54:15 2000  Andrew Cagney  <cagney@b1.cygnus.com>
 
 	From Daniel Berlin <dan@cgsoftware.com> and Tim Mooney

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)
 {
@@ -113,6 +135,30 @@ fetch_nwfpe_extended (unsigned int fn, FPA11 * fpa11)
   supply_register (F0_REGNUM + fn, (char *) &mem[0]);
 }
 
+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)
 {
@@ -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
+void
-   floating point stack into registers[].  */
+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])
+      fetch_nwfpe_register (regno, &fp);
-	{
-	  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;
-	    }
-	}
     }
 
-  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_regs (void)
+store_register (int regno)
 {
-  int ret, regno;
+  int ret, tid;
   struct pt_regs regs;
   
-  ret = ptrace (PTRACE_GETREGS, inferior_pid, 0, &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, tid;
+  struct pt_regs 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,12 +530,20 @@ store_regs (void)
 void
 fetch_inferior_registers (int regno)
 {
-  if ((regno < F0_REGNUM) || (regno > FPS_REGNUM))
+  if (-1 == regno)
+    {
       fetch_regs ();
-
-  if (((regno >= F0_REGNUM) && (regno <= FPS_REGNUM)) || (regno == -1))
       fetch_fpregs ();
     }
+  else 
+    {
+      if (regno < F0_REGNUM || regno > FPS_REGNUM)
+        fetch_register (regno);
+
+      if (regno >= F0_REGNUM && regno <= FPS_REGNUM)
+        fetch_fpregister (regno);
+    }
+}
 
 /* Store registers back into the inferior.  Store all registers if
    regno == -1, otherwise store all general registers or all floating
@@ -315,17 +552,118 @@ fetch_inferior_registers (int regno)
 void
 store_inferior_registers (int regno)
 {
-  if ((regno < F0_REGNUM) || (regno > FPS_REGNUM))
+  if (-1 == regno)
+    {
       store_regs ();
-
-  if (((regno >= F0_REGNUM) && (regno <= FPS_REGNUM)) || (regno == -1))
       store_fpregs ();
     }
-
+  else
-int
-arm_linux_register_u_addr (int blockend, int regnum)
     {
-  return blockend + REGISTER_BYTE (regnum);
+      if ((regno < F0_REGNUM) || (regno > FPS_REGNUM))
+        store_register (regno);
+
+      if ((regno >= F0_REGNUM) && (regno <= FPS_REGNUM))
+        store_fpregister (regno);
+    }
+}
+
+/* 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)
+{
+  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

gdb/config/arm/linux.mh

@@ -5,4 +5,7 @@ XDEPFILES= ser-tcp.o
 
 NAT_FILE= nm-linux.h
 NATDEPFILES= infptrace.o solib.o inftarg.o fork-child.o corelow.o \
-	     core-aout.o arm-linux-nat.o
+	     core-regset.o arm-linux-nat.o linux-thread.o lin-thread.o
+
+LOADLIBES= -ldl -rdynamic
+

gdb/config/arm/nm-linux.h

@@ -21,6 +21,8 @@
 #ifndef NM_ARMLINUX_H
 #define NM_ARMLINUX_H
 
+#include "nm-linux.h"
+
 /* Return sizeof user struct to callers in less machine dependent routines */
 extern int kernel_u_size (void);
 #define KERNEL_U_SIZE	arm_linux_kernel_u_size()
@@ -28,19 +30,4 @@ extern int kernel_u_size (void);
 /* Override copies of {fetch,store}_inferior_registers in infptrace.c.  */
 #define FETCH_INFERIOR_REGISTERS
 
-/* Tell gdb that we can attach and detach other processes.  */
-#define ATTACH_DETACH
-
-extern int arm_register_u_addr (int, int);
-#define REGISTER_U_ADDR(addr, blockend, regno) \
-	{ (addr) = arm_linux_register_u_addr((blockend), (regno)); }
-
-/* We define this if link.h is available, because with ELF we use SVR4 style
-   shared libraries. */
-
-#ifdef HAVE_LINK_H
-#define SVR4_SHARED_LIBS
-#include "solib.h"		/* Support for shared libraries. */
-#endif
-
 #endif /* NM_ARMLINUX_H */

gdb/configure.tgt

@@ -52,7 +52,9 @@ alpha*-*-linux*)	gdb_target=alpha-linux ;;
 arc-*-*)		gdb_target=arc ;;
 
 arm*-wince-pe)		gdb_target=wince ;;
-arm*-*-linux*)		gdb_target=linux ;;
+arm*-*-linux*)		gdb_target=linux 
+			configdirs="$configdirs gdbserver"
+			;;
 arm*-*-* | thumb*-*-* | strongarm*-*-*)
 			gdb_target=embed
                         configdirs="$configdirs rdi-share"