32#include <unordered_map>
145 if (result ==
nullptr)
189 : m_has_pseudo (has_pseudo)
216 m_inf_for_target_calls (inf_for_target_calls)
223 [&src] (int
regnum, gdb_byte *buf)
264 enum register_status
status = cooked_read (
regnum, dst_buf);
266 gdb_assert (
status != REG_UNKNOWN);
282 gdb_assert (src != NULL);
323 gdb_assert (regnum < m_descr->nr_cooked_registers);
332 = std::unordered_multimap<ptid_t, regcache_up>;
341 = std::unordered_map<process_stratum_target *, pid_ptid_regcache_map>;
356 gdb_assert (inf_for_target_calls !=
nullptr);
359 gdb_assert (proc_target !=
nullptr);
368 auto range = ptid_regc_map.equal_range (
ptid);
369 for (
auto it =
range.first; it !=
range.second; ++it)
371 if (it->second->arch () ==
arch)
372 return it->second.get ();
380 ptid_regc_map.insert (std::make_pair (
ptid,
regcache_up (new_regcache)));
408 gdb_assert (
ptid != null_ptid);
459 ptid_t old_ptid, ptid_t new_ptid)
462 auto pid_ptid_regc_map_it =
regcaches.find (target);
463 if (pid_ptid_regc_map_it ==
regcaches.end ())
468 auto ptid_regc_map_it = pid_ptid_regc_map.find (old_ptid.pid ());
469 if (ptid_regc_map_it == pid_ptid_regc_map.end ())
474 auto range = ptid_regc_map.equal_range (old_ptid);
475 for (
auto it =
range.first; it !=
range.second;)
478 rc->set_ptid (new_ptid);
482 it = ptid_regc_map.erase (it);
483 ptid_regc_map.insert (std::make_pair (new_ptid, std::move (rc)));
501 if (target ==
nullptr)
505 gdb_assert (
ptid == minus_one_ptid);
510 else if (
ptid.is_pid ())
516 auto pid_ptid_regc_map_it =
regcaches.find (target);
517 if (pid_ptid_regc_map_it !=
regcaches.end ())
520 = pid_ptid_regc_map_it->second;
522 pid_ptid_regc_map.erase (
ptid.pid ());
525 else if (
ptid != minus_one_ptid)
531 auto pid_ptid_regc_map_it =
regcaches.find (target);
532 if (pid_ptid_regc_map_it !=
regcaches.end ())
535 = pid_ptid_regc_map_it->second;
538 auto ptid_regc_map_it
539 = pid_ptid_regc_map.find (
ptid.pid ());
540 if (ptid_regc_map_it != pid_ptid_regc_map.end ())
543 = ptid_regc_map_it->second;
545 ptid_regc_map.erase (
ptid);
599 gdb::optional<scoped_restore_current_thread> maybe_restore_thread
615 gdb_assert (buf != NULL);
634template<
typename T,
typename>
640 gdb_byte *buf = (gdb_byte *) alloca (len);
643 *val = extract_integer<T> ({buf, len},
665template<
typename T,
typename>
690 enum register_status
status;
693 if (
status == REG_UNAVAILABLE)
694 throw_error (NOT_AVAILABLE_ERROR,
695 _(
"Register %d is not available"),
regnum);
703 gdb_assert (regnum < m_descr->nr_cooked_registers);
719 struct value *computed;
720 enum register_status result = REG_VALID;
732 result = REG_UNAVAILABLE;
746 gdb_assert (regnum < m_descr->nr_cooked_registers);
752 struct value *result;
781template<
typename T,
typename>
785 gdb_assert (
regnum >= 0 && regnum < m_descr->nr_cooked_registers);
787 gdb_byte *buf = (gdb_byte *) alloca (len);
790 *val = extract_integer<T> ({buf, len},
813template<
typename T,
typename>
819 gdb_assert (
regnum >=0 && regnum < m_descr->nr_cooked_registers);
838 gdb_assert (buf != NULL);
853 gdb::optional<scoped_restore_current_thread> maybe_restore_thread
862 = make_scope_exit ([&] { this->
invalidate (regnum); });
868 invalidator.release ();
875 gdb_assert (regnum < m_descr->nr_cooked_registers);
887 gdb_byte *out,
bool is_raw)
891 gdb_assert (out != NULL);
892 gdb_assert (offset >= 0 && offset <= reg_size);
893 gdb_assert (len >= 0 && offset + len <= reg_size);
895 if (offset == 0 && len == 0)
901 if (offset == 0 && len == reg_size)
907 enum register_status
status;
908 gdb_byte *reg = (gdb_byte *) alloca (reg_size);
916 memcpy (out, reg + offset, len);
928 gdb_assert (out !=
nullptr);
929 gdb_assert (offset >= 0 && offset <= reg_size);
930 gdb_assert (len >= 0 && offset + len <= reg_size);
932 if (offset == 0 && len == 0)
938 if (offset == 0 && len == reg_size)
945 gdb_byte *reg = (gdb_byte *) alloca (reg_size);
947 memcpy (out, reg + offset, len);
954 const gdb_byte *in,
bool is_raw)
958 gdb_assert (in != NULL);
959 gdb_assert (offset >= 0 && offset <= reg_size);
960 gdb_assert (len >= 0 && offset + len <= reg_size);
962 if (offset == 0 && len == 0)
968 if (offset == 0 && len == reg_size)
975 enum register_status
status;
976 gdb_byte *reg = (gdb_byte *) alloca (reg_size);
984 memcpy (reg + offset, in, len);
997 gdb_assert (in !=
nullptr);
998 gdb_assert (offset >= 0 && offset <= reg_size);
999 gdb_assert (len >= 0 && offset + len <= reg_size);
1001 if (offset == 0 && len == 0)
1007 if (offset == 0 && len == reg_size)
1013 gdb_byte *reg = (gdb_byte *) alloca (reg_size);
1019 memcpy (reg + offset, in, len);
1035 const gdb_byte *buf)
1047 gdb_assert (
regnum >= 0 && regnum < m_descr->nr_cooked_registers);
1055 const gdb_byte *buf)
1057 gdb_assert (
regnum >= 0 && regnum < m_descr->nr_cooked_registers);
1076 memcpy (regbuf, buf,
size);
1084 memset (regbuf, 0,
size);
1093 int addr_len,
bool is_signed)
1122 memset (regbuf, 0,
size);
1134 gdb_assert (buf != NULL);
1139 memcpy (buf, regbuf,
size);
1146 bool is_signed)
const
1149 const gdb_byte *regbuf;
1165 const gdb_byte *in_buf, gdb_byte *out_buf,
1166 int slot_size,
int offs)
const
1174 if (out_buf !=
nullptr)
1179 if (slot_size > reg_size)
1180 memset (out_buf + offs + reg_size, 0, slot_size - reg_size);
1182 else if (in_buf !=
nullptr)
1201 int regnum,
const gdb_byte *in_buf,
1202 gdb_byte *out_buf,
size_t size)
const
1205 int offs = 0, count;
1208 (count = map->
count) != 0;
1211 int regno = map->
regno;
1212 int slot_size = map->
size;
1222 && (regnum < regno || regnum >= regno + count)))
1223 offs += count * slot_size;
1226 for (; count--; regno++, offs += slot_size)
1228 if (offs + slot_size >
size)
1237 offs += (
regnum - regno) * slot_size;
1238 if (offs + slot_size >
size)
1296 int offs = 0,
count;
1301 int slot_size = map->
size;
1310 offs +=
count * slot_size;
1322 gdb_assert (buf != NULL);
1327 gdb_assert (
size >= offset);
1329 return (memcmp (buf, regbuf + offset,
size - offset) == 0);
1350 &raw_val) == REG_UNAVAILABLE)
1351 throw_error (NOT_AVAILABLE_ERROR, _(
"PC register is not available"));
1356 internal_error (_(
"regcache_read_pc: Unable to find PC"));
1370 catch (
const gdb_exception_error &ex)
1389 internal_error (_(
"regcache_write_pc: Unable to update PC"));
1421 for (
int i = 0; i <
size; i++)
1425 if (
size <=
sizeof (LONGEST))
1430 core_addr_to_string_nz (val), plongest (val));
1452 int footnote_nr = 0;
1453 int footnote_register_offset = 0;
1454 int footnote_register_type_name_null = 0;
1455 long register_offset = 0;
1457 gdb_assert (descr->nr_cooked_registers
1495 descr->register_offset[
regnum]);
1496 if (register_offset != descr->register_offset[
regnum]
1498 && (descr->register_offset[
regnum]
1499 != (descr->register_offset[
regnum - 1]
1500 + descr->sizeof_register[
regnum - 1])))
1503 if (!footnote_register_offset)
1504 footnote_register_offset = ++footnote_nr;
1505 gdb_printf (file,
"*%d", footnote_register_offset);
1509 register_offset = (descr->register_offset[
regnum]
1510 + descr->sizeof_register[
regnum]);
1522 std::string name_holder;
1528 static const char blt[] =
"builtin_type";
1533 if (!footnote_register_type_name_null)
1534 footnote_register_type_name_null = ++footnote_nr;
1535 name_holder = string_printf (
"*%d",
1536 footnote_register_type_name_null);
1537 t = name_holder.c_str ();
1540 if (startswith (t, blt))
1554 if (footnote_register_offset)
1555 gdb_printf (file,
"*%d: Inconsistent register offsets.\n",
1556 footnote_register_offset);
1557 if (footnote_register_type_name_null)
1559 "*%d: Register type's name NULL.\n",
1560 footnote_register_type_name_null);
1564#include "gdbsupport/selftest.h"
1575 for (
auto pid_ptid_regc_map_it =
regcaches.cbegin ();
1576 pid_ptid_regc_map_it !=
regcaches.cend ();
1577 ++pid_ptid_regc_map_it)
1580 = pid_ptid_regc_map_it->second;
1582 for (
auto ptid_regc_map_it = pid_ptid_regc_map.cbegin ();
1583 ptid_regc_map_it != pid_ptid_regc_map.cend ();
1587 = ptid_regc_map_it->second;
1589 size += ptid_regc_map.size ();
1602 auto pid_ptid_regc_map_it =
regcaches.find (target);
1603 if (pid_ptid_regc_map_it !=
regcaches.end ())
1608 auto ptid_regc_map_it = pid_ptid_regc_map.find (ptid.pid ());
1609 if (ptid_regc_map_it != pid_ptid_regc_map.end ())
1612 auto range = ptid_regc_map.equal_range (ptid);
1614 return std::distance (
range.first,
range.second);
1624get_thread_arch_aspace_regcache_and_check (
inferior *inf_for_target_calls,
1633 ptid, arch, aspace);
1644struct regcache_test_data
1646 regcache_test_data ()
1655 ~regcache_test_data ()
1661 scoped_mock_context<test_target_ops> test_ctx_1;
1662 scoped_mock_context<test_target_ops> test_ctx_2;
1665using regcache_test_data_up = std::unique_ptr<regcache_test_data>;
1672static regcache_test_data_up
1673populate_regcaches_for_test ()
1675 regcache_test_data_up
data (
new regcache_test_data);
1676 size_t expected_regcache_size = 0;
1678 SELF_CHECK (regcaches_size () == 0);
1682 for (
int pid : { 1, 2 })
1684 for (
long lwp : { 1, 2, 3 })
1686 get_thread_arch_aspace_regcache_and_check
1687 (&
data->test_ctx_1.mock_inferior, ptid_t (
pid, lwp));
1688 expected_regcache_size++;
1689 SELF_CHECK (regcaches_size () == expected_regcache_size);
1691 get_thread_arch_aspace_regcache_and_check
1692 (&
data->test_ctx_2.mock_inferior, ptid_t (
pid, lwp));
1693 expected_regcache_size++;
1694 SELF_CHECK (regcaches_size () == expected_regcache_size);
1702get_thread_arch_aspace_regcache_test ()
1706 regcache_test_data_up
data = populate_regcaches_for_test ();
1707 size_t regcaches_size_before = regcaches_size ();
1710 get_thread_arch_aspace_regcache_and_check (&
data->test_ctx_1.mock_inferior,
1712 SELF_CHECK (regcaches_size () == regcaches_size_before);
1718registers_changed_ptid_all_test ()
1720 regcache_test_data_up
data = populate_regcaches_for_test ();
1723 SELF_CHECK (regcaches_size () == 0);
1729registers_changed_ptid_target_test ()
1731 regcache_test_data_up
data = populate_regcaches_for_test ();
1734 SELF_CHECK (regcaches_size () == 6);
1737 SELF_CHECK (regcache_count (&
data->test_ctx_1.mock_target,
1738 ptid_t (2, 2)) == 0);
1739 SELF_CHECK (regcache_count (&
data->test_ctx_2.mock_target,
1740 ptid_t (2, 2)) == 1);
1746registers_changed_ptid_target_pid_test ()
1748 regcache_test_data_up
data = populate_regcaches_for_test ();
1751 SELF_CHECK (regcaches_size () == 9);
1755 SELF_CHECK (regcache_count (&
data->test_ctx_1.mock_target,
1756 ptid_t (2, 2)) == 0);
1757 SELF_CHECK (regcache_count (&
data->test_ctx_2.mock_target,
1758 ptid_t (2, 2)) == 1);
1764registers_changed_ptid_target_ptid_test ()
1766 regcache_test_data_up
data = populate_regcaches_for_test ();
1769 SELF_CHECK (regcaches_size () == 11);
1772 SELF_CHECK (regcache_count (&
data->test_ctx_1.mock_target,
1773 ptid_t (2, 2)) == 0);
1774 SELF_CHECK (regcache_count (&
data->test_ctx_2.mock_target,
1775 ptid_t (2, 2)) == 1);
1778class target_ops_no_register :
public test_target_ops
1781 target_ops_no_register ()
1782 : test_target_ops {}
1787 fetch_registers_called = 0;
1788 store_registers_called = 0;
1789 xfer_partial_called = 0;
1792 void fetch_registers (
regcache *regs,
int regno)
override;
1793 void store_registers (
regcache *regs,
int regno)
override;
1796 const char *annex, gdb_byte *readbuf,
1797 const gdb_byte *writebuf,
1798 ULONGEST offset, ULONGEST len,
1799 ULONGEST *xfered_len)
override;
1801 unsigned int fetch_registers_called = 0;
1802 unsigned int store_registers_called = 0;
1803 unsigned int xfer_partial_called = 0;
1807target_ops_no_register::fetch_registers (
regcache *regs,
int regno)
1811 this->fetch_registers_called++;
1815target_ops_no_register::store_registers (
regcache *regs,
int regno)
1817 this->store_registers_called++;
1821target_ops_no_register::xfer_partial (
enum target_object object,
1822 const char *annex, gdb_byte *readbuf,
1823 const gdb_byte *writebuf,
1824 ULONGEST offset, ULONGEST len,
1825 ULONGEST *xfered_len)
1827 this->xfer_partial_called++;
1833class readwrite_regcache :
public regcache
1836 readwrite_regcache (
inferior *inf_for_target_calls,
1856 return (strcmp (
name,
"m68hc11") == 0
1857 || strcmp (
name,
"m68hc12") == 0
1858 || strcmp (
name,
"m68hc12:HCS12") == 0);
1867 if (selftest_skiparch (
gdbarch))
1870 scoped_mock_context<target_ops_no_register> mockctx (
gdbarch);
1877 for (nonzero_regnum = 0;
1885 readwrite_regcache readwrite (&mockctx.mock_inferior,
gdbarch);
1886 readwrite.set_ptid (mockctx.mock_ptid);
1889 readwrite.raw_read (nonzero_regnum, buf.data ());
1892 SELF_CHECK (mockctx.mock_target.fetch_registers_called > 0);
1893 mockctx.mock_target.reset ();
1898 readwrite.raw_update (i);
1900 mockctx.mock_target.reset ();
1910 SELF_CHECK (REG_VALID == readwrite.cooked_read (
regnum,
1911 inner_buf.data ()));
1913 SELF_CHECK (mockctx.mock_target.fetch_registers_called == 0);
1914 SELF_CHECK (mockctx.mock_target.store_registers_called == 0);
1915 SELF_CHECK (mockctx.mock_target.xfer_partial_called == 0);
1917 mockctx.mock_target.reset ();
1924 mockctx.mock_target.reset ();
1932 enum register_status
status = readonly.cooked_read (
regnum,
1939 if (bfd_arch == bfd_arch_amdgcn
1940 || bfd_arch == bfd_arch_frv || bfd_arch == bfd_arch_h8300
1941 || bfd_arch == bfd_arch_m32c || bfd_arch == bfd_arch_sh
1942 || bfd_arch == bfd_arch_alpha || bfd_arch == bfd_arch_v850
1943 || bfd_arch == bfd_arch_msp430 || bfd_arch == bfd_arch_mep
1944 || bfd_arch == bfd_arch_mips || bfd_arch == bfd_arch_v850_rh850
1945 || bfd_arch == bfd_arch_tic6x || bfd_arch == bfd_arch_mn10300
1946 || bfd_arch == bfd_arch_rl78 || bfd_arch == bfd_arch_score
1947 || bfd_arch == bfd_arch_riscv || bfd_arch == bfd_arch_csky)
1952 SELF_CHECK (
status == REG_VALID);
1954 SELF_CHECK (
status == REG_UNKNOWN);
1957 SELF_CHECK (
status == REG_VALID);
1962 SELF_CHECK (
status == REG_VALID);
1970 if (bfd_arch == bfd_arch_frv
1971 || bfd_arch == bfd_arch_m32c
1972 || bfd_arch == bfd_arch_mep
1973 || bfd_arch == bfd_arch_sh)
1974 SELF_CHECK (
status == REG_VALID ||
status == REG_UNKNOWN);
1975 else if (bfd_arch == bfd_arch_mips
1976 || bfd_arch == bfd_arch_h8300)
1977 SELF_CHECK (
status == REG_UNKNOWN);
1979 SELF_CHECK (
status == REG_VALID);
1983 SELF_CHECK (mockctx.mock_target.fetch_registers_called == 0);
1984 SELF_CHECK (mockctx.mock_target.store_registers_called == 0);
1985 SELF_CHECK (mockctx.mock_target.xfer_partial_called == 0);
1987 mockctx.mock_target.reset ();
1998 if (selftest_skiparch (
gdbarch))
2002 scoped_mock_context<target_ops_no_register> ctx (
gdbarch);
2003 readwrite_regcache readwrite (&ctx.mock_inferior,
gdbarch);
2004 readwrite.set_ptid (ctx.mock_ptid);
2015 if (bfd_arch == bfd_arch_sparc
2028 ||
type->
code () == TYPE_CODE_DECFLOAT)
2033 else if (
type->
code () == TYPE_CODE_INT
2034 ||
type->
code () == TYPE_CODE_ARRAY
2036 ||
type->
code () == TYPE_CODE_UNION
2037 ||
type->
code () == TYPE_CODE_STRUCT)
2039 if (bfd_arch == bfd_arch_ia64
2041 && (bfd_arch == bfd_arch_xtensa
2042 || bfd_arch == bfd_arch_bfin
2043 || bfd_arch == bfd_arch_m32c
2045 || bfd_arch == bfd_arch_m68hc11
2046 || bfd_arch == bfd_arch_m68hc12
2047 || bfd_arch == bfd_arch_s390))
2048 || (bfd_arch == bfd_arch_frv
2055 else if (bfd_arch == bfd_arch_rl78 &&
regnum == 40)
2067 else if (
type->
code () == TYPE_CODE_FLAGS)
2079 readwrite.cooked_write (
regnum, expected.data ());
2081 SELF_CHECK (readwrite.cooked_read (
regnum, buf.data ()) == REG_VALID);
2082 SELF_CHECK (expected == buf);
2100 scoped_mock_context<test_target_ops> target1 (arch);
2101 scoped_mock_context<test_target_ops> target2 (arch);
2103 ptid_t old_ptid (111, 222);
2104 ptid_t new_ptid (111, 333);
2106 target1.mock_inferior.pid = old_ptid.pid ();
2107 target1.mock_thread.ptid = old_ptid;
2108 target1.mock_inferior.ptid_thread_map.clear ();
2109 target1.mock_inferior.ptid_thread_map[old_ptid] = &target1.mock_thread;
2111 target2.mock_inferior.pid = old_ptid.pid ();
2112 target2.mock_thread.ptid = old_ptid;
2113 target2.mock_inferior.ptid_thread_map.clear ();
2114 target2.mock_inferior.ptid_thread_map[old_ptid] = &target2.mock_thread;
2125 gdb_assert (regcache_count (&target1.mock_target, old_ptid) == 1);
2126 gdb_assert (regcache_count (&target1.mock_target, new_ptid) == 0);
2127 gdb_assert (regcache_count (&target2.mock_target, old_ptid) == 1);
2128 gdb_assert (regcache_count (&target2.mock_target, new_ptid) == 0);
2133 gdb_assert (regcache_count (&target1.mock_target, old_ptid) == 0);
2134 gdb_assert (regcache_count (&target1.mock_target, new_ptid) == 1);
2135 gdb_assert (regcache_count (&target2.mock_target, old_ptid) == 1);
2136 gdb_assert (regcache_count (&target2.mock_target, new_ptid) == 0);
2159 _(
"Force gdb to flush its register and frame cache."),
2161 c =
add_com_alias (
"flushregs", maintenance_flush_register_cache_cmd,
2166 selftests::register_test (
"get_thread_arch_aspace_regcache",
2167 selftests::get_thread_arch_aspace_regcache_test);
2168 selftests::register_test (
"registers_changed_ptid_all",
2169 selftests::registers_changed_ptid_all_test);
2170 selftests::register_test (
"registers_changed_ptid_target",
2171 selftests::registers_changed_ptid_target_test);
2172 selftests::register_test (
"registers_changed_ptid_target_pid",
2173 selftests::registers_changed_ptid_target_pid_test);
2174 selftests::register_test (
"registers_changed_ptid_target_ptid",
2175 selftests::registers_changed_ptid_target_ptid_test);
2178 selftests::cooked_read_test);
2180 selftests::cooked_write_test);
2181 selftests::register_test (
"regcache_thread_ptid_changed",
2182 selftests::regcache_thread_ptid_changed);
struct process_stratum_target * process_target()
struct address_space * aspace
virtual void raw_update(int regnum)=0
enum register_status raw_read(int regnum, gdb_byte *buf)
struct value * cooked_read_value(int regnum)
enum register_status read_part(int regnum, int offset, int len, gdb_byte *out, bool is_raw)
enum register_status cooked_read_part(int regnum, int offset, int len, gdb_byte *buf)
enum register_status raw_read_part(int regnum, int offset, int len, gdb_byte *buf)
enum register_status cooked_read(int regnum, gdb_byte *buf)
readonly_detached_regcache(regcache &src)
gdb_byte * register_buffer(int regnum) const
void raw_collect_integer(int regnum, gdb_byte *addr, int addr_len, bool is_signed) const
void raw_supply_integer(int regnum, const gdb_byte *addr, int addr_len, bool is_signed)
void assert_regnum(int regnum) const
void invalidate(int regnum)
void raw_collect(int regnum, void *buf) const override
std::unique_ptr< gdb_byte[]> m_registers
void raw_supply(int regnum, const void *buf) override
reg_buffer(gdbarch *gdbarch, bool has_pseudo)
void raw_supply_part(int regnum, int offset, int len, const gdb_byte *in)
int num_raw_registers() const
enum register_status get_register_status(int regnum) const override
std::unique_ptr< register_status[]> m_register_status
void raw_supply_zeroed(int regnum)
bool raw_compare(int regnum, const void *buf, int offset) const override
struct regcache_descr * m_descr
void raw_collect_part(int regnum, int offset, int len, gdb_byte *out) const
void save(register_read_ftype cooked_read)
void cooked_write(int regnum, const gdb_byte *buf)
void raw_write_part(int regnum, int offset, int len, const gdb_byte *buf)
void cooked_write_part(int regnum, int offset, int len, const gdb_byte *buf)
void raw_write(int regnum, const gdb_byte *buf)
void transfer_regset_register(struct regcache *out_regcache, int regnum, const gdb_byte *in_buf, gdb_byte *out_buf, int slot_size, int offs) const
void raw_update(int regnum) override
void transfer_regset(const struct regset *regset, int regbase, struct regcache *out_regcache, int regnum, const gdb_byte *in_buf, gdb_byte *out_buf, size_t size) const
void collect_regset(const struct regset *regset, int regbase, int regnum, void *buf, size_t size) const
const address_space * aspace() const
void restore(readonly_detached_regcache *src)
inferior * m_inf_for_target_calls
void debug_print_register(const char *func, int regno)
enum register_status write_part(int regnum, int offset, int len, const gdb_byte *in, bool is_raw)
void set_ptid(const ptid_t ptid)
void supply_regset(const struct regset *regset, int regbase, int regnum, const void *buf, size_t size)
virtual void dump_reg(ui_file *file, int regnum)=0
void set(unsigned key, void *datum)
struct cmd_list_element * maintenanceflushlist
struct cmd_list_element * add_cmd(const char *name, enum command_class theclass, const char *doc, struct cmd_list_element **list)
cmd_list_element * add_com_alias(const char *name, cmd_list_element *target, command_class theclass, int abbrev_flag)
struct cmd_list_element * deprecate_cmd(struct cmd_list_element *cmd, const char *replacement)
void store_integer(gdb_byte *addr, int len, enum bfd_endian byte_order, T val)
void copy_integer_to_size(gdb_byte *dest, int dest_size, const gdb_byte *source, int source_size, bool is_signed, enum bfd_endian byte_order)
static ULONGEST extract_unsigned_integer(gdb::array_view< const gdb_byte > buf, enum bfd_endian byte_order)
void reinit_frame_cache(void)
int gdbarch_pc_regnum(struct gdbarch *gdbarch)
bool gdbarch_read_pc_p(struct gdbarch *gdbarch)
void gdbarch_write_pc(struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR val)
int gdbarch_cannot_store_register(struct gdbarch *gdbarch, int regnum)
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
const char * gdbarch_register_name(struct gdbarch *gdbarch, int regnr)
struct type * gdbarch_register_type(struct gdbarch *gdbarch, int reg_nr)
void gdbarch_pseudo_register_write(struct gdbarch *gdbarch, struct regcache *regcache, int cookednum, const gdb_byte *buf)
int gdbarch_num_regs(struct gdbarch *gdbarch)
struct value * gdbarch_pseudo_register_read_value(struct gdbarch *gdbarch, readable_regcache *regcache, int cookednum)
enum register_status gdbarch_pseudo_register_read(struct gdbarch *gdbarch, readable_regcache *regcache, int cookednum, gdb_byte *buf)
CORE_ADDR gdbarch_read_pc(struct gdbarch *gdbarch, readable_regcache *regcache)
CORE_ADDR gdbarch_addr_bits_remove(struct gdbarch *gdbarch, CORE_ADDR addr)
int gdbarch_register_reggroup_p(struct gdbarch *gdbarch, int regnum, const struct reggroup *reggroup)
bool gdbarch_write_pc_p(struct gdbarch *gdbarch)
const struct bfd_arch_info * gdbarch_bfd_arch_info(struct gdbarch *gdbarch)
bool gdbarch_pseudo_register_read_value_p(struct gdbarch *gdbarch)
int gdbarch_ptr_bit(struct gdbarch *gdbarch)
#define GDBARCH_OBSTACK_CALLOC(GDBARCH, NR, TYPE)
static int gdbarch_num_cooked_regs(gdbarch *arch)
struct thread_info * inferior_thread(void)
void thread_change_ptid(process_stratum_target *targ, ptid_t old_ptid, ptid_t new_ptid)
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t int int rusage_t pid_t pid
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t int status
struct inferior * find_inferior_ptid(process_stratum_target *targ, ptid_t ptid)
void set_current_inferior(struct inferior *inf)
gdb::optional< scoped_restore_current_thread > maybe_switch_inferior(inferior *inf)
struct inferior * current_inferior(void)
observable< struct target_ops * > target_changed
observable< process_stratum_target *, ptid_t, ptid_t > thread_ptid_changed
void register_test_foreach_arch(const std::string &name, self_test_foreach_arch_function *function)
CORE_ADDR regcache_read_pc(struct regcache *regcache)
static void reg_flush_command(const char *command, int from_tty)
int regcache_register_size(const struct regcache *regcache, int n)
void _initialize_regcache()
void registers_changed_ptid(process_stratum_target *target, ptid_t ptid)
static const registry< gdbarch >::key< struct regcache_descr > regcache_descr_handle
std::unordered_map< int, ptid_regcache_map > pid_ptid_regcache_map
enum register_status regcache_raw_read_signed(struct regcache *regcache, int regnum, LONGEST *val)
enum register_status regcache_cooked_read_signed(struct regcache *regcache, int regnum, LONGEST *val)
void regcache_raw_write_signed(struct regcache *regcache, int regnum, LONGEST val)
static struct regcache_descr * regcache_descr(struct gdbarch *gdbarch)
static ptid_t current_thread_ptid
void regcache_collect_regset(const struct regset *regset, const struct regcache *regcache, int regnum, void *buf, size_t size)
struct regcache * get_thread_arch_aspace_regcache(inferior *inf_for_target_calls, ptid_t ptid, gdbarch *arch, struct address_space *aspace)
enum register_status regcache_raw_read_unsigned(struct regcache *regcache, int regnum, ULONGEST *val)
static void regcache_observer_target_changed(struct target_ops *target)
struct regcache * get_thread_regcache_for_ptid(ptid_t ptid)
int register_size(struct gdbarch *gdbarch, int regnum)
CORE_ADDR regcache_read_pc_protected(regcache *regcache)
struct regcache * get_thread_arch_regcache(process_stratum_target *target, ptid_t ptid, struct gdbarch *gdbarch)
void regcache_cooked_write_signed(struct regcache *regcache, int regnum, LONGEST val)
static struct gdbarch * current_thread_arch
std::unordered_multimap< ptid_t, regcache_up > ptid_regcache_map
enum register_status regcache_cooked_read_unsigned(struct regcache *regcache, int regnum, ULONGEST *val)
bool regcache_map_supplies(const struct regcache_map_entry *map, int regnum, struct gdbarch *gdbarch, size_t size)
LONGEST regcache_raw_get_signed(struct regcache *regcache, int regnum)
static void regcache_thread_ptid_changed(process_stratum_target *target, ptid_t old_ptid, ptid_t new_ptid)
void regcache_raw_write_unsigned(struct regcache *regcache, int regnum, ULONGEST val)
void registers_changed_thread(thread_info *thread)
void regcache_write_pc(struct regcache *regcache, CORE_ADDR pc)
static target_pid_ptid_regcache_map regcaches
static struct regcache_descr * init_regcache_descr(struct gdbarch *gdbarch)
struct regcache * get_current_regcache(void)
struct regcache * get_thread_regcache(process_stratum_target *target, ptid_t ptid)
static process_stratum_target * current_thread_target
void regcache_cooked_write_unsigned(struct regcache *regcache, int regnum, ULONGEST val)
std::unordered_map< process_stratum_target *, pid_ptid_regcache_map > target_pid_ptid_regcache_map
void registers_changed(void)
void regcache_supply_regset(const struct regset *regset, struct regcache *regcache, int regnum, const void *buf, size_t size)
struct type * register_type(struct gdbarch *gdbarch, int regnum)
int register_size(struct gdbarch *gdbarch, int regnum)
gdb::function_view< register_status(int regnum, gdb_byte *buf) register_read_ftype)
std::unique_ptr< regcache > regcache_up
struct type * register_type(struct gdbarch *gdbarch, int regnum)
const reggroup *const save_reggroup
const reggroup *const restore_reggroup
void(* func)(remote_target *remote, char *)
long sizeof_raw_registers
struct type ** register_type
long sizeof_cooked_registers
const char * name() const
static struct value * allocate(struct type *type)
void set_lval(lval_type val)
void mark_bytes_unavailable(LONGEST offset, ULONGEST length)
bool entirely_available()
gdb::array_view< gdb_byte > contents_raw()
struct type * type() const
bool target_float_from_string(gdb_byte *addr, const struct type *type, const std::string &string)
struct address_space * target_thread_address_space(ptid_t ptid)
void target_fetch_registers(struct regcache *regcache, int regno)
gdbarch * target_thread_architecture(ptid_t ptid)
void target_prepare_to_store(regcache *regcache)
void target_store_registers(struct regcache *regcache, int regno)
void gdb_printf(struct ui_file *stream, const char *format,...)
#define VALUE_REGNUM(val)