/* Cache and manage the values of registers for GDB, the GNU debugger.
- Copyright (C) 1986-2018 Free Software Foundation, Inc.
+ Copyright (C) 1986-2019 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
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;
}
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 *
struct address_space *aspace)
{
for (const auto ®cache : regcache::current_regcache)
- if (ptid_equal (regcache->ptid (), ptid) && regcache->arch () == gdbarch)
+ if (regcache->ptid () == ptid && regcache->arch () == gdbarch)
return regcache;
regcache *new_regcache = new regcache (gdbarch, aspace);
struct regcache *
get_thread_regcache (ptid_t ptid)
{
- if (!current_thread_arch || !ptid_equal (current_thread_ptid, ptid))
+ if (!current_thread_arch || current_thread_ptid != ptid)
{
current_thread_ptid = ptid;
current_thread_arch = target_thread_architecture (ptid);
{
for (auto ®cache : regcache::current_regcache)
{
- if (ptid_equal (regcache->ptid (), old_ptid))
+ if (regcache->ptid () == old_ptid)
regcache->set_ptid (new_ptid);
}
}
it != regcache::current_regcache.end ();
)
{
- if (ptid_match ((*it)->ptid (), ptid))
+ if ((*it)->ptid ().matches (ptid))
{
delete *it;
it = regcache::current_regcache.erase_after (oit);
oit = it++;
}
- if (ptid_match (current_thread_ptid, ptid))
+ if (current_thread_ptid.matches (ptid))
{
current_thread_ptid = null_ptid;
current_thread_arch = NULL;
}
- if (ptid_match (inferior_ptid, ptid))
+ if (inferior_ptid.matches (ptid))
{
/* We just deleted the regcache of the current thread. Need to
forget about any frames we have cached, too. */
/* 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);
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++)
{
}
#if GDB_SELF_TEST
-#include "selftest.h"
+#include "common/selftest.h"
#include "selftest-arch.h"
-#include "gdbthread.h"
#include "target-float.h"
namespace selftests {
{
/* 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.aspace = &mock_aspace;
thread_info mock_thread (&mock_inferior, mock_ptid);
- scoped_restore restore_thread_list
- = make_scoped_restore (&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
/* 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));
+ 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);
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. */
readwrite_regcache readwrite (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++)
{
projects / deliverable / binutils-gdb.git / blobdiff