/* Cache and manage the values of registers for GDB, the GNU debugger.
- Copyright (C) 1986-2018 Free Software Foundation, Inc.
+ Copyright (C) 1986-2020 Free Software Foundation, Inc.
This file is part of GDB.
#include "inferior.h"
#include "gdbthread.h"
#include "target.h"
+#include "test-target.h"
#include "gdbarch.h"
#include "gdbcmd.h"
#include "regcache.h"
/* Total size of the register space. The raw registers are mapped
directly onto the raw register cache while the pseudo's are
either mapped onto raw-registers or memory. */
- descr->nr_cooked_registers = gdbarch_num_regs (gdbarch)
- + gdbarch_num_pseudo_regs (gdbarch);
+ descr->nr_cooked_registers = gdbarch_num_cooked_regs (gdbarch);
/* Fill in a table of register types. */
descr->register_type
/* 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. */
struct regcache_descr *descr = regcache_descr (gdbarch);
int size;
- gdb_assert (regnum >= 0
- && regnum < (gdbarch_num_regs (gdbarch)
- + gdbarch_num_pseudo_regs (gdbarch)));
+ gdb_assert (regnum >= 0 && regnum < gdbarch_num_cooked_regs (gdbarch));
size = descr->sizeof_register[regnum];
return size;
}
-/* See common/common-regcache.h. */
+/* See gdbsupport/common-regcache.h. */
int
regcache_register_size (const struct regcache *regcache, int n)
}
}
-regcache::regcache (gdbarch *gdbarch, const address_space *aspace_)
+regcache::regcache (process_stratum_target *target, gdbarch *gdbarch,
+ const address_space *aspace_)
/* The register buffers. A read/write register cache can only hold
[0 .. gdbarch_num_regs). */
- : detached_regcache (gdbarch, false), m_aspace (aspace_)
+ : detached_regcache (gdbarch, false), m_aspace (aspace_), m_target (target)
{
m_ptid = minus_one_ptid;
}
return m_descr->gdbarch;
}
-/* Cleanup class for invalidating a register. */
-
-class regcache_invalidator
-{
-public:
-
- regcache_invalidator (struct regcache *regcache, int regnum)
- : m_regcache (regcache),
- m_regnum (regnum)
- {
- }
-
- ~regcache_invalidator ()
- {
- if (m_regcache != nullptr)
- m_regcache->invalidate (m_regnum);
- }
-
- DISABLE_COPY_AND_ASSIGN (regcache_invalidator);
-
- void release ()
- {
- m_regcache = nullptr;
- }
-
-private:
-
- struct regcache *m_regcache;
- int m_regnum;
-};
-
/* Return a pointer to register REGNUM's buffer cache. */
gdb_byte *
}
}
-/* See common/common-regcache.h. */
+/* See gdbsupport/common-regcache.h. */
enum register_status
reg_buffer::get_register_status (int regnum) const
std::forward_list<regcache *> regcache::current_regcache;
struct regcache *
-get_thread_arch_aspace_regcache (ptid_t ptid, struct gdbarch *gdbarch,
+get_thread_arch_aspace_regcache (process_stratum_target *target,
+ ptid_t ptid, struct gdbarch *gdbarch,
struct address_space *aspace)
{
+ gdb_assert (target != nullptr);
+
for (const auto ®cache : regcache::current_regcache)
- if (ptid_equal (regcache->ptid (), ptid) && regcache->arch () == gdbarch)
+ if (regcache->target () == target
+ && regcache->ptid () == ptid
+ && regcache->arch () == gdbarch)
return regcache;
- regcache *new_regcache = new regcache (gdbarch, aspace);
+ regcache *new_regcache = new regcache (target, gdbarch, aspace);
regcache::current_regcache.push_front (new_regcache);
new_regcache->set_ptid (ptid);
}
struct regcache *
-get_thread_arch_regcache (ptid_t ptid, struct gdbarch *gdbarch)
+get_thread_arch_regcache (process_stratum_target *target, ptid_t ptid,
+ struct gdbarch *gdbarch)
{
+ scoped_restore_current_inferior restore_current_inferior;
+ set_current_inferior (find_inferior_ptid (target, ptid));
address_space *aspace = target_thread_address_space (ptid);
- return get_thread_arch_aspace_regcache (ptid, gdbarch, aspace);
+ return get_thread_arch_aspace_regcache (target, ptid, gdbarch, aspace);
}
+static process_stratum_target *current_thread_target;
static ptid_t current_thread_ptid;
static struct gdbarch *current_thread_arch;
struct regcache *
-get_thread_regcache (ptid_t ptid)
+get_thread_regcache (process_stratum_target *target, ptid_t ptid)
{
- if (!current_thread_arch || !ptid_equal (current_thread_ptid, ptid))
+ if (!current_thread_arch
+ || target != current_thread_target
+ || current_thread_ptid != ptid)
{
+ gdb_assert (ptid != null_ptid);
+
current_thread_ptid = ptid;
+ current_thread_target = target;
+
+ scoped_restore_current_inferior restore_current_inferior;
+ set_current_inferior (find_inferior_ptid (target, ptid));
current_thread_arch = target_thread_architecture (ptid);
}
- return get_thread_arch_regcache (ptid, current_thread_arch);
+ return get_thread_arch_regcache (target, ptid, current_thread_arch);
}
/* See regcache.h. */
struct regcache *
get_thread_regcache (thread_info *thread)
{
- return get_thread_regcache (thread->ptid);
+ return get_thread_regcache (thread->inf->process_target (),
+ thread->ptid);
}
struct regcache *
return get_thread_regcache (inferior_thread ());
}
-/* See common/common-regcache.h. */
+/* See gdbsupport/common-regcache.h. */
struct regcache *
get_thread_regcache_for_ptid (ptid_t ptid)
{
- return get_thread_regcache (ptid);
+ /* This function doesn't take a process_stratum_target parameter
+ because it's a gdbsupport/ routine implemented by both gdb and
+ gdbserver. It always refers to a ptid of the current target. */
+ process_stratum_target *proc_target = current_inferior ()->process_target ();
+ return get_thread_regcache (proc_target, ptid);
}
/* Observer for the target_changed event. */
{
for (auto ®cache : regcache::current_regcache)
{
- if (ptid_equal (regcache->ptid (), old_ptid))
+ if (regcache->ptid () == old_ptid)
regcache->set_ptid (new_ptid);
}
}
Indicate that registers may have changed, so invalidate the cache. */
void
-registers_changed_ptid (ptid_t ptid)
+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 (ptid_match ((*it)->ptid (), ptid))
+ struct regcache *regcache = *it;
+ if ((target == nullptr || regcache->target () == target)
+ && regcache->ptid ().matches (ptid))
{
- delete *it;
+ delete regcache;
it = regcache::current_regcache.erase_after (oit);
}
else
oit = it++;
}
- if (ptid_match (current_thread_ptid, ptid))
+ if ((target == nullptr || current_thread_target == target)
+ && current_thread_ptid.matches (ptid))
{
+ current_thread_target = NULL;
current_thread_ptid = null_ptid;
current_thread_arch = NULL;
}
- if (ptid_match (inferior_ptid, ptid))
+ if ((target == nullptr || current_inferior ()->process_target () == target)
+ && inferior_ptid.matches (ptid))
{
/* We just deleted the regcache of the current thread. Need to
forget about any frames we have cached, too. */
void
registers_changed_thread (thread_info *thread)
{
- registers_changed_ptid (thread->ptid);
+ registers_changed_ptid (thread->inf->process_target (), thread->ptid);
}
void
registers_changed (void)
{
- registers_changed_ptid (minus_one_ptid);
-
- /* Force cleanup of any alloca areas if using C alloca instead of
- a builtin alloca. This particular call is used to clean up
- areas allocated by low level target code which may build up
- during lengthy interactions between gdb and the target before
- gdb gives control to the user (ie watchpoints). */
- alloca (0);
+ registers_changed_ptid (nullptr, minus_one_ptid);
}
void
/* Invalidate the register after it is written, in case of a
failure. */
- regcache_invalidator invalidator (this, regnum);
+ auto invalidator
+ = make_scope_exit ([&] { this->invalidate (regnum); });
target_store_registers (this, regnum);
int reg_size = register_size (arch (), regnum);
gdb_assert (out != NULL);
- gdb_assert (offset >= 0 && len >= 0 && offset + len <= reg_size);
+ gdb_assert (offset >= 0 && offset <= reg_size);
+ gdb_assert (len >= 0 && offset + len <= reg_size);
if (offset == 0 && len == 0)
{
/* See regcache.h. */
+void
+reg_buffer::raw_collect_part (int regnum, int offset, int len,
+ gdb_byte *out) const
+{
+ int reg_size = register_size (arch (), regnum);
+
+ gdb_assert (out != nullptr);
+ gdb_assert (offset >= 0 && offset <= reg_size);
+ gdb_assert (len >= 0 && offset + len <= reg_size);
+
+ if (offset == 0 && len == 0)
+ {
+ /* Nothing to do. */
+ return;
+ }
+
+ if (offset == 0 && len == reg_size)
+ {
+ /* Collect the full register. */
+ return raw_collect (regnum, out);
+ }
+
+ /* Read to buffer, then write out. */
+ gdb_byte *reg = (gdb_byte *) alloca (reg_size);
+ raw_collect (regnum, reg);
+ memcpy (out, reg + offset, len);
+}
+
+/* See regcache.h. */
+
enum register_status
regcache::write_part (int regnum, int offset, int len,
const gdb_byte *in, bool is_raw)
int reg_size = register_size (arch (), regnum);
gdb_assert (in != NULL);
- gdb_assert (offset >= 0 && len >= 0 && offset + len <= reg_size);
+ gdb_assert (offset >= 0 && offset <= reg_size);
+ gdb_assert (len >= 0 && offset + len <= reg_size);
if (offset == 0 && len == 0)
{
/* See regcache.h. */
+void
+reg_buffer::raw_supply_part (int regnum, int offset, int len,
+ const gdb_byte *in)
+{
+ int reg_size = register_size (arch (), regnum);
+
+ gdb_assert (in != nullptr);
+ gdb_assert (offset >= 0 && offset <= reg_size);
+ gdb_assert (len >= 0 && offset + len <= reg_size);
+
+ if (offset == 0 && len == 0)
+ {
+ /* Nothing to do. */
+ return;
+ }
+
+ if (offset == 0 && len == reg_size)
+ {
+ /* Supply the full register. */
+ return raw_supply (regnum, in);
+ }
+
+ gdb_byte *reg = (gdb_byte *) alloca (reg_size);
+
+ /* Read existing value to buffer. */
+ raw_collect (regnum, reg);
+
+ /* Write to buffer, then write out. */
+ memcpy (reg + offset, in, len);
+ raw_supply (regnum, reg);
+}
+
enum register_status
readable_regcache::raw_read_part (int regnum, int offset, int len,
gdb_byte *buf)
write_part (regnum, offset, len, buf, false);
}
-/* See common/common-regcache.h. */
+/* See gdbsupport/common-regcache.h. */
void
reg_buffer::raw_supply (int regnum, const void *buf)
m_register_status[regnum] = REG_VALID;
}
-/* See common/common-regcache.h. */
+/* See gdbsupport/common-regcache.h. */
void
reg_buffer::raw_collect (int regnum, void *buf) const
byte_order);
}
-/* Transfer a single or all registers belonging to a certain register
- set to or from a buffer. This is the main worker function for
- regcache_supply_regset and regcache_collect_regset. */
+/* See regcache.h. */
+
+void
+regcache::transfer_regset_register (struct regcache *out_regcache, int regnum,
+ const gdb_byte *in_buf, gdb_byte *out_buf,
+ int slot_size, int offs) const
+{
+ struct gdbarch *gdbarch = arch ();
+ int reg_size = std::min (register_size (gdbarch, regnum), slot_size);
+
+ /* Use part versions and reg_size to prevent possible buffer overflows when
+ accessing the regcache. */
+
+ if (out_buf != nullptr)
+ {
+ raw_collect_part (regnum, 0, reg_size, out_buf + offs);
+
+ /* Ensure any additional space is cleared. */
+ if (slot_size > reg_size)
+ memset (out_buf + offs + reg_size, 0, slot_size - reg_size);
+ }
+ else if (in_buf != nullptr)
+ out_regcache->raw_supply_part (regnum, 0, reg_size, in_buf + offs);
+ else
+ {
+ /* Invalidate the register. */
+ out_regcache->raw_supply (regnum, nullptr);
+ }
+}
+
+/* See regcache.h. */
void
regcache::transfer_regset (const struct regset *regset,
struct regcache *out_regcache,
- int regnum, const void *in_buf,
- void *out_buf, size_t size) const
+ int regnum, const gdb_byte *in_buf,
+ gdb_byte *out_buf, size_t size) const
{
const struct regcache_map_entry *map;
int offs = 0, count;
if (offs + slot_size > size)
break;
- if (out_buf)
- raw_collect (regno, (gdb_byte *) out_buf + offs);
- else
- out_regcache->raw_supply (regno, in_buf
- ? (const gdb_byte *) in_buf + offs
- : NULL);
+ transfer_regset_register (out_regcache, regno, in_buf, out_buf,
+ slot_size, offs);
}
else
{
if (offs + slot_size > size)
return;
- if (out_buf)
- raw_collect (regnum, (gdb_byte *) out_buf + offs);
- else
- out_regcache->raw_supply (regnum, in_buf
- ? (const gdb_byte *) in_buf + offs
- : NULL);
+ transfer_regset_register (out_regcache, regnum, in_buf, out_buf,
+ slot_size, offs);
return;
}
}
struct regcache *regcache,
int regnum, const void *buf, size_t size)
{
- regcache->supply_regset (regset, regnum, buf, size);
+ regcache->supply_regset (regset, regnum, (const gdb_byte *) buf, size);
}
void
regcache::supply_regset (const struct regset *regset,
int regnum, const void *buf, size_t size)
{
- transfer_regset (regset, this, regnum, buf, NULL, size);
+ transfer_regset (regset, this, regnum, (const gdb_byte *) buf, nullptr, size);
}
/* Collect register REGNUM from REGCACHE to BUF, using the register
const struct regcache *regcache,
int regnum, void *buf, size_t size)
{
- regcache->collect_regset (regset, regnum, buf, size);
+ regcache->collect_regset (regset, regnum, (gdb_byte *) buf, size);
}
void
regcache::collect_regset (const struct regset *regset,
int regnum, void *buf, size_t size) const
{
- transfer_regset (regset, NULL, regnum, NULL, buf, size);
+ transfer_regset (regset, nullptr, regnum, nullptr, (gdb_byte *) buf, size);
}
-/* See common/common-regcache.h. */
+/* See gdbsupport/common-regcache.h. */
bool
reg_buffer::raw_compare (int regnum, const void *buf, int offset) const
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)
{
long register_offset = 0;
gdb_assert (descr->nr_cooked_registers
- == (gdbarch_num_regs (m_gdbarch)
- + gdbarch_num_pseudo_regs (m_gdbarch)));
+ == gdbarch_num_cooked_regs (m_gdbarch));
for (regnum = -1; regnum < descr->nr_cooked_registers; regnum++)
{
{
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)
}
#if GDB_SELF_TEST
-#include "selftest.h"
+#include "gdbsupport/selftest.h"
#include "selftest-arch.h"
-#include "gdbthread.h"
#include "target-float.h"
namespace selftests {
}
};
+/* 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)
+{
+ struct regcache *regcache
+ = get_thread_arch_aspace_regcache (target, ptid, gdbarch, aspace);
+ SELF_CHECK (regcache != NULL);
+ SELF_CHECK (regcache->target () == target);
+ SELF_CHECK (regcache->ptid () == ptid);
+ SELF_CHECK (regcache->aspace () == aspace);
+}
+
static void
current_regcache_test (void)
{
ptid_t ptid1 (1), ptid2 (2), ptid3 (3);
- /* Get regcache from ptid1, a new regcache is added to
- current_regcache. */
- regcache *regcache = get_thread_arch_aspace_regcache (ptid1,
- target_gdbarch (),
- NULL);
+ test_target_ops test_target1;
+ test_target_ops test_target2;
- SELF_CHECK (regcache != NULL);
- SELF_CHECK (regcache->ptid () == ptid1);
+ /* 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 ptid2, a new regcache is added to
+ /* Get regcache from (target1,ptid2), a new regcache is added to
current_regcache. */
- regcache = get_thread_arch_aspace_regcache (ptid2,
- target_gdbarch (),
- NULL);
- SELF_CHECK (regcache != NULL);
- SELF_CHECK (regcache->ptid () == ptid2);
+ test_get_thread_arch_aspace_regcache (&test_target1, ptid2,
+ target_gdbarch (),
+ NULL);
SELF_CHECK (regcache_access::current_regcache_size () == 2);
- /* Get regcache from ptid3, a new regcache is added to
+ /* Get regcache from (target1,ptid3), a new regcache is added to
current_regcache. */
- regcache = get_thread_arch_aspace_regcache (ptid3,
- target_gdbarch (),
- NULL);
- SELF_CHECK (regcache != NULL);
- SELF_CHECK (regcache->ptid () == ptid3);
+ test_get_thread_arch_aspace_regcache (&test_target1, ptid3,
+ target_gdbarch (),
+ NULL);
SELF_CHECK (regcache_access::current_regcache_size () == 3);
- /* Get regcache from ptid2 again, nothing is added to
+ /* Get regcache from (target1,ptid2) again, nothing is added to
current_regcache. */
- regcache = get_thread_arch_aspace_regcache (ptid2,
- target_gdbarch (),
- NULL);
- SELF_CHECK (regcache != NULL);
- SELF_CHECK (regcache->ptid () == ptid2);
+ test_get_thread_arch_aspace_regcache (&test_target1, ptid2,
+ target_gdbarch (),
+ NULL);
SELF_CHECK (regcache_access::current_regcache_size () == 3);
- /* Mark ptid2 is changed, so regcache of ptid2 should be removed from
- current_regcache. */
- registers_changed_ptid (ptid2);
- SELF_CHECK (regcache_access::current_regcache_size () == 2);
+ /* 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);
}
class target_ops_no_register : public test_target_ops
class readwrite_regcache : public regcache
{
public:
- readwrite_regcache (struct gdbarch *gdbarch)
- : regcache (gdbarch, nullptr)
+ readwrite_regcache (process_stratum_target *target,
+ struct gdbarch *gdbarch)
+ : regcache (target, gdbarch, nullptr)
{}
};
{
/* Error out if debugging something, because we're going to push the
test target, which would pop any existing target. */
- if (current_top_target ()->to_stratum >= process_stratum)
+ if (current_top_target ()->stratum () >= process_stratum)
error (_("target already pushed"));
/* Create a mock environment. An inferior with a thread, with a
mock_inferior.gdbarch = gdbarch;
mock_inferior.aspace = &mock_aspace;
thread_info mock_thread (&mock_inferior, mock_ptid);
-
- scoped_restore restore_thread_list
- = make_scoped_restore (&thread_list, &mock_thread);
+ mock_inferior.thread_list = &mock_thread;
/* Add the mock inferior to the inferior list so that look ups by
target+ptid can find it. */
/* Test that read one raw register from regcache_no_target will go
to the target layer. */
- int regnum;
/* Find a raw register which size isn't zero. */
- for (regnum = 0; regnum < gdbarch_num_regs (gdbarch); regnum++)
+ int nonzero_regnum;
+ for (nonzero_regnum = 0;
+ nonzero_regnum < gdbarch_num_regs (gdbarch);
+ nonzero_regnum++)
{
- if (register_size (gdbarch, regnum) != 0)
+ if (register_size (gdbarch, nonzero_regnum) != 0)
break;
}
- readwrite_regcache readwrite (gdbarch);
- gdb::def_vector<gdb_byte> buf (register_size (gdbarch, regnum));
+ readwrite_regcache readwrite (&mock_target, gdbarch);
+ gdb::def_vector<gdb_byte> buf (register_size (gdbarch, nonzero_regnum));
- readwrite.raw_read (regnum, buf.data ());
+ readwrite.raw_read (nonzero_regnum, buf.data ());
/* raw_read calls target_fetch_registers. */
SELF_CHECK (mock_target.fetch_registers_called > 0);
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_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
- regnum++)
+ for (int regnum = 0; regnum < gdbarch_num_cooked_regs (gdbarch); regnum++)
{
if (register_size (gdbarch, regnum) == 0)
continue;
- gdb::def_vector<gdb_byte> buf (register_size (gdbarch, regnum));
+ gdb::def_vector<gdb_byte> inner_buf (register_size (gdbarch, regnum));
- SELF_CHECK (REG_VALID == readwrite.cooked_read (regnum, buf.data ()));
+ 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);
-
- /* Some SPU pseudo registers are got via TARGET_OBJECT_SPU. */
- if (gdbarch_bfd_arch_info (gdbarch)->arch != bfd_arch_spu)
- SELF_CHECK (mock_target.xfer_partial_called == 0);
+ SELF_CHECK (mock_target.xfer_partial_called == 0);
mock_target.reset ();
}
readonly regcache. */
mock_target.reset ();
- for (int regnum = 0;
- regnum < gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
- regnum++)
+ for (int regnum = 0; regnum < gdbarch_num_cooked_regs (gdbarch); regnum++)
{
if (register_size (gdbarch, regnum) == 0)
continue;
- gdb::def_vector<gdb_byte> buf (register_size (gdbarch, regnum));
+ gdb::def_vector<gdb_byte> inner_buf (register_size (gdbarch, regnum));
enum register_status status = readonly.cooked_read (regnum,
- buf.data ());
+ inner_buf.data ());
if (regnum < gdbarch_num_regs (gdbarch))
{
|| bfd_arch == bfd_arch_mips || bfd_arch == bfd_arch_v850_rh850
|| bfd_arch == bfd_arch_tic6x || bfd_arch == bfd_arch_mn10300
|| bfd_arch == bfd_arch_rl78 || bfd_arch == bfd_arch_score
- || bfd_arch == bfd_arch_riscv)
+ || bfd_arch == bfd_arch_riscv || bfd_arch == bfd_arch_csky)
{
/* Raw registers. If raw registers are not in save_reggroup,
their status are unknown. */
{
/* Error out if debugging something, because we're going to push the
test target, which would pop any existing target. */
- if (current_top_target ()->to_stratum >= process_stratum)
+ if (current_top_target ()->stratum () >= process_stratum)
error (_("target already pushed"));
/* Create a mock environment. A process_stratum target pushed. */
}
} pop_targets;
- readwrite_regcache readwrite (gdbarch);
+ readwrite_regcache readwrite (&mock_target, gdbarch);
- const int num_regs = (gdbarch_num_regs (gdbarch)
- + gdbarch_num_pseudo_regs (gdbarch));
+ const int num_regs = gdbarch_num_cooked_regs (gdbarch);
for (auto regnum = 0; regnum < num_regs; regnum++)
{
auto bfd_arch = gdbarch_bfd_arch_info (gdbarch)->arch;
- if ((bfd_arch == bfd_arch_sparc
- /* SPARC64_CWP_REGNUM, SPARC64_PSTATE_REGNUM,
- SPARC64_ASI_REGNUM and SPARC64_CCR_REGNUM are hard to test. */
- && gdbarch_ptr_bit (gdbarch) == 64
- && (regnum >= gdbarch_num_regs (gdbarch)
- && regnum <= gdbarch_num_regs (gdbarch) + 4))
- || (bfd_arch == bfd_arch_spu
- /* SPU pseudo registers except SPU_SP_REGNUM are got by
- TARGET_OBJECT_SPU. */
- && regnum >= gdbarch_num_regs (gdbarch) && regnum != 130))
+ if (bfd_arch == bfd_arch_sparc
+ /* SPARC64_CWP_REGNUM, SPARC64_PSTATE_REGNUM,
+ SPARC64_ASI_REGNUM and SPARC64_CCR_REGNUM are hard to test. */
+ && gdbarch_ptr_bit (gdbarch) == 64
+ && (regnum >= gdbarch_num_regs (gdbarch)
+ && regnum <= gdbarch_num_regs (gdbarch) + 4))
continue;
std::vector<gdb_byte> expected (register_size (gdbarch, regnum), 0);
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;
} // namespace selftests
#endif /* GDB_SELF_TEST */
+void _initialize_regcache ();
void
-_initialize_regcache (void)
+_initialize_regcache ()
{
regcache_descr_handle
= gdbarch_data_register_post_init (init_regcache_descr);
(regcache::regcache_thread_ptid_changed);
add_com ("flushregs", class_maintenance, reg_flush_command,
- _("Force gdb to flush its register cache (maintainer command)"));
+ _("Force gdb to flush its register cache (maintainer command)."));
#if GDB_SELF_TEST
selftests::register_test ("current_regcache", selftests::current_regcache_test);