[25/26] gdbserver: refuse null argument in regcache::supply_regblock

  The regcache::supply_regblock method implements two different
behaviors based on whether its 'buf' argument is null.  The null
behavior is used only in tracepoint.cc.  Refuse the null pointer
argument and use the 'discard' method to obtain that second behavior.

Note that the original code resets register statuses to
REG_UNAVAILABLE, but 'discard' sets them to REG_UNKNOWN.  For the
current purposes of resetting the regcache, the difference does not
seem to be important.
---
 gdbserver/regcache.cc   | 19 +++++--------------
 gdbserver/regcache.h    |  3 +--
 gdbserver/tracepoint.cc |  8 ++++----
 3 files changed, 10 insertions(+), 20 deletions(-)
  

On 2023-02-28 06:28, Tankut Baris Aktemur via Gdb-patches wrote:
> The regcache::supply_regblock method implements two different
> behaviors based on whether its 'buf' argument is null.  The null
> behavior is used only in tracepoint.cc.  Refuse the null pointer
> argument and use the 'discard' method to obtain that second behavior.
> 
> Note that the original code resets register statuses to
> REG_UNAVAILABLE, but 'discard' sets them to REG_UNKNOWN.  For the
> current purposes of resetting the regcache, the difference does not
> seem to be important.

Ah, glad to see this, it matches one of my comment on an earlier patch
(and as you can see, I read patch series in a very linear way with no
lookahead).

In the spots inside the in-process agent, the regcache doesn't even
track statuses, so it doesn't make a difference indeed.

> diff --git a/gdbserver/tracepoint.cc b/gdbserver/tracepoint.cc
> index 9833e7c3b0f..9622d53cd82 100644
> --- a/gdbserver/tracepoint.cc
> +++ b/gdbserver/tracepoint.cc
> @@ -4707,7 +4707,7 @@ get_context_regcache (struct tracepoint_hit_ctx *ctx)
>  	{
>  	  fctx->regcache_initted = 1;
>  	  fctx->regcache.initialize (ipa_tdesc, fctx->regspace);
> -	  fctx->regcache.supply_regblock (nullptr);
> +	  fctx->regcache.discard ();
>  	  supply_fast_tracepoint_registers (&fctx->regcache, fctx->regs);

I think the call to discard is pointless.  The call to discard does (and
should) pretty much bring the regcache back to its state just after
initialization.  In this case, it was initialized at the line just before.

>  	}
>        regcache = &fctx->regcache;
> @@ -4722,7 +4722,7 @@ get_context_regcache (struct tracepoint_hit_ctx *ctx)
>  	{
>  	  sctx->regcache_initted = 1;
>  	  sctx->regcache.initialize (ipa_tdesc, sctx->regspace);
> -	  sctx->regcache.supply_regblock (nullptr);
> +	  sctx->regcache.discard ();

Same here.

>  	  /* Pass down the tracepoint address, because REGS doesn't
>  	     include the PC, but we know what it must have been.  */
>  	  supply_static_tracepoint_registers (&sctx->regcache,
> @@ -5179,8 +5179,8 @@ fetch_traceframe_registers (int tfnum, struct regcache *regcache, int regnum)
>    dataptr = traceframe_find_regblock (tframe, tfnum);
>    if (dataptr == NULL)
>      {
> -      /* Mark registers unavailable.  */
> -      regcache->supply_regblock (nullptr);
> +      /* Wipe out the cache.  */
> +      regcache->discard ();

So, I think this is a spot where you would actually want to make the
registers REG_UNAVAILABLE.  We are filling a regcache meant to represent
the registers that were collected when hitting a given tracepoint.  If
traceframe_find_regblock returns nullptr, I guess it means that we
didn't collect the registers.  So all registers are unavailable.

In practice, it won't make a difference, because that regcache is then
fed to registers_to_string, which will have the same behavior for
REG_UNAVAILABLE and REG_UNKNOWN.  But if you want to be accurate, I
think that REG_UNAVAILABLE makes more sense here.

Simon