Re: read_register_byte can't work with pseudo-reg model

[Andrew Cagney <ac131313 at cygnus dot com>]

> Given the following code in read_register_byte:

[read_register_bytes]

>      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.  */
> 	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, registers + reg_start, reg_len);

I'm guessing. Try:

	if (REGISTER_READ_P ())
	  {
	    do something fairly sane;
	  }
	else
	  {
	    all the legacy cruft including the call to
	    legacy_read_register_gen() and that test.
	  }

Thing is that there is only one target in the FSF using 
READ_REGISTER_P() so there is this dividing line - something using 
read_register_p() can be given far stronger requirements than for the 
older code.

``do something sane'' would be go straight through to the raw cache 
(regcache_read) for [0..REG_NUM) and go via READ_REGISTER() for anything 
else.

Elena, how would sh5 cope with this change?

> Then the new model of having all named registers be pseudos will never 
> re-read the registers, because all registers with an entry in registers[] 
> will not have a name.
> 
> Shouldn't the "REGISTER_NAME" check be a direct check for 
> register_cached(regno) == 0
> 
> That would mean that we could change the above to be something like
> 
>      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_cached (regnum) == 0)
> 	/* Force the cache to fetch the entire register.  */
> 	legacy_read_register_gen (regnum, reg_buf);

Thinking about it, my sugestion isn't sufficent :-(  One of the problems 
with read_register_bytes is that it is used to both read the raw 
register cache (a rawreg thing) and read sequences of pseudo registers 
(a cookedreg thing).

>       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, registers + reg_start, reg_len);
> 
> Though I'm still not sure what we should do for a pseudo with no entry in 
> the cache.

Andrew