darkkirb/old-cross-binutils
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

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

Browse source 
* regcache.h (regcache_cooked_read_using_offset_hack)
	(regcache_cooked_write_using_offset_hack): Delete declarations.
	(register_changed): Delete declaration.
	* regcache.c (regcache_cooked_read_using_offset_hack)
	(regcache_cooked_write_using_offset_hack): Delete functions.
	(cooked_xfer_using_offset_hack): Delete function.
	(register_changed): Delete function.
This commit is contained in:
Andrew Cagney 2002-11-07 21:43:23 +00:00
parent 568f87394b
commit e600bd345d
3 changed files with 16 additions and 110 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

10
gdb/ChangeLog
View file

@ -1,3 +1,13 @@
2002-11-07 Andrew Cagney <ac131313@redhat.com>
* regcache.h (regcache_cooked_read_using_offset_hack)
(regcache_cooked_write_using_offset_hack): Delete declarations.
(register_changed): Delete declaration.
* regcache.c (regcache_cooked_read_using_offset_hack)
(regcache_cooked_write_using_offset_hack): Delete functions.
(cooked_xfer_using_offset_hack): Delete function.
(register_changed): Delete function.
2002-11-07 Jim Blandy <jimb@redhat.com>
* macroscope.c: #include "complaints.h".

87
gdb/regcache.c
View file

@ -474,15 +474,6 @@ set_register_cached (int regnum, int state)
current_regcache->raw_register_valid_p[regnum] = state;
}
/* REGISTER_CHANGED
invalidate a single register REGNUM in the cache */
void
register_changed (int regnum)
{
set_register_cached (regnum, 0);
}
/* If REGNUM >= 0, return a pointer to register REGNUM's cache buffer area,
else return a pointer to the start of the cache buffer. */
@ -1064,84 +1055,6 @@ register_offset_hack (struct gdbarch *gdbarch, int regnum)
return descr->register_offset[regnum];
}
static void
cooked_xfer_using_offset_hack (struct regcache *regcache,
int buf_start, int buf_len, void *in_b,
const void *out_b)
{
struct regcache_descr *descr = regcache->descr;
struct gdbarch *gdbarch = descr->gdbarch;
bfd_byte *in_buf = in_b;
const bfd_byte *out_buf = out_b;
int buf_end = buf_start + buf_len;
int regnum;
char *reg_buf = alloca (descr->max_register_size);
/* NOTE: cagney/2002-08-17: This code assumes that the register
offsets are strictly increasing and do not overlap. If this
isn't the case then the bug is in the target architecture and NOT
this code. */
/* NOTE: cagney/2002-08-17: This code assumes that only the
registers covered by BUF_START:BUF_LEN should be transfered. If,
for some reason, there is a gap between two registers, then that
gap isn't transfered. (The gap shouldn't be there but that is
another story.) */
/* Iterate through all registers looking for those that lie within
BUF_START:BUF_LEN. */
for (regnum = 0; regnum < descr->nr_cooked_registers; regnum++)
{
/* The register's location. */
int reg_start = descr->register_offset[regnum];
int reg_len = descr->sizeof_register[regnum];
int reg_end = reg_start + reg_len;
/* The START, END and LEN that falls within the current
register. */
int xfer_start;
int xfer_end;
int xfer_len;
/* start = max (reg_start, buf_start) */
if (reg_start > buf_start)
xfer_start = reg_start;
else
xfer_start = buf_start;
/* end = min (reg_end, buf_end) */
if (reg_end < buf_end)
xfer_end = reg_end;
else
xfer_end = buf_end;
/* The number of bytes to transfer. If there isn't anything to
transfer (the end is before the start) this will be -ve. */
xfer_len = xfer_end - xfer_start;
if (xfer_len > 0)
regcache_xfer_part (regcache, regnum, xfer_start - reg_start,
xfer_len, in_b, out_b, regcache_cooked_read,
regcache_cooked_write);
}
}
void
regcache_cooked_read_using_offset_hack (struct regcache *regcache,
int buf_start, int buf_len, void *b)
{
cooked_xfer_using_offset_hack (regcache, buf_start, buf_len, b, NULL);
}
void
regcache_cooked_write_using_offset_hack (struct regcache *regcache,
int buf_start, int buf_len,
const void *b)
{
cooked_xfer_using_offset_hack (regcache, buf_start, buf_len, NULL, b);
}
/* Return the contents of register REGNUM as an unsigned integer. */
ULONGEST

29
gdb/regcache.h
View file

@ -94,29 +94,14 @@ extern void regcache_collect (int regnum, void *buf);
/* The register's ``offset''.
NOTE: cagney/2002-08-17: The ``struct value'' and expression
evaluator treat the register cache as a large liner buffer.
Instead of reading/writing a register using its register number,
the code read/writes registers by specifying their offset into the
buffer and a number of bytes. The code also assumes that these
byte read/writes can cross register boundaries, adjacent registers
treated as a contiguous set of bytes.
The below map that model onto the real register cache. New code
should go out of their way to avoid using these interfaces.
FIXME: cagney/2002-08-17: The ``struct value'' and expression
evaluator should be fixed. Instead of using the { offset, length }
pair to describe a value within one or more registers, the code
should use a chain of { regnum, offset, len } tripples. */
FIXME: cagney/2002-11-07: The get_saved_register() function, when
specifying the real location of a register, does so using that
registers offset in the register cache. That offset is then used
by valops.c to determine the location of the register. The code
should instead use the register's number and a location expression
to describe a value spread across multiple registers or memory. */
extern int register_offset_hack (struct gdbarch *gdbarch, int regnum);
extern void regcache_cooked_read_using_offset_hack (struct regcache *regcache,
int offset, int len,
void *buf);
extern void regcache_cooked_write_using_offset_hack (struct regcache *regcache,
int offset, int len,
const void *buf);
/* The type of a register. This function is slightly more efficient
@ -201,8 +186,6 @@ extern int register_cached (int regnum);
extern void set_register_cached (int regnum, int state);
extern void register_changed (int regnum);
extern void registers_changed (void);