/* Cache and manage the values of registers for GDB, the GNU debugger.
- Copyright 1986, 1987, 1989, 1991, 1994, 1995, 1996, 1998, 2000,
- 2001, 2002, 2004 Free Software Foundation, Inc.
+ Copyright (C) 1986, 1987, 1989, 1991, 1994, 1995, 1996, 1998, 2000, 2001,
+ 2002, 2004, 2007 Free Software Foundation, Inc.
This file is part of GDB.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA. */
+ Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA. */
#include "defs.h"
#include "inferior.h"
/* The register buffers. A read-only register cache can hold the
full [0 .. NUM_REGS + NUM_PSEUDO_REGS) while a read/write
register cache can only hold [0 .. NUM_REGS). */
- char *registers;
- char *register_valid_p;
+ gdb_byte *registers;
+ /* Register cache status:
+ register_valid_p[REG] == 0 if REG value is not in the cache
+ > 0 if REG value is in the cache
+ < 0 if REG value is permanently unavailable */
+ signed char *register_valid_p;
/* Is this a read-only cache? A read-only cache is used for saving
the target's register state (e.g, across an inferior function
call or just before forcing a function return). A read-only
regcache = XMALLOC (struct regcache);
regcache->descr = descr;
regcache->registers
- = XCALLOC (descr->sizeof_raw_registers, char);
+ = XCALLOC (descr->sizeof_raw_registers, gdb_byte);
regcache->register_valid_p
- = XCALLOC (descr->sizeof_raw_register_valid_p, char);
+ = XCALLOC (descr->sizeof_raw_register_valid_p, gdb_byte);
regcache->readonly_p = 1;
return regcache;
}
/* Return a pointer to register REGNUM's buffer cache. */
-static char *
+static gdb_byte *
register_buffer (const struct regcache *regcache, int regnum)
{
return regcache->registers + regcache->descr->register_offset[regnum];
void *src)
{
struct gdbarch *gdbarch = dst->descr->gdbarch;
- char buf[MAX_REGISTER_SIZE];
+ gdb_byte buf[MAX_REGISTER_SIZE];
int regnum;
/* The DST should be `read-only', if it wasn't then the save would
end up trying to write the register values back out to the
void
regcache_restore (struct regcache *dst,
regcache_cooked_read_ftype *cooked_read,
- void *src)
+ void *cooked_read_context)
{
struct gdbarch *gdbarch = dst->descr->gdbarch;
- char buf[MAX_REGISTER_SIZE];
+ gdb_byte buf[MAX_REGISTER_SIZE];
int regnum;
/* The dst had better not be read-only. If it is, the `restore'
doesn't make much sense. */
{
if (gdbarch_register_reggroup_p (gdbarch, regnum, restore_reggroup))
{
- int valid = cooked_read (src, regnum, buf);
+ int valid = cooked_read (cooked_read_context, regnum, buf);
if (valid)
regcache_cooked_write (dst, regnum, buf);
}
}
static int
-do_cooked_read (void *src, int regnum, void *buf)
+do_cooked_read (void *src, int regnum, gdb_byte *buf)
{
struct regcache *regcache = src;
if (!regcache->register_valid_p[regnum] && regcache->readonly_p)
regcache_cpy (struct regcache *dst, struct regcache *src)
{
int i;
- char *buf;
+ gdb_byte *buf;
gdb_assert (src != NULL && dst != NULL);
gdb_assert (src->descr->gdbarch == dst->descr->gdbarch);
gdb_assert (src != dst);
return regcache->register_valid_p[regnum];
}
-char *
-deprecated_grub_regcache_for_registers (struct regcache *regcache)
-{
- return regcache->registers;
-}
-
/* Global structure containing the current regcache. */
/* FIXME: cagney/2002-05-11: The two global arrays registers[] and
deprecated_register_valid[] currently point into this structure. */
Fetching all real regs NEVER accounts for pseudo-regs. */
}
-/* deprecated_read_register_bytes and deprecated_write_register_bytes
- are generally a *BAD* idea. They are inefficient because they need
- to check for partial updates, which can only be done by scanning
- through all of the registers and seeing if the bytes that are being
- read/written fall inside of an invalid register. [The main reason
- this is necessary is that register sizes can vary, so a simple
- index won't suffice.] It is far better to call read_register_gen
- and write_register_gen if you want to get at the raw register
- contents, as it only takes a regnum as an argument, and therefore
- can't do a partial register update.
-
- Prior to the recent fixes to check for partial updates, both read
- and deprecated_write_register_bytes always checked to see if any
- registers were stale, and then called target_fetch_registers (-1)
- to update the whole set. This caused really slowed things down for
- remote targets. */
-
-/* Copy INLEN bytes of consecutive data from registers
- starting with the INREGBYTE'th byte of register data
- into memory at MYADDR. */
-
-void
-deprecated_read_register_bytes (int in_start, char *in_buf, int in_len)
-{
- int in_end = in_start + in_len;
- int regnum;
- char reg_buf[MAX_REGISTER_SIZE];
-
- /* See if we are trying to read bytes from out-of-date registers. If so,
- update just those registers. */
-
- for (regnum = 0; regnum < NUM_REGS + NUM_PSEUDO_REGS; regnum++)
- {
- int reg_start;
- int reg_end;
- int reg_len;
- int start;
- int end;
- int byte;
-
- reg_start = DEPRECATED_REGISTER_BYTE (regnum);
- reg_len = register_size (current_gdbarch, regnum);
- reg_end = reg_start + reg_len;
-
- if (reg_end <= in_start || in_end <= reg_start)
- /* The range the user wants to read doesn't overlap with regnum. */
- continue;
-
- if (REGISTER_NAME (regnum) != NULL && *REGISTER_NAME (regnum) != '\0')
- /* Force the cache to fetch the entire register. */
- deprecated_read_register_gen (regnum, reg_buf);
-
- /* Legacy note: This function, for some reason, allows a NULL
- input buffer. If the buffer is NULL, the registers are still
- fetched, just the final transfer is skipped. */
- if (in_buf == NULL)
- continue;
-
- /* start = max (reg_start, in_start) */
- if (reg_start > in_start)
- start = reg_start;
- else
- start = in_start;
-
- /* end = min (reg_end, in_end) */
- if (reg_end < in_end)
- end = reg_end;
- else
- end = in_end;
-
- /* Transfer just the bytes common to both IN_BUF and REG_BUF */
- for (byte = start; byte < end; byte++)
- {
- in_buf[byte - in_start] = reg_buf[byte - reg_start];
- }
- }
-}
-
void
-regcache_raw_read (struct regcache *regcache, int regnum, void *buf)
+regcache_raw_read (struct regcache *regcache, int regnum, gdb_byte *buf)
{
gdb_assert (regcache != NULL && buf != NULL);
gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
void
regcache_raw_read_signed (struct regcache *regcache, int regnum, LONGEST *val)
{
- char *buf;
+ gdb_byte *buf;
gdb_assert (regcache != NULL);
gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
buf = alloca (regcache->descr->sizeof_register[regnum]);
regcache_raw_read_unsigned (struct regcache *regcache, int regnum,
ULONGEST *val)
{
- char *buf;
+ gdb_byte *buf;
gdb_assert (regcache != NULL);
gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
buf = alloca (regcache->descr->sizeof_register[regnum]);
}
void
-deprecated_read_register_gen (int regnum, char *buf)
+deprecated_read_register_gen (int regnum, gdb_byte *buf)
{
gdb_assert (current_regcache != NULL);
gdb_assert (current_regcache->descr->gdbarch == current_gdbarch);
}
void
-regcache_cooked_read (struct regcache *regcache, int regnum, void *buf)
+regcache_cooked_read (struct regcache *regcache, int regnum, gdb_byte *buf)
{
gdb_assert (regnum >= 0);
gdb_assert (regnum < regcache->descr->nr_cooked_registers);
regcache_cooked_read_signed (struct regcache *regcache, int regnum,
LONGEST *val)
{
- char *buf;
+ gdb_byte *buf;
gdb_assert (regcache != NULL);
gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_cooked_registers);
buf = alloca (regcache->descr->sizeof_register[regnum]);
regcache_cooked_read_unsigned (struct regcache *regcache, int regnum,
ULONGEST *val)
{
- char *buf;
+ gdb_byte *buf;
gdb_assert (regcache != NULL);
gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_cooked_registers);
buf = alloca (regcache->descr->sizeof_register[regnum]);
}
void
-regcache_raw_write (struct regcache *regcache, int regnum, const void *buf)
+regcache_raw_write (struct regcache *regcache, int regnum,
+ const gdb_byte *buf)
{
gdb_assert (regcache != NULL && buf != NULL);
gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
}
void
-deprecated_write_register_gen (int regnum, char *buf)
+deprecated_write_register_gen (int regnum, gdb_byte *buf)
{
gdb_assert (current_regcache != NULL);
gdb_assert (current_regcache->descr->gdbarch == current_gdbarch);
}
void
-regcache_cooked_write (struct regcache *regcache, int regnum, const void *buf)
+regcache_cooked_write (struct regcache *regcache, int regnum,
+ const gdb_byte *buf)
{
gdb_assert (regnum >= 0);
gdb_assert (regnum < regcache->descr->nr_cooked_registers);
regnum, buf);
}
-/* Copy INLEN bytes of consecutive data from memory at MYADDR
- into registers starting with the MYREGSTART'th byte of register data. */
-
-void
-deprecated_write_register_bytes (int myregstart, char *myaddr, int inlen)
-{
- int myregend = myregstart + inlen;
- int regnum;
-
- target_prepare_to_store ();
-
- /* Scan through the registers updating any that are covered by the
- range myregstart<=>myregend using write_register_gen, which does
- nice things like handling threads, and avoiding updates when the
- new and old contents are the same. */
-
- for (regnum = 0; regnum < NUM_REGS + NUM_PSEUDO_REGS; regnum++)
- {
- int regstart, regend;
-
- regstart = DEPRECATED_REGISTER_BYTE (regnum);
- regend = regstart + register_size (current_gdbarch, regnum);
-
- /* Is this register completely outside the range the user is writing? */
- if (myregend <= regstart || regend <= myregstart)
- /* do nothing */ ;
-
- /* Is this register completely within the range the user is writing? */
- else if (myregstart <= regstart && regend <= myregend)
- deprecated_write_register_gen (regnum, myaddr + (regstart - myregstart));
-
- /* The register partially overlaps the range being written. */
- else
- {
- char regbuf[MAX_REGISTER_SIZE];
- /* What's the overlap between this register's bytes and
- those the caller wants to write? */
- int overlapstart = max (regstart, myregstart);
- int overlapend = min (regend, myregend);
-
- /* We may be doing a partial update of an invalid register.
- Update it from the target before scribbling on it. */
- deprecated_read_register_gen (regnum, regbuf);
-
- target_store_registers (regnum);
- }
- }
-}
-
/* Perform a partial register transfer using a read, modify, write
operation. */
static 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)
+ void (*read) (struct regcache *regcache, int regnum,
+ gdb_byte *buf),
+ void (*write) (struct regcache *regcache, int regnum,
+ const gdb_byte *buf))
{
struct regcache_descr *descr = regcache->descr;
gdb_byte reg[MAX_REGISTER_SIZE];
void
regcache_raw_read_part (struct regcache *regcache, int regnum,
- int offset, int len, void *buf)
+ int offset, int len, gdb_byte *buf)
{
struct regcache_descr *descr = regcache->descr;
gdb_assert (regnum >= 0 && regnum < descr->nr_raw_registers);
void
regcache_raw_write_part (struct regcache *regcache, int regnum,
- int offset, int len, const void *buf)
+ int offset, int len, const gdb_byte *buf)
{
struct regcache_descr *descr = regcache->descr;
gdb_assert (regnum >= 0 && regnum < descr->nr_raw_registers);
void
regcache_cooked_read_part (struct regcache *regcache, int regnum,
- int offset, int len, void *buf)
+ int offset, int len, gdb_byte *buf)
{
struct regcache_descr *descr = regcache->descr;
gdb_assert (regnum >= 0 && regnum < descr->nr_cooked_registers);
void
regcache_cooked_write_part (struct regcache *regcache, int regnum,
- int offset, int len, const void *buf)
+ int offset, int len, const gdb_byte *buf)
{
struct regcache_descr *descr = regcache->descr;
gdb_assert (regnum >= 0 && regnum < descr->nr_cooked_registers);
return descr->register_offset[regnum];
}
-/* Hack to keep code using register_bytes working. */
-
-int
-deprecated_register_bytes (void)
-{
- return current_regcache->descr->sizeof_raw_registers;
-}
-
/* Return the contents of register REGNUM as an unsigned integer. */
ULONGEST
read_register (int regnum)
{
- char *buf = alloca (register_size (current_gdbarch, regnum));
+ gdb_byte *buf = alloca (register_size (current_gdbarch, regnum));
deprecated_read_register_gen (regnum, buf);
return (extract_unsigned_integer (buf, register_size (current_gdbarch, regnum)));
}
projects / deliverable / binutils-gdb.git / blobdiff