Hello,

I was investigating some behaviour change after a 6.3->6.4 migration and
found this out:

It seems the gdb_byte-ification of regcache has been a bit to zealous.
struct regcache uses an array of chars to store the status of each
register in the cache. This array has been converted to an array of
gdb_bytes which doesn't make any sense as it's not a target buffer, and
moreover it prevents the cache status from being negative. This is an
issue if you look at the register_cached function:

/* 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];
}

This means that with the current code, when a target sets as register as
unavailable, it will be wrongly reported as fetched. 

If you wonder if any target uses this, remote.c has code setting
registers as unavailable in remote_fetch_register and
fetch_registers_using_p.

The observable symptom is that for example 'info register' will display
a 0 value instead of "*value not available*". Some variables will also
get a 0 value instead of an unknown value.

The attached patch fixes this by declaring register_valid_p as a signed
char array and also adds a comment (partly copied from the
register_cached one).

:ADDPATCH regcache:

While reading the code to find this out, I also noticed a little
inconsistency. I don't really think this deserves a fix, but I thought
I'd mention it anyway. 
Most people are using dwarf2 as debug format today, and with dwarf2
symbols in registers are marked as LOC_COMPUTED. The read_var_value
function will return NULL when a dwarf2 computed symbol needs access to
a register that the target has marked as unavailable (register_valid_p <
0). This will make functions like print_frame_args output something like
"my_var=???" for the unavailable var value.
Yet if you use another debug format that marks the symbol as
LOC_REGISTER, read_var_value will call error() if it can't read the
register which is a lot more radical than the above behaviour. 


Regards,
Fred