96a4ee76e5
* regcache.c (register_size): Only check REGISTER_RAW_SIZE once. Add comments about the checks.
1714 lines
53 KiB
C
1714 lines
53 KiB
C
/* 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.
|
|
|
|
This file is part of GDB.
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 2 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
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. */
|
|
|
|
#include "defs.h"
|
|
#include "inferior.h"
|
|
#include "target.h"
|
|
#include "gdbarch.h"
|
|
#include "gdbcmd.h"
|
|
#include "regcache.h"
|
|
#include "reggroups.h"
|
|
#include "gdb_assert.h"
|
|
#include "gdb_string.h"
|
|
#include "gdbcmd.h" /* For maintenanceprintlist. */
|
|
|
|
/*
|
|
* DATA STRUCTURE
|
|
*
|
|
* Here is the actual register cache.
|
|
*/
|
|
|
|
/* Per-architecture object describing the layout of a register cache.
|
|
Computed once when the architecture is created */
|
|
|
|
struct gdbarch_data *regcache_descr_handle;
|
|
|
|
struct regcache_descr
|
|
{
|
|
/* The architecture this descriptor belongs to. */
|
|
struct gdbarch *gdbarch;
|
|
|
|
/* 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;
|
|
|
|
/* The cooked register space. Each cooked register in the range
|
|
[0..NR_RAW_REGISTERS) is direct-mapped onto the corresponding raw
|
|
register. The remaining [NR_RAW_REGISTERS
|
|
.. NR_COOKED_REGISTERS) (a.k.a. pseudo regiters) are mapped onto
|
|
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
|
|
[NR_RAW_REGISTERS .. NR_COOKED_REGISTERS) are given an offset.
|
|
Assigning all registers an offset makes it possible to keep
|
|
legacy code, such as that found in read_register_bytes() and
|
|
write_register_bytes() working. */
|
|
long *register_offset;
|
|
long *sizeof_register;
|
|
|
|
/* Cached table containing the type of each register. */
|
|
struct type **register_type;
|
|
};
|
|
|
|
static void
|
|
init_legacy_regcache_descr (struct gdbarch *gdbarch,
|
|
struct regcache_descr *descr)
|
|
{
|
|
int i;
|
|
/* FIXME: cagney/2002-05-11: gdbarch_data() should take that
|
|
``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);
|
|
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));
|
|
}
|
|
|
|
/* Compute the real size of the register buffer. Start out by
|
|
trusting DEPRECATED_REGISTER_BYTES, but then adjust it upwards
|
|
should that be found to not be sufficient. */
|
|
/* FIXME: cagney/2002-11-05: Instead of using the macro
|
|
DEPRECATED_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 = DEPRECATED_REGISTER_BYTES; /* OK */
|
|
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. */
|
|
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
|
|
rely on this and the pseudo_register_write() method. */
|
|
descr->sizeof_raw_registers = descr->sizeof_cooked_registers;
|
|
}
|
|
|
|
static void *
|
|
init_regcache_descr (struct gdbarch *gdbarch)
|
|
{
|
|
int i;
|
|
struct regcache_descr *descr;
|
|
gdb_assert (gdbarch != NULL);
|
|
|
|
/* Create an initial, zero filled, table. */
|
|
descr = XCALLOC (1, struct regcache_descr);
|
|
descr->gdbarch = gdbarch;
|
|
|
|
/* Total size of the register space. The raw registers are mapped
|
|
directly onto the raw register cache while the pseudo's are
|
|
either mapped onto raw-registers or memory. */
|
|
descr->nr_cooked_registers = NUM_REGS + NUM_PSEUDO_REGS;
|
|
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 *);
|
|
for (i = 0; i < descr->nr_cooked_registers; i++)
|
|
{
|
|
if (gdbarch_register_type_p (gdbarch))
|
|
{
|
|
gdb_assert (!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. */
|
|
/* NOTE: cagney/2003-06-29: If either of REGISTER_BYTE or
|
|
REGISTER_RAW_SIZE are still present, things are most likely
|
|
totally screwed. Ex: an architecture with raw register sizes
|
|
smaller than what REGISTER_BYTE indicates; non monotonic
|
|
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))
|
|
|| REGISTER_BYTE_P () || REGISTER_RAW_SIZE_P ())
|
|
{
|
|
descr->legacy_p = 1;
|
|
init_legacy_regcache_descr (gdbarch, descr);
|
|
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 = descr->sizeof_cooked_register_valid_p;
|
|
|
|
/* 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
|
|
register's raw size, virtual size and type length are all the
|
|
same. */
|
|
|
|
{
|
|
long offset = 0;
|
|
descr->sizeof_register = XCALLOC (descr->nr_cooked_registers, long);
|
|
descr->register_offset = XCALLOC (descr->nr_cooked_registers, long);
|
|
for (i = 0; i < descr->nr_cooked_registers; i++)
|
|
{
|
|
descr->sizeof_register[i] = TYPE_LENGTH (descr->register_type[i]);
|
|
descr->register_offset[i] = offset;
|
|
offset += descr->sizeof_register[i];
|
|
gdb_assert (MAX_REGISTER_SIZE >= descr->sizeof_register[i]);
|
|
}
|
|
/* Set the real size of the register cache buffer. */
|
|
descr->sizeof_cooked_registers = offset;
|
|
}
|
|
|
|
/* 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;
|
|
|
|
/* 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). */
|
|
for (i = 0; i < descr->nr_cooked_registers; i++)
|
|
{
|
|
if (REGISTER_BYTE_P ())
|
|
gdb_assert (descr->register_offset[i] == 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));
|
|
#endif
|
|
}
|
|
/* gdb_assert (descr->sizeof_raw_registers == DEPRECATED_REGISTER_BYTES (i)); */
|
|
|
|
return descr;
|
|
}
|
|
|
|
static struct regcache_descr *
|
|
regcache_descr (struct gdbarch *gdbarch)
|
|
{
|
|
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. */
|
|
|
|
struct type *
|
|
register_type (struct gdbarch *gdbarch, int regnum)
|
|
{
|
|
struct regcache_descr *descr = regcache_descr (gdbarch);
|
|
gdb_assert (regnum >= 0 && regnum < descr->nr_cooked_registers);
|
|
return descr->register_type[regnum];
|
|
}
|
|
|
|
/* Utility functions returning useful register attributes stored in
|
|
the regcache descr. */
|
|
|
|
int
|
|
register_size (struct gdbarch *gdbarch, int regnum)
|
|
{
|
|
struct regcache_descr *descr = regcache_descr (gdbarch);
|
|
int size;
|
|
gdb_assert (regnum >= 0 && regnum < (NUM_REGS + NUM_PSEUDO_REGS));
|
|
size = descr->sizeof_register[regnum];
|
|
/* NB: The deprecated REGISTER_RAW_SIZE, if not provided, defaults
|
|
to the size of the register's type. */
|
|
gdb_assert (size == 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;
|
|
}
|
|
|
|
/* The register cache for storing raw register values. */
|
|
|
|
struct regcache
|
|
{
|
|
struct regcache_descr *descr;
|
|
/* 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;
|
|
/* 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
|
|
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;
|
|
};
|
|
|
|
struct regcache *
|
|
regcache_xmalloc (struct gdbarch *gdbarch)
|
|
{
|
|
struct regcache_descr *descr;
|
|
struct regcache *regcache;
|
|
gdb_assert (gdbarch != NULL);
|
|
descr = regcache_descr (gdbarch);
|
|
regcache = XMALLOC (struct regcache);
|
|
regcache->descr = descr;
|
|
regcache->registers
|
|
= XCALLOC (descr->sizeof_raw_registers, char);
|
|
regcache->register_valid_p
|
|
= XCALLOC (descr->sizeof_raw_register_valid_p, char);
|
|
regcache->readonly_p = 1;
|
|
return regcache;
|
|
}
|
|
|
|
void
|
|
regcache_xfree (struct regcache *regcache)
|
|
{
|
|
if (regcache == NULL)
|
|
return;
|
|
xfree (regcache->registers);
|
|
xfree (regcache->register_valid_p);
|
|
xfree (regcache);
|
|
}
|
|
|
|
static void
|
|
do_regcache_xfree (void *data)
|
|
{
|
|
regcache_xfree (data);
|
|
}
|
|
|
|
struct cleanup *
|
|
make_cleanup_regcache_xfree (struct regcache *regcache)
|
|
{
|
|
return make_cleanup (do_regcache_xfree, regcache);
|
|
}
|
|
|
|
/* Return a pointer to register REGNUM's buffer cache. */
|
|
|
|
static char *
|
|
register_buffer (struct regcache *regcache, int regnum)
|
|
{
|
|
return regcache->registers + regcache->descr->register_offset[regnum];
|
|
}
|
|
|
|
void
|
|
regcache_save (struct regcache *dst, regcache_cooked_read_ftype *cooked_read,
|
|
void *src)
|
|
{
|
|
struct gdbarch *gdbarch = dst->descr->gdbarch;
|
|
char 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
|
|
target. */
|
|
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))
|
|
{
|
|
int valid = cooked_read (src, regnum, buf);
|
|
if (valid)
|
|
{
|
|
memcpy (register_buffer (dst, regnum), buf,
|
|
register_size (gdbarch, regnum));
|
|
dst->register_valid_p[regnum] = 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
regcache_restore (struct regcache *dst,
|
|
regcache_cooked_read_ftype *cooked_read,
|
|
void *src)
|
|
{
|
|
struct gdbarch *gdbarch = dst->descr->gdbarch;
|
|
char buf[MAX_REGISTER_SIZE];
|
|
int regnum;
|
|
/* The dst had better not be read-only. If it is, the `restore'
|
|
doesn't make much sense. */
|
|
gdb_assert (!dst->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 < dst->descr->nr_cooked_registers; regnum++)
|
|
{
|
|
if (gdbarch_register_reggroup_p (gdbarch, regnum, restore_reggroup))
|
|
{
|
|
int valid = cooked_read (src, regnum, buf);
|
|
if (valid)
|
|
regcache_cooked_write (dst, regnum, buf);
|
|
}
|
|
}
|
|
}
|
|
|
|
static int
|
|
do_cooked_read (void *src, int regnum, void *buf)
|
|
{
|
|
struct regcache *regcache = src;
|
|
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. */
|
|
return 0;
|
|
regcache_cooked_read (regcache, regnum, buf);
|
|
return 1;
|
|
}
|
|
|
|
|
|
void
|
|
regcache_cpy (struct regcache *dst, struct regcache *src)
|
|
{
|
|
int i;
|
|
char *buf;
|
|
gdb_assert (src != NULL && dst != NULL);
|
|
gdb_assert (src->descr->gdbarch == dst->descr->gdbarch);
|
|
gdb_assert (src != dst);
|
|
gdb_assert (src->readonly_p || dst->readonly_p);
|
|
if (!src->readonly_p)
|
|
regcache_save (dst, do_cooked_read, src);
|
|
else if (!dst->readonly_p)
|
|
regcache_restore (dst, do_cooked_read, src);
|
|
else
|
|
regcache_cpy_no_passthrough (dst, src);
|
|
}
|
|
|
|
void
|
|
regcache_cpy_no_passthrough (struct regcache *dst, struct regcache *src)
|
|
{
|
|
int i;
|
|
gdb_assert (src != NULL && dst != NULL);
|
|
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. */
|
|
gdb_assert (dst != current_regcache);
|
|
memcpy (dst->registers, src->registers, dst->descr->sizeof_raw_registers);
|
|
memcpy (dst->register_valid_p, src->register_valid_p,
|
|
dst->descr->sizeof_raw_register_valid_p);
|
|
}
|
|
|
|
struct regcache *
|
|
regcache_dup (struct regcache *src)
|
|
{
|
|
struct regcache *newbuf;
|
|
gdb_assert (current_regcache != NULL);
|
|
newbuf = regcache_xmalloc (src->descr->gdbarch);
|
|
regcache_cpy (newbuf, src);
|
|
return newbuf;
|
|
}
|
|
|
|
struct regcache *
|
|
regcache_dup_no_passthrough (struct regcache *src)
|
|
{
|
|
struct regcache *newbuf;
|
|
gdb_assert (current_regcache != NULL);
|
|
newbuf = regcache_xmalloc (src->descr->gdbarch);
|
|
regcache_cpy_no_passthrough (newbuf, src);
|
|
return newbuf;
|
|
}
|
|
|
|
int
|
|
regcache_valid_p (struct regcache *regcache, int regnum)
|
|
{
|
|
gdb_assert (regcache != NULL);
|
|
gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
|
|
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. */
|
|
struct regcache *current_regcache;
|
|
|
|
/* NOTE: this is a write-through cache. There is no "dirty" bit for
|
|
recording if the register values have been changed (eg. by the
|
|
user). Therefore all registers must be written back to the
|
|
target when appropriate. */
|
|
|
|
/* REGISTERS contains the cached register values (in target byte order). */
|
|
|
|
char *deprecated_registers;
|
|
|
|
/* DEPRECATED_REGISTER_VALID is 0 if the register needs to be fetched,
|
|
1 if it has been fetched, and
|
|
-1 if the register value was not available.
|
|
|
|
"Not available" indicates that the target is not not able to supply
|
|
the register at this state. The register may become available at a
|
|
later time (after the next resume). This often occures when GDB is
|
|
manipulating a target that contains only a snapshot of the entire
|
|
system being debugged - some of the registers in such a system may
|
|
not have been saved. */
|
|
|
|
signed char *deprecated_register_valid;
|
|
|
|
/* The thread/process associated with the current set of registers. */
|
|
|
|
static ptid_t registers_ptid;
|
|
|
|
/*
|
|
* FUNCTIONS:
|
|
*/
|
|
|
|
/* REGISTER_CACHED()
|
|
|
|
Returns 0 if the value is not in the cache (needs fetch).
|
|
>0 if the value is in the cache.
|
|
<0 if the value is permanently unavailable (don't ask again). */
|
|
|
|
int
|
|
register_cached (int regnum)
|
|
{
|
|
return deprecated_register_valid[regnum];
|
|
}
|
|
|
|
/* Record that REGNUM's value is cached if STATE is >0, uncached but
|
|
fetchable if STATE is 0, and uncached and unfetchable if STATE is <0. */
|
|
|
|
void
|
|
set_register_cached (int regnum, int state)
|
|
{
|
|
gdb_assert (regnum >= 0);
|
|
gdb_assert (regnum < current_regcache->descr->nr_raw_registers);
|
|
current_regcache->register_valid_p[regnum] = state;
|
|
}
|
|
|
|
/* Return whether register REGNUM is a real register. */
|
|
|
|
static int
|
|
real_register (int regnum)
|
|
{
|
|
return regnum >= 0 && regnum < NUM_REGS;
|
|
}
|
|
|
|
/* Low level examining and depositing of registers.
|
|
|
|
The caller is responsible for making sure that the inferior is
|
|
stopped before calling the fetching routines, or it will get
|
|
garbage. (a change from GDB version 3, in which the caller got the
|
|
value from the last stop). */
|
|
|
|
/* REGISTERS_CHANGED ()
|
|
|
|
Indicate that registers may have changed, so invalidate the cache. */
|
|
|
|
void
|
|
registers_changed (void)
|
|
{
|
|
int i;
|
|
|
|
registers_ptid = pid_to_ptid (-1);
|
|
|
|
/* Force cleanup of any alloca areas if using C alloca instead of
|
|
a builtin alloca. This particular call is used to clean up
|
|
areas allocated by low level target code which may build up
|
|
during lengthy interactions between gdb and the target before
|
|
gdb gives control to the user (ie watchpoints). */
|
|
alloca (0);
|
|
|
|
for (i = 0; i < current_regcache->descr->nr_raw_registers; i++)
|
|
set_register_cached (i, 0);
|
|
|
|
if (registers_changed_hook)
|
|
registers_changed_hook ();
|
|
}
|
|
|
|
/* DEPRECATED_REGISTERS_FETCHED ()
|
|
|
|
Indicate that all registers have been fetched, so mark them all valid. */
|
|
|
|
/* NOTE: cagney/2001-12-04: This function does not set valid on the
|
|
pseudo-register range since pseudo registers are always supplied
|
|
using supply_register(). */
|
|
/* FIXME: cagney/2001-12-04: This function is DEPRECATED. The target
|
|
code was blatting the registers[] array and then calling this.
|
|
Since targets should only be using supply_register() the need for
|
|
this function/hack is eliminated. */
|
|
|
|
void
|
|
deprecated_registers_fetched (void)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < NUM_REGS; i++)
|
|
set_register_cached (i, 1);
|
|
/* Do not assume that the pseudo-regs have also been fetched.
|
|
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 = REGISTER_BYTE (regnum);
|
|
reg_len = REGISTER_RAW_SIZE (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);
|
|
else
|
|
/* Legacy note: even though this register is ``invalid'' we
|
|
still need to return something. It would appear that some
|
|
code relies on apparent gaps in the register array also
|
|
being returned. */
|
|
/* FIXME: cagney/2001-08-18: This is just silly. It defeats
|
|
the entire register read/write flow of control. Must
|
|
resist temptation to return 0xdeadbeef. */
|
|
memcpy (reg_buf, &deprecated_registers[reg_start], reg_len);
|
|
|
|
/* 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];
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Read register REGNUM into memory at MYADDR, which must be large
|
|
enough for REGISTER_RAW_BYTES (REGNUM). Target byte-order. If the
|
|
register is known to be the size of a CORE_ADDR or smaller,
|
|
read_register can be used instead. */
|
|
|
|
static void
|
|
legacy_read_register_gen (int regnum, char *myaddr)
|
|
{
|
|
gdb_assert (regnum >= 0 && regnum < (NUM_REGS + NUM_PSEUDO_REGS));
|
|
if (! ptid_equal (registers_ptid, inferior_ptid))
|
|
{
|
|
registers_changed ();
|
|
registers_ptid = inferior_ptid;
|
|
}
|
|
|
|
if (!register_cached (regnum))
|
|
target_fetch_registers (regnum);
|
|
|
|
memcpy (myaddr, register_buffer (current_regcache, regnum),
|
|
REGISTER_RAW_SIZE (regnum));
|
|
}
|
|
|
|
void
|
|
regcache_raw_read (struct regcache *regcache, int regnum, void *buf)
|
|
{
|
|
gdb_assert (regcache != NULL && buf != NULL);
|
|
gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
|
|
if (regcache->descr->legacy_p
|
|
&& !regcache->readonly_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 deprecated_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->readonly_p)
|
|
{
|
|
gdb_assert (regcache == current_regcache);
|
|
if (! ptid_equal (registers_ptid, inferior_ptid))
|
|
{
|
|
registers_changed ();
|
|
registers_ptid = inferior_ptid;
|
|
}
|
|
if (!register_cached (regnum))
|
|
target_fetch_registers (regnum);
|
|
}
|
|
/* Copy the value directly into the register cache. */
|
|
memcpy (buf, register_buffer (regcache, regnum),
|
|
regcache->descr->sizeof_register[regnum]);
|
|
}
|
|
|
|
void
|
|
regcache_raw_read_signed (struct regcache *regcache, int regnum, LONGEST *val)
|
|
{
|
|
char *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 (regcache, regnum, buf);
|
|
(*val) = extract_signed_integer (buf,
|
|
regcache->descr->sizeof_register[regnum]);
|
|
}
|
|
|
|
void
|
|
regcache_raw_read_unsigned (struct regcache *regcache, int regnum,
|
|
ULONGEST *val)
|
|
{
|
|
char *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 (regcache, regnum, buf);
|
|
(*val) = extract_unsigned_integer (buf,
|
|
regcache->descr->sizeof_register[regnum]);
|
|
}
|
|
|
|
void
|
|
regcache_raw_write_signed (struct regcache *regcache, int regnum, LONGEST val)
|
|
{
|
|
void *buf;
|
|
gdb_assert (regcache != NULL);
|
|
gdb_assert (regnum >=0 && regnum < regcache->descr->nr_raw_registers);
|
|
buf = alloca (regcache->descr->sizeof_register[regnum]);
|
|
store_signed_integer (buf, regcache->descr->sizeof_register[regnum], val);
|
|
regcache_raw_write (regcache, regnum, buf);
|
|
}
|
|
|
|
void
|
|
regcache_raw_write_unsigned (struct regcache *regcache, int regnum,
|
|
ULONGEST val)
|
|
{
|
|
void *buf;
|
|
gdb_assert (regcache != NULL);
|
|
gdb_assert (regnum >=0 && regnum < regcache->descr->nr_raw_registers);
|
|
buf = alloca (regcache->descr->sizeof_register[regnum]);
|
|
store_unsigned_integer (buf, regcache->descr->sizeof_register[regnum], val);
|
|
regcache_raw_write (regcache, regnum, buf);
|
|
}
|
|
|
|
void
|
|
deprecated_read_register_gen (int regnum, char *buf)
|
|
{
|
|
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;
|
|
}
|
|
regcache_cooked_read (current_regcache, regnum, buf);
|
|
}
|
|
|
|
void
|
|
regcache_cooked_read (struct regcache *regcache, int regnum, void *buf)
|
|
{
|
|
gdb_assert (regnum >= 0);
|
|
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);
|
|
}
|
|
|
|
void
|
|
regcache_cooked_read_signed (struct regcache *regcache, int regnum,
|
|
LONGEST *val)
|
|
{
|
|
char *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 (regcache, regnum, buf);
|
|
(*val) = extract_signed_integer (buf,
|
|
regcache->descr->sizeof_register[regnum]);
|
|
}
|
|
|
|
void
|
|
regcache_cooked_read_unsigned (struct regcache *regcache, int regnum,
|
|
ULONGEST *val)
|
|
{
|
|
char *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 (regcache, regnum, buf);
|
|
(*val) = extract_unsigned_integer (buf,
|
|
regcache->descr->sizeof_register[regnum]);
|
|
}
|
|
|
|
void
|
|
regcache_cooked_write_signed (struct regcache *regcache, int regnum,
|
|
LONGEST val)
|
|
{
|
|
void *buf;
|
|
gdb_assert (regcache != NULL);
|
|
gdb_assert (regnum >=0 && regnum < regcache->descr->nr_cooked_registers);
|
|
buf = alloca (regcache->descr->sizeof_register[regnum]);
|
|
store_signed_integer (buf, regcache->descr->sizeof_register[regnum], val);
|
|
regcache_cooked_write (regcache, regnum, buf);
|
|
}
|
|
|
|
void
|
|
regcache_cooked_write_unsigned (struct regcache *regcache, int regnum,
|
|
ULONGEST val)
|
|
{
|
|
void *buf;
|
|
gdb_assert (regcache != NULL);
|
|
gdb_assert (regnum >=0 && regnum < regcache->descr->nr_cooked_registers);
|
|
buf = alloca (regcache->descr->sizeof_register[regnum]);
|
|
store_unsigned_integer (buf, regcache->descr->sizeof_register[regnum], val);
|
|
regcache_cooked_write (regcache, regnum, buf);
|
|
}
|
|
|
|
/* Write register REGNUM at MYADDR to the target. MYADDR points at
|
|
REGISTER_RAW_BYTES(REGNUM), which must be in target byte-order. */
|
|
|
|
static void
|
|
legacy_write_register_gen (int regnum, const void *myaddr)
|
|
{
|
|
int size;
|
|
gdb_assert (regnum >= 0 && regnum < (NUM_REGS + NUM_PSEUDO_REGS));
|
|
|
|
/* 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;
|
|
|
|
if (! ptid_equal (registers_ptid, inferior_ptid))
|
|
{
|
|
registers_changed ();
|
|
registers_ptid = inferior_ptid;
|
|
}
|
|
|
|
size = REGISTER_RAW_SIZE (regnum);
|
|
|
|
if (real_register (regnum))
|
|
{
|
|
/* 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 (current_regcache, regnum), myaddr, size)
|
|
== 0))
|
|
return;
|
|
else
|
|
target_prepare_to_store ();
|
|
}
|
|
|
|
memcpy (register_buffer (current_regcache, regnum), myaddr, size);
|
|
|
|
set_register_cached (regnum, 1);
|
|
target_store_registers (regnum);
|
|
}
|
|
|
|
void
|
|
regcache_raw_write (struct regcache *regcache, int regnum, const void *buf)
|
|
{
|
|
gdb_assert (regcache != NULL && buf != NULL);
|
|
gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
|
|
gdb_assert (!regcache->readonly_p);
|
|
|
|
if (regcache->descr->legacy_p)
|
|
{
|
|
/* For moment, just use underlying legacy code. Ulgh!!! This
|
|
silently and very indirectly updates the regcache's buffers
|
|
via the globals deprecated_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;
|
|
|
|
/* 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->register_valid_p[regnum] = 1;
|
|
target_store_registers (regnum);
|
|
}
|
|
|
|
void
|
|
deprecated_write_register_gen (int regnum, char *buf)
|
|
{
|
|
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;
|
|
}
|
|
regcache_cooked_write (current_regcache, regnum, buf);
|
|
}
|
|
|
|
void
|
|
regcache_cooked_write (struct regcache *regcache, int regnum, const void *buf)
|
|
{
|
|
gdb_assert (regnum >= 0);
|
|
gdb_assert (regnum < regcache->descr->nr_cooked_registers);
|
|
if (regnum < regcache->descr->nr_raw_registers)
|
|
regcache_raw_write (regcache, regnum, buf);
|
|
else
|
|
gdbarch_pseudo_register_write (regcache->descr->gdbarch, regcache,
|
|
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 = REGISTER_BYTE (regnum);
|
|
regend = regstart + REGISTER_RAW_SIZE (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);
|
|
|
|
memcpy (&deprecated_registers[overlapstart],
|
|
myaddr + (overlapstart - myregstart),
|
|
overlapend - overlapstart);
|
|
|
|
target_store_registers (regnum);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Perform a partial register transfer using a read, modify, write
|
|
operation. */
|
|
|
|
typedef void (regcache_read_ftype) (struct regcache *regcache, int regnum,
|
|
void *buf);
|
|
typedef void (regcache_write_ftype) (struct regcache *regcache, int regnum,
|
|
const void *buf);
|
|
|
|
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)
|
|
{
|
|
struct regcache_descr *descr = regcache->descr;
|
|
bfd_byte reg[MAX_REGISTER_SIZE];
|
|
gdb_assert (offset >= 0 && offset <= descr->sizeof_register[regnum]);
|
|
gdb_assert (len >= 0 && offset + len <= descr->sizeof_register[regnum]);
|
|
/* Something to do? */
|
|
if (offset + len == 0)
|
|
return;
|
|
/* Read (when needed) ... */
|
|
if (in != NULL
|
|
|| offset > 0
|
|
|| offset + len < descr->sizeof_register[regnum])
|
|
{
|
|
gdb_assert (read != NULL);
|
|
read (regcache, regnum, reg);
|
|
}
|
|
/* ... modify ... */
|
|
if (in != NULL)
|
|
memcpy (in, reg + offset, len);
|
|
if (out != NULL)
|
|
memcpy (reg + offset, out, len);
|
|
/* ... write (when needed). */
|
|
if (out != NULL)
|
|
{
|
|
gdb_assert (write != NULL);
|
|
write (regcache, regnum, reg);
|
|
}
|
|
}
|
|
|
|
void
|
|
regcache_raw_read_part (struct regcache *regcache, int regnum,
|
|
int offset, int len, void *buf)
|
|
{
|
|
struct regcache_descr *descr = regcache->descr;
|
|
gdb_assert (regnum >= 0 && regnum < descr->nr_raw_registers);
|
|
regcache_xfer_part (regcache, regnum, offset, len, buf, NULL,
|
|
regcache_raw_read, regcache_raw_write);
|
|
}
|
|
|
|
void
|
|
regcache_raw_write_part (struct regcache *regcache, int regnum,
|
|
int offset, int len, const void *buf)
|
|
{
|
|
struct regcache_descr *descr = regcache->descr;
|
|
gdb_assert (regnum >= 0 && regnum < descr->nr_raw_registers);
|
|
regcache_xfer_part (regcache, regnum, offset, len, NULL, buf,
|
|
regcache_raw_read, regcache_raw_write);
|
|
}
|
|
|
|
void
|
|
regcache_cooked_read_part (struct regcache *regcache, int regnum,
|
|
int offset, int len, void *buf)
|
|
{
|
|
struct regcache_descr *descr = regcache->descr;
|
|
gdb_assert (regnum >= 0 && regnum < descr->nr_cooked_registers);
|
|
regcache_xfer_part (regcache, regnum, offset, len, buf, NULL,
|
|
regcache_cooked_read, regcache_cooked_write);
|
|
}
|
|
|
|
void
|
|
regcache_cooked_write_part (struct regcache *regcache, int regnum,
|
|
int offset, int len, const void *buf)
|
|
{
|
|
struct regcache_descr *descr = regcache->descr;
|
|
gdb_assert (regnum >= 0 && regnum < descr->nr_cooked_registers);
|
|
regcache_xfer_part (regcache, regnum, offset, len, NULL, buf,
|
|
regcache_cooked_read, regcache_cooked_write);
|
|
}
|
|
|
|
/* Hack to keep code that view the register buffer as raw bytes
|
|
working. */
|
|
|
|
int
|
|
register_offset_hack (struct gdbarch *gdbarch, int regnum)
|
|
{
|
|
struct regcache_descr *descr = regcache_descr (gdbarch);
|
|
gdb_assert (regnum >= 0 && regnum < descr->nr_cooked_registers);
|
|
return descr->register_offset[regnum];
|
|
}
|
|
|
|
/* Return the contents of register REGNUM as an unsigned integer. */
|
|
|
|
ULONGEST
|
|
read_register (int regnum)
|
|
{
|
|
char *buf = alloca (REGISTER_RAW_SIZE (regnum));
|
|
deprecated_read_register_gen (regnum, buf);
|
|
return (extract_unsigned_integer (buf, REGISTER_RAW_SIZE (regnum)));
|
|
}
|
|
|
|
ULONGEST
|
|
read_register_pid (int regnum, ptid_t ptid)
|
|
{
|
|
ptid_t save_ptid;
|
|
int save_pid;
|
|
CORE_ADDR retval;
|
|
|
|
if (ptid_equal (ptid, inferior_ptid))
|
|
return read_register (regnum);
|
|
|
|
save_ptid = inferior_ptid;
|
|
|
|
inferior_ptid = ptid;
|
|
|
|
retval = read_register (regnum);
|
|
|
|
inferior_ptid = save_ptid;
|
|
|
|
return retval;
|
|
}
|
|
|
|
/* Store VALUE into the raw contents of register number REGNUM. */
|
|
|
|
void
|
|
write_register (int regnum, LONGEST val)
|
|
{
|
|
void *buf;
|
|
int size;
|
|
size = REGISTER_RAW_SIZE (regnum);
|
|
buf = alloca (size);
|
|
store_signed_integer (buf, size, (LONGEST) val);
|
|
deprecated_write_register_gen (regnum, buf);
|
|
}
|
|
|
|
void
|
|
write_register_pid (int regnum, CORE_ADDR val, ptid_t ptid)
|
|
{
|
|
ptid_t save_ptid;
|
|
|
|
if (ptid_equal (ptid, inferior_ptid))
|
|
{
|
|
write_register (regnum, val);
|
|
return;
|
|
}
|
|
|
|
save_ptid = inferior_ptid;
|
|
|
|
inferior_ptid = ptid;
|
|
|
|
write_register (regnum, val);
|
|
|
|
inferior_ptid = save_ptid;
|
|
}
|
|
|
|
/* SUPPLY_REGISTER()
|
|
|
|
Record that register REGNUM contains VAL. This is used when the
|
|
value is obtained from the inferior or core dump, so there is no
|
|
need to store the value there.
|
|
|
|
If VAL is a NULL pointer, then it's probably an unsupported register.
|
|
We just set its value to all zeros. We might want to record this
|
|
fact, and report it to the users of read_register and friends. */
|
|
|
|
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));
|
|
|
|
/* 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. */
|
|
|
|
/* NOTE: cagney/2001-03-16: The macro CLEAN_UP_REGISTER_VALUE is
|
|
going to be deprecated. Instead architectures will leave the raw
|
|
register value as is and instead clean things up as they pass
|
|
through the method gdbarch_pseudo_register_read() clean up the
|
|
values. */
|
|
|
|
#ifdef DEPRECATED_CLEAN_UP_REGISTER_VALUE
|
|
DEPRECATED_CLEAN_UP_REGISTER_VALUE \
|
|
(regnum, register_buffer (current_regcache, regnum));
|
|
#endif
|
|
}
|
|
|
|
void
|
|
regcache_collect (int regnum, void *buf)
|
|
{
|
|
memcpy (buf, register_buffer (current_regcache, regnum),
|
|
REGISTER_RAW_SIZE (regnum));
|
|
}
|
|
|
|
|
|
/* read_pc, write_pc, read_sp, deprecated_read_fp, etc. Special
|
|
handling for registers PC, SP, and FP. */
|
|
|
|
/* NOTE: cagney/2001-02-18: The functions read_pc_pid(), read_pc(),
|
|
read_sp(), and deprecated_read_fp(), will eventually be replaced by
|
|
per-frame methods. Instead of relying on the global INFERIOR_PTID,
|
|
they will use the contextual information provided by the FRAME.
|
|
These functions do not belong in the register cache. */
|
|
|
|
/* NOTE: cagney/2003-06-07: The functions generic_target_write_pc(),
|
|
write_pc_pid(), write_pc(), and deprecated_read_fp(), all need to
|
|
be replaced by something that does not rely on global state. But
|
|
what? */
|
|
|
|
CORE_ADDR
|
|
read_pc_pid (ptid_t ptid)
|
|
{
|
|
ptid_t saved_inferior_ptid;
|
|
CORE_ADDR pc_val;
|
|
|
|
/* In case ptid != inferior_ptid. */
|
|
saved_inferior_ptid = inferior_ptid;
|
|
inferior_ptid = ptid;
|
|
|
|
if (TARGET_READ_PC_P ())
|
|
pc_val = TARGET_READ_PC (ptid);
|
|
/* Else use per-frame method on get_current_frame. */
|
|
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;
|
|
}
|
|
else
|
|
internal_error (__FILE__, __LINE__, "read_pc_pid: Unable to find PC");
|
|
|
|
inferior_ptid = saved_inferior_ptid;
|
|
return pc_val;
|
|
}
|
|
|
|
CORE_ADDR
|
|
read_pc (void)
|
|
{
|
|
return read_pc_pid (inferior_ptid);
|
|
}
|
|
|
|
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
|
|
}
|
|
|
|
void
|
|
write_pc_pid (CORE_ADDR pc, ptid_t ptid)
|
|
{
|
|
ptid_t saved_inferior_ptid;
|
|
|
|
/* In case ptid != inferior_ptid. */
|
|
saved_inferior_ptid = inferior_ptid;
|
|
inferior_ptid = ptid;
|
|
|
|
TARGET_WRITE_PC (pc, ptid);
|
|
|
|
inferior_ptid = saved_inferior_ptid;
|
|
}
|
|
|
|
void
|
|
write_pc (CORE_ADDR pc)
|
|
{
|
|
write_pc_pid (pc, inferior_ptid);
|
|
}
|
|
|
|
/* Cope with strage ways of getting to the stack and frame pointers */
|
|
|
|
CORE_ADDR
|
|
read_sp (void)
|
|
{
|
|
if (TARGET_READ_SP_P ())
|
|
return TARGET_READ_SP ();
|
|
else if (gdbarch_unwind_sp_p (current_gdbarch))
|
|
return get_frame_sp (get_current_frame ());
|
|
else if (SP_REGNUM >= 0)
|
|
/* Try SP_REGNUM last: this makes all sorts of [wrong] assumptions
|
|
about the architecture so put it at the end. */
|
|
return read_register (SP_REGNUM);
|
|
internal_error (__FILE__, __LINE__, "read_sp: Unable to find SP");
|
|
}
|
|
|
|
void
|
|
deprecated_write_sp (CORE_ADDR val)
|
|
{
|
|
gdb_assert (SP_REGNUM >= 0);
|
|
write_register (SP_REGNUM, val);
|
|
}
|
|
|
|
CORE_ADDR
|
|
deprecated_read_fp (void)
|
|
{
|
|
if (DEPRECATED_TARGET_READ_FP_P ())
|
|
return DEPRECATED_TARGET_READ_FP ();
|
|
else if (DEPRECATED_FP_REGNUM >= 0)
|
|
return read_register (DEPRECATED_FP_REGNUM);
|
|
else
|
|
internal_error (__FILE__, __LINE__, "deprecated_read_fp");
|
|
}
|
|
|
|
/* ARGSUSED */
|
|
static void
|
|
reg_flush_command (char *command, int from_tty)
|
|
{
|
|
/* Force-flush the register cache. */
|
|
registers_changed ();
|
|
if (from_tty)
|
|
printf_filtered ("Register cache flushed.\n");
|
|
}
|
|
|
|
static void
|
|
build_regcache (void)
|
|
{
|
|
current_regcache = regcache_xmalloc (current_gdbarch);
|
|
current_regcache->readonly_p = 0;
|
|
deprecated_registers = deprecated_grub_regcache_for_registers (current_regcache);
|
|
deprecated_register_valid = current_regcache->register_valid_p;
|
|
}
|
|
|
|
static void
|
|
dump_endian_bytes (struct ui_file *file, enum bfd_endian endian,
|
|
const unsigned char *buf, long len)
|
|
{
|
|
int i;
|
|
switch (endian)
|
|
{
|
|
case BFD_ENDIAN_BIG:
|
|
for (i = 0; i < len; i++)
|
|
fprintf_unfiltered (file, "%02x", buf[i]);
|
|
break;
|
|
case BFD_ENDIAN_LITTLE:
|
|
for (i = len - 1; i >= 0; i--)
|
|
fprintf_unfiltered (file, "%02x", buf[i]);
|
|
break;
|
|
default:
|
|
internal_error (__FILE__, __LINE__, "Bad switch");
|
|
}
|
|
}
|
|
|
|
enum regcache_dump_what
|
|
{
|
|
regcache_dump_none, regcache_dump_raw, regcache_dump_cooked, regcache_dump_groups
|
|
};
|
|
|
|
static void
|
|
regcache_dump (struct regcache *regcache, struct ui_file *file,
|
|
enum regcache_dump_what what_to_dump)
|
|
{
|
|
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;
|
|
int footnote_register_offset = 0;
|
|
int footnote_register_type_name_null = 0;
|
|
long register_offset = 0;
|
|
unsigned char buf[MAX_REGISTER_SIZE];
|
|
|
|
#if 0
|
|
fprintf_unfiltered (file, "legacy_p %d\n", regcache->descr->legacy_p);
|
|
fprintf_unfiltered (file, "nr_raw_registers %d\n",
|
|
regcache->descr->nr_raw_registers);
|
|
fprintf_unfiltered (file, "nr_cooked_registers %d\n",
|
|
regcache->descr->nr_cooked_registers);
|
|
fprintf_unfiltered (file, "sizeof_raw_registers %ld\n",
|
|
regcache->descr->sizeof_raw_registers);
|
|
fprintf_unfiltered (file, "sizeof_raw_register_valid_p %ld\n",
|
|
regcache->descr->sizeof_raw_register_valid_p);
|
|
fprintf_unfiltered (file, "NUM_REGS %d\n", NUM_REGS);
|
|
fprintf_unfiltered (file, "NUM_PSEUDO_REGS %d\n", NUM_PSEUDO_REGS);
|
|
#endif
|
|
|
|
gdb_assert (regcache->descr->nr_cooked_registers
|
|
== (NUM_REGS + NUM_PSEUDO_REGS));
|
|
|
|
for (regnum = -1; regnum < regcache->descr->nr_cooked_registers; regnum++)
|
|
{
|
|
/* Name. */
|
|
if (regnum < 0)
|
|
fprintf_unfiltered (file, " %-10s", "Name");
|
|
else
|
|
{
|
|
const char *p = REGISTER_NAME (regnum);
|
|
if (p == NULL)
|
|
p = "";
|
|
else if (p[0] == '\0')
|
|
p = "''";
|
|
fprintf_unfiltered (file, " %-10s", p);
|
|
}
|
|
|
|
/* Number. */
|
|
if (regnum < 0)
|
|
fprintf_unfiltered (file, " %4s", "Nr");
|
|
else
|
|
fprintf_unfiltered (file, " %4d", regnum);
|
|
|
|
/* Relative number. */
|
|
if (regnum < 0)
|
|
fprintf_unfiltered (file, " %4s", "Rel");
|
|
else if (regnum < NUM_REGS)
|
|
fprintf_unfiltered (file, " %4d", regnum);
|
|
else
|
|
fprintf_unfiltered (file, " %4d", (regnum - NUM_REGS));
|
|
|
|
/* Offset. */
|
|
if (regnum < 0)
|
|
fprintf_unfiltered (file, " %6s ", "Offset");
|
|
else
|
|
{
|
|
fprintf_unfiltered (file, " %6ld",
|
|
regcache->descr->register_offset[regnum]);
|
|
if (register_offset != regcache->descr->register_offset[regnum]
|
|
|| register_offset != REGISTER_BYTE (regnum)
|
|
|| (regnum > 0
|
|
&& (regcache->descr->register_offset[regnum]
|
|
!= (regcache->descr->register_offset[regnum - 1]
|
|
+ regcache->descr->sizeof_register[regnum - 1])))
|
|
)
|
|
{
|
|
if (!footnote_register_offset)
|
|
footnote_register_offset = ++footnote_nr;
|
|
fprintf_unfiltered (file, "*%d", footnote_register_offset);
|
|
}
|
|
else
|
|
fprintf_unfiltered (file, " ");
|
|
register_offset = (regcache->descr->register_offset[regnum]
|
|
+ regcache->descr->sizeof_register[regnum]);
|
|
}
|
|
|
|
/* Size. */
|
|
if (regnum < 0)
|
|
fprintf_unfiltered (file, " %5s ", "Size");
|
|
else
|
|
{
|
|
fprintf_unfiltered (file, " %5ld",
|
|
regcache->descr->sizeof_register[regnum]);
|
|
if ((regcache->descr->sizeof_register[regnum]
|
|
!= REGISTER_RAW_SIZE (regnum))
|
|
|| (regcache->descr->sizeof_register[regnum]
|
|
!= REGISTER_VIRTUAL_SIZE (regnum))
|
|
|| (regcache->descr->sizeof_register[regnum]
|
|
!= TYPE_LENGTH (register_type (regcache->descr->gdbarch,
|
|
regnum)))
|
|
)
|
|
{
|
|
if (!footnote_register_size)
|
|
footnote_register_size = ++footnote_nr;
|
|
fprintf_unfiltered (file, "*%d", footnote_register_size);
|
|
}
|
|
else
|
|
fprintf_unfiltered (file, " ");
|
|
}
|
|
|
|
/* Type. */
|
|
{
|
|
const char *t;
|
|
if (regnum < 0)
|
|
t = "Type";
|
|
else
|
|
{
|
|
static const char blt[] = "builtin_type";
|
|
t = TYPE_NAME (register_type (regcache->descr->gdbarch, regnum));
|
|
if (t == NULL)
|
|
{
|
|
char *n;
|
|
if (!footnote_register_type_name_null)
|
|
footnote_register_type_name_null = ++footnote_nr;
|
|
xasprintf (&n, "*%d", footnote_register_type_name_null);
|
|
make_cleanup (xfree, n);
|
|
t = n;
|
|
}
|
|
/* Chop a leading builtin_type. */
|
|
if (strncmp (t, blt, strlen (blt)) == 0)
|
|
t += strlen (blt);
|
|
}
|
|
fprintf_unfiltered (file, " %-15s", t);
|
|
}
|
|
|
|
/* Leading space always present. */
|
|
fprintf_unfiltered (file, " ");
|
|
|
|
/* Value, raw. */
|
|
if (what_to_dump == regcache_dump_raw)
|
|
{
|
|
if (regnum < 0)
|
|
fprintf_unfiltered (file, "Raw value");
|
|
else if (regnum >= regcache->descr->nr_raw_registers)
|
|
fprintf_unfiltered (file, "<cooked>");
|
|
else if (!regcache_valid_p (regcache, regnum))
|
|
fprintf_unfiltered (file, "<invalid>");
|
|
else
|
|
{
|
|
regcache_raw_read (regcache, regnum, buf);
|
|
fprintf_unfiltered (file, "0x");
|
|
dump_endian_bytes (file, TARGET_BYTE_ORDER, buf,
|
|
REGISTER_RAW_SIZE (regnum));
|
|
}
|
|
}
|
|
|
|
/* Value, cooked. */
|
|
if (what_to_dump == regcache_dump_cooked)
|
|
{
|
|
if (regnum < 0)
|
|
fprintf_unfiltered (file, "Cooked value");
|
|
else
|
|
{
|
|
regcache_cooked_read (regcache, regnum, buf);
|
|
fprintf_unfiltered (file, "0x");
|
|
dump_endian_bytes (file, TARGET_BYTE_ORDER, buf,
|
|
REGISTER_VIRTUAL_SIZE (regnum));
|
|
}
|
|
}
|
|
|
|
/* Group members. */
|
|
if (what_to_dump == regcache_dump_groups)
|
|
{
|
|
if (regnum < 0)
|
|
fprintf_unfiltered (file, "Groups");
|
|
else
|
|
{
|
|
int i;
|
|
const char *sep = "";
|
|
for (i = 0; groups[i] != NULL; i++)
|
|
{
|
|
if (gdbarch_register_reggroup_p (gdbarch, regnum, groups[i]))
|
|
{
|
|
fprintf_unfiltered (file, "%s%s", sep, reggroup_name (groups[i]));
|
|
sep = ",";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fprintf_unfiltered (file, "\n");
|
|
}
|
|
|
|
if (footnote_register_size)
|
|
fprintf_unfiltered (file, "*%d: Inconsistent register sizes.\n",
|
|
footnote_register_size);
|
|
if (footnote_register_offset)
|
|
fprintf_unfiltered (file, "*%d: Inconsistent register offsets.\n",
|
|
footnote_register_offset);
|
|
if (footnote_register_type_name_null)
|
|
fprintf_unfiltered (file,
|
|
"*%d: Register type's name NULL.\n",
|
|
footnote_register_type_name_null);
|
|
do_cleanups (cleanups);
|
|
}
|
|
|
|
static void
|
|
regcache_print (char *args, enum regcache_dump_what what_to_dump)
|
|
{
|
|
if (args == NULL)
|
|
regcache_dump (current_regcache, gdb_stdout, what_to_dump);
|
|
else
|
|
{
|
|
struct ui_file *file = gdb_fopen (args, "w");
|
|
if (file == NULL)
|
|
perror_with_name ("maintenance print architecture");
|
|
regcache_dump (current_regcache, file, what_to_dump);
|
|
ui_file_delete (file);
|
|
}
|
|
}
|
|
|
|
static void
|
|
maintenance_print_registers (char *args, int from_tty)
|
|
{
|
|
regcache_print (args, regcache_dump_none);
|
|
}
|
|
|
|
static void
|
|
maintenance_print_raw_registers (char *args, int from_tty)
|
|
{
|
|
regcache_print (args, regcache_dump_raw);
|
|
}
|
|
|
|
static void
|
|
maintenance_print_cooked_registers (char *args, int from_tty)
|
|
{
|
|
regcache_print (args, regcache_dump_cooked);
|
|
}
|
|
|
|
static void
|
|
maintenance_print_register_groups (char *args, int from_tty)
|
|
{
|
|
regcache_print (args, regcache_dump_groups);
|
|
}
|
|
|
|
extern initialize_file_ftype _initialize_regcache; /* -Wmissing-prototype */
|
|
|
|
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);
|
|
|
|
add_com ("flushregs", class_maintenance, reg_flush_command,
|
|
"Force gdb to flush its register cache (maintainer command)");
|
|
|
|
/* Initialize the thread/process associated with the current set of
|
|
registers. For now, -1 is special, and means `no current process'. */
|
|
registers_ptid = pid_to_ptid (-1);
|
|
|
|
add_cmd ("registers", class_maintenance,
|
|
maintenance_print_registers,
|
|
"Print the internal register configuration.\
|
|
Takes an optional file parameter.",
|
|
&maintenanceprintlist);
|
|
add_cmd ("raw-registers", class_maintenance,
|
|
maintenance_print_raw_registers,
|
|
"Print the internal register configuration including raw values.\
|
|
Takes an optional file parameter.",
|
|
&maintenanceprintlist);
|
|
add_cmd ("cooked-registers", class_maintenance,
|
|
maintenance_print_cooked_registers,
|
|
"Print the internal register configuration including cooked values.\
|
|
Takes an optional file parameter.",
|
|
&maintenanceprintlist);
|
|
add_cmd ("register-groups", class_maintenance,
|
|
maintenance_print_register_groups,
|
|
"Print the internal register configuration including each register's group.\
|
|
Takes an optional file parameter.",
|
|
&maintenanceprintlist);
|
|
|
|
}
|