From 159ed7d93fff1ce245ab5f86597e91e81d8e2453 Mon Sep 17 00:00:00 2001 From: Simon Marchi Date: Thu, 6 Aug 2020 16:23:48 -0400 Subject: [PATCH] gdb: move regcache::regcaches to regcache.c I don't really understand why `regcache_thread_ptid_changed` is a static method of `struct regcache` instead of being a static free function in regcache.c. And I don't understand why `current_regcache` is a static member of `struct regcache` instead of being a static global in regcache.c. It's not wrong per-se, but there's no other place where we do it like this in GDB (as far as I remember) and it just exposes things unnecessarily in the .h. Move them to be just static in regcache.c. As a result, registers_changed_ptid doesn't need to be friend of the regcache class anymore. Removing the include of forward_list in regcache.h showed that we were missing an include for it in dwarf2/index-write.c, record-btrace.c and sparc64-tdep.c. gdb/ChangeLog: * regcache.h (class regcache): Remove friend registers_changed_ptid. : Remove. : Remove. * regcache.c (regcache::regcaches): Rename to... (regcaches): ... this. Make static. (get_thread_arch_aspace_regcache): Update. (regcache::regcache_thread_ptid_changed): Rename to... (regcache_thread_ptid_changed): ... this. Update. (class regcache_access): Remove. (regcaches_test): Update. (_initialize_regcache): Update. * sparc64-tdep.c, dwarf2/index-write.c, record-btrace.c: Include . Change-Id: Iabc25759848010cfbb7ee7e27f60eaca17d61c12 --- gdb/ChangeLog | 17 +++++++++ gdb/dwarf2/index-write.c | 1 + gdb/record-btrace.c | 1 + gdb/regcache.c | 74 +++++++++++++++++----------------------- gdb/regcache.h | 7 ---- gdb/sparc64-tdep.c | 2 +- 6 files changed, 52 insertions(+), 50 deletions(-) diff --git a/gdb/ChangeLog b/gdb/ChangeLog index db8df0346f6..9963f4397ea 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,3 +1,20 @@ +2020-08-06 Simon Marchi + + * regcache.h (class regcache): Remove friend + registers_changed_ptid. + : Remove. + : Remove. + * regcache.c (regcache::regcaches): Rename to... + (regcaches): ... this. Make static. + (get_thread_arch_aspace_regcache): Update. + (regcache::regcache_thread_ptid_changed): Rename to... + (regcache_thread_ptid_changed): ... this. Update. + (class regcache_access): Remove. + (regcaches_test): Update. + (_initialize_regcache): Update. + * sparc64-tdep.c, dwarf2/index-write.c, record-btrace.c: Include + . + 2020-08-06 Simon Marchi * regcache.h (class regcache) : Rename to... diff --git a/gdb/dwarf2/index-write.c b/gdb/dwarf2/index-write.c index 97b2310656c..aa7a37e4ef2 100644 --- a/gdb/dwarf2/index-write.c +++ b/gdb/dwarf2/index-write.c @@ -41,6 +41,7 @@ #include #include +#include #include #include #include diff --git a/gdb/record-btrace.c b/gdb/record-btrace.c index 718de62f280..a1a3efc3d68 100644 --- a/gdb/record-btrace.c +++ b/gdb/record-btrace.c @@ -43,6 +43,7 @@ #include "gdbarch.h" #include "cli/cli-style.h" #include "async-event.h" +#include static const target_info record_btrace_target_info = { "record-btrace", diff --git a/gdb/regcache.c b/gdb/regcache.c index b9b937b8581..3c460f255fd 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::regcaches; +static std::forward_list 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::regcaches) + for (const auto ®cache : 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::regcaches.push_front (new_regcache); + regcaches.push_front (new_regcache); new_regcache->set_ptid (ptid); return new_regcache; @@ -412,12 +412,11 @@ regcache_observer_target_changed (struct target_ops *target) registers_changed (); } -/* Update global variables old ptids to hold NEW_PTID if they were - holding OLD_PTID. */ -void -regcache::regcache_thread_ptid_changed (ptid_t old_ptid, ptid_t new_ptid) +/* Update regcaches related to OLD_PTID to now use NEW_PTID. */ +static void +regcache_thread_ptid_changed (ptid_t old_ptid, ptid_t new_ptid) { - for (auto ®cache : regcache::regcaches) + for (auto ®cache : regcaches) { if (regcache->ptid () == old_ptid) regcache->set_ptid (new_ptid); @@ -438,15 +437,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::regcaches.before_begin (), it = std::next (oit); - it != regcache::regcaches.end (); ) + for (auto oit = regcaches.before_begin (), it = std::next (oit); + it != regcaches.end (); ) { struct regcache *regcache = *it; if ((target == nullptr || regcache->target () == target) && regcache->ptid ().matches (ptid)) { delete regcache; - it = regcache::regcaches.erase_after (oit); + it = regcaches.erase_after (oit); } else oit = it++; @@ -1431,19 +1430,12 @@ register_dump::dump (ui_file *file) namespace selftests { -class regcache_access : public regcache +static size_t +regcaches_size () { -public: - - /* Return the number of elements in regcache::regcaches. */ - - static size_t - regcaches_size () - { - return std::distance (regcache::regcaches.begin (), - regcache::regcaches.end ()); - } -}; + return std::distance (regcaches.begin (), + regcaches.end ()); +} /* Wrapper around get_thread_arch_aspace_regcache that does some self checks. */ @@ -1464,7 +1456,7 @@ static void regcaches_test () { /* It is empty at the start. */ - SELF_CHECK (regcache_access::regcaches_size () == 0); + SELF_CHECK (regcaches_size () == 0); ptid_t ptid1 (1), ptid2 (2), ptid3 (3); @@ -1472,57 +1464,56 @@ regcaches_test () test_target_ops test_target2; /* Get regcache from (target1,ptid1), a new regcache is added to - regcache::regcaches. */ + REGCACHES. */ test_get_thread_arch_aspace_regcache (&test_target1, ptid1, target_gdbarch (), NULL); - SELF_CHECK (regcache_access::regcaches_size () == 1); + SELF_CHECK (regcaches_size () == 1); /* Get regcache from (target1,ptid2), a new regcache is added to - regcache::regcaches. */ + REGCACHES. */ test_get_thread_arch_aspace_regcache (&test_target1, ptid2, target_gdbarch (), NULL); - SELF_CHECK (regcache_access::regcaches_size () == 2); + SELF_CHECK (regcaches_size () == 2); /* Get regcache from (target1,ptid3), a new regcache is added to - regcache::regcaches. */ + REGCACHES. */ test_get_thread_arch_aspace_regcache (&test_target1, ptid3, target_gdbarch (), NULL); - SELF_CHECK (regcache_access::regcaches_size () == 3); + SELF_CHECK (regcaches_size () == 3); /* Get regcache from (target1,ptid2) again, nothing is added to - regcache::regcaches. */ + REGCACHES. */ test_get_thread_arch_aspace_regcache (&test_target1, ptid2, target_gdbarch (), NULL); - SELF_CHECK (regcache_access::regcaches_size () == 3); + SELF_CHECK (regcaches_size () == 3); /* Get regcache from (target2,ptid2), a new regcache is added to - regcache::regcaches, since this time we're using a differen - target. */ + REGCACHES, since this time we're using a different target. */ test_get_thread_arch_aspace_regcache (&test_target2, ptid2, target_gdbarch (), NULL); - SELF_CHECK (regcache_access::regcaches_size () == 4); + SELF_CHECK (regcaches_size () == 4); /* Mark that (target1,ptid2) changed. The regcache of (target1, - ptid2) should be removed from regcache::regcaches. */ + ptid2) should be removed from REGCACHES. */ registers_changed_ptid (&test_target1, ptid2); - SELF_CHECK (regcache_access::regcaches_size () == 3); + SELF_CHECK (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::regcaches_size () == 3); + SELF_CHECK (regcaches_size () == 3); /* Confirm that marking all regcaches of all targets as changed - clears regcache::regcaches. */ + clears REGCACHES. */ registers_changed_ptid (nullptr, minus_one_ptid); - SELF_CHECK (regcache_access::regcaches_size () == 0); + SELF_CHECK (regcaches_size () == 0); } class target_ops_no_register : public test_target_ops @@ -1837,8 +1828,7 @@ _initialize_regcache () = gdbarch_data_register_post_init (init_regcache_descr); gdb::observers::target_changed.attach (regcache_observer_target_changed); - gdb::observers::thread_ptid_changed.attach - (regcache::regcache_thread_ptid_changed); + gdb::observers::thread_ptid_changed.attach (regcache_thread_ptid_changed); add_com ("flushregs", class_maintenance, reg_flush_command, _("Force gdb to flush its register cache (maintainer command).")); diff --git a/gdb/regcache.h b/gdb/regcache.h index f2627958aa1..dd0c2f27f95 100644 --- a/gdb/regcache.h +++ b/gdb/regcache.h @@ -22,7 +22,6 @@ #include "gdbsupport/common-regcache.h" #include "gdbsupport/function-view.h" -#include struct regcache; struct regset; @@ -397,13 +396,10 @@ public: debug. */ void debug_print_register (const char *func, int regno); - static void regcache_thread_ptid_changed (ptid_t old_ptid, ptid_t new_ptid); protected: regcache (process_stratum_target *target, gdbarch *gdbarch, const address_space *aspace); - static std::forward_list regcaches; - private: /* Helper function for transfer_regset. Copies across a single register. */ @@ -437,9 +433,6 @@ private: get_thread_arch_aspace_regcache (process_stratum_target *target, ptid_t ptid, struct gdbarch *gdbarch, struct address_space *aspace); - - friend void - registers_changed_ptid (process_stratum_target *target, ptid_t ptid); }; class readonly_detached_regcache : public readable_regcache diff --git a/gdb/sparc64-tdep.c b/gdb/sparc64-tdep.c index f4810523dfa..95979ab76f5 100644 --- a/gdb/sparc64-tdep.c +++ b/gdb/sparc64-tdep.c @@ -33,8 +33,8 @@ #include "target-descriptions.h" #include "target.h" #include "value.h" - #include "sparc64-tdep.h" +#include /* This file implements the SPARC 64-bit ABI as defined by the section "Low-Level System Information" of the SPARC Compliance -- 2.30.2