[RFA] cleanup alpha core read/write registers

[RFA] cleanup alpha core read/write registers

[Richard Henderson]

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?


r~



	* alpha-nat.c: Remove all instances of "register".
	(zerobuf): Move out from subroutines.
	(fetch_elf_core_registers): Use supply_register.
	(supply_gregset): Use alpha-specific register macros; supply
	ALPHA_UNIQUE_REGNUM if the gregset is large enough.
	(fill_gregset): Similarly.  Use regcache_collect. 
	(supply_fpregset): Use alpha-specific register macros.
	(fill_fpregset): Similarly. Use regcache_collect.

Index: alpha-nat.c
===================================================================
RCS file: /cvs/src/src/gdb/alpha-nat.c,v
retrieving revision 1.18
diff -c -p -d -r1.18 alpha-nat.c
*** alpha-nat.c	1 Jun 2003 21:46:37 -0000	1.18
--- alpha-nat.c	2 Jun 2003 17:01:58 -0000
***************
*** 42,47 ****
--- 42,49 ----
  static void fetch_osf_core_registers (char *, unsigned, int, CORE_ADDR);
  static void fetch_elf_core_registers (char *, unsigned, int, CORE_ADDR);
  
+ static const char zerobuf[ALPHA_REGISTER_SIZE] = {0};
+ 
  /* Extract the register values out of the core file and store
     them where `read_register' will find them.
  
*************** static void
*** 59,66 ****
  fetch_osf_core_registers (char *core_reg_sect, unsigned core_reg_size,
  			  int which, CORE_ADDR reg_addr)
  {
!   register int regno;
!   register int addr;
    int bad_reg = -1;
  
    /* Table to map a gdb regnum to an index in the core register
--- 61,68 ----
  fetch_osf_core_registers (char *core_reg_sect, unsigned core_reg_size,
  			  int which, CORE_ADDR reg_addr)
  {
!   int regno;
!   int addr;
    int bad_reg = -1;
  
    /* Table to map a gdb regnum to an index in the core register
*************** fetch_osf_core_registers (char *core_reg
*** 94,100 ****
      EF_PC, -1
  #endif
    };
-   static char zerobuf[ALPHA_REGISTER_SIZE] = {0};
  
    for (regno = 0; regno < NUM_REGS; regno++)
      {
--- 96,101 ----
*************** static void
*** 124,129 ****
--- 125,132 ----
  fetch_elf_core_registers (char *core_reg_sect, unsigned core_reg_size,
  			  int which, CORE_ADDR reg_addr)
  {
+   int i;
+ 
    if (core_reg_size < 32 * 8)
      {
        error ("Core file register section too small (%u bytes).", core_reg_size);
*************** fetch_elf_core_registers (char *core_reg
*** 132,164 ****
  
    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
      {
        /* 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;
  
        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;
! 	}
      }
  }
  
- 
  /* Map gdb internal register number to a ptrace ``address''.
     These ``addresses'' are defined in <sys/ptrace.h>, with
     the exception of ALPHA_UNIQUE_PTRACE_ADDR.  */
--- 135,158 ----
  
    if (which == 2)
      {
!       /* The Floating Point Registers.  */
!       for (i = 0; i < 31; ++i)
! 	supply_register (ALPHA_FP0_REGNUM + i, core_reg_sect + i * 8);
!       supply_register (ALPHA_FPCR_REGNUM, core_reg_sect + 31 * 8);
      }
    else
      {
        /* The General Registers.  */
!       for (i = 0; i < 31; ++i)
! 	supply_register (ALPHA_V0_REGNUM + i, core_reg_sect + i * 8);
!       supply_register (ALPHA_ZERO_REGNUM, zerobuf);
!       supply_register (ALPHA_PC_REGNUM, core_reg_sect + 31 * 8);
  
        if (core_reg_size >= 33 * 8)
! 	supply_register (ALPHA_UNIQUE_REGNUM, core_reg_sect + 32 * 8);
      }
  }
  
  /* Map gdb internal register number to a ptrace ``address''.
     These ``addresses'' are defined in <sys/ptrace.h>, with
     the exception of ALPHA_UNIQUE_PTRACE_ADDR.  */
*************** kernel_u_size (void)
*** 199,212 ****
  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));
  
    /* Fill inaccessible registers with zero.  */
    supply_register (ALPHA_ZERO_REGNUM, zerobuf);
--- 193,208 ----
  void
  supply_gregset (gdb_gregset_t *gregsetp)
  {
!   int regi;
!   long *regp = ALPHA_REGSET_BASE (gregsetp);
  
    for (regi = 0; regi < 31; regi++)
!     supply_register (regi, regp + regi);
  
!   supply_register (ALPHA_PC_REGNUM, regp + 31);
! 
!   if (sizeof (*gregsetp) >= 33 * 8)
!     supply_register (ALPHA_UNIQUE_REGNUM, regp + 32);
  
    /* Fill inaccessible registers with zero.  */
    supply_register (ALPHA_ZERO_REGNUM, zerobuf);
*************** void
*** 216,229 ****
  fill_gregset (gdb_gregset_t *gregsetp, int regno)
  {
    int regi;
!   register long *regp = ALPHA_REGSET_BASE (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)];
  }
  
  /*
--- 212,229 ----
  fill_gregset (gdb_gregset_t *gregsetp, int regno)
  {
    int regi;
!   long *regp = ALPHA_REGSET_BASE (gregsetp);
  
    for (regi = 0; regi < 31; regi++)
!     if (regno == -1 || regno == regi)
!       regcache_collect (regi, regp + regi);
  
!   if (regno == -1 || regno == ALPHA_PC_REGNUM)
!     regcache_collect (ALPHA_PC_REGNUM, regp + 31);
! 
!   if (sizeof (*gregsetp) >= 33 * 8
!       && (regno == -1 || regno == ALPHA_UNIQUE_REGNUM))
!     regcache_collect (ALPHA_UNIQUE_REGNUM, regp + 32);
  }
  
  /*
*************** fill_gregset (gdb_gregset_t *gregsetp, i
*** 234,260 ****
  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));
  }
  
  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)];
! 	}
!     }
  }
  #endif
  \f
--- 234,260 ----
  void
  supply_fpregset (gdb_fpregset_t *fpregsetp)
  {
!   int regi;
!   long *regp = ALPHA_REGSET_BASE (fpregsetp);
  
!   for (regi = 0; regi < 31; regi++)
!     supply_register (regi + ALPHA_FP0_REGNUM, regp + regi);
! 
!   supply_register (ALPHA_FPCR_REGNUM, regp + 31);
  }
  
  void
  fill_fpregset (gdb_fpregset_t *fpregsetp, int regno)
  {
    int regi;
!   long *regp = ALPHA_REGSET_BASE (fpregsetp);
  
!   for (regi = ALPHA_FP0_REGNUM; regi < ALPHA_FP0_REGNUM+31; regi++)
!     if (regno == -1 || regno == regi)
!       regcache_collect (regi, regp + regi - ALPHA_FP0_REGNUM);
! 
!   if (regno == -1 || regno == ALPHA_FPCR_REGNUM)
!     regcache_collect (ALPHA_FPCR_REGNUM, regp + 31);
  }
  #endif
  \f

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

[Richard Henderson]

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
 \f
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
 }
 
 \f
+/* 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);
+}
+
+\f
 /* 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
 

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

[Daniel Jacobowitz]

On Mon, Jun 02, 2003 at 01:29:49PM -0700, Richard Henderson wrote:
> 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.

I don't have anywhere to test it either, but it looks good.  This
touches some code which would be triggered on Tru64, right?  If so and
you're particularly nervous about it, ask Joel Brobecker to test it.
Otherwise I think it's OK to check in.

> 
> 
> 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.

-- 
Daniel Jacobowitz
MontaVista Software                         Debian GNU/Linux Developer