OpenE2K/binutils-gdb
12
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

* regcache.c (regcache_invalidate): New function.

Browse Source 
(register_cached): Remove.
	(set_register_cached): Remove.
	(deprecated_registers_fetched): Remove.
	(registers_changed): Use regcache_invalidate instead
	of set_register_cached.
	(regcache_raw_read): Update comment.

	* regcache.h (regcache_invalidate): Add prototype.
	(register_cached): Remove.
	(set_register_cached): Remove.
	(deprecated_registers_fetched): Remove.

	* findvar.c (value_of_register): Do not call register_cached.
	* frame.c (frame_register): Likewise.
	* tui/tui-regs.c (tui_get_register): Likewise.

	* remote.c (fetch_register_using_p): Do not call set_register_cached.
	(process_g_packet): Likewise.
	(remote_fetch_registers): Likewise.
	* remote-sim.c (gdbsim_fetch_register): Likewise.
	* mt-tdep.c (mt_select_coprocessor): Replace set_register_cached call
	by regcache_invalidate.
	(mt_pseudo_register_write): Likewise.
	* sh-tdep.c (sh_pseudo_register_write): Likewise.

	* corelow.c (get_core_registers): Replace deprecated_registers_fetched
	call by loop over regcache_raw_supply (..., NULL).
This commit is contained in:
Ulrich Weigand 2007-05-06 19:37:31 +00:00
parent 316f20603a
commit 9c5ea4d965
11 changed files with 73 additions and 113 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

31
gdb/ChangeLog
View File

@ -1,3 +1,34 @@
2007-05-06 Ulrich Weigand <uweigand@de.ibm.com>
* regcache.c (regcache_invalidate): New function.
(register_cached): Remove.
(set_register_cached): Remove.
(deprecated_registers_fetched): Remove.
(registers_changed): Use regcache_invalidate instead
of set_register_cached.
(regcache_raw_read): Update comment.
* regcache.h (regcache_invalidate): Add prototype.
(register_cached): Remove.
(set_register_cached): Remove.
(deprecated_registers_fetched): Remove.
* findvar.c (value_of_register): Do not call register_cached.
* frame.c (frame_register): Likewise.
* tui/tui-regs.c (tui_get_register): Likewise.
* remote.c (fetch_register_using_p): Do not call set_register_cached.
(process_g_packet): Likewise.
(remote_fetch_registers): Likewise.
* remote-sim.c (gdbsim_fetch_register): Likewise.
* mt-tdep.c (mt_select_coprocessor): Replace set_register_cached call
by regcache_invalidate.
(mt_pseudo_register_write): Likewise.
* sh-tdep.c (sh_pseudo_register_write): Likewise.
* corelow.c (get_core_registers): Replace deprecated_registers_fetched
call by loop over regcache_raw_supply (..., NULL).
2007-05-06 Ulrich Weigand <uweigand@de.ibm.com>
* target.h (struct target_ops): Add REGCACHE parameter to

7
gdb/corelow.c
View File

@ -485,7 +485,7 @@ get_core_register_section (struct regcache *regcache,
static void
get_core_registers (struct regcache *regcache, int regno)
{
int status;
int i;
if (!(core_gdbarch && gdbarch_regset_from_core_section_p (core_gdbarch))
&& (core_vec == NULL || core_vec->core_read_registers == NULL))
@ -502,7 +502,10 @@ get_core_registers (struct regcache *regcache, int regno)
get_core_register_section (regcache,
".reg-xfp", 3, "extended floating-point", 0);
deprecated_registers_fetched ();
/* Supply dummy value for all registers not found in the core. */
for (i = 0; i < NUM_REGS; i++)
if (!regcache_valid_p (regcache, i))
regcache_raw_supply (regcache, i, NULL);
}
static void

15
gdb/findvar.c
View File

@ -250,10 +250,7 @@ store_typed_address (gdb_byte *buf, struct type *type, CORE_ADDR addr)
/* Return a `value' with the contents of (virtual or cooked) register
REGNUM as found in the specified FRAME. The register's type is
determined by register_type().
NOTE: returns NULL if register value is not available. Caller will
check return value or die! */
determined by register_type(). */
struct value *
value_of_register (int regnum, struct frame_info *frame)
@ -272,16 +269,6 @@ value_of_register (int regnum, struct frame_info *frame)
frame_register (frame, regnum, &optim, &lval, &addr, &realnum, raw_buffer);
/* FIXME: cagney/2002-05-15: This test is just bogus.
It indicates that the target failed to supply a value for a
register because it was "not available" at this time. Problem
is, the target still has the register and so get saved_register()
may be returning a value saved on the stack. */
if (register_cached (regnum) < 0)
return NULL; /* register value not available */
reg_val = allocate_value (register_type (current_gdbarch, regnum));
memcpy (value_contents_raw (reg_val), raw_buffer,

10
gdb/frame.c
View File

@ -738,16 +738,6 @@ frame_register_read (struct frame_info *frame, int regnum,
int realnum;
frame_register (frame, regnum, &optimized, &lval, &addr, &realnum, myaddr);
/* FIXME: cagney/2002-05-15: This test is just bogus.
It indicates that the target failed to supply a value for a
register because it was "not available" at this time. Problem
is, the target still has the register and so get saved_register()
may be returning a value saved on the stack. */
if (register_cached (regnum) < 0)
return 0; /* register value not available */
return !optimized;
}

4
gdb/mt-tdep.c
View File

@ -495,7 +495,7 @@ mt_select_coprocessor (struct gdbarch *gdbarch,
/* We must flush the cache, as it is now invalid. */
for (ix = MT_NUM_CPU_REGS; ix != MT_NUM_REGS; ix++)
set_register_cached (ix, 0);
regcache_invalidate (regcache, ix);
}
return index;
@ -573,7 +573,7 @@ mt_pseudo_register_write (struct gdbarch *gdbarch,
case MT_COPRO_PSEUDOREG_REGNUM:
regcache_raw_write (regcache, MT_COPRO_REGNUM, buf);
for (i = MT_NUM_CPU_REGS; i < MT_NUM_REGS; i++)
set_register_cached (i, 0);
regcache_invalidate (regcache, i);
break;
case MT_MAC_REGNUM:
case MT_MAC_PSEUDOREG_REGNUM:

61
gdb/regcache.c
View File

@ -393,6 +393,17 @@ regcache_valid_p (const struct regcache *regcache, int regnum)
return regcache->register_valid_p[regnum];
}
void
regcache_invalidate (struct regcache *regcache, int regnum)
{
gdb_assert (regcache != NULL);
gdb_assert (regnum >= 0);
gdb_assert (!regcache->readonly_p);
gdb_assert (regnum < regcache->descr->nr_raw_registers);
regcache->register_valid_p[regnum] = 0;
}
/* 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. */
@ -407,33 +418,6 @@ struct regcache *current_regcache;
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 current_regcache->register_valid_p[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;
}
/* Observer for the target_changed event. */
void
@ -468,28 +452,9 @@ registers_changed (void)
alloca (0);
for (i = 0; i < current_regcache->descr->nr_raw_registers; i++)
set_register_cached (i, 0);
regcache_invalidate (current_regcache, i);
}
/* DEPRECATED_REGISTERS_FETCHED ()
Indicate that all registers have been fetched, so mark them all valid. */
/* 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 regcache_raw_supply() 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. */
}
void
regcache_raw_read (struct regcache *regcache, int regnum, gdb_byte *buf)
@ -517,7 +482,7 @@ regcache_raw_read (struct regcache *regcache, int regnum, gdb_byte *buf)
that a register is in one of the possible states: valid,
undefined, unknown. The last of which isn't yet
possible. */
gdb_assert (register_cached (regnum));
gdb_assert (regcache_valid_p (regcache, regnum));
#endif
}
/* Copy the value directly into the register cache. */

10
gdb/regcache.h
View File

@ -61,6 +61,8 @@ void regcache_raw_write_part (struct regcache *regcache, int regnum,
int regcache_valid_p (const struct regcache *regcache, int regnum);
void regcache_invalidate (struct regcache *regcache, int regnum);
/* Transfer a cooked register [0..NUM_REGS+NUM_PSEUDO_REGS). */
void regcache_cooked_read (struct regcache *regcache, int rawnum,
gdb_byte *buf);
@ -157,14 +159,6 @@ extern struct regcache *regcache_dup_no_passthrough (struct regcache *regcache);
extern void regcache_cpy (struct regcache *dest, struct regcache *src);
extern void regcache_cpy_no_passthrough (struct regcache *dest, struct regcache *src);
/* NOTE: cagney/2002-11-05: This function has been superseeded by
regcache_raw_supply(). */
extern void deprecated_registers_fetched (void);
extern int register_cached (int regnum);
extern void set_register_cached (int regnum, int state);
extern void registers_changed (void);

1
gdb/remote-sim.c
View File

@ -300,7 +300,6 @@ gdbsim_fetch_register (struct regcache *regcache, int regno)
int nr_bytes;
memset (buf, 0, MAX_REGISTER_SIZE);
regcache_raw_supply (regcache, regno, buf);
set_register_cached (regno, -1);
break;
}

4
gdb/remote.c
View File

@ -3522,7 +3522,6 @@ fetch_register_using_p (struct regcache *regcache, struct packet_reg *reg)
if (buf[0] == 'x')
{
regcache_raw_supply (regcache, reg->regnum, NULL);
set_register_cached (reg->regnum, -1);
return 1;
}
@ -3661,7 +3660,6 @@ process_g_packet (struct regcache *regcache)
/* The register isn't available, mark it as such (at
the same time setting the value to zero). */
regcache_raw_supply (regcache, r->regnum, NULL);
set_register_cached (i, -1);
}
else
regcache_raw_supply (regcache, r->regnum,
@ -3708,7 +3706,6 @@ remote_fetch_registers (struct regcache *regcache, int regnum)
/* This register is not available. */
regcache_raw_supply (regcache, reg->regnum, NULL);
set_register_cached (reg->regnum, -1);
return;
}
@ -3721,7 +3718,6 @@ remote_fetch_registers (struct regcache *regcache, int regnum)
{
/* This register is not available. */
regcache_raw_supply (regcache, i, NULL);
set_register_cached (i, -1);
}
}

2
gdb/sh-tdep.c
View File

@ -2055,7 +2055,7 @@ sh_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
regcache_raw_write (regcache, BANK_REGNUM, buffer);
for (bregnum = R0_BANK0_REGNUM; bregnum < MACLB_REGNUM; ++bregnum)
set_register_cached (bregnum, 0);
regcache_invalidate (regcache, bregnum);
}
else if (reg_nr >= DR0_REGNUM && reg_nr <= DR_LAST_REGNUM)
{

41
gdb/tui/tui-regs.c
View File

@ -710,32 +710,27 @@ tui_get_register (struct gdbarch *gdbarch, struct frame_info *frame,
if (target_has_registers)
{
gdb_byte buf[MAX_REGISTER_SIZE];
get_frame_register (frame, regnum, buf);
/* NOTE: cagney/2003-03-13: This is bogus. It is refering to
the register cache and not the frame which could have pulled
the register value off the stack. */
if (register_cached (regnum) >= 0)
{
if (changedp)
{
int size = register_size (gdbarch, regnum);
char *old = (char*) data->value;
int i;
for (i = 0; i < size; i++)
if (buf[i] != old[i])
{
*changedp = TRUE;
old[i] = buf[i];
}
}
if (changedp)
{
int size = register_size (gdbarch, regnum);
char *old = (char*) data->value;
int i;
/* Reformat the data content if the value changed. */
if (changedp == 0 || *changedp == TRUE)
tui_register_format (gdbarch, frame, data, regnum);
ret = TUI_SUCCESS;
}
for (i = 0; i < size; i++)
if (buf[i] != old[i])
{
*changedp = TRUE;
old[i] = buf[i];
}
}
/* Reformat the data content if the value changed. */
if (changedp == 0 || *changedp == TRUE)
tui_register_format (gdbarch, frame, data, regnum);
ret = TUI_SUCCESS;
}
return ret;
}