2002-08-18 Andrew Cagney <ac131313@redhat.com>

* regcache.c (regcache_xfer_part): New function.
(regcache_raw_read_part): New function.
(regcache_raw_write_part): New function.
(regcache_cooked_read_part): New function.
(regcache_cooked_write_part): New function.
* regcache.h (regcache_raw_read_part): Declare.
(regcache_raw_write_part): Declare.
(regcache_cooked_read_part): Declare.
(regcache_cooked_write_part): Declare.

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index ba4f285010061700b35beab4a3593a0e53eca125..585c3d52331df3907c98c450fcc8bfe878e88098 100644 (file)
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,15 @@
+2002-08-18  Andrew Cagney  <ac131313@redhat.com>
+
+       * regcache.c (regcache_xfer_part): New function.
+       (regcache_raw_read_part): New function.
+       (regcache_raw_write_part): New function.
+       (regcache_cooked_read_part): New function.
+       (regcache_cooked_write_part): New function.
+       * regcache.h (regcache_raw_read_part): Declare.
+       (regcache_raw_write_part): Declare.
+       (regcache_cooked_read_part): Declare.
+       (regcache_cooked_write_part): Declare.
+
 2002-08-18  Daniel Jacobowitz  <drow@mvista.com>
 
        * remote.c (remote_open_1): Add async_p.

diff --git a/gdb/regcache.c b/gdb/regcache.c
index e46f082c843fb273a950cc74b17b8e10228fdf51..e483de08cfd72ad5fff83192e0a68523a23face7 100644 (file)
--- a/gdb/regcache.c
+++ b/gdb/regcache.c
@@ -916,6 +916,86 @@ write_register_bytes (int myregstart, char *myaddr, int inlen)
     }
 }
 
+/* Perform a partial register transfer using a read, modify, write
+   operation.  */
+
+typedef void (regcache_read_ftype) (struct regcache *regcache, int regnum,
+                                   void *buf);
+typedef void (regcache_write_ftype) (struct regcache *regcache, int regnum,
+                                    const void *buf);
+
+void
+regcache_xfer_part (struct regcache *regcache, int regnum,
+                   int offset, int len, void *in, const void *out,
+                   regcache_read_ftype *read, regcache_write_ftype *write)
+{
+  struct regcache_descr *descr = regcache->descr;
+  bfd_byte *reg = alloca (descr->max_register_size);
+  gdb_assert (offset >= 0 && offset <= descr->sizeof_register[regnum]);
+  gdb_assert (len >= 0 && offset + len <= descr->sizeof_register[regnum]);
+  /* Something to do?  */
+  if (offset + len == 0)
+    return;
+  /* Read (when needed) ... */
+  if (in != NULL
+      || offset > 0
+      || offset + len < descr->sizeof_register[regnum])
+    {
+      gdb_assert (read != NULL);
+      read (regcache, regnum, reg);
+    }
+  /* ... modify ... */
+  if (in != NULL)
+    memcpy (in, reg + offset, len);
+  if (out != NULL)
+    memcpy (reg + offset, out, len);
+  /* ... write (when needed).  */
+  if (out != NULL)
+    {
+      gdb_assert (write != NULL);
+      write (regcache, regnum, reg);
+    }
+}
+
+void
+regcache_raw_read_part (struct regcache *regcache, int regnum,
+                       int offset, int len, void *buf)
+{
+  struct regcache_descr *descr = regcache->descr;
+  gdb_assert (regnum >= 0 && regnum < descr->nr_raw_registers);
+  regcache_xfer_part (regcache, regnum, offset, len, buf, NULL,
+                     regcache_raw_read, regcache_raw_write);
+}
+
+void
+regcache_raw_write_part (struct regcache *regcache, int regnum,
+                        int offset, int len, const void *buf)
+{
+  struct regcache_descr *descr = regcache->descr;
+  gdb_assert (regnum >= 0 && regnum < descr->nr_raw_registers);
+  regcache_xfer_part (regcache, regnum, offset, len, NULL, buf,
+                     regcache_raw_read, regcache_raw_write);
+}
+
+void
+regcache_cooked_read_part (struct regcache *regcache, int regnum,
+                          int offset, int len, void *buf)
+{
+  struct regcache_descr *descr = regcache->descr;
+  gdb_assert (regnum >= 0 && regnum < descr->nr_cooked_registers);
+  regcache_xfer_part (regcache, regnum, offset, len, buf, NULL,
+                     regcache_cooked_read, regcache_cooked_write);
+}
+
+void
+regcache_cooked_write_part (struct regcache *regcache, int regnum,
+                           int offset, int len, const void *buf)
+{
+  struct regcache_descr *descr = regcache->descr;
+  gdb_assert (regnum >= 0 && regnum < descr->nr_cooked_registers);
+  regcache_xfer_part (regcache, regnum, offset, len, NULL, buf,
+                     regcache_cooked_read, regcache_cooked_write);
+}
 
 /* Return the contents of register REGNUM as an unsigned integer.  */
 

diff --git a/gdb/regcache.h b/gdb/regcache.h
index 4f6a07976634b29151d46369aedbef5cbe128bfb..da91fd69325e3985446ccc6e73d56cfdf280a951 100644 (file)
--- a/gdb/regcache.h
+++ b/gdb/regcache.h
@@ -42,6 +42,15 @@ extern void regcache_raw_read_signed (struct regcache *regcache,
                                      int regnum, LONGEST *val);
 extern void regcache_raw_read_unsigned (struct regcache *regcache,
                                        int regnum, ULONGEST *val);
+
+/* Partial transfer of a raw registers.  These perform read, modify,
+   write style operations.  */
+
+void regcache_raw_read_part (struct regcache *regcache, int regnum,
+                            int offset, int len, void *buf);
+void regcache_raw_write_part (struct regcache *regcache, int regnum,
+                             int offset, int len, const void *buf);
+
 int regcache_valid_p (struct regcache *regcache, int regnum);
 
 /* Transfer a cooked register [0..NUM_REGS+NUM_PSEUDO_REGS).  */
@@ -63,6 +72,14 @@ extern void regcache_cooked_read_signed (struct regcache *regcache,
 extern void regcache_cooked_read_unsigned (struct regcache *regcache,
                                           int regnum, ULONGEST *val);
 
+/* Partial transfer of a cooked register.  These perform read, modify,
+   write style operations.  */
+
+void regcache_cooked_read_part (struct regcache *regcache, int regnum,
+                               int offset, int len, void *buf);
+void regcache_cooked_write_part (struct regcache *regcache, int regnum,
+                                int offset, int len, const void *buf);
+
 /* Transfer a raw register [0..NUM_REGS) between the regcache and the
    target.  These functions are called by the target in response to a
    target_fetch_registers() or target_store_registers().  */