This is the mail archive of the
gdb-patches@sources.redhat.com
mailing list for the GDB project.
Re: [patch/cagney_regbuf-20020515-branch] Really separate out old andnew
- From: Michael Snyder <msnyder at redhat dot com>
- To: Andrew Cagney <ac131313 at cygnus dot com>
- Cc: gdb-patches at sources dot redhat dot com
- Date: Fri, 24 May 2002 16:47:35 -0700
- Subject: Re: [patch/cagney_regbuf-20020515-branch] Really separate out old andnew
- Organization: Red Hat, Inc.
- References: <3CED2E95.3080102@cygnus.com>
Andrew Cagney wrote:
>
> Hello,
>
> The attached patch, to the cagney_regbuf-20020515-branch, more strongly
> differentiates between the old and new style register caches by using
> regcache->descr->legacy_p.
>
> For the old case, all registers can be in the cache. For the new case,
> only 0..NUM_REGS are allowed in the register cache.
>
> In addition, the regcache code only calls legacy_*() functions when
> ->legacy_p. The new code goes straight through.
>
> I think I'm about done with that branch. I'll next post a full patch
> and figure out how to get something equivalent into the trunk. More
> importantly, how to do it without breaking SH5.
>
> enjoy,
> Andrew
OK -- I was trying to ignore this, but it breaks one of my targets.
What do I have to do, to make my old target use the old legacy method?
>
> ------------------------------------------------------------------------
> 2002-05-23 Andrew Cagney <ac131313@redhat.com>
>
> * regcache.c (register_buffer): Add regcache parameter. Update
> callers.
> (struct regcache_descr): Add nr_raw_registers and
> max_register_size. Add legacy_p. Change registers to
> raw_registers, register_valid_p to raw_register_valid_p. Update
> all callers.
> (legacy_regcache_descr): New function handle legacy case.
> (regcache_descr): Use legacy function. For non-legacy case,
> restrict the register cache to just NUM_REGS.
> (regcache_read, regcache_write): When non-legacy case, implement
> regcache read and write directly.
> (regcache_write): Use regcache_valid_p.
>
> * regcache.h (deprecated_grub_regcache_for_registers): Rename
> grub_around_regcache_for_registers
> (deprecated_grub_regcache_for_register_valid): Rename
> grub_around_regcache_for_register_valid.
> * regcache.c (deprecated_grub_around_regcache_for_registers)
> (deprecated_grub_regcache_for_register_valid): Rename.
> * rs6000-tdep.c (rs6000_extract_return_value): Update.
> * regcache.c (build_regcache): Update.
>
> Index: regcache.c
> ===================================================================
> RCS file: /cvs/src/src/gdb/regcache.c,v
> retrieving revision 1.36.2.4
> diff -u -r1.36.2.4 regcache.c
> --- regcache.c 17 May 2002 16:17:30 -0000 1.36.2.4
> +++ regcache.c 23 May 2002 17:47:27 -0000
> @@ -43,26 +43,39 @@
> {
> /* The architecture this descriptor belongs to. */
> struct gdbarch *gdbarch;
> - /* Total number of registers in the buffer. */
> - int nr_registers;
> - /* Size of the register buffer, over-allocate making room for both
> - real and pseudo-registers. */
> - /* FIXME: cagney/2002-05-11: This over-allocation shouldn't be
> - necessary. Unfortunatly, some targets store real values in
> - pseudo-registers and we want to be sure those targets don't crash
> - GDB. Once that code has been trashed this can be pruned down to
> - just raw registers. */
> - long sizeof_registers;
> - /* Offset into the register buffer for each register. */
> +
> + /* Is this a ``legacy'' register cache? Such caches reserve space
> + for raw and pseudo registers and allow access to both. */
> + int legacy_p;
> +
> + /* The raw register cache. This should contain just [0
> + .. NUM_RAW_REGISTERS). However, for older targets, it contains
> + space for the full [0 .. NUM_RAW_REGISTERS +
> + NUM_PSEUDO_REGISTERS). */
> + int nr_raw_registers;
> + long sizeof_raw_registers;
> + long sizeof_raw_register_valid_p;
> +
> + /* Offset, in bytes, of reach register in the raw register cache.
> + Pseudo registers have an offset even though they don't
> + (shouldn't) have a correspoinding space in the register cache.
> + It is to keep existing code, that relies on
> + write/write_register_bytes working. */
> long *register_offset;
> - /* Size, in bytes of the register valid array. */
> - long sizeof_register_valid_p;
> - /* Size, in ``bytes'', of a register. */
> +
> + /* The cooked / frame / virtual register space. The registers in
> + the range [0..NR_RAW_REGISTERS) should be mapped directly onto
> + the corresponding raw register. The next [NR_RAW_REGISTERS
> + .. NR_REGISTERS) should have been mapped, via
> + gdbarch_register_read/write onto either raw registers or memory. */
> + int nr_registers;
> long *sizeof_register;
> + long max_register_size;
> +
> };
>
> static struct regcache_descr *
> -regcache_descr (struct gdbarch *gdbarch)
> +legacy_regcache_descr (struct gdbarch *gdbarch)
> {
> int i;
> struct regcache_descr *descr;
> @@ -76,11 +89,13 @@
>
> descr = XMALLOC (struct regcache_descr);
> descr->gdbarch = gdbarch;
> + descr->legacy_p = 1;
>
> /* FIXME: cagney/2002-05-11: Shouldn't be including pseudo-registers
> in the register buffer. Unfortunatly some architectures do. */
> descr->nr_registers = NUM_REGS + NUM_PSEUDO_REGS;
> - descr->sizeof_register_valid_p = NUM_REGS + NUM_PSEUDO_REGS;
> + descr->nr_raw_registers = descr->nr_registers;
> + descr->sizeof_raw_register_valid_p = descr->nr_registers;
>
> /* FIXME: cagney/2002-05-11: Instead of using REGISTER_BYTE() this
> code should compute the offets et.al. at runtime. This currently
> @@ -89,14 +104,17 @@
> registers. */
> descr->sizeof_register = XCALLOC (descr->nr_registers, long);
> descr->register_offset = XCALLOC (descr->nr_registers, long);
> + descr->max_register_size = 0;
> for (i = 0; i < descr->nr_registers; i++)
> {
> descr->register_offset[i] = REGISTER_BYTE (i);
> descr->sizeof_register[i] = REGISTER_RAW_SIZE (i);
> + if (descr->max_register_size < REGISTER_RAW_SIZE (i))
> + descr->max_register_size = REGISTER_RAW_SIZE (i);
> }
>
> /* Come up with the real size of the registers buffer. */
> - descr->sizeof_registers = REGISTER_BYTES; /* OK use. */
> + descr->sizeof_raw_registers = REGISTER_BYTES; /* OK use. */
> for (i = 0; i < descr->nr_registers; i++)
> {
> long regend;
> @@ -111,13 +129,94 @@
> 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_registers < regend)
> - descr->sizeof_registers = regend;
> + if (descr->sizeof_raw_registers < regend)
> + descr->sizeof_raw_registers = regend;
> }
> set_gdbarch_data (gdbarch, regcache_data_handle, descr);
> return descr;
> }
>
> +static struct regcache_descr *
> +regcache_descr (struct gdbarch *gdbarch)
> +{
> + int i;
> + struct regcache_descr *descr;
> + gdb_assert (gdbarch != NULL);
> +
> + /* If the value has previously been computed, just return that. */
> + descr = gdbarch_data (gdbarch, regcache_data_handle);
> + if (descr != NULL)
> + return descr;
> +
> + /* If an old style architecture, construct the register cache
> + description using all the register macros. */
> + if (!gdbarch_register_read_p (gdbarch)
> + && !gdbarch_register_write_p (gdbarch))
> + return legacy_regcache_descr (gdbarch);
> +
> + descr = XMALLOC (struct regcache_descr);
> + descr->gdbarch = gdbarch;
> + descr->legacy_p = 0;
> +
> + /* Total size of the register space. The raw registers should
> + directly map onto the raw register cache while the pseudo's are
> + either mapped onto raw-registers or memory. */
> + descr->nr_registers = 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;
> + descr->sizeof_raw_register_valid_p = NUM_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.
> +
> + NOTE: cagney/2002-05-22: Only REGISTER_VIRTUAL_TYPE() needs to be
> + used when constructing the register cache. It is assumed that
> + register raw size, virtual size and type length of the type are
> + all the same. */
> +
> + {
> + long offset = 0;
> + descr->sizeof_register = XCALLOC (descr->nr_registers, long);
> + descr->register_offset = XCALLOC (descr->nr_registers, long);
> + descr->max_register_size = 0;
> + for (i = 0; i < descr->nr_registers; i++)
> + {
> + descr->sizeof_register[i] = TYPE_LENGTH (REGISTER_VIRTUAL_TYPE (i));
> + descr->register_offset[i] = offset;
> + offset += descr->sizeof_register[i];
> + if (descr->max_register_size < descr->sizeof_register[i])
> + 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]; */
> + }
> +
> + set_gdbarch_data (gdbarch, regcache_data_handle, descr);
> +
> + /* Sanity check. Confirm that the assumptions about gdbarch are
> + true. The REGCACHE_DATA_HANDLE is set before doing the checks so
> + that targets using the generic methods supplied by regcache don't
> + go into infinite recursion trying to, again, create the regcache. */
> + for (i = 0; i < descr->nr_registers; i++)
> + {
> + gdb_assert (descr->sizeof_register[i] == REGISTER_RAW_SIZE (i));
> + gdb_assert (descr->sizeof_register[i] == REGISTER_VIRTUAL_SIZE (i));
> + gdb_assert (descr->register_offset[i] == REGISTER_BYTE (i));
> + }
> + /* gdb_assert (descr->sizeof_raw_registers == REGISTER_BYTES (i)); */
> + return descr;
> +}
> +
> static void
> xfree_regcache_descr (struct gdbarch *gdbarch, void *ptr)
> {
> @@ -131,13 +230,13 @@
> xfree (descr);
> }
>
> -/* For moment, ``struct regcache'' is just a character buffer. */
> +/* The register cache for storing raw register values. */
>
> struct regcache
> {
> struct regcache_descr *descr;
> - char *registers;
> - char *register_valid_p;
> + 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;
> @@ -152,8 +251,10 @@
> descr = regcache_descr (gdbarch);
> regcache = XMALLOC (struct regcache);
> regcache->descr = descr;
> - regcache->registers = XCALLOC (descr->sizeof_registers, char);
> - regcache->register_valid_p = XCALLOC (descr->sizeof_register_valid_p, char);
> + 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;
> return regcache;
> }
> @@ -163,8 +264,8 @@
> {
> if (regcache == NULL)
> return;
> - xfree (regcache->registers);
> - xfree (regcache->register_valid_p);
> + xfree (regcache->raw_registers);
> + xfree (regcache->raw_register_valid_p);
> xfree (regcache);
> }
>
> @@ -186,33 +287,32 @@
> regcache_cpy (struct regcache *dst, struct regcache *src)
> {
> int i;
> - char *buf = alloca (MAX_REGISTER_RAW_SIZE);
> + char *buf;
> 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 the register cache. */
> - if (src == current_regcache
> - && !gdbarch_register_read_p (src->descr->gdbarch))
> + 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->registers, REGISTER_BYTES);
> + 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 the register cache. */
> - if (dst == current_regcache
> - && !gdbarch_register_read_p (dst->descr->gdbarch))
> + 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->registers, REGISTER_BYTES);
> + write_register_bytes (0, src->raw_registers, REGISTER_BYTES);
> return;
> }
> - for (i = 0; i < current_regcache->descr->nr_registers; i++)
> + 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_read (src, i, buf);
> @@ -230,10 +330,10 @@
> 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->registers, src->registers,
> - dst->descr->sizeof_registers);
> - memcpy (dst->register_valid_p, src->register_valid_p,
> - dst->descr->sizeof_register_valid_p);
> + memcpy (dst->raw_registers, src->raw_registers,
> + dst->descr->sizeof_raw_registers);
> + memcpy (dst->raw_register_valid_p, src->raw_register_valid_p,
> + dst->descr->sizeof_raw_register_valid_p);
> }
>
> struct regcache *
> @@ -260,8 +360,8 @@
> regcache_valid_p (struct regcache *regcache, int regnum)
> {
> gdb_assert (regcache != NULL);
> - gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_registers);
> - return regcache->register_valid_p[regnum];
> + gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
> + return regcache->raw_register_valid_p[regnum];
> }
>
> CORE_ADDR
> @@ -269,22 +369,22 @@
> {
> char *buf;
> gdb_assert (regcache != NULL);
> - gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_registers);
> + gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
> buf = alloca (regcache->descr->sizeof_register[regnum]);
> regcache_read (regcache, regnum, buf);
> return extract_address (buf, regcache->descr->sizeof_register[regnum]);
> }
>
> char *
> -grub_around_regcache_for_registers (struct regcache *regcache)
> +deprecated_grub_regcache_for_registers (struct regcache *regcache)
> {
> - return regcache->registers;
> + return regcache->raw_registers;
> }
>
> char *
> -grub_around_regcache_for_register_valid (struct regcache *regcache)
> +deprecated_grub_regcache_for_register_valid (struct regcache *regcache)
> {
> - return regcache->register_valid_p;
> + return regcache->raw_register_valid_p;
> }
>
> /* Global structure containing the current regcache. */
> @@ -356,10 +456,9 @@
> else return a pointer to the start of the cache buffer. */
>
> static char *
> -register_buffer (int regnum)
> +register_buffer (struct regcache *regcache, int regnum)
> {
> - gdb_assert (regnum >= 0 && regnum < (NUM_REGS + NUM_PSEUDO_REGS));
> - return ®isters[REGISTER_BYTE (regnum)];
> + return regcache->raw_registers + regcache->descr->register_offset[regnum];
> }
>
> /* Return whether register REGNUM is a real register. */
> @@ -570,7 +669,7 @@
> if (!register_cached (regnum))
> fetch_register (regnum);
>
> - memcpy (myaddr, register_buffer (regnum),
> + memcpy (myaddr, register_buffer (current_regcache, regnum),
> REGISTER_RAW_SIZE (regnum));
> }
>
> @@ -578,24 +677,44 @@
> regcache_read (struct regcache *regcache, int regnum, char *buf)
> {
> gdb_assert (regcache != NULL && buf != NULL);
> - gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_registers);
> + gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
> + if (regcache->descr->legacy_p
> + && regcache->passthrough_p)
> + {
> + gdb_assert (regcache == current_regcache);
> + /* For moment, just use underlying legacy code. Ulgh!!! This
> + silently and very indirectly updates the regcache's regcache
> + via the global register_valid[]. */
> + legacy_read_register_gen (regnum, buf);
> + return;
> + }
> + /* Make certain that the register cache is up-to-date with respect
> + 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)
> - /* For moment, just use underlying legacy code. Ulgh!!! This
> - silently and very indirectly updates the regcache's regcache via
> - the global register_valid[]. */
> - legacy_read_register_gen (regnum, buf);
> - else
> {
> - memcpy (buf, (regcache->registers
> - + regcache->descr->register_offset[regnum]),
> - regcache->descr->sizeof_register[regnum]);
> + gdb_assert (regcache == current_regcache);
> + if (! ptid_equal (registers_ptid, inferior_ptid))
> + {
> + registers_changed ();
> + registers_ptid = inferior_ptid;
> + }
> + if (!register_cached (regnum))
> + fetch_register (regnum);
> }
> + /* Copy the value directly into the register cache. */
> + memcpy (buf, (regcache->raw_registers
> + + regcache->descr->register_offset[regnum]),
> + regcache->descr->sizeof_register[regnum]);
> }
>
> void
> read_register_gen (int regnum, char *buf)
> {
> - if (! gdbarch_register_read_p (current_gdbarch))
> + gdb_assert (current_regcache != NULL);
> + gdb_assert (current_regcache->descr->gdbarch == current_gdbarch);
> + if (current_regcache->descr->legacy_p)
> {
> legacy_read_register_gen (regnum, buf);
> return;
> @@ -631,13 +750,14 @@
> /* If we have a valid copy of the register, and new value == old
> value, then don't bother doing the actual store. */
> if (register_cached (regnum)
> - && memcmp (register_buffer (regnum), myaddr, size) == 0)
> + && (memcmp (register_buffer (current_regcache, regnum), myaddr, size)
> + == 0))
> return;
> else
> target_prepare_to_store ();
> }
>
> - memcpy (register_buffer (regnum), myaddr, size);
> + memcpy (register_buffer (current_regcache, regnum), myaddr, size);
>
> set_register_cached (regnum, 1);
> store_register (regnum);
> @@ -647,24 +767,63 @@
> regcache_write (struct regcache *regcache, int regnum, char *buf)
> {
> gdb_assert (regcache != NULL && buf != NULL);
> - gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_registers);
> - if (regcache->passthrough_p)
> - /* For moment, just use underlying legacy code. Ulgh!!! This
> - silently and very indirectly updates the regcache's regcache via
> - the global register_valid[]. */
> - legacy_write_register_gen (regnum, buf);
> - else
> + gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
> +
> + if (regcache->passthrough_p
> + && regcache->descr->legacy_p)
> {
> - memcpy (regcache->registers + regcache->descr->register_offset[regnum], buf,
> + /* For moment, just use underlying legacy code. Ulgh!!! This
> + silently and very indirectly updates the regcache's buffers
> + via the globals register_valid[] and registers[]. */
> + gdb_assert (regcache == current_regcache);
> + legacy_write_register_gen (regnum, buf);
> + return;
> + }
> +
> + /* On the sparc, writing %g0 is a no-op, so we don't even want to
> + change the registers array if something writes to this register. */
> + 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->register_valid_p[regnum] = 1;
> + 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))
> + {
> + registers_changed ();
> + registers_ptid = inferior_ptid;
> + }
> +
> + /* If we have a valid copy of the register, and new value == old
> + value, then don't bother doing the actual store. */
> + if (regcache_valid_p (regcache, regnum)
> + && (memcmp (register_buffer (regcache, regnum), buf,
> + regcache->descr->sizeof_register[regnum]) == 0))
> + return;
> +
> + target_prepare_to_store ();
> + memcpy (register_buffer (regcache, regnum), buf,
> + regcache->descr->sizeof_register[regnum]);
> + regcache->raw_register_valid_p[regnum] = 1;
> + store_register (regnum);
> }
>
> void
> write_register_gen (int regnum, char *buf)
> {
> - if (! gdbarch_register_write_p (current_gdbarch))
> + gdb_assert (current_regcache != NULL);
> + gdb_assert (current_regcache->descr->gdbarch == current_gdbarch);
> + if (current_regcache->descr->legacy_p)
> {
> legacy_write_register_gen (regnum, buf);
> return;
> @@ -843,10 +1002,10 @@
>
> set_register_cached (regnum, 1);
> if (val)
> - memcpy (register_buffer (regnum), val,
> + memcpy (register_buffer (current_regcache, regnum), val,
> REGISTER_RAW_SIZE (regnum));
> else
> - memset (register_buffer (regnum), '\000',
> + memset (register_buffer (current_regcache, regnum), '\000',
> REGISTER_RAW_SIZE (regnum));
>
> /* On some architectures, e.g. HPPA, there are a few stray bits in
> @@ -866,7 +1025,8 @@
> void
> regcache_collect (int regnum, void *buf)
> {
> - memcpy (buf, register_buffer (regnum), REGISTER_RAW_SIZE (regnum));
> + memcpy (buf, register_buffer (current_regcache, regnum),
> + REGISTER_RAW_SIZE (regnum));
> }
>
>
> @@ -1036,15 +1196,14 @@
> {
> current_regcache = regcache_xmalloc (current_gdbarch);
> current_regcache->passthrough_p = 1;
> - registers = grub_around_regcache_for_registers (current_regcache);
> - register_valid = grub_around_regcache_for_register_valid (current_regcache);
> + registers = deprecated_grub_regcache_for_registers (current_regcache);
> + register_valid = deprecated_grub_regcache_for_register_valid (current_regcache);
> }
>
> void
> regcache_save (struct regcache *regcache)
> {
> int i;
> - char *buf = alloca (MAX_REGISTER_RAW_SIZE);
> gdb_assert (current_regcache != NULL && regcache != NULL);
> gdb_assert (current_regcache->descr->gdbarch == regcache->descr->gdbarch);
> regcache_cpy (regcache, current_regcache);
> @@ -1062,7 +1221,6 @@
> regcache_restore (struct regcache *regcache)
> {
> int i;
> - char *buf = alloca (MAX_REGISTER_RAW_SIZE);
> gdb_assert (current_regcache != NULL && regcache != NULL);
> gdb_assert (current_regcache->descr->gdbarch == regcache->descr->gdbarch);
> regcache_cpy (current_regcache, regcache);
> Index: regcache.h
> ===================================================================
> RCS file: /cvs/src/src/gdb/regcache.h,v
> retrieving revision 1.6.6.4
> diff -u -r1.6.6.4 regcache.h
> --- regcache.h 17 May 2002 16:17:30 -0000 1.6.6.4
> +++ regcache.h 23 May 2002 17:47:27 -0000
> @@ -73,8 +73,8 @@
> extern void regcache_cpy (struct regcache *dest, struct regcache *src);
> extern void regcache_cpy_no_passthrough (struct regcache *dest, struct regcache *src);
>
> -extern char *grub_around_regcache_for_registers (struct regcache *);
> -extern char *grub_around_regcache_for_register_valid (struct regcache *);
> +extern char *deprecated_grub_regcache_for_registers (struct regcache *);
> +extern char *deprecated_grub_regcache_for_register_valid (struct regcache *);
>
> extern int register_cached (int regnum);
>
> Index: rs6000-tdep.c
> ===================================================================
> RCS file: /cvs/src/src/gdb/rs6000-tdep.c,v
> retrieving revision 1.64.2.2
> diff -u -r1.64.2.2 rs6000-tdep.c
> --- rs6000-tdep.c 16 May 2002 19:08:01 -0000 1.64.2.2
> +++ rs6000-tdep.c 23 May 2002 17:47:29 -0000
> @@ -1150,7 +1150,7 @@
> {
> int offset = 0;
> struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
> - char *regbuf = grub_around_regcache_for_registers (regs);
> + char *regbuf = deprecated_grub_regcache_for_registers (regs);
>
> if (TYPE_CODE (valtype) == TYPE_CODE_FLT)
> {