[patch/rfc] Overhaul regcache for {save,restore}_reggroup

Andrew Cagney
2002-11-07T20:38:52Z

[-- Attachment #1: Type: text/plain, Size: 845 bytes --]

Hello,

This patch brings in the last big change sitting on the reggroups branch.

It adds regcache save/restore functions to to the regcache.
These functions save/restore a subset of registers determined by the
save/restore reggroups (by default REGNUMs in the range [0 .. NUM_REGS)
are in both the save_reggroup and restore_reggroup, and hence are
saved/restored).

As part of this, a saved read-only regcache is expanded so that it can
hold the saved value of any register in the full [0 ..
NUM_REGS+NUM_PSEUDO_REGS) range. This is so that architectures with
memory-mapped registers (which fall into the range [NUM_REGS ..
NUM_REGS+NUM_PSEUDO_REGS) have somewhere to save them.

I'll look to commit it in a few days,

(Oh, and it deletes the last remaining core reference to
read_register_bytes() or write_register_bytes()).

Andrew

[-- Attachment #2: diffs --]
[-- Type: text/plain, Size: 20543 bytes --]

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

* regcache.h (regcache_save, regcache_restore): Declare.

* regcache.c (struct regcache_descr): Add fields
sizeof_cooked_registers and sizeof_cooked_register_valid_p.
(init_legacy_regcache_descr): Compute sizeof_cooked_registers.
Update comments.
(init_regcache_descr): Compute sizeof_cooked_register_valid_p and
sizeof_cooked_registers. Update comments.
(struct regcache): Replace passthrough_p with readonly_p. Replace
raw_registers and raw_register_valid_p with registers and
register_valid_p.
(regcache_cooked_read): Check for cached cooked values.
(regcache_xmalloc): Update.
(regcache_save): New function.
(regcache_restore): New function.
(regcache_cpy): Rewrite using regcache_save, regcache_restore and
regcache_cpy_no_passthrough.
(regcache_raw_read): Update.
(regcache_raw_write): Update.
(build_regcache): Update.
(regcache_xfree): Update.
(regcache_cpy_no_passthrough): Update.
(regcache_valid_p): Update.
(deprecated_grub_regcache_for_registers): Update.
(deprecated_grub_regcache_for_register_valid): Update.
(register_buffer): Move declaration to start. Update.
(regcache_raw_read): Update.
(regcache_raw_write): Update.

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 20:27:39 -0000
@@ -66,6 +66,8 @@
both raw registers and memory by the architecture methods
gdbarch_register_read and gdbarch_register_write. */
int nr_cooked_registers;
+ long sizeof_cooked_registers;
+ long sizeof_cooked_register_valid_p;

/* Offset and size (in 8 bit bytes), of reach register in the
register cache. All registers (including those in the range
@@ -92,21 +94,23 @@
``gdbarch'' as a parameter. */
gdb_assert (gdbarch != NULL);

- /* FIXME: cagney/2002-05-11: Shouldn't be including pseudo-registers
- in the register buffer. Unfortunatly some architectures do. */
- descr->nr_raw_registers = descr->nr_cooked_registers;
- descr->sizeof_raw_register_valid_p = descr->nr_cooked_registers;
-
- /* FIXME: cagney/2002-05-11: Instead of using REGISTER_BYTE() this
- code should compute the offets et.al. at runtime. This currently
- isn't possible because some targets overlap register locations -
- see the mess in read_register_bytes() and write_register_bytes()
- registers. */
+ /* Compute the offset of each register. Legacy architectures define
+ REGISTER_BYTE() so use that. */
+ /* FIXME: cagney/2002-11-07: Instead of using REGISTER_BYTE() this
+ code should, as is done in init_regcache_descr(), compute the
+ offets at runtime. This currently isn't possible as some ISAs
+ define overlapping register regions - see the mess in
+ read_register_bytes() and write_register_bytes() registers. */
descr->sizeof_register = XCALLOC (descr->nr_cooked_registers, long);
descr->register_offset = XCALLOC (descr->nr_cooked_registers, long);
descr->max_register_size = 0;
for (i = 0; i < descr->nr_cooked_registers; i++)
{
+ /* FIXME: cagney/2001-12-04: This code shouldn't need to use
+ REGISTER_BYTE(). Unfortunatly, legacy code likes to lay the
+ buffer out so that certain registers just happen to overlap.
+ Ulgh! New targets use gdbarch's register read/write and
+ entirely avoid this uglyness. */
descr->register_offset[i] = REGISTER_BYTE (i);
descr->sizeof_register[i] = REGISTER_RAW_SIZE (i);
if (descr->max_register_size < REGISTER_RAW_SIZE (i))
@@ -115,25 +119,29 @@
descr->max_register_size = REGISTER_VIRTUAL_SIZE (i);
}

- /* Come up with the real size of the registers buffer. */
- descr->sizeof_raw_registers = REGISTER_BYTES; /* OK use. */
+ /* Compute the real size of the register buffer. Start out by
+ trusting REGISTER_BYTES, but then adjust it upwards should that
+ be found to not be sufficient. */
+ /* FIXME: cagney/2002-11-05: Instead of using REGISTER_BYTES, this
+ code should, as is done in init_regcache_descr(), compute the
+ total number of register bytes using the accumulated offsets. */
+ descr->sizeof_cooked_registers = REGISTER_BYTES; /* OK use. */
for (i = 0; i < descr->nr_cooked_registers; i++)
{
- long regend;
/* Keep extending the buffer so that there is always enough
space for all registers. The comparison is necessary since
legacy code is free to put registers in random places in the
buffer separated by holes. Once REGISTER_BYTE() is killed
this can be greatly simplified. */
- /* FIXME: cagney/2001-12-04: This code shouldn't need to use
- REGISTER_BYTE(). Unfortunatly, legacy code likes to lay the
- buffer out so that certain registers just happen to overlap.
- Ulgh! New targets use gdbarch's register read/write and
- entirely avoid this uglyness. */
- regend = descr->register_offset[i] + descr->sizeof_register[i];
- if (descr->sizeof_raw_registers < regend)
- descr->sizeof_raw_registers = regend;
+ long regend = descr->register_offset[i] + descr->sizeof_register[i];
+ if (descr->sizeof_cooked_registers < regend)
+ descr->sizeof_cooked_registers = regend;
}
+ /* FIXME: cagney/2002-05-11: Shouldn't be including pseudo-registers
+ in a raw register buffer. Unfortunatly some architectures do. */
+ descr->nr_raw_registers = descr->nr_cooked_registers;
+ descr->sizeof_raw_registers = descr->sizeof_cooked_registers;
+ descr->sizeof_raw_register_valid_p = descr->nr_cooked_registers;
}

static void *
@@ -170,20 +178,7 @@
return descr;
}

- /* Construct a strictly RAW register cache. Don't allow pseudo's
- into the register cache. */
- descr->nr_raw_registers = NUM_REGS;
-
- /* FIXME: cagney/2002-08-13: Overallocate the register_valid_p
- array. This pretects GDB from erant code that accesses elements
- of the global register_valid_p[] array in the range [NUM_REGS
- .. NUM_REGS + NUM_PSEUDO_REGS). */
- descr->sizeof_raw_register_valid_p = NUM_REGS + NUM_PSEUDO_REGS;
-
- /* Lay out the register cache. The pseud-registers are included in
- the layout even though their value isn't stored in the register
- cache. Some code, via read_register_bytes() access a register
- using an offset/length rather than a register number.
+ /* Lay out the register cache.

NOTE: cagney/2002-05-22: Only register_type() is used when
constructing the register cache. It is assumed that the
@@ -204,15 +199,27 @@
descr->max_register_size = descr->sizeof_register[i];
}
/* Set the real size of the register cache buffer. */
- /* FIXME: cagney/2002-05-22: Should only need to allocate space
- for the raw registers. Unfortunatly some code still accesses
- the register array directly using the global registers[].
- Until that code has been purged, play safe and over allocating
- the register buffer. Ulgh! */
- descr->sizeof_raw_registers = offset;
- /* = descr->register_offset[descr->nr_raw_registers]; */
+ descr->sizeof_cooked_registers = offset;
+ descr->sizeof_cooked_register_valid_p = NUM_REGS + NUM_PSEUDO_REGS;
}

+ /* Construct a strictly RAW register cache. Don't allow pseudo's
+ into the register cache. */
+ descr->nr_raw_registers = NUM_REGS;
+
+ /* FIXME: cagney/2002-08-13: Overallocate the register_valid_p
+ array. This pretects GDB from erant code that accesses elements
+ of the global register_valid_p[] array in the range [NUM_REGS
+ .. NUM_REGS + NUM_PSEUDO_REGS). */
+ descr->sizeof_raw_register_valid_p = descr->sizeof_cooked_register_valid_p;
+
+ /* FIXME: cagney/2002-05-22: Should only need to allocate space for
+ the raw registers. Unfortunatly some code still accesses the
+ register array directly using the global registers[]. Until that
+ code has been purged, play safe and over allocating the register
+ buffer. Ulgh! */
+ descr->sizeof_raw_registers = descr->sizeof_cooked_registers;
+
#if 0
/* Sanity check. Confirm that the assumptions about gdbarch are
true. The REGCACHE_DESCR_HANDLE is set before doing the checks
@@ -276,12 +283,20 @@

struct regcache
{
+ /* The regcache's parent. */
struct regcache_descr *descr;
- char *raw_registers;
- char *raw_register_valid_p;
- /* If a value isn't in the cache should the corresponding target be
- queried for a value. */
- int passthrough_p;
+ /* Is this a read-only cache? A read-only cache is used for saving
+ the target's register, for instance across an inferior function
+ call or just before forcing a function return. A read-only cache
+ can only be updated via the methods regcache_dup() and
+ regcache_cpy(). The actual contents are determined by the
+ reggroup_save and reggroup_restore methods. */
+ int readonly_p;
+ /* The register buffer. NR_REGISTERS is the number of registers
+ actually in the buffer. A read-only register cache is allowed to
+ cache pseudo registers. A read/write register cache is not. */
+ char *registers;
+ char *register_valid_p;
};

struct regcache *
@@ -292,12 +307,13 @@
gdb_assert (gdbarch != NULL);
descr = regcache_descr (gdbarch);
regcache = XMALLOC (struct regcache);
+ regcache->readonly_p = 1;
regcache->descr = descr;
- regcache->raw_registers
- = XCALLOC (descr->sizeof_raw_registers, char);
- regcache->raw_register_valid_p
- = XCALLOC (descr->sizeof_raw_register_valid_p, char);
- regcache->passthrough_p = 0;
+ /* By default create a read-only cache. A read-only cache includes
+ space for the full cooked range of registers. */
+ regcache->registers = XCALLOC (descr->sizeof_cooked_registers, char);
+ regcache->register_valid_p = XCALLOC (descr->sizeof_cooked_register_valid_p,
+ char);
return regcache;
}

@@ -306,8 +322,8 @@
{
if (regcache == NULL)
return;
- xfree (regcache->raw_registers);
- xfree (regcache->raw_register_valid_p);
+ xfree (regcache->registers);
+ xfree (regcache->register_valid_p);
xfree (regcache);
}

@@ -323,6 +339,69 @@
return make_cleanup (do_regcache_xfree, regcache);
}

+/* If REGNUM >= 0, return a pointer to register REGNUM's cache buffer area,
+ else return a pointer to the start of the cache buffer. */
+
+static char *
+register_buffer (struct regcache *regcache, int regnum)
+{
+ return regcache->registers + regcache->descr->register_offset[regnum];
+}
+
+void
+regcache_save (struct regcache *dst, struct regcache *src)
+{
+ struct gdbarch *gdbarch = dst->descr->gdbarch;
+ int regnum;
+ /* The SRC and DST register caches had better belong to the same
+ architecture. */
+ gdb_assert (src->descr->gdbarch == dst->descr->gdbarch);
+ /* The DST should be `read-only', if it wasn't then the save would
+ end up trying to write the register values out through to the
+ target. */
+ gdb_assert (!src->readonly_p);
+ gdb_assert (dst->readonly_p);
+ /* Clear the dest. */
+ memset (dst->registers, 0, dst->descr->sizeof_cooked_registers);
+ memset (dst->register_valid_p, 0, dst->descr->sizeof_cooked_register_valid_p);
+ /* Copy over any registers (identified by their membership in the
+ save_reggroup) and mark them as valid. The full [0
+ .. NUM_REGS+NUM_PSEUDO_REGS) range is checked since some
+ architectures need to save/restore `cooked' registers that live
+ in memory. */
+ for (regnum = 0; regnum < dst->descr->nr_cooked_registers; regnum++)
+ {
+ if (gdbarch_register_reggroup_p (gdbarch, regnum, save_reggroup))
+ {
+ regcache_cooked_read (src, regnum, register_buffer (dst, regnum));
+ dst->register_valid_p[regnum] = 1;
+ }
+ }
+}
+
+void
+regcache_restore (struct regcache *dst, struct regcache *src)
+{
+ struct gdbarch *gdbarch = dst->descr->gdbarch;
+ int regnum;
+ gdb_assert (src->descr->gdbarch == dst->descr->gdbarch);
+ gdb_assert (!dst->readonly_p);
+ gdb_assert (src->readonly_p);
+ /* Copy over any registers, being careful to only restore those that
+ were both saved and need to be restored. The full [0
+ .. NUM_REGS+NUM_PSEUDO_REGS) range is checked since some
+ architectures need to save/restore `cooked' registers that live
+ in memory. */
+ for (regnum = 0; regnum < src->descr->nr_cooked_registers; regnum++)
+ {
+ if (gdbarch_register_reggroup_p (gdbarch, regnum, restore_reggroup)
+ && src->register_valid_p[regnum])
+ {
+ regcache_cooked_write (dst, regnum, register_buffer (src, regnum));
+ }
+ }
+}
+
void
regcache_cpy (struct regcache *dst, struct regcache *src)
{
@@ -331,33 +410,13 @@
gdb_assert (src != NULL && dst != NULL);
gdb_assert (src->descr->gdbarch == dst->descr->gdbarch);
gdb_assert (src != dst);
- /* FIXME: cagney/2002-05-17: To say this bit is bad is being polite.
- It keeps the existing code working where things rely on going
- through to the register cache. */
- if (src == current_regcache && src->descr->legacy_p)
- {
- /* ULGH!!!! Old way. Use REGISTER bytes and let code below
- untangle fetch. */
- read_register_bytes (0, dst->raw_registers, REGISTER_BYTES);
- return;
- }
- /* FIXME: cagney/2002-05-17: To say this bit is bad is being polite.
- It keeps the existing code working where things rely on going
- through to the register cache. */
- if (dst == current_regcache && dst->descr->legacy_p)
- {
- /* ULGH!!!! Old way. Use REGISTER bytes and let code below
- untangle fetch. */
- write_register_bytes (0, src->raw_registers, REGISTER_BYTES);
- return;
- }
- buf = alloca (src->descr->max_register_size);
- for (i = 0; i < src->descr->nr_raw_registers; i++)
- {
- /* Should we worry about the valid bit here? */
- regcache_raw_read (src, i, buf);
- regcache_raw_write (dst, i, buf);
- }
+ gdb_assert (src->readonly_p || dst->readonly_p);
+ if (!src->readonly_p)
+ regcache_save (dst, src);
+ else if (!dst->readonly_p)
+ regcache_restore (dst, src);
+ else
+ regcache_cpy_no_passthrough (dst, src);
}

void
@@ -370,9 +429,9 @@
move of data into the current_regcache(). Doing this would be
silly - it would mean that valid_p would be completly invalid. */
gdb_assert (dst != current_regcache);
- memcpy (dst->raw_registers, src->raw_registers,
+ memcpy (dst->registers, src->registers,
dst->descr->sizeof_raw_registers);
- memcpy (dst->raw_register_valid_p, src->raw_register_valid_p,
+ memcpy (dst->register_valid_p, src->register_valid_p,
dst->descr->sizeof_raw_register_valid_p);
}

@@ -401,19 +460,19 @@
{
gdb_assert (regcache != NULL);
gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
- return regcache->raw_register_valid_p[regnum];
+ return regcache->register_valid_p[regnum];
}

char *
deprecated_grub_regcache_for_registers (struct regcache *regcache)
{
- return regcache->raw_registers;
+ return regcache->registers;
}

char *
deprecated_grub_regcache_for_register_valid (struct regcache *regcache)
{
- return regcache->raw_register_valid_p;
+ return regcache->register_valid_p;
}

/* Global structure containing the current regcache. */
@@ -471,7 +530,7 @@
{
gdb_assert (regnum >= 0);
gdb_assert (regnum < current_regcache->descr->nr_raw_registers);
- current_regcache->raw_register_valid_p[regnum] = state;
+ current_regcache->register_valid_p[regnum] = state;
}

/* REGISTER_CHANGED
@@ -483,15 +542,6 @@
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. */
-
-static char *
-register_buffer (struct regcache *regcache, int regnum)
-{
- return regcache->raw_registers + regcache->descr->register_offset[regnum];
-}
-
/* Return whether register REGNUM is a real register. */

static int
@@ -670,7 +720,7 @@
gdb_assert (regcache != NULL && buf != NULL);
gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
if (regcache->descr->legacy_p
- && regcache->passthrough_p)
+ && !regcache->readonly_p)
{
gdb_assert (regcache == current_regcache);
/* For moment, just use underlying legacy code. Ulgh!!! This
@@ -683,7 +733,7 @@
to the current thread. This switching shouldn't be necessary
only there is still only one target side register cache. Sigh!
On the bright side, at least there is a regcache object. */
- if (regcache->passthrough_p)
+ if (!regcache->readonly_p)
{
gdb_assert (regcache == current_regcache);
if (! ptid_equal (registers_ptid, inferior_ptid))
@@ -695,8 +745,7 @@
target_fetch_registers (regnum);
}
/* Copy the value directly into the register cache. */
- memcpy (buf, (regcache->raw_registers
- + regcache->descr->register_offset[regnum]),
+ memcpy (buf, register_buffer (regcache, regnum),
regcache->descr->sizeof_register[regnum]);
}

@@ -768,6 +817,12 @@
gdb_assert (regnum < regcache->descr->nr_cooked_registers);
if (regnum < regcache->descr->nr_raw_registers)
regcache_raw_read (regcache, regnum, buf);
+ else if (regcache->readonly_p
+ && regnum < regcache->descr->nr_cooked_registers
+ && regcache->register_valid_p[regnum])
+ /* Read-only register cache, perhaphs the cooked value was cached? */
+ memcpy (buf, register_buffer (regcache, regnum),
+ regcache->descr->sizeof_register[regnum]);
else
gdbarch_pseudo_register_read (regcache->descr->gdbarch, regcache,
regnum, buf);
@@ -844,9 +899,9 @@
{
gdb_assert (regcache != NULL && buf != NULL);
gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
+ gdb_assert (!regcache->readonly_p);

- if (regcache->passthrough_p
- && regcache->descr->legacy_p)
+ if (regcache->descr->legacy_p)
{
/* For moment, just use underlying legacy code. Ulgh!!! This
silently and very indirectly updates the regcache's buffers
@@ -861,17 +916,6 @@
if (CANNOT_STORE_REGISTER (regnum))
return;

- /* Handle the simple case first -> not write through so just store
- value in cache. */
- if (!regcache->passthrough_p)
- {
- memcpy ((regcache->raw_registers
- + regcache->descr->register_offset[regnum]), buf,
- regcache->descr->sizeof_register[regnum]);
- regcache->raw_register_valid_p[regnum] = 1;
- return;
- }
-
/* Make certain that the correct cache is selected. */
gdb_assert (regcache == current_regcache);
if (! ptid_equal (registers_ptid, inferior_ptid))
@@ -890,7 +934,7 @@
target_prepare_to_store ();
memcpy (register_buffer (regcache, regnum), buf,
regcache->descr->sizeof_register[regnum]);
- regcache->raw_register_valid_p[regnum] = 1;
+ regcache->register_valid_p[regnum] = 1;
target_store_registers (regnum);
}

@@ -1453,7 +1497,7 @@
build_regcache (void)
{
current_regcache = regcache_xmalloc (current_gdbarch);
- current_regcache->passthrough_p = 1;
+ current_regcache->readonly_p = 0;
registers = deprecated_grub_regcache_for_registers (current_regcache);
deprecated_register_valid = deprecated_grub_regcache_for_register_valid (current_regcache);
}
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 20:27:39 -0000
@@ -149,6 +149,16 @@

extern char *registers;

+/* 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. */
+
+extern void regcache_save (struct regcache *dst, struct regcache *src);
+extern void regcache_restore (struct regcache *dst, struct regcache *src);
+
/* Copy/duplicate the contents of a register cache. By default, the
operation is pass-through. Writes to DST and reads from SRC will
go through to the target.