X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fregcache.c;h=adffa415e5bda2c2c5af9327f8a13ce844561957;hb=42b502299d428786938f90363cbfb62ae768cadb;hp=536322bded892074d6665990193bdb3355e60b5a;hpb=33bab475a6984afedac8a036b3bb40b5555b4127;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/regcache.c b/gdb/regcache.c index 536322bded..adffa415e5 100644 --- a/gdb/regcache.c +++ b/gdb/regcache.c @@ -1,6 +1,6 @@ /* 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. @@ -19,7 +19,9 @@ #include "defs.h" #include "inferior.h" +#include "gdbthread.h" #include "target.h" +#include "test-target.h" #include "gdbarch.h" #include "gdbcmd.h" #include "regcache.h" @@ -85,8 +87,7 @@ init_regcache_descr (struct gdbarch *gdbarch) /* 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 @@ -162,14 +163,12 @@ register_size (struct gdbarch *gdbarch, int regnum) 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) @@ -220,37 +219,6 @@ reg_buffer::arch () const 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 * @@ -316,7 +284,7 @@ regcache::restore (readonly_detached_regcache *src) } } -/* See common/common-regcache.h. */ +/* See gdbsupport/common-regcache.h. */ enum register_status reg_buffer::get_register_status (int regnum) const @@ -349,21 +317,58 @@ 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; + +/* Key for the hash map keeping the regcaches. */ + +struct ptid_arch +{ + ptid_arch (ptid_t ptid, gdbarch *arch) + : ptid (ptid), arch (arch) + {} + + ptid_t ptid; + gdbarch *arch; + + bool operator== (const ptid_arch &other) const + { + return this->ptid == other.ptid && this->arch == other.arch; + } +}; + +/* Hash function for ptid_arch. */ + +struct hash_ptid_arch +{ + size_t operator() (const ptid_arch &val) const + { + hash_ptid h_ptid; + std::hash h_long; + return h_ptid (val.ptid) + h_long ((long) val.arch); + } +}; + +using ptid_arch_regcache_map = std::unordered_map; + +/* Hash map containing the regcaches. */ + +static ptid_arch_regcache_map the_regcaches; struct regcache * -get_thread_arch_aspace_regcache (ptid_t ptid, struct gdbarch *gdbarch, +get_thread_arch_aspace_regcache (ptid_t ptid, gdbarch *arch, struct address_space *aspace) { - for (const auto ®cache : regcache::current_regcache) - if (ptid_equal (regcache->ptid (), ptid) && regcache->arch () == gdbarch) - return regcache; - - regcache *new_regcache = new regcache (gdbarch, aspace); + /* Look up a regcache for this (ptid, arch). */ + ptid_arch key (ptid, arch); + auto it = the_regcaches.find (key); + if (it != the_regcaches.end ()) + return it->second; - regcache::current_regcache.push_front (new_regcache); + /* It does not exist, create it. */ + regcache *new_regcache = new regcache (arch, aspace); new_regcache->set_ptid (ptid); + the_regcaches[key] = new_regcache; + return new_regcache; } @@ -381,7 +386,7 @@ static struct gdbarch *current_thread_arch; 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); @@ -390,13 +395,21 @@ get_thread_regcache (ptid_t ptid) return get_thread_arch_regcache (ptid, current_thread_arch); } +/* See regcache.h. */ + +struct regcache * +get_thread_regcache (thread_info *thread) +{ + return get_thread_regcache (thread->ptid); +} + struct regcache * get_current_regcache (void) { - return get_thread_regcache (inferior_ptid); + 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) @@ -414,13 +427,32 @@ regcache_observer_target_changed (struct target_ops *target) /* 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) +static void +regcache_thread_ptid_changed (ptid_t old_ptid, ptid_t new_ptid) { - for (auto ®cache : regcache::current_regcache) + std::vector keys_to_update; + + /* Find all the regcaches to updates. */ + for (auto &pair : the_regcaches) + { + regcache *rc = pair.second; + if (rc->ptid () == old_ptid) + keys_to_update.push_back (pair.first); + } + + for (const ptid_arch &old_key : keys_to_update) { - if (ptid_equal (regcache->ptid (), old_ptid)) - regcache->set_ptid (new_ptid); + /* Get the regcache, delete the hash map entry. */ + auto it = the_regcaches.find (old_key); + gdb_assert (it != the_regcaches.end ()); + regcache *rc = it->second; + + the_regcaches.erase (it); + + /* Insert the regcache back, with an updated key. */ + ptid_arch new_key (new_ptid, rc->arch ()); + rc->set_ptid (new_ptid); + the_regcaches[new_key] = rc; } } @@ -438,27 +470,26 @@ regcache::regcache_thread_ptid_changed (ptid_t old_ptid, ptid_t new_ptid) void registers_changed_ptid (ptid_t ptid) { - for (auto oit = regcache::current_regcache.before_begin (), - it = std::next (oit); - it != regcache::current_regcache.end (); - ) + for (auto iter = the_regcaches.begin (); iter != the_regcaches.end (); ) { - if (ptid_match ((*it)->ptid (), ptid)) + regcache *rc = iter->second; + + if (rc->ptid ().matches (ptid)) { - delete *it; - it = regcache::current_regcache.erase_after (oit); + delete iter->second; + iter = the_regcaches.erase (iter); } else - oit = it++; + ++iter; } - 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. */ @@ -466,17 +497,18 @@ registers_changed_ptid (ptid_t ptid) } } +/* See regcache.h. */ + +void +registers_changed_thread (thread_info *thread) +{ + registers_changed_ptid (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); } void @@ -754,7 +786,8 @@ regcache::raw_write (int regnum, const gdb_byte *buf) /* 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); @@ -784,7 +817,8 @@ readable_regcache::read_part (int regnum, int offset, int len, 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) { @@ -813,6 +847,36 @@ readable_regcache::read_part (int regnum, int offset, int len, /* 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) @@ -820,7 +884,8 @@ regcache::write_part (int regnum, int offset, int len, 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) { @@ -851,6 +916,38 @@ regcache::write_part (int regnum, int offset, int len, /* 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) @@ -889,7 +986,7 @@ regcache::cooked_write_part (int regnum, int offset, int len, 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) @@ -954,7 +1051,7 @@ reg_buffer::raw_supply_zeroed (int regnum) 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 @@ -989,15 +1086,43 @@ reg_buffer::raw_collect_integer (int regnum, gdb_byte *addr, int addr_len, 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; @@ -1023,12 +1148,8 @@ regcache::transfer_regset (const struct regset *regset, 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 { @@ -1037,12 +1158,8 @@ regcache::transfer_regset (const struct regset *regset, 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; } } @@ -1057,14 +1174,14 @@ regcache_supply_regset (const struct regset *regset, 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 @@ -1076,17 +1193,17 @@ regcache_collect_regset (const struct regset *regset, 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 @@ -1210,8 +1327,7 @@ register_dump::dump (ui_file *file) 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++) { @@ -1319,9 +1435,8 @@ register_dump::dump (ui_file *file) } #if GDB_SELF_TEST -#include "selftest.h" +#include "gdbsupport/selftest.h" #include "selftest-arch.h" -#include "gdbthread.h" #include "target-float.h" namespace selftests { @@ -1335,8 +1450,7 @@ public: static size_t current_regcache_size () { - return std::distance (regcache::current_regcache.begin (), - regcache::current_regcache.end ()); + return the_regcaches.size (); } }; @@ -1462,7 +1576,7 @@ 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 ()->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 @@ -1475,9 +1589,7 @@ cooked_read_test (struct gdbarch *gdbarch) 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_map[mock_ptid] = &mock_thread; /* Add the mock inferior to the inferior list so that look ups by target+ptid can find it. */ @@ -1508,19 +1620,21 @@ cooked_read_test (struct gdbarch *gdbarch) /* 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 buf (register_size (gdbarch, regnum)); + gdb::def_vector 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); @@ -1534,23 +1648,19 @@ cooked_read_test (struct gdbarch *gdbarch) 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 buf (register_size (gdbarch, regnum)); + gdb::def_vector 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 (); } @@ -1561,16 +1671,14 @@ cooked_read_test (struct gdbarch *gdbarch) 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 buf (register_size (gdbarch, regnum)); + gdb::def_vector 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)) { @@ -1583,7 +1691,7 @@ cooked_read_test (struct gdbarch *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. */ @@ -1636,7 +1744,7 @@ cooked_write_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 ()->to_stratum >= process_stratum) + if (current_top_target ()->stratum () >= process_stratum) error (_("target already pushed")); /* Create a mock environment. A process_stratum target pushed. */ @@ -1658,8 +1766,7 @@ cooked_write_test (struct gdbarch *gdbarch) 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++) { @@ -1669,16 +1776,12 @@ cooked_write_test (struct gdbarch *gdbarch) 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 expected (register_size (gdbarch, regnum), 0); @@ -1754,11 +1857,10 @@ _initialize_regcache (void) = 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)")); + _("Force gdb to flush its register cache (maintainer command).")); #if GDB_SELF_TEST selftests::register_test ("current_regcache", selftests::current_regcache_test);