32#include <unordered_map>
145 if (result ==
nullptr)
189 : m_has_pseudo (has_pseudo)
222 [&src] (int
regnum, gdb_byte *buf)
263 enum register_status
status = cooked_read (
regnum, dst_buf);
265 gdb_assert (
status != REG_UNKNOWN);
281 gdb_assert (src != NULL);
322 gdb_assert (regnum < m_descr->nr_cooked_registers);
331 = std::unordered_multimap<ptid_t, regcache_up, hash_ptid>;
340 = std::unordered_map<process_stratum_target *, pid_ptid_regcache_map>;
355 gdb_assert (
target !=
nullptr);
364 auto range = ptid_regc_map.equal_range (
ptid);
365 for (
auto it =
range.first; it !=
range.second; ++it)
367 if (it->second->arch () ==
arch)
368 return it->second.get ();
376 ptid_regc_map.insert (std::make_pair (
ptid,
regcache_up (new_regcache)));
403 gdb_assert (
ptid != null_ptid);
454 ptid_t old_ptid, ptid_t new_ptid)
458 if (pid_ptid_regc_map_it ==
regcaches.end ())
463 auto ptid_regc_map_it = pid_ptid_regc_map.find (old_ptid.pid ());
464 if (ptid_regc_map_it == pid_ptid_regc_map.end ())
469 auto range = ptid_regc_map.equal_range (old_ptid);
470 for (
auto it =
range.first; it !=
range.second;)
473 rc->set_ptid (new_ptid);
477 it = ptid_regc_map.erase (it);
478 ptid_regc_map.insert (std::make_pair (new_ptid, std::move (rc)));
500 gdb_assert (
ptid == minus_one_ptid);
505 else if (
ptid.is_pid ())
512 if (pid_ptid_regc_map_it !=
regcaches.end ())
515 = pid_ptid_regc_map_it->second;
517 pid_ptid_regc_map.erase (
ptid.pid ());
520 else if (
ptid != minus_one_ptid)
527 if (pid_ptid_regc_map_it !=
regcaches.end ())
530 = pid_ptid_regc_map_it->second;
533 auto ptid_regc_map_it
534 = pid_ptid_regc_map.find (
ptid.pid ());
535 if (ptid_regc_map_it != pid_ptid_regc_map.end ())
538 = ptid_regc_map_it->second;
540 ptid_regc_map.erase (
ptid);
607 gdb_assert (buf != NULL);
626template<
typename T,
typename>
632 gdb_byte *buf = (gdb_byte *) alloca (len);
635 *val = extract_integer<T> ({buf, len},
657template<
typename T,
typename>
682 enum register_status
status;
685 if (
status == REG_UNAVAILABLE)
686 throw_error (NOT_AVAILABLE_ERROR,
687 _(
"Register %d is not available"),
regnum);
695 gdb_assert (regnum < m_descr->nr_cooked_registers);
711 struct value *computed;
712 enum register_status result = REG_VALID;
724 result = REG_UNAVAILABLE;
738 gdb_assert (regnum < m_descr->nr_cooked_registers);
744 struct value *result;
773template<
typename T,
typename>
777 gdb_assert (
regnum >= 0 && regnum < m_descr->nr_cooked_registers);
779 gdb_byte *buf = (gdb_byte *) alloca (len);
782 *val = extract_integer<T> ({buf, len},
805template<
typename T,
typename>
811 gdb_assert (
regnum >=0 && regnum < m_descr->nr_cooked_registers);
830 gdb_assert (buf != NULL);
851 = make_scope_exit ([&] { this->
invalidate (regnum); });
857 invalidator.release ();
864 gdb_assert (regnum < m_descr->nr_cooked_registers);
876 gdb_byte *out,
bool is_raw)
880 gdb_assert (out != NULL);
881 gdb_assert (offset >= 0 && offset <= reg_size);
882 gdb_assert (len >= 0 && offset + len <= reg_size);
884 if (offset == 0 && len == 0)
890 if (offset == 0 && len == reg_size)
896 enum register_status
status;
897 gdb_byte *reg = (gdb_byte *) alloca (reg_size);
905 memcpy (out, reg + offset, len);
917 gdb_assert (out !=
nullptr);
918 gdb_assert (offset >= 0 && offset <= reg_size);
919 gdb_assert (len >= 0 && offset + len <= reg_size);
921 if (offset == 0 && len == 0)
927 if (offset == 0 && len == reg_size)
934 gdb_byte *reg = (gdb_byte *) alloca (reg_size);
936 memcpy (out, reg + offset, len);
943 const gdb_byte *in,
bool is_raw)
947 gdb_assert (in != NULL);
948 gdb_assert (offset >= 0 && offset <= reg_size);
949 gdb_assert (len >= 0 && offset + len <= reg_size);
951 if (offset == 0 && len == 0)
957 if (offset == 0 && len == reg_size)
964 enum register_status
status;
965 gdb_byte *reg = (gdb_byte *) alloca (reg_size);
973 memcpy (reg + offset, in, len);
986 gdb_assert (in !=
nullptr);
987 gdb_assert (offset >= 0 && offset <= reg_size);
988 gdb_assert (len >= 0 && offset + len <= reg_size);
990 if (offset == 0 && len == 0)
996 if (offset == 0 && len == reg_size)
1002 gdb_byte *reg = (gdb_byte *) alloca (reg_size);
1008 memcpy (reg + offset, in, len);
1024 const gdb_byte *buf)
1036 gdb_assert (
regnum >= 0 && regnum < m_descr->nr_cooked_registers);
1044 const gdb_byte *buf)
1046 gdb_assert (
regnum >= 0 && regnum < m_descr->nr_cooked_registers);
1065 memcpy (regbuf, buf,
size);
1073 memset (regbuf, 0,
size);
1082 int addr_len,
bool is_signed)
1111 memset (regbuf, 0,
size);
1123 gdb_assert (buf != NULL);
1128 memcpy (buf, regbuf,
size);
1135 bool is_signed)
const
1138 const gdb_byte *regbuf;
1154 const gdb_byte *in_buf, gdb_byte *out_buf,
1155 int slot_size,
int offs)
const
1163 if (out_buf !=
nullptr)
1168 if (slot_size > reg_size)
1169 memset (out_buf + offs + reg_size, 0, slot_size - reg_size);
1171 else if (in_buf !=
nullptr)
1190 int regnum,
const gdb_byte *in_buf,
1191 gdb_byte *out_buf,
size_t size)
const
1194 int offs = 0, count;
1197 (count = map->
count) != 0;
1200 int regno = map->
regno;
1201 int slot_size = map->
size;
1211 && (regnum < regno || regnum >= regno + count)))
1212 offs += count * slot_size;
1215 for (; count--; regno++, offs += slot_size)
1217 if (offs + slot_size >
size)
1226 offs += (
regnum - regno) * slot_size;
1227 if (offs + slot_size >
size)
1285 int offs = 0,
count;
1290 int slot_size = map->
size;
1299 offs +=
count * slot_size;
1311 gdb_assert (buf != NULL);
1316 gdb_assert (
size >= offset);
1318 return (memcmp (buf, regbuf + offset,
size - offset) == 0);
1339 &raw_val) == REG_UNAVAILABLE)
1340 throw_error (NOT_AVAILABLE_ERROR, _(
"PC register is not available"));
1345 internal_error (_(
"regcache_read_pc: Unable to find PC"));
1359 catch (
const gdb_exception_error &ex)
1378 internal_error (_(
"regcache_write_pc: Unable to update PC"));
1410 for (
int i = 0; i <
size; i++)
1414 if (
size <=
sizeof (LONGEST))
1419 core_addr_to_string_nz (val), plongest (val));
1441 int footnote_nr = 0;
1442 int footnote_register_offset = 0;
1443 int footnote_register_type_name_null = 0;
1444 long register_offset = 0;
1446 gdb_assert (descr->nr_cooked_registers
1484 descr->register_offset[
regnum]);
1485 if (register_offset != descr->register_offset[
regnum]
1487 && (descr->register_offset[
regnum]
1488 != (descr->register_offset[
regnum - 1]
1489 + descr->sizeof_register[
regnum - 1])))
1492 if (!footnote_register_offset)
1493 footnote_register_offset = ++footnote_nr;
1494 gdb_printf (file,
"*%d", footnote_register_offset);
1498 register_offset = (descr->register_offset[
regnum]
1499 + descr->sizeof_register[
regnum]);
1511 std::string name_holder;
1517 static const char blt[] =
"builtin_type";
1522 if (!footnote_register_type_name_null)
1523 footnote_register_type_name_null = ++footnote_nr;
1524 name_holder = string_printf (
"*%d",
1525 footnote_register_type_name_null);
1526 t = name_holder.c_str ();
1529 if (startswith (t, blt))
1543 if (footnote_register_offset)
1544 gdb_printf (file,
"*%d: Inconsistent register offsets.\n",
1545 footnote_register_offset);
1546 if (footnote_register_type_name_null)
1548 "*%d: Register type's name NULL.\n",
1549 footnote_register_type_name_null);
1553#include "gdbsupport/selftest.h"
1564 for (
auto pid_ptid_regc_map_it =
regcaches.cbegin ();
1565 pid_ptid_regc_map_it !=
regcaches.cend ();
1566 ++pid_ptid_regc_map_it)
1569 = pid_ptid_regc_map_it->second;
1571 for (
auto ptid_regc_map_it = pid_ptid_regc_map.cbegin ();
1572 ptid_regc_map_it != pid_ptid_regc_map.cend ();
1576 = ptid_regc_map_it->second;
1578 size += ptid_regc_map.size ();
1591 auto pid_ptid_regc_map_it =
regcaches.find (target);
1592 if (pid_ptid_regc_map_it !=
regcaches.end ())
1597 auto ptid_regc_map_it = pid_ptid_regc_map.find (ptid.pid ());
1598 if (ptid_regc_map_it != pid_ptid_regc_map.end ())
1601 auto range = ptid_regc_map.equal_range (ptid);
1603 return std::distance (
range.first,
range.second);
1634struct regcache_test_data
1636 regcache_test_data ()
1642 ~regcache_test_data ()
1648 test_target_ops test_target1;
1649 test_target_ops test_target2;
1652using regcache_test_data_up = std::unique_ptr<regcache_test_data>;
1659static regcache_test_data_up
1660populate_regcaches_for_test ()
1662 regcache_test_data_up
data (
new regcache_test_data);
1663 size_t expected_regcache_size = 0;
1665 SELF_CHECK (regcaches_size () == 0);
1669 for (
int pid : { 1, 2 })
1671 for (
long lwp : { 1, 2, 3 })
1673 get_thread_arch_aspace_regcache_and_check
1674 (&
data->test_target1, ptid_t (
pid, lwp));
1675 expected_regcache_size++;
1676 SELF_CHECK (regcaches_size () == expected_regcache_size);
1678 get_thread_arch_aspace_regcache_and_check
1679 (&
data->test_target2, ptid_t (
pid, lwp));
1680 expected_regcache_size++;
1681 SELF_CHECK (regcaches_size () == expected_regcache_size);
1689get_thread_arch_aspace_regcache_test ()
1693 regcache_test_data_up
data = populate_regcaches_for_test ();
1694 size_t regcaches_size_before = regcaches_size ();
1697 get_thread_arch_aspace_regcache_and_check (&
data->test_target1, ptid_t (2, 2));
1698 SELF_CHECK (regcaches_size () == regcaches_size_before);
1704registers_changed_ptid_all_test ()
1706 regcache_test_data_up
data = populate_regcaches_for_test ();
1709 SELF_CHECK (regcaches_size () == 0);
1715registers_changed_ptid_target_test ()
1717 regcache_test_data_up
data = populate_regcaches_for_test ();
1720 SELF_CHECK (regcaches_size () == 6);
1723 SELF_CHECK (regcache_count (&
data->test_target1, ptid_t (2, 2)) == 0);
1724 SELF_CHECK (regcache_count (&
data->test_target2, ptid_t (2, 2)) == 1);
1730registers_changed_ptid_target_pid_test ()
1732 regcache_test_data_up
data = populate_regcaches_for_test ();
1735 SELF_CHECK (regcaches_size () == 9);
1739 SELF_CHECK (regcache_count (&
data->test_target1, ptid_t (2, 2)) == 0);
1740 SELF_CHECK (regcache_count (&
data->test_target2, ptid_t (2, 2)) == 1);
1746registers_changed_ptid_target_ptid_test ()
1748 regcache_test_data_up
data = populate_regcaches_for_test ();
1751 SELF_CHECK (regcaches_size () == 11);
1754 SELF_CHECK (regcache_count (&
data->test_target1, ptid_t (2, 2)) == 0);
1755 SELF_CHECK (regcache_count (&
data->test_target2, ptid_t (2, 2)) == 1);
1758class target_ops_no_register :
public test_target_ops
1761 target_ops_no_register ()
1762 : test_target_ops {}
1767 fetch_registers_called = 0;
1768 store_registers_called = 0;
1769 xfer_partial_called = 0;
1772 void fetch_registers (
regcache *regs,
int regno)
override;
1773 void store_registers (
regcache *regs,
int regno)
override;
1776 const char *annex, gdb_byte *readbuf,
1777 const gdb_byte *writebuf,
1778 ULONGEST offset, ULONGEST len,
1779 ULONGEST *xfered_len)
override;
1781 unsigned int fetch_registers_called = 0;
1782 unsigned int store_registers_called = 0;
1783 unsigned int xfer_partial_called = 0;
1787target_ops_no_register::fetch_registers (
regcache *regs,
int regno)
1791 this->fetch_registers_called++;
1795target_ops_no_register::store_registers (
regcache *regs,
int regno)
1797 this->store_registers_called++;
1801target_ops_no_register::xfer_partial (
enum target_object object,
1802 const char *annex, gdb_byte *readbuf,
1803 const gdb_byte *writebuf,
1804 ULONGEST offset, ULONGEST len,
1805 ULONGEST *xfered_len)
1807 this->xfer_partial_called++;
1813class readwrite_regcache :
public regcache
1836 return (strcmp (
name,
"m68hc11") == 0
1837 || strcmp (
name,
"m68hc12") == 0
1838 || strcmp (
name,
"m68hc12:HCS12") == 0);
1847 if (selftest_skiparch (
gdbarch))
1850 scoped_mock_context<target_ops_no_register> mockctx (
gdbarch);
1857 for (nonzero_regnum = 0;
1865 readwrite_regcache readwrite (&mockctx.mock_target,
gdbarch);
1868 readwrite.raw_read (nonzero_regnum, buf.data ());
1871 SELF_CHECK (mockctx.mock_target.fetch_registers_called > 0);
1872 mockctx.mock_target.reset ();
1877 readwrite.raw_update (i);
1879 mockctx.mock_target.reset ();
1889 SELF_CHECK (REG_VALID == readwrite.cooked_read (
regnum,
1890 inner_buf.data ()));
1892 SELF_CHECK (mockctx.mock_target.fetch_registers_called == 0);
1893 SELF_CHECK (mockctx.mock_target.store_registers_called == 0);
1894 SELF_CHECK (mockctx.mock_target.xfer_partial_called == 0);
1896 mockctx.mock_target.reset ();
1903 mockctx.mock_target.reset ();
1911 enum register_status
status = readonly.cooked_read (
regnum,
1918 if (bfd_arch == bfd_arch_frv || bfd_arch == bfd_arch_h8300
1919 || bfd_arch == bfd_arch_m32c || bfd_arch == bfd_arch_sh
1920 || bfd_arch == bfd_arch_alpha || bfd_arch == bfd_arch_v850
1921 || bfd_arch == bfd_arch_msp430 || bfd_arch == bfd_arch_mep
1922 || bfd_arch == bfd_arch_mips || bfd_arch == bfd_arch_v850_rh850
1923 || bfd_arch == bfd_arch_tic6x || bfd_arch == bfd_arch_mn10300
1924 || bfd_arch == bfd_arch_rl78 || bfd_arch == bfd_arch_score
1925 || bfd_arch == bfd_arch_riscv || bfd_arch == bfd_arch_csky)
1930 SELF_CHECK (
status == REG_VALID);
1932 SELF_CHECK (
status == REG_UNKNOWN);
1935 SELF_CHECK (
status == REG_VALID);
1940 SELF_CHECK (
status == REG_VALID);
1948 if (bfd_arch == bfd_arch_frv
1949 || bfd_arch == bfd_arch_m32c
1950 || bfd_arch == bfd_arch_mep
1951 || bfd_arch == bfd_arch_sh)
1952 SELF_CHECK (
status == REG_VALID ||
status == REG_UNKNOWN);
1953 else if (bfd_arch == bfd_arch_mips
1954 || bfd_arch == bfd_arch_h8300)
1955 SELF_CHECK (
status == REG_UNKNOWN);
1957 SELF_CHECK (
status == REG_VALID);
1961 SELF_CHECK (mockctx.mock_target.fetch_registers_called == 0);
1962 SELF_CHECK (mockctx.mock_target.store_registers_called == 0);
1963 SELF_CHECK (mockctx.mock_target.xfer_partial_called == 0);
1965 mockctx.mock_target.reset ();
1976 if (selftest_skiparch (
gdbarch))
1980 scoped_mock_context<target_ops_no_register> ctx (
gdbarch);
1981 readwrite_regcache readwrite (&ctx.mock_target,
gdbarch);
1992 if (bfd_arch == bfd_arch_sparc
2005 ||
type->
code () == TYPE_CODE_DECFLOAT)
2010 else if (
type->
code () == TYPE_CODE_INT
2011 ||
type->
code () == TYPE_CODE_ARRAY
2013 ||
type->
code () == TYPE_CODE_UNION
2014 ||
type->
code () == TYPE_CODE_STRUCT)
2016 if (bfd_arch == bfd_arch_ia64
2018 && (bfd_arch == bfd_arch_xtensa
2019 || bfd_arch == bfd_arch_bfin
2020 || bfd_arch == bfd_arch_m32c
2022 || bfd_arch == bfd_arch_m68hc11
2023 || bfd_arch == bfd_arch_m68hc12
2024 || bfd_arch == bfd_arch_s390))
2025 || (bfd_arch == bfd_arch_frv
2032 else if (bfd_arch == bfd_arch_rl78 &&
regnum == 40)
2044 else if (
type->
code () == TYPE_CODE_FLAGS)
2056 readwrite.cooked_write (
regnum, expected.data ());
2058 SELF_CHECK (readwrite.cooked_read (
regnum, buf.data ()) == REG_VALID);
2059 SELF_CHECK (expected == buf);
2077 scoped_mock_context<test_target_ops> target1 (arch);
2078 scoped_mock_context<test_target_ops> target2 (arch);
2080 ptid_t old_ptid (111, 222);
2081 ptid_t new_ptid (111, 333);
2083 target1.mock_inferior.pid = old_ptid.pid ();
2084 target1.mock_thread.ptid = old_ptid;
2085 target1.mock_inferior.ptid_thread_map.clear ();
2086 target1.mock_inferior.ptid_thread_map[old_ptid] = &target1.mock_thread;
2088 target2.mock_inferior.pid = old_ptid.pid ();
2089 target2.mock_thread.ptid = old_ptid;
2090 target2.mock_inferior.ptid_thread_map.clear ();
2091 target2.mock_inferior.ptid_thread_map[old_ptid] = &target2.mock_thread;
2102 gdb_assert (regcache_count (&target1.mock_target, old_ptid) == 1);
2103 gdb_assert (regcache_count (&target1.mock_target, new_ptid) == 0);
2104 gdb_assert (regcache_count (&target2.mock_target, old_ptid) == 1);
2105 gdb_assert (regcache_count (&target2.mock_target, new_ptid) == 0);
2110 gdb_assert (regcache_count (&target1.mock_target, old_ptid) == 0);
2111 gdb_assert (regcache_count (&target1.mock_target, new_ptid) == 1);
2112 gdb_assert (regcache_count (&target2.mock_target, old_ptid) == 1);
2113 gdb_assert (regcache_count (&target2.mock_target, new_ptid) == 0);
2136 _(
"Force gdb to flush its register and frame cache."),
2138 c =
add_com_alias (
"flushregs", maintenance_flush_register_cache_cmd,
2143 selftests::register_test (
"get_thread_arch_aspace_regcache",
2144 selftests::get_thread_arch_aspace_regcache_test);
2145 selftests::register_test (
"registers_changed_ptid_all",
2146 selftests::registers_changed_ptid_all_test);
2147 selftests::register_test (
"registers_changed_ptid_target",
2148 selftests::registers_changed_ptid_target_test);
2149 selftests::register_test (
"registers_changed_ptid_target_pid",
2150 selftests::registers_changed_ptid_target_pid_test);
2151 selftests::register_test (
"registers_changed_ptid_target_ptid",
2152 selftests::registers_changed_ptid_target_ptid_test);
2155 selftests::cooked_read_test);
2157 selftests::cooked_write_test);
2158 selftests::register_test (
"regcache_thread_ptid_changed",
2159 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)
process_stratum_target * target() const
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)
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)
struct regcache * get_thread_arch_aspace_regcache(process_stratum_target *target, ptid_t ptid, gdbarch *arch, struct address_space *aspace)
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 ptid_t current_thread_ptid
void regcache_collect_regset(const struct regset *regset, const struct regcache *regcache, int regnum, void *buf, size_t size)
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
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)
std::unordered_multimap< ptid_t, regcache_up, hash_ptid > ptid_regcache_map
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
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,...)
struct type * value_type(const struct value *value)
int value_entirely_available(struct value *value)
struct value * allocate_value(struct type *type)
void mark_value_bytes_unavailable(struct value *value, LONGEST offset, LONGEST length)
gdb::array_view< gdb_byte > value_contents_raw(struct value *value)
#define VALUE_REGNUM(val)