From: Simon Marchi Date: Thu, 6 Aug 2020 20:23:36 +0000 (-0400) Subject: gdb: rename regcache::current_regcache to regcache::regcaches X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=174981ae1f95f2de534d5da77d0057144ba65066;p=binutils-gdb.git gdb: rename regcache::current_regcache to regcache::regcaches 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) : Rename to... : ... 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) : Rename to... : ... this. (current_regcache_test): Rename to... (regcaches_test): ... this. (_initialize_regcache): Update. Change-Id: I87de67154f5fe17a1f6aee7c4f2036647ee27b99 --- diff --git a/gdb/ChangeLog b/gdb/ChangeLog index 0dd7dcd29e9..db8df0346f6 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,3 +1,18 @@ +2020-08-06 Simon Marchi + + * regcache.h (class regcache) : Rename to... + : ... 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) : Rename to... + : ... this. + (current_regcache_test): Rename to... + (regcaches_test): ... this. + (_initialize_regcache): Update. + 2020-08-06 Victor Collod * amd64-tdep.c (amd64_analyze_prologue): Fix incorrect comment. diff --git a/gdb/regcache.c b/gdb/regcache.c index 4ebb8cb0452..b9b937b8581 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::current_regcache; +std::forward_list 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 ®cache : regcache::current_regcache) + for (const auto ®cache : 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 ®cache : regcache::current_regcache) + for (auto ®cache : 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 () { /* 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 b8561d714c9..f2627958aa1 100644 --- a/gdb/regcache.h +++ b/gdb/regcache.h @@ -402,7 +402,7 @@ protected: regcache (process_stratum_target *target, gdbarch *gdbarch, const address_space *aspace); - static std::forward_list current_regcache; + static std::forward_list regcaches; private: