This is the mail archive of the gdb-patches@sources.redhat.com mailing list for the GDB project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

Re: [RFA] cleanup alpha core read/write registers


On Mon, Jun 02, 2003 at 11:19:37AM -0700, Richard Henderson wrote:
> RFA because I'm touching systems I can't test.
> 
> As far as alpha-nat is concerned, this gets rid of the use
> of the deprecated register array.  Indeed, there are no
> longer *any* instances of "deprecated" in the alpha port.
> 
> As far as Linux is concerned, this fixes the gcore test
> because we now properly dump the FPCR and UNIQUE registers.
> 
> As far as the BSD's are concerned, this should be a no-op,
> just avoiding some amount of code duplication.
> 
> Ok?

Gah.  This is the patch I meant to send.


r~



	* alpha-tdep.c (alpha_supply_int_regs, alpha_fill_int_regs): New.
	(alpha_supply_fp_regs, alpha_fill_fp_regs): New.
	* alpha-tdep.h: Declare them.

	* alpha-nat.c (fetch_osf_core_registers): Constify core_reg_mapping.
	Remove zerobuf.  Don't error on UNIQUE.
	(fetch_elf_core_registers): Use alpha_supply_{int,fp}_regs.
	(ALPHA_REGSET_UNIQUE): Provide default.
	(supply_gregset): Use alpha_supply_int_regs.
	(fill_gregset): Use alpha_fill_int_regs.
	(supply_fpregset): Use alpha_supply_fp_regs.
	(fill_fpregset): Use alpha_fill_fp_regs.
	* alphabsd-tdep.c (NUM_GREGS, NUM_FPREGS): Remove.
	(alphabsd_supply_reg): Use alpha_supply_int_regs.
	(alphabsd_fill_reg): Use alpha_fill_int_regs.
	(alphabsd_supply_fpreg): Use alpha_supply_fp_regs.
	(alphabsd_fill_fpreg): Use alpha_fill_fp_regs.
	* config/alpha/nm-linux.h (ALPHA_REGSET_UNIQUE): New.

Index: alpha-nat.c
===================================================================
RCS file: /cvs/src/src/gdb/alpha-nat.c,v
retrieving revision 1.18
diff -c -p -d -u -r1.18 alpha-nat.c
--- alpha-nat.c	1 Jun 2003 21:46:37 -0000	1.18
+++ alpha-nat.c	2 Jun 2003 20:27:39 -0000
@@ -68,7 +68,7 @@ fetch_osf_core_registers (char *core_reg
      OSF/1.2 core files.  OSF5 uses different names for the register
      enum list, need to handle two cases.  The actual values are the
      same.  */
-  static int core_reg_mapping[ALPHA_NUM_REGS] =
+  static int const core_reg_mapping[ALPHA_NUM_REGS] =
   {
 #ifdef NCF_REGS
 #define EFL NCF_REGS
@@ -94,18 +94,23 @@ fetch_osf_core_registers (char *core_reg
     EF_PC, -1
 #endif
   };
-  static char zerobuf[ALPHA_REGISTER_SIZE] = {0};
 
-  for (regno = 0; regno < NUM_REGS; regno++)
+  for (regno = 0; regno < ALPHA_NUM_REGS; regno++)
     {
       if (CANNOT_FETCH_REGISTER (regno))
 	{
-	  supply_register (regno, zerobuf);
+	  supply_register (regno, NULL);
 	  continue;
 	}
       addr = 8 * core_reg_mapping[regno];
       if (addr < 0 || addr >= core_reg_size)
 	{
+	  /* ??? UNIQUE is a new addition.  Don't generate an error.  */
+	  if (regno == ALPHA_UNIQUE_REGNUM)
+	    {
+	      supply_register (regno, NULL);
+	      continue;
+	    }
 	  if (bad_reg < 0)
 	    bad_reg = regno;
 	}
@@ -130,31 +135,22 @@ fetch_elf_core_registers (char *core_reg
       return;
     }
 
-  if (which == 2)
-    {
-      /* The FPU Registers.  */
-      memcpy (&deprecated_registers[REGISTER_BYTE (FP0_REGNUM)],
-	      core_reg_sect, 31 * 8);
-      memset (&deprecated_registers[REGISTER_BYTE (FP0_REGNUM + 31)], 0, 8);
-      memset (&deprecated_register_valid[FP0_REGNUM], 1, 32);
-    }
-  else
+  switch (which)
     {
-      /* The General Registers.  */
-      memcpy (&deprecated_registers[REGISTER_BYTE (ALPHA_V0_REGNUM)],
-	      core_reg_sect, 31 * 8);
-      memcpy (&deprecated_registers[REGISTER_BYTE (PC_REGNUM)],
-	      core_reg_sect + 31 * 8, 8);
-      memset (&deprecated_registers[REGISTER_BYTE (ALPHA_ZERO_REGNUM)], 0, 8);
-      memset (&deprecated_register_valid[ALPHA_V0_REGNUM], 1, 32);
-      deprecated_register_valid[PC_REGNUM] = 1;
+    case 0: /* integer registers */
+      /* PC is in slot 32; UNIQUE is in slot 33, if present.  */
+      alpha_supply_int_regs (-1, core_reg_sect, core_reg_sect + 31*8,
+			     (core_reg_size >= 33 * 8
+			      ? core_reg_sect + 32*8 : NULL));
+      break;
 
-      if (core_reg_size >= 33 * 8)
-	{
-	  memcpy (&deprecated_registers[REGISTER_BYTE (ALPHA_UNIQUE_REGNUM)],
-		  core_reg_sect + 32 * 8, 8);
-	  deprecated_register_valid[ALPHA_UNIQUE_REGNUM] = 1;
-	}
+    case 2: /* floating-point registers */
+      /* FPCR is in slot 32.  */
+      alpha_supply_fp_regs (-1, core_reg_sect, core_reg_sect + 31*8);
+      break;
+
+    default:
+      break;
     }
 }
 
@@ -192,6 +188,11 @@ kernel_u_size (void)
 /* Prototypes for supply_gregset etc. */
 #include "gregset.h"
 
+/* Locate the UNIQUE value within the gregset_t.  */
+#ifndef ALPHA_REGSET_UNIQUE
+#define ALPHA_REGSET_UNIQUE(ptr) NULL
+#endif
+
 /*
  * See the comment in m68k-tdep.c regarding the utility of these functions.
  */
@@ -199,31 +200,21 @@ kernel_u_size (void)
 void
 supply_gregset (gdb_gregset_t *gregsetp)
 {
-  register int regi;
   register long *regp = ALPHA_REGSET_BASE (gregsetp);
-  static char zerobuf[ALPHA_REGISTER_SIZE] = {0};
-
-  for (regi = 0; regi < 31; regi++)
-    supply_register (regi, (char *) (regp + regi));
-
-  supply_register (PC_REGNUM, (char *) (regp + 31));
+  void *unique = ALPHA_REGSET_UNIQUE (gregsetp);
 
-  /* Fill inaccessible registers with zero.  */
-  supply_register (ALPHA_ZERO_REGNUM, zerobuf);
+  /* PC is in slot 32.  */
+  alpha_supply_int_regs (-1, regp, regp + 31, unique);
 }
 
 void
 fill_gregset (gdb_gregset_t *gregsetp, int regno)
 {
-  int regi;
   register long *regp = ALPHA_REGSET_BASE (gregsetp);
+  void *unique = ALPHA_REGSET_UNIQUE (gregsetp);
 
-  for (regi = 0; regi < 31; regi++)
-    if ((regno == -1) || (regno == regi))
-      *(regp + regi) = *(long *) &deprecated_registers[REGISTER_BYTE (regi)];
-
-  if ((regno == -1) || (regno == PC_REGNUM))
-    *(regp + 31) = *(long *) &deprecated_registers[REGISTER_BYTE (PC_REGNUM)];
+  /* PC is in slot 32.  */
+  alpha_fill_int_regs (regno, regp, regp + 31, unique);
 }
 
 /*
@@ -234,27 +225,19 @@ fill_gregset (gdb_gregset_t *gregsetp, i
 void
 supply_fpregset (gdb_fpregset_t *fpregsetp)
 {
-  register int regi;
   register long *regp = ALPHA_REGSET_BASE (fpregsetp);
 
-  for (regi = 0; regi < 32; regi++)
-    supply_register (regi + FP0_REGNUM, (char *) (regp + regi));
+  /* FPCR is in slot 32.  */
+  alpha_supply_fp_regs (-1, regp, regp + 31);
 }
 
 void
 fill_fpregset (gdb_fpregset_t *fpregsetp, int regno)
 {
-  int regi;
   register long *regp = ALPHA_REGSET_BASE (fpregsetp);
 
-  for (regi = FP0_REGNUM; regi < FP0_REGNUM + 32; regi++)
-    {
-      if ((regno == -1) || (regno == regi))
-	{
-	  *(regp + regi - FP0_REGNUM) =
-	    *(long *) &deprecated_registers[REGISTER_BYTE (regi)];
-	}
-    }
+  /* FPCR is in slot 32.  */
+  alpha_fill_fp_regs (regno, regp, regp + 31);
 }
 #endif
 
Index: alpha-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/alpha-tdep.c,v
retrieving revision 1.102
diff -c -p -d -u -r1.102 alpha-tdep.c
--- alpha-tdep.c	2 Jun 2003 16:18:32 -0000	1.102
+++ alpha-tdep.c	2 Jun 2003 20:27:40 -0000
@@ -1260,6 +1260,73 @@ alpha_unwind_pc (struct gdbarch *gdbarch
 }
 
 
+/* Helper routines for alpha*-nat.c files to move register sets to and
+   from core files.  The UNIQUE pointer is allowed to be NULL, as most
+   targets don't supply this value in their core files.  */
+
+void
+alpha_supply_int_regs (int regno, const void *r0_r30,
+		       const void *pc, const void *unique)
+{
+  int i;
+
+  for (i = 0; i < 31; ++i)
+    if (regno == i || regno == -1)
+      supply_register (i, (const char *)r0_r30 + i*8);
+
+  if (regno == ALPHA_ZERO_REGNUM || regno == -1)
+    supply_register (ALPHA_ZERO_REGNUM, NULL);
+
+  if (regno == ALPHA_PC_REGNUM || regno == -1)
+    supply_register (ALPHA_PC_REGNUM, pc);
+
+  if (regno == ALPHA_UNIQUE_REGNUM || regno == -1)
+    supply_register (ALPHA_UNIQUE_REGNUM, unique);
+}
+
+void
+alpha_fill_int_regs (int regno, void *r0_r30, void *pc, void *unique)
+{
+  int i;
+
+  for (i = 0; i < 31; ++i)
+    if (regno == i || regno == -1)
+      regcache_collect (i, (char *)r0_r30 + i*8);
+
+  if (regno == ALPHA_PC_REGNUM || regno == -1)
+    regcache_collect (ALPHA_PC_REGNUM, pc);
+
+  if (unique && (regno == ALPHA_UNIQUE_REGNUM || regno == -1))
+    regcache_collect (ALPHA_UNIQUE_REGNUM, unique);
+}
+
+void
+alpha_supply_fp_regs (int regno, const void *f0_f30, const void *fpcr)
+{
+  int i;
+
+  for (i = ALPHA_FP0_REGNUM; i < ALPHA_FP0_REGNUM + 31; ++i)
+    if (regno == i || regno == -1)
+      supply_register (i, (const char *)f0_f30 + (i - ALPHA_FP0_REGNUM) * 8);
+
+  if (regno == ALPHA_FPCR_REGNUM || regno == -1)
+    supply_register (ALPHA_FPCR_REGNUM, fpcr);
+}
+
+void
+alpha_fill_fp_regs (int regno, void *f0_f30, void *fpcr)
+{
+  int i;
+
+  for (i = ALPHA_FP0_REGNUM; i < ALPHA_FP0_REGNUM + 31; ++i)
+    if (regno == i || regno == -1)
+      regcache_collect (i, (char *)f0_f30 + (i - ALPHA_FP0_REGNUM) * 8);
+
+  if (regno == ALPHA_FPCR_REGNUM || regno == -1)
+    regcache_collect (ALPHA_FPCR_REGNUM, fpcr);
+}
+
+
 /* alpha_software_single_step() is called just before we want to resume
    the inferior, if we want to single-step it but there is no hardware
    or kernel single-step support (NetBSD on Alpha, for example).  We find
Index: alpha-tdep.h
===================================================================
RCS file: /cvs/src/src/gdb/alpha-tdep.h,v
retrieving revision 1.16
diff -c -p -d -u -r1.16 alpha-tdep.h
--- alpha-tdep.h	2 Jun 2003 16:13:58 -0000	1.16
+++ alpha-tdep.h	2 Jun 2003 20:27:40 -0000
@@ -94,4 +94,10 @@ extern CORE_ADDR alpha_after_prologue (C
 
 extern void alpha_mdebug_init_abi (struct gdbarch_info, struct gdbarch *);
 
+extern void alpha_supply_int_regs (int, const void *, const void *,
+				   const void *);
+extern void alpha_fill_int_regs (int, void *, void *, void *);
+extern void alpha_supply_fp_regs (int, const void *, const void *);
+extern void alpha_fill_fp_regs (int, void *, void *);
+
 #endif /* ALPHA_TDEP_H */
Index: alphabsd-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/alphabsd-tdep.c,v
retrieving revision 1.1
diff -c -p -d -u -r1.1 alphabsd-tdep.c
--- alphabsd-tdep.c	11 May 2002 16:21:16 -0000	1.1
+++ alphabsd-tdep.c	2 Jun 2003 20:27:40 -0000
@@ -19,84 +19,37 @@
    Boston, MA 02111-1307, USA.  */
 
 #include "defs.h"
-#include "regcache.h"
 
 #include "alpha-tdep.h"
 #include "alphabsd-tdep.h"
 
-/* Number of general-purpose registers.  */
-#define NUM_GREGS 32
-
-/* Number of floating-point registers.  */
-#define NUM_FPREGS 31
-
 /* Conviently, GDB uses the same register numbering as the
    ptrace register structure used by BSD on Alpha.  */
 
 void
 alphabsd_supply_reg (char *regs, int regno)
 {
-  int i;
-
-  for (i = 0; i < NUM_GREGS; i++)
-    {
-      if (i == regno || regno == -1)
-	{
-	  if (CANNOT_FETCH_REGISTER (i))
-	    supply_register (i, NULL);
-	  else
-	    supply_register (i, regs + (i * 8));
-	}
-    }
-
-  /* The PC travels in the ZERO slot.  */
-  if (regno == PC_REGNUM || regno == -1)
-    supply_register (PC_REGNUM, regs + (31 * 8));
+  /* PC is at slot 32; UNIQUE not present.  */
+  alpha_supply_int_regs (regno, regs, regs + 31*8, NULL);
 }
 
 void
 alphabsd_fill_reg (char *regs, int regno)
 {
-  int i;
-
-  for (i = 0; i < NUM_GREGS; i++)
-    if ((regno == i || regno == -1) && ! CANNOT_STORE_REGISTER (i))
-      regcache_collect (i, regs + (i * 8));
-
-  /* The PC travels in the ZERO slot.  */
-  if (regno == PC_REGNUM || regno == -1)
-    regcache_collect (PC_REGNUM, regs + (31 * 8));
+  /* PC is at slot 32; UNIQUE not present.  */
+  alpha_fill_int_regs (regno, regs, regs + 31*8, NULL);
 }
 
 void
 alphabsd_supply_fpreg (char *fpregs, int regno)
 {
-  int i;
-
-  for (i = FP0_REGNUM; i < FP0_REGNUM + NUM_FPREGS; i++)
-    {
-      if (i == regno || regno == -1)
-	{
-	  if (CANNOT_FETCH_REGISTER (i))
-	    supply_register (i, NULL);
-	  else
-	    supply_register (i, fpregs + ((i - FP0_REGNUM) * 8));
-	}
-    }
-
-  if (regno == ALPHA_FPCR_REGNUM || regno == -1)
-    supply_register (ALPHA_FPCR_REGNUM, fpregs + (32 * 8));
+  /* FPCR is at slot 33; slot 32 unused.  */
+  alpha_supply_fp_regs (regno, regs, regs + 32*8);
 }
 
 void
 alphabsd_fill_fpreg (char *fpregs, int regno)
 {
-  int i;
-
-  for (i = FP0_REGNUM; i < FP0_REGNUM + NUM_FPREGS; i++)
-    if ((regno == i || regno == -1) && ! CANNOT_STORE_REGISTER (i))
-      regcache_collect (i, fpregs + ((i - FP0_REGNUM) * 8));
-
-  if (regno == ALPHA_FPCR_REGNUM || regno == -1)
-    regcache_collect (ALPHA_FPCR_REGNUM, fpregs + (32 * 8));
+  /* FPCR is at slot 33; slot 32 unused.  */
+  alpha_fill_fp_regs (regno, regs, regs + 32*8);
 }
Index: config/alpha/nm-linux.h
===================================================================
RCS file: /cvs/src/src/gdb/config/alpha/nm-linux.h,v
retrieving revision 1.13
diff -c -p -d -u -r1.13 nm-linux.h
--- config/alpha/nm-linux.h	31 Jan 2003 18:28:25 -0000	1.13
+++ config/alpha/nm-linux.h	2 Jun 2003 20:27:41 -0000
@@ -45,6 +45,9 @@
    pointer to the first register.  */
 #define ALPHA_REGSET_BASE(regsetp)  ((long *) (regsetp))
 
+/* Given a pointer to a gregset_t, locate the UNIQUE value.  */
+#define ALPHA_REGSET_UNIQUE(regsetp)  ((long *)(regsetp) + 32)
+
 /* The address of UNIQUE for ptrace.  */
 #define ALPHA_UNIQUE_PTRACE_ADDR 65
 


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]