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]

[RFA] cleanup alpha core read/write registers


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


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