[PATCH 1/4] gdb: rename regcache::current_regcache to regcache::regcaches

Simon Marchi
2020-07-20T20:41:23Z

The name `current_regcache` for the list of currently-existing regcaches
sounds wrong. The name is singular, but it holds multiple regcaches, so
it could at least be `current_regcaches`.

But in other places in GDB, "current" usually means "the object we are
working with right now". For example, we swap the "current thread" when
we want to operate on a given thread. This is not the case here, this
variable just holds all regcaches that exist at any given time, not "the
regcache we are working with right now".

So, I think calling it `regcaches` is better. I also considered
`regcache_list`, but a subsequent patch will make it a map and not a
list, so it would sound wrong again. `regcaches` sounds right for any
collection of regcache, whatever the type.

Rename a few other things that were related to this `current_regcache`
field. Note that there is a `get_current_regcache` function, which
returns the regcache of the current thread. That one is fine, because
it returns the regcache for the current thread.

gdb/ChangeLog:

* regcache.h (class regcache) <current_regcache>: Rename to...
<regcaches>: ... this. Move doc here.
* regcache.c (regcache::current_regcache) Rename to...
(regcache::regcaches): ... this. Move doc to header.
(get_thread_arch_aspace_regcache): Update.
(regcache::regcache_thread_ptid_changed): Update.
(registers_changed_ptid): Update.
(class regcache_access) <current_regcache_size>: Rename to...
<regcaches_size>: ... this.
(current_regcache_test): Rename to...
(regcaches_test): ... this.
(_initialize_regcache): Update.

Change-Id: I87de67154f5fe17a1f6aee7c4f2036647ee27b99
---
gdb/regcache.c | 60 ++++++++++++++++++++++++--------------------------
gdb/regcache.h | 2 +-
2 files changed, 30 insertions(+), 32 deletions(-)

diff --git a/gdb/regcache.c b/gdb/regcache.c
index 4ebb8cb04527..3d8e4adf0efd 100644
--- a/gdb/regcache.c
+++ b/gdb/regcache.c
@@ -319,7 +319,7 @@ reg_buffer::assert_regnum (int regnum) const
recording if the register values have been changed (eg. by the
user). Therefore all registers must be written back to the
target when appropriate. */
-std::forward_list<regcache *> regcache::current_regcache;
+std::forward_list<regcache *> regcache::regcaches;

struct regcache *
get_thread_arch_aspace_regcache (process_stratum_target *target,
@@ -328,7 +328,7 @@ get_thread_arch_aspace_regcache (process_stratum_target *target,
{
gdb_assert (target != nullptr);

- for (const auto &regcache : regcache::current_regcache)
+ for (const auto &regcache : regcache::regcaches)
if (regcache->target () == target
&& regcache->ptid () == ptid
&& regcache->arch () == gdbarch)
@@ -336,7 +336,7 @@ get_thread_arch_aspace_regcache (process_stratum_target *target,

regcache *new_regcache = new regcache (target, gdbarch, aspace);

- regcache::current_regcache.push_front (new_regcache);
+ regcache::regcaches.push_front (new_regcache);
new_regcache->set_ptid (ptid);

return new_regcache;
@@ -417,7 +417,7 @@ regcache_observer_target_changed (struct target_ops *target)
void
regcache::regcache_thread_ptid_changed (ptid_t old_ptid, ptid_t new_ptid)
{
- for (auto &regcache : regcache::current_regcache)
+ for (auto &regcache : regcache::regcaches)
{
if (regcache->ptid () == old_ptid)
regcache->set_ptid (new_ptid);
@@ -438,17 +438,15 @@ regcache::regcache_thread_ptid_changed (ptid_t old_ptid, ptid_t new_ptid)
void
registers_changed_ptid (process_stratum_target *target, ptid_t ptid)
{
- for (auto oit = regcache::current_regcache.before_begin (),
- it = std::next (oit);
- it != regcache::current_regcache.end ();
- )
+ for (auto oit = regcache::regcaches.before_begin (), it = std::next (oit);
+ it != regcache::regcaches.end (); )
{
struct regcache *regcache = *it;
if ((target == nullptr || regcache->target () == target)
&& regcache->ptid ().matches (ptid))
{
delete regcache;
- it = regcache::current_regcache.erase_after (oit);
+ it = regcache::regcaches.erase_after (oit);
}
else
oit = it++;
@@ -1437,13 +1435,13 @@ class regcache_access : public regcache
{
public:

- /* Return the number of elements in current_regcache. */
+ /* Return the number of elements in regcache::regcaches. */

static size_t
- current_regcache_size ()
+ regcaches_size ()
{
- return std::distance (regcache::current_regcache.begin (),
- regcache::current_regcache.end ());
+ return std::distance (regcache::regcaches.begin (),
+ regcache::regcaches.end ());
}
};

@@ -1463,10 +1461,10 @@ test_get_thread_arch_aspace_regcache (process_stratum_target *target,
}

static void
-current_regcache_test (void)
+regcaches_test (void)
{
/* It is empty at the start. */
- SELF_CHECK (regcache_access::current_regcache_size () == 0);
+ SELF_CHECK (regcache_access::regcaches_size () == 0);

ptid_t ptid1 (1), ptid2 (2), ptid3 (3);

@@ -1474,57 +1472,57 @@ current_regcache_test (void)
test_target_ops test_target2;

/* Get regcache from (target1,ptid1), a new regcache is added to
- current_regcache. */
+ regcache::regcaches. */
test_get_thread_arch_aspace_regcache (&test_target1, ptid1,
target_gdbarch (),
NULL);
- SELF_CHECK (regcache_access::current_regcache_size () == 1);
+ SELF_CHECK (regcache_access::regcaches_size () == 1);

/* Get regcache from (target1,ptid2), a new regcache is added to
- current_regcache. */
+ regcache::regcaches. */
test_get_thread_arch_aspace_regcache (&test_target1, ptid2,
target_gdbarch (),
NULL);
- SELF_CHECK (regcache_access::current_regcache_size () == 2);
+ SELF_CHECK (regcache_access::regcaches_size () == 2);

/* Get regcache from (target1,ptid3), a new regcache is added to
- current_regcache. */
+ regcache::regcaches. */
test_get_thread_arch_aspace_regcache (&test_target1, ptid3,
target_gdbarch (),
NULL);
- SELF_CHECK (regcache_access::current_regcache_size () == 3);
+ SELF_CHECK (regcache_access::regcaches_size () == 3);

/* Get regcache from (target1,ptid2) again, nothing is added to
- current_regcache. */
+ regcache::regcaches. */
test_get_thread_arch_aspace_regcache (&test_target1, ptid2,
target_gdbarch (),
NULL);
- SELF_CHECK (regcache_access::current_regcache_size () == 3);
+ SELF_CHECK (regcache_access::regcaches_size () == 3);

/* Get regcache from (target2,ptid2), a new regcache is added to
- current_regcache, since this time we're using a differen
+ regcache::regcaches, since this time we're using a differen
target. */
test_get_thread_arch_aspace_regcache (&test_target2, ptid2,
target_gdbarch (),
NULL);
- SELF_CHECK (regcache_access::current_regcache_size () == 4);
+ SELF_CHECK (regcache_access::regcaches_size () == 4);

/* Mark that (target1,ptid2) changed. The regcache of (target1,
- ptid2) should be removed from current_regcache. */
+ ptid2) should be removed from regcache::regcaches. */
registers_changed_ptid (&test_target1, ptid2);
- SELF_CHECK (regcache_access::current_regcache_size () == 3);
+ SELF_CHECK (regcache_access::regcaches_size () == 3);

/* Get the regcache from (target2,ptid2) again, confirming the
registers_changed_ptid call above did not delete it. */
test_get_thread_arch_aspace_regcache (&test_target2, ptid2,
target_gdbarch (),
NULL);
- SELF_CHECK (regcache_access::current_regcache_size () == 3);
+ SELF_CHECK (regcache_access::regcaches_size () == 3);

/* Confirm that marking all regcaches of all targets as changed
- clears current_regcache. */
+ clears regcache::regcaches. */
registers_changed_ptid (nullptr, minus_one_ptid);
- SELF_CHECK (regcache_access::current_regcache_size () == 0);
+ SELF_CHECK (regcache_access::regcaches_size () == 0);
}

class target_ops_no_register : public test_target_ops
@@ -1846,7 +1844,7 @@ _initialize_regcache ()
_("Force gdb to flush its register cache (maintainer command)."));

#if GDB_SELF_TEST
- selftests::register_test ("current_regcache", selftests::current_regcache_test);
+ selftests::register_test ("regcaches", selftests::regcaches_test);

selftests::register_test_foreach_arch ("regcache::cooked_read_test",
selftests::cooked_read_test);
diff --git a/gdb/regcache.h b/gdb/regcache.h
index b8561d714c9e..f2627958aa12 100644
--- a/gdb/regcache.h
+++ b/gdb/regcache.h
@@ -402,7 +402,7 @@ class regcache : public detached_regcache
regcache (process_stratum_target *target, gdbarch *gdbarch,
const address_space *aspace);

- static std::forward_list<regcache *> current_regcache;
+ static std::forward_list<regcache *> regcaches;

private:

--
2.26.2