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]

[patch] Remove dead regcache functions


Hello,

The functions noted in the changelog below aren't used at all, the attached removes them.

(I thought I was going to need regcache_cooked_read_using_offset_hack() but managed to rewrite the code so that it didn't.)

committed,
Andrew
2002-11-07  Andrew Cagney  <ac131313@redhat.com>

	* regcache.h (regcache_cooked_read_using_offset_hack)
	(regcache_cooked_write_using_offset_hack): Delete declarations.
	(register_changed): Delete declaration.
	* regcache.c (regcache_cooked_read_using_offset_hack)
	(regcache_cooked_write_using_offset_hack): Delete functions.
	(cooked_xfer_using_offset_hack): Delete function.
	(register_changed): Delete function.

Index: regcache.c
===================================================================
RCS file: /cvs/src/src/gdb/regcache.c,v
retrieving revision 1.62
diff -u -r1.62 regcache.c
--- regcache.c	7 Nov 2002 15:31:31 -0000	1.62
+++ regcache.c	7 Nov 2002 21:39:54 -0000
@@ -474,15 +474,6 @@
   current_regcache->raw_register_valid_p[regnum] = state;
 }
 
-/* REGISTER_CHANGED
-
-   invalidate a single register REGNUM in the cache */
-void
-register_changed (int regnum)
-{
-  set_register_cached (regnum, 0);
-}
-
 /* If REGNUM >= 0, return a pointer to register REGNUM's cache buffer area,
    else return a pointer to the start of the cache buffer.  */
 
@@ -1062,84 +1053,6 @@
   struct regcache_descr *descr = regcache_descr (gdbarch);
   gdb_assert (regnum >= 0 && regnum < descr->nr_cooked_registers);
   return descr->register_offset[regnum];
-}
-
-static void
-cooked_xfer_using_offset_hack (struct regcache *regcache,
-			       int buf_start, int buf_len, void *in_b,
-			       const void *out_b)
-{
-  struct regcache_descr *descr = regcache->descr;
-  struct gdbarch *gdbarch = descr->gdbarch;
-  bfd_byte *in_buf = in_b;
-  const bfd_byte *out_buf = out_b;
-  int buf_end = buf_start + buf_len;
-  int regnum;
-  char *reg_buf = alloca (descr->max_register_size);
-
-  /* NOTE: cagney/2002-08-17: This code assumes that the register
-     offsets are strictly increasing and do not overlap.  If this
-     isn't the case then the bug is in the target architecture and NOT
-     this code.  */
-
-  /* NOTE: cagney/2002-08-17: This code assumes that only the
-     registers covered by BUF_START:BUF_LEN should be transfered.  If,
-     for some reason, there is a gap between two registers, then that
-     gap isn't transfered.  (The gap shouldn't be there but that is
-     another story.)  */
-
-  /* Iterate through all registers looking for those that lie within
-     BUF_START:BUF_LEN.  */
-
-  for (regnum = 0; regnum < descr->nr_cooked_registers; regnum++)
-    {
-      /* The register's location.  */
-      int reg_start = descr->register_offset[regnum];
-      int reg_len = descr->sizeof_register[regnum];
-      int reg_end = reg_start + reg_len;
-
-      /* The START, END and LEN that falls within the current
-         register.  */
-      int xfer_start;
-      int xfer_end;
-      int xfer_len;
-
-      /* start = max (reg_start, buf_start) */
-      if (reg_start > buf_start)
-	xfer_start = reg_start;
-      else
-	xfer_start = buf_start;
-      
-      /* end = min (reg_end, buf_end) */
-      if (reg_end < buf_end)
-	xfer_end = reg_end;
-      else
-	xfer_end = buf_end;
-      
-      /* The number of bytes to transfer.  If there isn't anything to
-         transfer (the end is before the start) this will be -ve.  */
-      xfer_len = xfer_end - xfer_start;
-
-      if (xfer_len > 0)
-	regcache_xfer_part (regcache, regnum, xfer_start - reg_start,
-			    xfer_len, in_b, out_b, regcache_cooked_read,
-			    regcache_cooked_write);
-    }
-}
-
-void
-regcache_cooked_read_using_offset_hack (struct regcache *regcache,
-					int buf_start, int buf_len, void *b)
-{
-  cooked_xfer_using_offset_hack (regcache, buf_start, buf_len, b, NULL);
-}
-
-void
-regcache_cooked_write_using_offset_hack (struct regcache *regcache,
-					 int buf_start, int buf_len,
-					 const void *b)
-{
-  cooked_xfer_using_offset_hack (regcache, buf_start, buf_len, NULL, b);
 }
 
 /* Return the contents of register REGNUM as an unsigned integer.  */
Index: regcache.h
===================================================================
RCS file: /cvs/src/src/gdb/regcache.h,v
retrieving revision 1.23
diff -u -r1.23 regcache.h
--- regcache.h	7 Nov 2002 15:31:31 -0000	1.23
+++ regcache.h	7 Nov 2002 21:39:54 -0000
@@ -94,29 +94,14 @@
 
 /* The register's ``offset''.
 
-   NOTE: cagney/2002-08-17: The ``struct value'' and expression
-   evaluator treat the register cache as a large liner buffer.
-   Instead of reading/writing a register using its register number,
-   the code read/writes registers by specifying their offset into the
-   buffer and a number of bytes.  The code also assumes that these
-   byte read/writes can cross register boundaries, adjacent registers
-   treated as a contiguous set of bytes.
-
-   The below map that model onto the real register cache.  New code
-   should go out of their way to avoid using these interfaces.
-
-   FIXME: cagney/2002-08-17: The ``struct value'' and expression
-   evaluator should be fixed.  Instead of using the { offset, length }
-   pair to describe a value within one or more registers, the code
-   should use a chain of { regnum, offset, len } tripples.  */
+   FIXME: cagney/2002-11-07: The get_saved_register() function, when
+   specifying the real location of a register, does so using that
+   registers offset in the register cache.  That offset is then used
+   by valops.c to determine the location of the register.  The code
+   should instead use the register's number and a location expression
+   to describe a value spread across multiple registers or memory.  */
 
 extern int register_offset_hack (struct gdbarch *gdbarch, int regnum);
-extern void regcache_cooked_read_using_offset_hack (struct regcache *regcache,
-						    int offset, int len,
-						    void *buf);
-extern void regcache_cooked_write_using_offset_hack (struct regcache *regcache,
-						     int offset, int len,
-						     const void *buf);
 
 
 /* The type of a register.  This function is slightly more efficient
@@ -200,8 +185,6 @@
 extern int register_cached (int regnum);
 
 extern void set_register_cached (int regnum, int state);
-
-extern void register_changed (int regnum);
 
 extern void registers_changed (void);
 

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