Re: [rfa/c] Signed read_register()

[Andrew Cagney <ac131313 at cygnus dot com>]

And the patch .....

Andrew Cagney wrote:
> 
> Hello,
> 
> The attatched patch adds a signed version of the read_register{,_pid}()
> functions (read_signed_register{,_pid}()).  MIPS uses this when reading
> registers such as the PC/SP (well it will when I check in a few other
> changes :-).
> 
> I think the existing read_register*() functions should be explicitly
> re-named to read_unsigned_register() but that is another story :-)
> 
> Ok?  MichaelS, regcache.c is yours.
> 
>         Andrew
Tue Jul 11 12:52:31 2000  Andrew Cagney  <cagney@b1.cygnus.com>

	* value.h (read_register, read_signed_register): Change return
 	type to ULONGEST.
	(read_signed_register, read_signed_register_pid): Declare.

	* regcache.c (read_register, read_register_pid): Update.
	(read_signed_register_pid, read_signed_register): New functions.
	
Index: regcache.c
===================================================================
RCS file: /cvs/src/src/gdb/regcache.c,v
retrieving revision 1.2
diff -p -r1.2 regcache.c
*** regcache.c	2000/07/10 06:16:51	1.2
--- regcache.c	2000/07/11 03:17:11
*************** write_register_bytes (int myregstart, ch
*** 500,506 ****
     integer.  This probably should be returning LONGEST rather than
     CORE_ADDR.  */
  
! CORE_ADDR
  read_register (int regno)
  {
    if (registers_pid != inferior_pid)
--- 500,506 ----
     integer.  This probably should be returning LONGEST rather than
     CORE_ADDR.  */
  
! ULONGEST
  read_register (int regno)
  {
    if (registers_pid != inferior_pid)
*************** read_register (int regno)
*** 512,523 ****
    if (!register_valid[regno])
      target_fetch_registers (regno);
  
!   return ((CORE_ADDR)
! 	  extract_unsigned_integer (&registers[REGISTER_BYTE (regno)],
  				    REGISTER_RAW_SIZE (regno)));
  }
  
! CORE_ADDR
  read_register_pid (int regno, int pid)
  {
    int save_pid;
--- 512,538 ----
    if (!register_valid[regno])
      target_fetch_registers (regno);
  
!   return (extract_unsigned_integer (&registers[REGISTER_BYTE (regno)],
  				    REGISTER_RAW_SIZE (regno)));
  }
  
! LONGEST
! read_signed_register (int regno)
! {
!   if (registers_pid != inferior_pid)
!     {
!       registers_changed ();
!       registers_pid = inferior_pid;
!     }
! 
!   if (!register_valid[regno])
!     target_fetch_registers (regno);
! 
!   return (extract_signed_integer (&registers[REGISTER_BYTE (regno)],
! 				  REGISTER_RAW_SIZE (regno)));
! }
! 
! ULONGEST
  read_register_pid (int regno, int pid)
  {
    int save_pid;
*************** read_register_pid (int regno, int pid)
*** 531,536 ****
--- 546,571 ----
    inferior_pid = pid;
  
    retval = read_register (regno);
+ 
+   inferior_pid = save_pid;
+ 
+   return retval;
+ }
+ 
+ LONGEST
+ read_signed_register_pid (int regno, int pid)
+ {
+   int save_pid;
+   LONGEST retval;
+ 
+   if (pid == inferior_pid)
+     return read_signed_register (regno);
+ 
+   save_pid = inferior_pid;
+ 
+   inferior_pid = pid;
+ 
+   retval = read_signed_register (regno);
  
    inferior_pid = save_pid;
  
Index: value.h
===================================================================
RCS file: /cvs/src/src/gdb/value.h,v
retrieving revision 1.6
diff -p -r1.6 value.h
*** value.h	2000/07/10 06:16:51	1.6
--- value.h	2000/07/11 03:17:13
*************** extern void read_register_gen (int regno
*** 461,469 ****
  
  extern void write_register_gen (int regno, char *myaddr);
  
! extern CORE_ADDR read_register (int regno);
  
! extern CORE_ADDR read_register_pid (int regno, int pid);
  
  extern void write_register (int regno, LONGEST val);
  
--- 461,475 ----
  
  extern void write_register_gen (int regno, char *myaddr);
  
! /* Rename to read_unsigned_register()? */
! extern ULONGEST read_register (int regno);
  
! extern LONGEST read_signed_register (int regno);
! 
! /* Rename to read_unsigned_register_pid()? */
! extern ULONGEST read_register_pid (int regno, int pid);
! 
! extern LONGEST read_signed_register_pid (int regno, int pid);
  
  extern void write_register (int regno, LONGEST val);