2003-04-12 Andrew Cagney <cagney@redhat.com>

[binutils-gdb.git] / gdb / regcache.h

diff --git a/gdb/regcache.h b/gdb/regcache.h
index 8dfd2e92633b6c0a9927fe60b0acde02af82ba15..3fb43c437a469c21207db8a8d4a0d9a1971f74bb 100644 (file)
--- a/gdb/regcache.h
+++ b/gdb/regcache.h
@@ -75,6 +75,10 @@ extern void regcache_cooked_read_signed (struct regcache *regcache,
                                         int regnum, LONGEST *val);
 extern void regcache_cooked_read_unsigned (struct regcache *regcache,
                                           int regnum, ULONGEST *val);
+extern void regcache_cooked_write_signed (struct regcache *regcache,
+                                         int regnum, LONGEST val);
+extern void regcache_cooked_write_unsigned (struct regcache *regcache,
+                                           int regnum, ULONGEST val);
 
 /* Partial transfer of a cooked register.  These perform read, modify,
    write style operations.  */
@@ -94,7 +98,7 @@ extern void regcache_collect (int regnum, void *buf);
 
 /* The register's ``offset''.
 
-   FIXME: cagney/2002-11-07: The get_saved_register() function, when
+   FIXME: cagney/2002-11-07: The frame_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
@@ -129,15 +133,45 @@ extern struct type *register_type (struct gdbarch *gdbarch, int regnum);
 extern int max_register_size (struct gdbarch *gdbarch);
 
 
-/* Save/restore a register cache.  The registers saved/restored is
-   determined by the save_reggroup and restore_reggroup (although you
-   can't restore a register that wasn't saved as well :-).  You can
-   only save to a read-only cache (default from regcache_xmalloc())
-   from a live cache and you can only restore from a read-only cache
-   to a live cache.  */
+/* Return the size of register REGNUM.  All registers should have only
+   one size.
 
-extern void regcache_save (struct regcache *dst, struct regcache *src);
-extern void regcache_restore (struct regcache *dst, struct regcache *src);
+   FIXME: cagney/2003-02-28:
+
+   Unfortunatly, thanks to some legacy architectures, this doesn't
+   hold.  A register's cooked (nee virtual) and raw size can differ
+   (see MIPS).  Such architectures should be using different register
+   numbers for the different sized views of identical registers.
+
+   Anyway, the up-shot is that, until that mess is fixed, core code
+   can end up being very confused - should the RAW or VIRTUAL size be
+   used?  As a rule of thumb, use REGISTER_VIRTUAL_SIZE in cooked
+   code, but with the comment:
+
+   OK: REGISTER_VIRTUAL_SIZE
+
+   or just
+
+   OK
+
+   appended to the end of the line.  */
+   
+extern int register_size (struct gdbarch *gdbarch, int regnum);
+
+
+/* Save/restore a register cache.  The set of registers saved /
+   restored into the DST regcache determined by the save_reggroup /
+   restore_reggroup respectively.  COOKED_READ returns zero iff the
+   register's value can't be returned.  */
+
+typedef int (regcache_cooked_read_ftype) (void *src, int regnum, void *buf);
+
+extern void regcache_save (struct regcache *dst,
+                          regcache_cooked_read_ftype *cooked_read,
+                          void *src);
+extern void regcache_restore (struct regcache *dst,
+                             regcache_cooked_read_ftype *cooked_read,
+                             void *src);
 
 /* Copy/duplicate the contents of a register cache.  By default, the
    operation is pass-through.  Writes to DST and reads from SRC will