23#include "gdbsupport/common-regcache.h"
24#include "gdbsupport/function-view.h"
44 (
inferior *inf_for_target_calls, ptid_t,
47extern enum register_status
63extern enum register_status
66extern enum register_status
68 int regnum, ULONGEST *val);
131 for (
int i = 0; map[i].
count != 0; i++)
132 size += (map[i].count * map[i].
size);
147 int regnum,
const void *buf,
175typedef gdb::function_view<register_status (
int regnum, gdb_byte *buf)>
210 bool is_signed)
const;
286 template<
typename T,
typename = RequireLongest<T>>
299 template<
typename T,
typename = RequireLongest<T>>
315 gdb_byte *out,
bool is_raw);
359 template<
typename T,
typename = RequireLongest<T>>
365 template<
typename T,
typename = RequireLongest<T>>
377 const gdb_byte *buf);
390 void *buf,
size_t size)
const;
401 void *buf,
size_t size)
const
410 gdb_assert (
m_ptid != minus_one_ptid);
432 const gdb_byte *in_buf, gdb_byte *out_buf,
433 int slot_size,
int offs)
const;
440 int regnum,
const gdb_byte *in_buf,
441 gdb_byte *out_buf,
size_t size)
const;
446 const gdb_byte *in,
bool is_raw);
DISABLE_COPY_AND_ASSIGN(detached_regcache)
void raw_update(int regnum) override
detached_regcache(gdbarch *gdbarch, bool has_pseudo)
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)
readable_regcache(gdbarch *gdbarch, bool has_pseudo)
readonly_detached_regcache(gdbarch *gdbarch, register_read_ftype cooked_read)
readonly_detached_regcache(regcache &src)
DISABLE_COPY_AND_ASSIGN(readonly_detached_regcache)
void raw_update(int regnum) override
void raw_supply(int regnum, const reg_buffer &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)
DISABLE_COPY_AND_ASSIGN(reg_buffer)
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
virtual ~reg_buffer()=default
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 collect_regset(const struct regset *regset, int regnum, void *buf, size_t size) const
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
friend struct regcache * get_thread_arch_aspace_regcache(inferior *inf_for_target_calls, ptid_t ptid, struct gdbarch *gdbarch, struct address_space *aspace)
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)
const address_space *const m_aspace
void supply_regset(const struct regset *regset, int regnum, const void *buf, size_t size)
DISABLE_COPY_AND_ASSIGN(regcache)
void set_ptid(const ptid_t ptid)
void supply_regset(const struct regset *regset, int regbase, int regnum, const void *buf, size_t size)
register_dump(gdbarch *arch)
virtual ~register_dump()=default
virtual void dump_reg(ui_file *file, int regnum)=0
void registers_changed_ptid(process_stratum_target *target, ptid_t ptid)
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)
void regcache_collect_regset(const struct regset *regset, const struct regcache *regcache, int regnum, void *buf, size_t size)
int register_size(struct gdbarch *gdbarch, int regnum)
struct regcache * get_thread_arch_aspace_regcache(inferior *inf_for_target_calls, ptid_t, struct gdbarch *, struct address_space *)
gdb::function_view< register_status(int regnum, gdb_byte *buf) register_read_ftype)
struct regcache * get_thread_arch_regcache(process_stratum_target *targ, ptid_t, struct gdbarch *)
void regcache_cooked_write_signed(struct regcache *regcache, int regnum, LONGEST val)
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)
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)
struct regcache * get_current_regcache(void)
static int regcache_map_entry_size(const struct regcache_map_entry *map)
struct regcache * get_thread_regcache(process_stratum_target *target, ptid_t ptid)
void regcache_cooked_write_unsigned(struct regcache *regcache, int regnum, ULONGEST val)
void registers_changed(void)
void regcache_supply_regset(const struct regset *regset, struct regcache *regcache, int regnum, const void *buf, size_t size)
std::unique_ptr< regcache > regcache_up
struct type * register_type(struct gdbarch *gdbarch, int regnum)
void(* func)(remote_target *remote, char *)