/* Cache and manage the values of registers for GDB, the GNU debugger.
- Copyright (C) 1986-2020 Free Software Foundation, Inc.
+ Copyright (C) 1986-2021 Free Software Foundation, Inc.
This file is part of GDB.
#include "gdbthread.h"
#include "target.h"
#include "test-target.h"
+#include "scoped-mock-context.h"
#include "gdbarch.h"
#include "gdbcmd.h"
#include "regcache.h"
#include "reggroups.h"
#include "observable.h"
#include "regset.h"
-#include <forward_list>
+#include <unordered_map>
+#include "cli/cli-cmds.h"
/*
* DATA STRUCTURE
/* Per-architecture object describing the layout of a register cache.
Computed once when the architecture is created. */
-struct gdbarch_data *regcache_descr_handle;
+static struct gdbarch_data *regcache_descr_handle;
struct regcache_descr
{
/* Lay out the register cache.
- NOTE: cagney/2002-05-22: Only register_type() is used when
+ NOTE: cagney/2002-05-22: Only register_type () is used when
constructing the register cache. It is assumed that the
register's raw size, virtual size and type length are all the
same. */
gdb_assert (gdbarch != NULL);
m_descr = regcache_descr (gdbarch);
+ /* We don't zero-initialize the M_REGISTERS array, as the bytes it contains
+ aren't meaningful as long as the corresponding register status is not
+ REG_VALID. */
if (has_pseudo)
{
- m_registers.reset (new gdb_byte[m_descr->sizeof_cooked_registers] ());
+ m_registers.reset (new gdb_byte[m_descr->sizeof_cooked_registers]);
m_register_status.reset
(new register_status[m_descr->nr_cooked_registers] ());
}
else
{
- m_registers.reset (new gdb_byte[m_descr->sizeof_raw_registers] ());
+ m_registers.reset (new gdb_byte[m_descr->sizeof_raw_registers]);
m_register_status.reset
(new register_status[gdbarch_num_regs (gdbarch)] ());
}
gdb_assert (regnum < gdbarch_num_regs (arch ()));
}
-/* Global structure containing the current regcache. */
+/* Type to map a ptid to a list of regcaches (one thread may have multiple
+ regcaches, associated to different gdbarches). */
+
+using ptid_regcache_map
+ = std::unordered_multimap<ptid_t, regcache_up, hash_ptid>;
+
+/* Type holding regcaches for a given pid. */
+
+using pid_ptid_regcache_map = std::unordered_map<int, ptid_regcache_map>;
+
+/* Type holding regcaches for a given target. */
+
+using target_pid_ptid_regcache_map
+ = std::unordered_map<process_stratum_target *, pid_ptid_regcache_map>;
+
+/* Global structure containing the existing regcaches. */
/* NOTE: this is a write-through cache. There is no "dirty" bit for
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;
+static target_pid_ptid_regcache_map regcaches;
struct regcache *
get_thread_arch_aspace_regcache (process_stratum_target *target,
- ptid_t ptid, struct gdbarch *gdbarch,
+ ptid_t ptid, gdbarch *arch,
struct address_space *aspace)
{
gdb_assert (target != nullptr);
- for (const auto ®cache : regcache::current_regcache)
- if (regcache->target () == target
- && regcache->ptid () == ptid
- && regcache->arch () == gdbarch)
- return regcache;
+ /* Find the map for this target. */
+ pid_ptid_regcache_map &pid_ptid_regc_map = regcaches[target];
- regcache *new_regcache = new regcache (target, gdbarch, aspace);
+ /* Find the map for this pid. */
+ ptid_regcache_map &ptid_regc_map = pid_ptid_regc_map[ptid.pid ()];
- regcache::current_regcache.push_front (new_regcache);
+ /* Check first if a regcache for this arch already exists. */
+ auto range = ptid_regc_map.equal_range (ptid);
+ for (auto it = range.first; it != range.second; ++it)
+ {
+ if (it->second->arch () == arch)
+ return it->second.get ();
+ }
+
+ /* It does not exist, create it. */
+ regcache *new_regcache = new regcache (target, arch, aspace);
new_regcache->set_ptid (ptid);
+ /* Work around a problem with g++ 4.8 (PR96537): Call the regcache_up
+ constructor explictly instead of implicitly. */
+ ptid_regc_map.insert (std::make_pair (ptid, regcache_up (new_regcache)));
return new_regcache;
}
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 (process_stratum_target *target,
+ ptid_t old_ptid, ptid_t new_ptid)
{
- for (auto ®cache : regcache::current_regcache)
+ /* Look up map for target. */
+ auto pid_ptid_regc_map_it = regcaches.find (target);
+ if (pid_ptid_regc_map_it == regcaches.end ())
+ return;
+
+ /* Look up map for pid. */
+ pid_ptid_regcache_map &pid_ptid_regc_map = pid_ptid_regc_map_it->second;
+ auto ptid_regc_map_it = pid_ptid_regc_map.find (old_ptid.pid ());
+ if (ptid_regc_map_it == pid_ptid_regc_map.end ())
+ return;
+
+ /* Update all regcaches belonging to old_ptid. */
+ ptid_regcache_map &ptid_regc_map = ptid_regc_map_it->second;
+ auto range = ptid_regc_map.equal_range (old_ptid);
+ for (auto it = range.first; it != range.second;)
{
- if (regcache->ptid () == old_ptid)
- regcache->set_ptid (new_ptid);
+ regcache_up rc = std::move (it->second);
+ rc->set_ptid (new_ptid);
+
+ /* Remove old before inserting new, to avoid rehashing,
+ which would invalidate iterators. */
+ it = ptid_regc_map.erase (it);
+ ptid_regc_map.insert (std::make_pair (new_ptid, std::move (rc)));
}
}
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 ();
- )
+ if (target == nullptr)
{
- struct regcache *regcache = *it;
- if ((target == nullptr || regcache->target () == target)
- && regcache->ptid ().matches (ptid))
+ /* Since there can be ptid clashes between targets, it's not valid to
+ pass a ptid without saying to which target it belongs. */
+ gdb_assert (ptid == minus_one_ptid);
+
+ /* Delete all the regcaches of all targets. */
+ regcaches.clear ();
+ }
+ else if (ptid.is_pid ())
+ {
+ /* Non-NULL target and pid ptid, delete all regcaches belonging
+ to this (TARGET, PID). */
+
+ /* Look up map for target. */
+ auto pid_ptid_regc_map_it = regcaches.find (target);
+ if (pid_ptid_regc_map_it != regcaches.end ())
{
- delete regcache;
- it = regcache::current_regcache.erase_after (oit);
+ pid_ptid_regcache_map &pid_ptid_regc_map
+ = pid_ptid_regc_map_it->second;
+
+ pid_ptid_regc_map.erase (ptid.pid ());
}
- else
- oit = it++;
+ }
+ else if (ptid != minus_one_ptid)
+ {
+ /* Non-NULL target and non-minus_one_ptid, delete all regcaches belonging
+ to this (TARGET, PTID). */
+
+ /* Look up map for target. */
+ auto pid_ptid_regc_map_it = regcaches.find (target);
+ if (pid_ptid_regc_map_it != regcaches.end ())
+ {
+ pid_ptid_regcache_map &pid_ptid_regc_map
+ = pid_ptid_regc_map_it->second;
+
+ /* Look up map for pid. */
+ auto ptid_regc_map_it
+ = pid_ptid_regc_map.find (ptid.pid ());
+ if (ptid_regc_map_it != pid_ptid_regc_map.end ())
+ {
+ ptid_regcache_map &ptid_regc_map
+ = ptid_regc_map_it->second;
+
+ ptid_regc_map.erase (ptid);
+ }
+ }
+ }
+ else
+ {
+ /* Non-NULL target and minus_one_ptid, delete all regcaches
+ associated to this target. */
+ regcaches.erase (target);
}
if ((target == nullptr || current_thread_target == target)
computed = gdbarch_pseudo_register_read_value (m_descr->gdbarch,
this, regnum);
if (value_entirely_available (computed))
- memcpy (buf, value_contents_raw (computed),
+ memcpy (buf, value_contents_raw (computed).data (),
m_descr->sizeof_register[regnum]);
else
{
direction than in the other one, even though the value-based
API is preferred. */
if (cooked_read (regnum,
- value_contents_raw (result)) == REG_UNAVAILABLE)
+ value_contents_raw (result).data ()) == REG_UNAVAILABLE)
mark_value_bytes_unavailable (result, 0,
TYPE_LENGTH (value_type (result)));
transfer_regset (regset, nullptr, regnum, nullptr, (gdb_byte *) buf, size);
}
+/* See regcache.h */
+
+bool
+regcache_map_supplies (const struct regcache_map_entry *map, int regnum,
+ struct gdbarch *gdbarch, size_t size)
+{
+ int offs = 0, count;
+
+ for (; (count = map->count) != 0; map++)
+ {
+ int regno = map->regno;
+ int slot_size = map->size;
+
+ if (slot_size == 0 && regno != REGCACHE_MAP_SKIP)
+ slot_size = register_size (gdbarch, regno);
+
+ if (regno != REGCACHE_MAP_SKIP && regnum >= regno
+ && regnum < regno + count)
+ return offs + (regnum - regno + 1) * slot_size <= size;
+
+ offs += count * slot_size;
+ if (offs >= size)
+ return false;
+ }
+ return false;
+}
+
/* See gdbsupport/common-regcache.h. */
bool
return pc_val;
}
+/* See gdbsupport/common-regcache.h. */
+
+CORE_ADDR
+regcache_read_pc_protected (regcache *regcache)
+{
+ CORE_ADDR pc;
+ try
+ {
+ pc = regcache_read_pc (regcache);
+ }
+ catch (const gdb_exception_error &ex)
+ {
+ pc = 0;
+ }
+
+ return pc;
+}
+
void
regcache_write_pc (struct regcache *regcache, CORE_ADDR pc)
{
fprintf_unfiltered (gdb_stdlog, "\n");
}
+/* Implement 'maint flush register-cache' command. */
+
static void
reg_flush_command (const char *command, int from_tty)
{
{
static const char blt[] = "builtin_type";
- t = TYPE_NAME (register_type (m_gdbarch, regnum));
+ t = register_type (m_gdbarch, regnum)->name ();
if (t == NULL)
{
if (!footnote_register_type_name_null)
namespace selftests {
-class regcache_access : public regcache
+static size_t
+regcaches_size ()
{
-public:
+ size_t size = 0;
- /* Return the number of elements in current_regcache. */
+ for (auto pid_ptid_regc_map_it = regcaches.cbegin ();
+ pid_ptid_regc_map_it != regcaches.cend ();
+ ++pid_ptid_regc_map_it)
+ {
+ const pid_ptid_regcache_map &pid_ptid_regc_map
+ = pid_ptid_regc_map_it->second;
- static size_t
- current_regcache_size ()
- {
- return std::distance (regcache::current_regcache.begin (),
- regcache::current_regcache.end ());
- }
+ for (auto ptid_regc_map_it = pid_ptid_regc_map.cbegin ();
+ ptid_regc_map_it != pid_ptid_regc_map.cend ();
+ ++ptid_regc_map_it)
+ {
+ const ptid_regcache_map &ptid_regc_map
+ = ptid_regc_map_it->second;
+
+ size += ptid_regc_map.size ();
+ }
+ }
+
+ return size;
+}
+
+/* Return the count of regcaches for (TARGET, PTID) in REGCACHES. */
+
+static int
+regcache_count (process_stratum_target *target, ptid_t ptid)
+{
+ /* Look up map for target. */
+ auto pid_ptid_regc_map_it = regcaches.find (target);
+ if (pid_ptid_regc_map_it != regcaches.end ())
+ {
+ pid_ptid_regcache_map &pid_ptid_regc_map = pid_ptid_regc_map_it->second;
+
+ /* Look map for pid. */
+ auto ptid_regc_map_it = pid_ptid_regc_map.find (ptid.pid ());
+ if (ptid_regc_map_it != pid_ptid_regc_map.end ())
+ {
+ ptid_regcache_map &ptid_regc_map = ptid_regc_map_it->second;
+ auto range = ptid_regc_map.equal_range (ptid);
+
+ return std::distance (range.first, range.second);
+ }
+ }
+
+ return 0;
};
/* Wrapper around get_thread_arch_aspace_regcache that does some self checks. */
static void
-test_get_thread_arch_aspace_regcache (process_stratum_target *target,
- ptid_t ptid, struct gdbarch *gdbarch,
- address_space *aspace)
+get_thread_arch_aspace_regcache_and_check (process_stratum_target *target,
+ ptid_t ptid)
{
- struct regcache *regcache
- = get_thread_arch_aspace_regcache (target, ptid, gdbarch, aspace);
+ /* We currently only test with a single gdbarch. Any gdbarch will do, so use
+ the current inferior's gdbarch. Also use the current inferior's address
+ space. */
+ gdbarch *arch = current_inferior ()->gdbarch;
+ address_space *aspace = current_inferior ()->aspace;
+ regcache *regcache
+ = get_thread_arch_aspace_regcache (target, ptid, arch, aspace);
+
SELF_CHECK (regcache != NULL);
SELF_CHECK (regcache->target () == target);
SELF_CHECK (regcache->ptid () == ptid);
+ SELF_CHECK (regcache->arch () == arch);
SELF_CHECK (regcache->aspace () == aspace);
}
-static void
-current_regcache_test (void)
+/* The data that the regcaches selftests must hold onto for the duration of the
+ test. */
+
+struct regcache_test_data
{
- /* It is empty at the start. */
- SELF_CHECK (regcache_access::current_regcache_size () == 0);
+ regcache_test_data ()
+ {
+ /* Ensure the regcaches container is empty at the start. */
+ registers_changed ();
+ }
- ptid_t ptid1 (1), ptid2 (2), ptid3 (3);
+ ~regcache_test_data ()
+ {
+ /* Make sure to leave the global regcaches container empty. */
+ registers_changed ();
+ }
test_target_ops test_target1;
test_target_ops test_target2;
+};
+
+using regcache_test_data_up = std::unique_ptr<regcache_test_data>;
+
+/* Set up a few regcaches from two different targets, for use in
+ regcache-management tests.
+
+ Return a pointer, because the `regcache_test_data` type is not moveable. */
+
+static regcache_test_data_up
+populate_regcaches_for_test ()
+{
+ regcache_test_data_up data (new regcache_test_data);
+ size_t expected_regcache_size = 0;
+
+ SELF_CHECK (regcaches_size () == 0);
+
+ /* Populate the regcache container with a few regcaches for the two test
+ targets. */
+ for (int pid : { 1, 2 })
+ {
+ for (long lwp : { 1, 2, 3 })
+ {
+ get_thread_arch_aspace_regcache_and_check
+ (&data->test_target1, ptid_t (pid, lwp));
+ expected_regcache_size++;
+ SELF_CHECK (regcaches_size () == expected_regcache_size);
+
+ get_thread_arch_aspace_regcache_and_check
+ (&data->test_target2, ptid_t (pid, lwp));
+ expected_regcache_size++;
+ SELF_CHECK (regcaches_size () == expected_regcache_size);
+ }
+ }
+
+ return data;
+}
+
+static void
+get_thread_arch_aspace_regcache_test ()
+{
+ /* populate_regcaches_for_test already tests most of the
+ get_thread_arch_aspace_regcache functionality. */
+ regcache_test_data_up data = populate_regcaches_for_test ();
+ size_t regcaches_size_before = regcaches_size ();
+
+ /* Test that getting an existing regcache doesn't create a new one. */
+ get_thread_arch_aspace_regcache_and_check (&data->test_target1, ptid_t (2, 2));
+ SELF_CHECK (regcaches_size () == regcaches_size_before);
+}
+
+ /* Test marking all regcaches of all targets as changed. */
+
+static void
+registers_changed_ptid_all_test ()
+{
+ regcache_test_data_up data = populate_regcaches_for_test ();
- /* Get regcache from (target1,ptid1), a new regcache is added to
- current_regcache. */
- test_get_thread_arch_aspace_regcache (&test_target1, ptid1,
- target_gdbarch (),
- NULL);
- SELF_CHECK (regcache_access::current_regcache_size () == 1);
-
- /* Get regcache from (target1,ptid2), a new regcache is added to
- current_regcache. */
- test_get_thread_arch_aspace_regcache (&test_target1, ptid2,
- target_gdbarch (),
- NULL);
- SELF_CHECK (regcache_access::current_regcache_size () == 2);
-
- /* Get regcache from (target1,ptid3), a new regcache is added to
- current_regcache. */
- test_get_thread_arch_aspace_regcache (&test_target1, ptid3,
- target_gdbarch (),
- NULL);
- SELF_CHECK (regcache_access::current_regcache_size () == 3);
-
- /* Get regcache from (target1,ptid2) again, nothing is added to
- current_regcache. */
- test_get_thread_arch_aspace_regcache (&test_target1, ptid2,
- target_gdbarch (),
- NULL);
- SELF_CHECK (regcache_access::current_regcache_size () == 3);
-
- /* Get regcache from (target2,ptid2), a new regcache is added to
- current_regcache, 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);
-
- /* Mark that (target1,ptid2) changed. The regcache of (target1,
- ptid2) should be removed from current_regcache. */
- registers_changed_ptid (&test_target1, ptid2);
- SELF_CHECK (regcache_access::current_regcache_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);
-
- /* Confirm that marking all regcaches of all targets as changed
- clears current_regcache. */
registers_changed_ptid (nullptr, minus_one_ptid);
- SELF_CHECK (regcache_access::current_regcache_size () == 0);
+ SELF_CHECK (regcaches_size () == 0);
+}
+
+/* Test marking regcaches of a specific target as changed. */
+
+static void
+registers_changed_ptid_target_test ()
+{
+ regcache_test_data_up data = populate_regcaches_for_test ();
+
+ registers_changed_ptid (&data->test_target1, minus_one_ptid);
+ SELF_CHECK (regcaches_size () == 6);
+
+ /* Check that we deleted the regcache for the right target. */
+ SELF_CHECK (regcache_count (&data->test_target1, ptid_t (2, 2)) == 0);
+ SELF_CHECK (regcache_count (&data->test_target2, ptid_t (2, 2)) == 1);
+}
+
+/* Test marking regcaches of a specific (target, pid) as changed. */
+
+static void
+registers_changed_ptid_target_pid_test ()
+{
+ regcache_test_data_up data = populate_regcaches_for_test ();
+
+ registers_changed_ptid (&data->test_target1, ptid_t (2));
+ SELF_CHECK (regcaches_size () == 9);
+
+ /* Regcaches from target1 should not exist, while regcaches from target2
+ should exist. */
+ SELF_CHECK (regcache_count (&data->test_target1, ptid_t (2, 2)) == 0);
+ SELF_CHECK (regcache_count (&data->test_target2, ptid_t (2, 2)) == 1);
+}
+
+/* Test marking regcaches of a specific (target, ptid) as changed. */
+
+static void
+registers_changed_ptid_target_ptid_test ()
+{
+ regcache_test_data_up data = populate_regcaches_for_test ();
+
+ registers_changed_ptid (&data->test_target1, ptid_t (2, 2));
+ SELF_CHECK (regcaches_size () == 11);
+
+ /* Check that we deleted the regcache for the right target. */
+ SELF_CHECK (regcache_count (&data->test_target1, ptid_t (2, 2)) == 0);
+ SELF_CHECK (regcache_count (&data->test_target2, ptid_t (2, 2)) == 1);
}
class target_ops_no_register : public test_target_ops
static void
cooked_read_test (struct gdbarch *gdbarch)
{
- /* Error out if debugging something, because we're going to push the
- test target, which would pop any existing target. */
- if (current_top_target ()->stratum () >= process_stratum)
- error (_("target already pushed"));
-
- /* Create a mock environment. An inferior with a thread, with a
- process_stratum target pushed. */
-
- target_ops_no_register mock_target;
- ptid_t mock_ptid (1, 1);
- inferior mock_inferior (mock_ptid.pid ());
- address_space mock_aspace {};
- mock_inferior.gdbarch = gdbarch;
- mock_inferior.aspace = &mock_aspace;
- thread_info mock_thread (&mock_inferior, mock_ptid);
- mock_inferior.thread_list = &mock_thread;
-
- /* Add the mock inferior to the inferior list so that look ups by
- target+ptid can find it. */
- scoped_restore restore_inferior_list
- = make_scoped_restore (&inferior_list);
- inferior_list = &mock_inferior;
-
- /* Switch to the mock inferior. */
- scoped_restore_current_inferior restore_current_inferior;
- set_current_inferior (&mock_inferior);
-
- /* Push the process_stratum target so we can mock accessing
- registers. */
- push_target (&mock_target);
-
- /* Pop it again on exit (return/exception). */
- struct on_exit
- {
- ~on_exit ()
- {
- pop_all_targets_at_and_above (process_stratum);
- }
- } pop_targets;
-
- /* Switch to the mock thread. */
- scoped_restore restore_inferior_ptid
- = make_scoped_restore (&inferior_ptid, mock_ptid);
+ scoped_mock_context<target_ops_no_register> mockctx (gdbarch);
/* Test that read one raw register from regcache_no_target will go
to the target layer. */
break;
}
- readwrite_regcache readwrite (&mock_target, gdbarch);
+ readwrite_regcache readwrite (&mockctx.mock_target, gdbarch);
gdb::def_vector<gdb_byte> buf (register_size (gdbarch, nonzero_regnum));
readwrite.raw_read (nonzero_regnum, buf.data ());
/* raw_read calls target_fetch_registers. */
- SELF_CHECK (mock_target.fetch_registers_called > 0);
- mock_target.reset ();
+ SELF_CHECK (mockctx.mock_target.fetch_registers_called > 0);
+ mockctx.mock_target.reset ();
/* Mark all raw registers valid, so the following raw registers
accesses won't go to target. */
for (auto i = 0; i < gdbarch_num_regs (gdbarch); i++)
readwrite.raw_update (i);
- mock_target.reset ();
+ mockctx.mock_target.reset ();
/* Then, read all raw and pseudo registers, and don't expect calling
to_{fetch,store}_registers. */
for (int regnum = 0; regnum < gdbarch_num_cooked_regs (gdbarch); regnum++)
SELF_CHECK (REG_VALID == readwrite.cooked_read (regnum,
inner_buf.data ()));
- SELF_CHECK (mock_target.fetch_registers_called == 0);
- SELF_CHECK (mock_target.store_registers_called == 0);
- SELF_CHECK (mock_target.xfer_partial_called == 0);
+ SELF_CHECK (mockctx.mock_target.fetch_registers_called == 0);
+ SELF_CHECK (mockctx.mock_target.store_registers_called == 0);
+ SELF_CHECK (mockctx.mock_target.xfer_partial_called == 0);
- mock_target.reset ();
+ mockctx.mock_target.reset ();
}
readonly_detached_regcache readonly (readwrite);
/* GDB may go to target layer to fetch all registers and memory for
readonly regcache. */
- mock_target.reset ();
+ mockctx.mock_target.reset ();
for (int regnum = 0; regnum < gdbarch_num_cooked_regs (gdbarch); regnum++)
{
}
}
- SELF_CHECK (mock_target.fetch_registers_called == 0);
- SELF_CHECK (mock_target.store_registers_called == 0);
- SELF_CHECK (mock_target.xfer_partial_called == 0);
+ SELF_CHECK (mockctx.mock_target.fetch_registers_called == 0);
+ SELF_CHECK (mockctx.mock_target.store_registers_called == 0);
+ SELF_CHECK (mockctx.mock_target.xfer_partial_called == 0);
- mock_target.reset ();
+ mockctx.mock_target.reset ();
}
}
{
/* Error out if debugging something, because we're going to push the
test target, which would pop any existing target. */
- if (current_top_target ()->stratum () >= process_stratum)
+ if (current_inferior ()->top_target ()->stratum () >= process_stratum)
error (_("target already pushed"));
/* Create a mock environment. A process_stratum target pushed. */
/* Push the process_stratum target so we can mock accessing
registers. */
- push_target (&mock_target);
+ current_inferior ()->push_target (&mock_target);
/* Pop it again on exit (return/exception). */
struct on_exit
std::vector<gdb_byte> buf (register_size (gdbarch, regnum), 0);
const auto type = register_type (gdbarch, regnum);
- if (TYPE_CODE (type) == TYPE_CODE_FLT
- || TYPE_CODE (type) == TYPE_CODE_DECFLOAT)
+ if (type->code () == TYPE_CODE_FLT
+ || type->code () == TYPE_CODE_DECFLOAT)
{
/* Generate valid float format. */
target_float_from_string (expected.data (), type, "1.25");
}
- else if (TYPE_CODE (type) == TYPE_CODE_INT
- || TYPE_CODE (type) == TYPE_CODE_ARRAY
- || TYPE_CODE (type) == TYPE_CODE_PTR
- || TYPE_CODE (type) == TYPE_CODE_UNION
- || TYPE_CODE (type) == TYPE_CODE_STRUCT)
+ else if (type->code () == TYPE_CODE_INT
+ || type->code () == TYPE_CODE_ARRAY
+ || type->code () == TYPE_CODE_PTR
+ || type->code () == TYPE_CODE_UNION
+ || type->code () == TYPE_CODE_STRUCT)
{
if (bfd_arch == bfd_arch_ia64
|| (regnum >= gdbarch_num_regs (gdbarch)
expected[j] = j;
}
}
- else if (TYPE_CODE (type) == TYPE_CODE_FLAGS)
+ else if (type->code () == TYPE_CODE_FLAGS)
{
/* No idea how to test flags. */
continue;
}
}
+/* Verify that when two threads with the same ptid exist (from two different
+ targets) and one of them changes ptid, we only update the appropriate
+ regcaches. */
+
+static void
+regcache_thread_ptid_changed ()
+{
+ /* This test relies on the global regcache list to initially be empty. */
+ registers_changed ();
+
+ /* Any arch will do. */
+ gdbarch *arch = current_inferior ()->gdbarch;
+
+ /* Prepare two targets with one thread each, with the same ptid. */
+ scoped_mock_context<test_target_ops> target1 (arch);
+ scoped_mock_context<test_target_ops> target2 (arch);
+
+ ptid_t old_ptid (111, 222);
+ ptid_t new_ptid (111, 333);
+
+ target1.mock_inferior.pid = old_ptid.pid ();
+ target1.mock_thread.ptid = old_ptid;
+ target1.mock_inferior.ptid_thread_map.clear ();
+ target1.mock_inferior.ptid_thread_map[old_ptid] = &target1.mock_thread;
+
+ target2.mock_inferior.pid = old_ptid.pid ();
+ target2.mock_thread.ptid = old_ptid;
+ target2.mock_inferior.ptid_thread_map.clear ();
+ target2.mock_inferior.ptid_thread_map[old_ptid] = &target2.mock_thread;
+
+ gdb_assert (regcaches.empty ());
+
+ /* Populate the regcaches container. */
+ get_thread_arch_aspace_regcache (&target1.mock_target, old_ptid, arch,
+ nullptr);
+ get_thread_arch_aspace_regcache (&target2.mock_target, old_ptid, arch,
+ nullptr);
+
+ gdb_assert (regcaches.size () == 2);
+ gdb_assert (regcache_count (&target1.mock_target, old_ptid) == 1);
+ gdb_assert (regcache_count (&target1.mock_target, new_ptid) == 0);
+ gdb_assert (regcache_count (&target2.mock_target, old_ptid) == 1);
+ gdb_assert (regcache_count (&target2.mock_target, new_ptid) == 0);
+
+ thread_change_ptid (&target1.mock_target, old_ptid, new_ptid);
+
+ gdb_assert (regcaches.size () == 2);
+ gdb_assert (regcache_count (&target1.mock_target, old_ptid) == 0);
+ gdb_assert (regcache_count (&target1.mock_target, new_ptid) == 1);
+ gdb_assert (regcache_count (&target2.mock_target, old_ptid) == 1);
+ gdb_assert (regcache_count (&target2.mock_target, new_ptid) == 0);
+
+ /* Leave the regcache list empty. */
+ registers_changed ();
+ gdb_assert (regcaches.empty ());
+}
+
} // namespace selftests
#endif /* GDB_SELF_TEST */
+void _initialize_regcache ();
void
-_initialize_regcache (void)
+_initialize_regcache ()
{
+ struct cmd_list_element *c;
+
regcache_descr_handle
= 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::target_changed.attach (regcache_observer_target_changed,
+ "regcache");
+ gdb::observers::thread_ptid_changed.attach (regcache_thread_ptid_changed,
+ "regcache");
- add_com ("flushregs", class_maintenance, reg_flush_command,
- _("Force gdb to flush its register cache (maintainer command)."));
+ cmd_list_element *maintenance_flush_register_cache_cmd
+ = add_cmd ("register-cache", class_maintenance, reg_flush_command,
+ _("Force gdb to flush its register and frame cache."),
+ &maintenanceflushlist);
+ c = add_com_alias ("flushregs", maintenance_flush_register_cache_cmd,
+ class_maintenance, 0);
+ deprecate_cmd (c, "maintenance flush register-cache");
#if GDB_SELF_TEST
- selftests::register_test ("current_regcache", selftests::current_regcache_test);
+ selftests::register_test ("get_thread_arch_aspace_regcache",
+ selftests::get_thread_arch_aspace_regcache_test);
+ selftests::register_test ("registers_changed_ptid_all",
+ selftests::registers_changed_ptid_all_test);
+ selftests::register_test ("registers_changed_ptid_target",
+ selftests::registers_changed_ptid_target_test);
+ selftests::register_test ("registers_changed_ptid_target_pid",
+ selftests::registers_changed_ptid_target_pid_test);
+ selftests::register_test ("registers_changed_ptid_target_ptid",
+ selftests::registers_changed_ptid_target_ptid_test);
selftests::register_test_foreach_arch ("regcache::cooked_read_test",
selftests::cooked_read_test);
selftests::register_test_foreach_arch ("regcache::cooked_write_test",
selftests::cooked_write_test);
+ selftests::register_test ("regcache_thread_ptid_changed",
+ selftests::regcache_thread_ptid_changed);
#endif
}