Re: [PATCH] Simplify regcache_cpy and remove regcache::cpy_no_passthrough

[Alan Hayward <Alan.Hayward@arm.com>]

> On 27 Jun 2017, at 08:37, Yao Qi <qiyaoltc@gmail.com> wrote:
> 
> Nowadays, regcache_cpy is used where src is read-only and dst is not
> read-only, so the regcache_cpy can be simplified to handle this case only.
> As a result, regcache::cpy_no_passthrough, which is about two read-only
> regcache copy, is no longer used, remove it as well.
> 

I like the simplification.

But, I don’t think it’s clear that regcache_cpy now only handles the single case
of read-only src with !read-only dest. It only becomes clear after reading the
gdb_asserts.

Would it be better to remove regcache_cpy completely?
There are only three places that use it, and they would call (for example)
get_current_regcache ()->restore (scratch) instead.
That would make the caller code clearer, and would remove an outside the class
regcache_ function.

If not, then there should be a comment above regcache_cpy stating the
restrictions.

> Regression tested on x86_64-linux, both native and gdbserver.
> 
> gdb:
> 
> 2017-06-27  Yao Qi  <yao.qi@linaro.org>
> 
> 	* regcache.c (regcache_cpy): Simplify it.
> 	(regcache::cpy_no_passthrough): Remove it.
> 	* regcache.h (cpy_no_passthrough): Remove it.
> ---
> gdb/regcache.c | 31 ++-----------------------------
> gdb/regcache.h |  2 --
> 2 files changed, 2 insertions(+), 31 deletions(-)
> 
> diff --git a/gdb/regcache.c b/gdb/regcache.c
> index 7eeb737..e8f92d6 100644
> --- a/gdb/regcache.c
> +++ b/gdb/regcache.c
> @@ -388,36 +388,9 @@ regcache_cpy (struct regcache *dst, struct regcache *src)
>   gdb_assert (src != NULL && dst != NULL);
>   gdb_assert (src->m_descr->gdbarch == dst->m_descr->gdbarch);
>   gdb_assert (src != dst);
> -  gdb_assert (src->m_readonly_p || dst->m_readonly_p);
> +  gdb_assert (src->m_readonly_p && !dst->m_readonly_p);
> 
> -  if (!src->m_readonly_p)
> -    regcache_save (dst, do_cooked_read, src);
> -  else if (!dst->m_readonly_p)
> -    dst->restore (src);
> -  else
> -    dst->cpy_no_passthrough (src);
> -}
> -
> -/* Copy/duplicate the contents of a register cache.  Unlike regcache_cpy,
> -   which is pass-through, this does not go through to the target.
> -   Only values values already in the cache are transferred.  The SRC and DST
> -   buffers must not overlap.  */
> -
> -void
> -regcache::cpy_no_passthrough (struct regcache *src)
> -{
> -  gdb_assert (src != NULL);
> -  gdb_assert (src->m_descr->gdbarch == m_descr->gdbarch);
> -  /* NOTE: cagney/2002-05-17: Don't let the caller do a no-passthrough
> -     move of data into a thread's regcache.  Doing this would be silly
> -     - it would mean that regcache->register_status would be
> -     completely invalid.  */
> -  gdb_assert (m_readonly_p && src->m_readonly_p);
> -
> -  memcpy (m_registers, src->m_registers,
> -	  m_descr->sizeof_cooked_registers);
> -  memcpy (m_register_status, src->m_register_status,
> -	  m_descr->sizeof_cooked_register_status);
> +  dst->restore (src);
> }
> 
> struct regcache *
> diff --git a/gdb/regcache.h b/gdb/regcache.h
> index b416d5e..03c042a 100644
> --- a/gdb/regcache.h
> +++ b/gdb/regcache.h
> @@ -369,8 +369,6 @@ private:
> 
>   void restore (struct regcache *src);
> 
> -  void cpy_no_passthrough (struct regcache *src);
> -
>   enum register_status xfer_part (int regnum, int offset, int len, void *in,
> 				  const void *out,
> 				  decltype (regcache_raw_read) read,
> -- 
> 1.9.1
> 

Alan.