From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from barracuda.ebox.ca (barracuda.ebox.ca [96.127.255.19]) by sourceware.org (Postfix) with ESMTPS id 3990E3861000 for ; Mon, 20 Jul 2020 20:41:23 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.3.2 sourceware.org 3990E3861000 X-ASG-Debug-ID: 1595277674-0c856e181010bdf0001-fS2M51 Received: from smtp.ebox.ca (smtp.ebox.ca [96.127.255.82]) by barracuda.ebox.ca with ESMTP id 8oVBQc9BWCBqsDb5 (version=TLSv1 cipher=DHE-RSA-AES256-SHA bits=256 verify=NO); Mon, 20 Jul 2020 16:41:14 -0400 (EDT) X-Barracuda-Envelope-From: simon.marchi@efficios.com X-Barracuda-RBL-Trusted-Forwarder: 96.127.255.82 Received: from smarchi-efficios.internal.efficios.com (192-222-181-218.qc.cable.ebox.net [192.222.181.218]) by smtp.ebox.ca (Postfix) with ESMTP id 7EE21441D65; Mon, 20 Jul 2020 16:41:14 -0400 (EDT) From: Simon Marchi X-Barracuda-RBL-IP: 192.222.181.218 X-Barracuda-Effective-Source-IP: 192-222-181-218.qc.cable.ebox.net[192.222.181.218] X-Barracuda-Apparent-Source-IP: 192.222.181.218 To: gdb-patches@sourceware.org Cc: Morichetti, Laurent , Simon Marchi Subject: [PATCH 1/4] gdb: rename regcache::current_regcache to regcache::regcaches Date: Mon, 20 Jul 2020 16:40:58 -0400 X-ASG-Orig-Subj: [PATCH 1/4] gdb: rename regcache::current_regcache to regcache::regcaches Message-Id: <20200720204101.2849535-2-simon.marchi@efficios.com> X-Mailer: git-send-email 2.26.2 In-Reply-To: <20200720204101.2849535-1-simon.marchi@efficios.com> References: <20200720204101.2849535-1-simon.marchi@efficios.com> MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Barracuda-Connect: smtp.ebox.ca[96.127.255.82] X-Barracuda-Start-Time: 1595277674 X-Barracuda-Encrypted: DHE-RSA-AES256-SHA X-Barracuda-URL: https://96.127.255.19:443/cgi-mod/mark.cgi X-Virus-Scanned: by bsmtpd at ebox.ca X-Barracuda-Scan-Msg-Size: 9041 X-Barracuda-BRTS-Status: 1 X-Barracuda-Spam-Score: 0.00 X-Barracuda-Spam-Status: No, SCORE=0.00 using global scores of TAG_LEVEL=1000.0 QUARANTINE_LEVEL=1000.0 KILL_LEVEL=8.0 tests= X-Barracuda-Spam-Report: Code version 3.2, rules version 3.2.3.83339 Rule breakdown below pts rule name description ---- ---------------------- -------------------------------------------------- X-Spam-Status: No, score=-23.9 required=5.0 tests=BAYES_00, GIT_PATCH_0, KAM_DMARC_NONE, KAM_DMARC_STATUS, RCVD_IN_DNSWL_LOW, SPF_HELO_NONE, SPF_SOFTFAIL, TXREP autolearn=ham autolearn_force=no version=3.4.2 X-Spam-Checker-Version: SpamAssassin 3.4.2 (2018-09-13) on server2.sourceware.org X-BeenThere: gdb-patches@sourceware.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gdb-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Mon, 20 Jul 2020 20:41:25 -0000 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 --- 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::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 (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 current_regcache; + static std::forward_list regcaches; private: -- 2.26.2