/* Cache and manage the values of registers for GDB, the GNU debugger.
Copyright 1986, 1987, 1989, 1991, 1994, 1995, 1996, 1998, 2000,
- 2001, 2002 Free Software Foundation, Inc.
+ 2001, 2002, 2004 Free Software Foundation, Inc.
This file is part of GDB.
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). */
+ /* The raw register cache. Each raw (or hard) register is supplied
+ by the target interface. The raw cache should not contain
+ redundant information - if the PC is constructed from two
+ registers then those regigisters and not the PC lives in the raw
+ cache. */
int nr_raw_registers;
long sizeof_raw_registers;
long sizeof_raw_register_valid_p;
``gdbarch'' as a parameter. */
gdb_assert (gdbarch != NULL);
- /* FIXME: cagney/2002-05-11: Shouldn't be including pseudo-registers
- in the register cache. Unfortunatly some architectures still
- rely on this and the pseudo_register_write() method. */
- descr->nr_raw_registers = descr->nr_cooked_registers;
- descr->sizeof_raw_register_valid_p = descr->sizeof_cooked_register_valid_p;
-
/* 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);
+ DEPRECATED_REGISTER_BYTE() so use that. */
+ /* FIXME: cagney/2002-11-07: Instead of using
+ DEPRECATED_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
+ = GDBARCH_OBSTACK_CALLOC (gdbarch, descr->nr_cooked_registers, long);
+ descr->register_offset
+ = GDBARCH_OBSTACK_CALLOC (gdbarch, descr->nr_cooked_registers, long);
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);
- gdb_assert (MAX_REGISTER_SIZE >= REGISTER_RAW_SIZE (i));
- gdb_assert (MAX_REGISTER_SIZE >= REGISTER_VIRTUAL_SIZE (i));
+ DEPRECATED_REGISTER_BYTE(). Unfortunately, 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] = DEPRECATED_REGISTER_BYTE (i);
+ descr->sizeof_register[i] = DEPRECATED_REGISTER_RAW_SIZE (i);
+ gdb_assert (MAX_REGISTER_SIZE >= DEPRECATED_REGISTER_RAW_SIZE (i));
+ gdb_assert (MAX_REGISTER_SIZE >= DEPRECATED_REGISTER_VIRTUAL_SIZE (i));
}
/* Compute the real size of the register buffer. Start out by
/* 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. */
+ buffer separated by holes. Once DEPRECATED_REGISTER_BYTE()
+ is killed this can be greatly simplified. */
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 the register cache. Unfortunatly some architectures still
+ in the register cache. Unfortunately some architectures still
rely on this and the pseudo_register_write() method. */
descr->sizeof_raw_registers = descr->sizeof_cooked_registers;
}
gdb_assert (gdbarch != NULL);
/* Create an initial, zero filled, table. */
- descr = XCALLOC (1, struct regcache_descr);
+ descr = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct regcache_descr);
descr->gdbarch = gdbarch;
/* Total size of the register space. The raw registers are mapped
descr->sizeof_cooked_register_valid_p = NUM_REGS + NUM_PSEUDO_REGS;
/* Fill in a table of register types. */
- descr->register_type = XCALLOC (descr->nr_cooked_registers,
- struct type *);
+ descr->register_type
+ = GDBARCH_OBSTACK_CALLOC (gdbarch, descr->nr_cooked_registers, struct type *);
for (i = 0; i < descr->nr_cooked_registers; i++)
{
if (gdbarch_register_type_p (gdbarch))
{
- gdb_assert (!REGISTER_VIRTUAL_TYPE_P ()); /* OK */
+ gdb_assert (!DEPRECATED_REGISTER_VIRTUAL_TYPE_P ()); /* OK */
descr->register_type[i] = gdbarch_register_type (gdbarch, i);
}
else
- descr->register_type[i] = REGISTER_VIRTUAL_TYPE (i); /* OK */
- }
-
- /* If an old style architecture, fill in the remainder of the
- register cache descriptor using the register macros. */
- if (!gdbarch_pseudo_register_read_p (gdbarch)
- && !gdbarch_pseudo_register_write_p (gdbarch)
- && !gdbarch_register_type_p (gdbarch))
- {
- /* NOTE: cagney/2003-05-02: Don't add a test for REGISTER_BYTE_P
- to the above. Doing that would cause all the existing
- architectures to revert back to the legacy regcache
- mechanisms, and that is not a good thing. Instead just,
- later, check that the register cache's layout is consistent
- with REGISTER_BYTE. */
- descr->legacy_p = 1;
- init_legacy_regcache_descr (gdbarch, descr);
- return descr;
+ descr->register_type[i] = DEPRECATED_REGISTER_VIRTUAL_TYPE (i); /* OK */
}
/* Construct a strictly RAW register cache. Don't allow pseudo's
.. NUM_REGS + NUM_PSEUDO_REGS). */
descr->sizeof_raw_register_valid_p = descr->sizeof_cooked_register_valid_p;
+ /* If an old style architecture, fill in the remainder of the
+ register cache descriptor using the register macros. */
+ /* NOTE: cagney/2003-06-29: If either of DEPRECATED_REGISTER_BYTE or
+ DEPRECATED_REGISTER_RAW_SIZE are still present, things are most likely
+ totally screwed. Ex: an architecture with raw register sizes
+ smaller than what DEPRECATED_REGISTER_BYTE indicates; non
+ monotonic DEPRECATED_REGISTER_BYTE values. For GDB 6 check for
+ these nasty methods and fall back to legacy code when present.
+ Sigh! */
+ if ((!gdbarch_pseudo_register_read_p (gdbarch)
+ && !gdbarch_pseudo_register_write_p (gdbarch)
+ && !gdbarch_register_type_p (gdbarch))
+ || DEPRECATED_REGISTER_BYTE_P ()
+ || DEPRECATED_REGISTER_RAW_SIZE_P ())
+ {
+ descr->legacy_p = 1;
+ init_legacy_regcache_descr (gdbarch, descr);
+ return descr;
+ }
+
/* Lay out the register cache.
NOTE: cagney/2002-05-22: Only register_type() is used when
{
long offset = 0;
- descr->sizeof_register = XCALLOC (descr->nr_cooked_registers, long);
- descr->register_offset = XCALLOC (descr->nr_cooked_registers, long);
+ descr->sizeof_register
+ = GDBARCH_OBSTACK_CALLOC (gdbarch, descr->nr_cooked_registers, long);
+ descr->register_offset
+ = GDBARCH_OBSTACK_CALLOC (gdbarch, descr->nr_cooked_registers, long);
for (i = 0; i < descr->nr_cooked_registers; i++)
{
descr->sizeof_register[i] = TYPE_LENGTH (descr->register_type[i]);
}
/* FIXME: cagney/2002-05-22: Should only need to allocate space for
- the raw registers. Unfortunatly some code still accesses the
+ the raw registers. Unfortunately 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;
/* Sanity check. Confirm that there is agreement between the
- regcache and the target's redundant REGISTER_BYTE (new targets
- should not even be defining it). */
+ regcache and the target's redundant DEPRECATED_REGISTER_BYTE (new
+ targets should not even be defining it). */
for (i = 0; i < descr->nr_cooked_registers; i++)
{
- if (REGISTER_BYTE_P ())
- gdb_assert (descr->register_offset[i] == REGISTER_BYTE (i));
+ if (DEPRECATED_REGISTER_BYTE_P ())
+ gdb_assert (descr->register_offset[i] == DEPRECATED_REGISTER_BYTE (i));
#if 0
- gdb_assert (descr->sizeof_register[i] == REGISTER_RAW_SIZE (i));
- gdb_assert (descr->sizeof_register[i] == REGISTER_VIRTUAL_SIZE (i));
+ gdb_assert (descr->sizeof_register[i] == DEPRECATED_REGISTER_RAW_SIZE (i));
+ gdb_assert (descr->sizeof_register[i] == DEPRECATED_REGISTER_VIRTUAL_SIZE (i));
#endif
}
/* gdb_assert (descr->sizeof_raw_registers == DEPRECATED_REGISTER_BYTES (i)); */
return gdbarch_data (gdbarch, regcache_descr_handle);
}
-static void
-xfree_regcache_descr (struct gdbarch *gdbarch, void *ptr)
-{
- struct regcache_descr *descr = ptr;
- if (descr == NULL)
- return;
- xfree (descr->register_offset);
- xfree (descr->sizeof_register);
- descr->register_offset = NULL;
- descr->sizeof_register = NULL;
- xfree (descr);
-}
-
/* Utility functions returning useful register attributes stored in
the regcache descr. */
int size;
gdb_assert (regnum >= 0 && regnum < (NUM_REGS + NUM_PSEUDO_REGS));
size = descr->sizeof_register[regnum];
- gdb_assert (size == REGISTER_RAW_SIZE (regnum)); /* OK */
- gdb_assert (size == REGISTER_RAW_SIZE (regnum)); /* OK */
+ /* NB: The deprecated DEPRECATED_REGISTER_RAW_SIZE, if not provided, defaults
+ to the size of the register's type. */
+ gdb_assert (size == DEPRECATED_REGISTER_RAW_SIZE (regnum)); /* OK */
+ /* NB: Don't check the register's virtual size. It, in say the case
+ of the MIPS, may not match the raw size! */
return size;
}
return make_cleanup (do_regcache_xfree, regcache);
}
+/* Return REGCACHE's architecture. */
+
+struct gdbarch *
+get_regcache_arch (const struct regcache *regcache)
+{
+ return regcache->descr->gdbarch;
+}
+
/* Return a pointer to register REGNUM's buffer cache. */
static char *
-register_buffer (struct regcache *regcache, int regnum)
+register_buffer (const struct regcache *regcache, int regnum)
{
return regcache->registers + regcache->descr->register_offset[regnum];
}
do_cooked_read (void *src, int regnum, void *buf)
{
struct regcache *regcache = src;
- if (!regcache_valid_p (regcache, regnum)
- && regcache->readonly_p)
+ if (!regcache->register_valid_p[regnum] && regcache->readonly_p)
/* Don't even think about fetching a register from a read-only
cache when the register isn't yet valid. There isn't a target
from which the register value can be fetched. */
gdb_assert (src->descr->gdbarch == dst->descr->gdbarch);
/* NOTE: cagney/2002-05-17: Don't let the caller do a no-passthrough
move of data into the current_regcache(). Doing this would be
- silly - it would mean that valid_p would be completly invalid. */
+ silly - it would mean that valid_p would be completely invalid. */
gdb_assert (dst != current_regcache);
memcpy (dst->registers, src->registers, dst->descr->sizeof_raw_registers);
memcpy (dst->register_valid_p, src->register_valid_p,
int end;
int byte;
- reg_start = REGISTER_BYTE (regnum);
- reg_len = REGISTER_RAW_SIZE (regnum);
+ reg_start = DEPRECATED_REGISTER_BYTE (regnum);
+ reg_len = DEPRECATED_REGISTER_RAW_SIZE (regnum);
reg_end = reg_start + reg_len;
if (reg_end <= in_start || in_end <= reg_start)
target_fetch_registers (regnum);
memcpy (myaddr, register_buffer (current_regcache, regnum),
- REGISTER_RAW_SIZE (regnum));
+ DEPRECATED_REGISTER_RAW_SIZE (regnum));
}
void
registers_ptid = inferior_ptid;
}
- size = REGISTER_RAW_SIZE (regnum);
+ size = DEPRECATED_REGISTER_RAW_SIZE (regnum);
if (real_register (regnum))
{
{
int regstart, regend;
- regstart = REGISTER_BYTE (regnum);
- regend = regstart + REGISTER_RAW_SIZE (regnum);
+ regstart = DEPRECATED_REGISTER_BYTE (regnum);
+ regend = regstart + DEPRECATED_REGISTER_RAW_SIZE (regnum);
/* Is this register completely outside the range the user is writing? */
if (myregend <= regstart || regend <= myregstart)
ULONGEST
read_register (int regnum)
{
- char *buf = alloca (REGISTER_RAW_SIZE (regnum));
+ char *buf = alloca (DEPRECATED_REGISTER_RAW_SIZE (regnum));
deprecated_read_register_gen (regnum, buf);
- return (extract_unsigned_integer (buf, REGISTER_RAW_SIZE (regnum)));
+ return (extract_unsigned_integer (buf, DEPRECATED_REGISTER_RAW_SIZE (regnum)));
}
ULONGEST
{
void *buf;
int size;
- size = REGISTER_RAW_SIZE (regnum);
+ size = DEPRECATED_REGISTER_RAW_SIZE (regnum);
buf = alloca (size);
store_signed_integer (buf, size, (LONGEST) val);
deprecated_write_register_gen (regnum, buf);
inferior_ptid = save_ptid;
}
+/* FIXME: kettenis/20030828: We should get rid of supply_register and
+ regcache_collect in favour of regcache_raw_supply and
+ regcache_raw_collect. */
+
/* SUPPLY_REGISTER()
Record that register REGNUM contains VAL. This is used when the
void
supply_register (int regnum, const void *val)
{
-#if 1
- if (! ptid_equal (registers_ptid, inferior_ptid))
- {
- registers_changed ();
- registers_ptid = inferior_ptid;
- }
-#endif
-
- set_register_cached (regnum, 1);
- if (val)
- memcpy (register_buffer (current_regcache, regnum), val,
- REGISTER_RAW_SIZE (regnum));
- else
- memset (register_buffer (current_regcache, regnum), '\000',
- REGISTER_RAW_SIZE (regnum));
+ regcache_raw_supply (current_regcache, regnum, val);
/* On some architectures, e.g. HPPA, there are a few stray bits in
some registers, that the rest of the code would like to ignore. */
void
regcache_collect (int regnum, void *buf)
{
- memcpy (buf, register_buffer (current_regcache, regnum),
- REGISTER_RAW_SIZE (regnum));
+ regcache_raw_collect (current_regcache, regnum, buf);
+}
+
+/* Supply register REGNUM, whose contents are stored in BUF, to REGCACHE. */
+
+void
+regcache_raw_supply (struct regcache *regcache, int regnum, const void *buf)
+{
+ void *regbuf;
+ size_t size;
+
+ gdb_assert (regcache != NULL);
+ gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
+ gdb_assert (!regcache->readonly_p);
+
+ /* FIXME: kettenis/20030828: It shouldn't be necessary to handle
+ CURRENT_REGCACHE specially here. */
+ if (regcache == current_regcache
+ && !ptid_equal (registers_ptid, inferior_ptid))
+ {
+ registers_changed ();
+ registers_ptid = inferior_ptid;
+ }
+
+ regbuf = register_buffer (regcache, regnum);
+ size = regcache->descr->sizeof_register[regnum];
+
+ if (buf)
+ memcpy (regbuf, buf, size);
+ else
+ memset (regbuf, 0, size);
+
+ /* Mark the register as cached. */
+ regcache->register_valid_p[regnum] = 1;
+}
+
+/* Collect register REGNUM from REGCACHE and store its contents in BUF. */
+
+void
+regcache_raw_collect (const struct regcache *regcache, int regnum, void *buf)
+{
+ const void *regbuf;
+ size_t size;
+
+ gdb_assert (regcache != NULL && buf != NULL);
+ gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
+
+ regbuf = register_buffer (regcache, regnum);
+ size = regcache->descr->sizeof_register[regnum];
+ memcpy (buf, regbuf, size);
}
else if (PC_REGNUM >= 0)
{
CORE_ADDR raw_val = read_register_pid (PC_REGNUM, ptid);
- CORE_ADDR pc_val = ADDR_BITS_REMOVE (raw_val);
- return pc_val;
+ pc_val = ADDR_BITS_REMOVE (raw_val);
}
else
internal_error (__FILE__, __LINE__, "read_pc_pid: Unable to find PC");
void
generic_target_write_pc (CORE_ADDR pc, ptid_t ptid)
{
-#ifdef PC_REGNUM
if (PC_REGNUM >= 0)
write_register_pid (PC_REGNUM, pc, ptid);
- if (NPC_REGNUM >= 0)
- write_register_pid (NPC_REGNUM, pc + 4, ptid);
-#else
- internal_error (__FILE__, __LINE__,
- "generic_target_write_pc");
-#endif
+ else
+ internal_error (__FILE__, __LINE__,
+ "generic_target_write_pc");
}
void
internal_error (__FILE__, __LINE__, "deprecated_read_fp");
}
-/* ARGSUSED */
static void
reg_flush_command (char *command, int from_tty)
{
{
struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
struct gdbarch *gdbarch = regcache->descr->gdbarch;
- struct reggroup *const *groups = reggroups (gdbarch);
int regnum;
int footnote_nr = 0;
int footnote_register_size = 0;
fprintf_unfiltered (file, " %6ld",
regcache->descr->register_offset[regnum]);
if (register_offset != regcache->descr->register_offset[regnum]
- || register_offset != REGISTER_BYTE (regnum)
+ || register_offset != DEPRECATED_REGISTER_BYTE (regnum)
|| (regnum > 0
&& (regcache->descr->register_offset[regnum]
!= (regcache->descr->register_offset[regnum - 1]
fprintf_unfiltered (file, " %5ld",
regcache->descr->sizeof_register[regnum]);
if ((regcache->descr->sizeof_register[regnum]
- != REGISTER_RAW_SIZE (regnum))
+ != DEPRECATED_REGISTER_RAW_SIZE (regnum))
|| (regcache->descr->sizeof_register[regnum]
- != REGISTER_VIRTUAL_SIZE (regnum))
+ != DEPRECATED_REGISTER_VIRTUAL_SIZE (regnum))
|| (regcache->descr->sizeof_register[regnum]
!= TYPE_LENGTH (register_type (regcache->descr->gdbarch,
regnum)))
regcache_raw_read (regcache, regnum, buf);
fprintf_unfiltered (file, "0x");
dump_endian_bytes (file, TARGET_BYTE_ORDER, buf,
- REGISTER_RAW_SIZE (regnum));
+ DEPRECATED_REGISTER_RAW_SIZE (regnum));
}
}
regcache_cooked_read (regcache, regnum, buf);
fprintf_unfiltered (file, "0x");
dump_endian_bytes (file, TARGET_BYTE_ORDER, buf,
- REGISTER_VIRTUAL_SIZE (regnum));
+ DEPRECATED_REGISTER_VIRTUAL_SIZE (regnum));
}
}
fprintf_unfiltered (file, "Groups");
else
{
- int i;
const char *sep = "";
- for (i = 0; groups[i] != NULL; i++)
+ struct reggroup *group;
+ for (group = reggroup_next (gdbarch, NULL);
+ group != NULL;
+ group = reggroup_next (gdbarch, group))
{
- if (gdbarch_register_reggroup_p (gdbarch, regnum, groups[i]))
+ if (gdbarch_register_reggroup_p (gdbarch, regnum, group))
{
- fprintf_unfiltered (file, "%s%s", sep, reggroup_name (groups[i]));
+ fprintf_unfiltered (file, "%s%s", sep, reggroup_name (group));
sep = ",";
}
}
void
_initialize_regcache (void)
{
- regcache_descr_handle = register_gdbarch_data (init_regcache_descr,
- xfree_regcache_descr);
- REGISTER_GDBARCH_SWAP (current_regcache);
- register_gdbarch_swap (&deprecated_registers, sizeof (deprecated_registers), NULL);
- register_gdbarch_swap (&deprecated_register_valid, sizeof (deprecated_register_valid), NULL);
- register_gdbarch_swap (NULL, 0, build_regcache);
+ regcache_descr_handle = register_gdbarch_data (init_regcache_descr);
+ DEPRECATED_REGISTER_GDBARCH_SWAP (current_regcache);
+ DEPRECATED_REGISTER_GDBARCH_SWAP (deprecated_registers);
+ DEPRECATED_REGISTER_GDBARCH_SWAP (deprecated_register_valid);
+ deprecated_register_gdbarch_swap (NULL, 0, build_regcache);
add_com ("flushregs", class_maintenance, reg_flush_command,
"Force gdb to flush its register cache (maintainer command)");