extern LONGEST regcache_raw_get_signed (struct regcache *regcache,
int regnum);
-/* Set a raw register's value in the regcache's buffer. Unlike
- regcache_raw_write, this is not write-through. The intention is
- allowing to change the buffer contents of a read-only regcache
- allocated with new. */
-
-extern void regcache_raw_set_cached_value
- (struct regcache *regcache, int regnum, const gdb_byte *buf);
-
/* Partial transfer of raw registers. These perform read, modify,
write style operations. The read variant returns the status of the
register. */
int regnum,
gdb_byte *buf);
-enum regcache_dump_what
-{
- regcache_dump_none, regcache_dump_raw,
- regcache_dump_cooked, regcache_dump_groups,
- regcache_dump_remote
-};
-
/* A (register_number, register_value) pair. */
typedef struct cached_reg
/* Return regcache's architecture. */
gdbarch *arch () const;
+ enum register_status get_register_status (int regnum) const;
+
virtual ~reg_buffer ()
{
xfree (m_registers);
xfree (m_register_status);
}
-
protected:
/* Assert on the range of REGNUM. */
void assert_regnum (int regnum) const;
gdb_byte *register_buffer (int regnum) const;
+ /* Save a register cache. The set of registers saved into the
+ regcache determined by the save_reggroup. COOKED_READ returns
+ zero iff the register's value can't be returned. */
+ void save (regcache_cooked_read_ftype *cooked_read, void *src);
+
struct regcache_descr *m_descr;
bool m_has_pseudo;
gdb_byte *m_registers;
/* Register cache status. */
signed char *m_register_status;
+
+ friend class regcache;
+ friend class detached_regcache;
};
/* An abstract class which only has methods doing read. */
bool is_raw);
};
-/* The register cache for storing raw register values. */
+/* Buffer of registers, can be read and written. */
-class regcache : public readable_regcache
+class detached_regcache : public readable_regcache
{
public:
- regcache (gdbarch *gdbarch)
- : regcache (gdbarch, nullptr, true)
+ detached_regcache (gdbarch *gdbarch, bool has_pseudo)
+ : readable_regcache (gdbarch, has_pseudo)
{}
- struct readonly_t {};
- static constexpr readonly_t readonly {};
+ void raw_supply (int regnum, const void *buf);
+
+ void raw_supply (int regnum, const reg_buffer &src)
+ {
+ raw_supply (regnum, src.register_buffer (regnum));
+ }
- /* Create a readonly regcache from a non-readonly regcache. */
- regcache (readonly_t, const regcache &src);
+ void raw_update (int regnum) override
+ {}
+ void raw_supply_integer (int regnum, const gdb_byte *addr, int addr_len,
+ bool is_signed);
+
+ void raw_supply_zeroed (int regnum);
+
+ void invalidate (int regnum);
+
+ DISABLE_COPY_AND_ASSIGN (detached_regcache);
+};
+
+class readonly_detached_regcache;
+
+/* The register cache for storing raw register values. */
+
+class regcache : public detached_regcache
+{
+public:
DISABLE_COPY_AND_ASSIGN (regcache);
/* Return REGCACHE's address space. */
return m_aspace;
}
-/* Save/restore 'this' regcache. The set of registers saved /
- restored into the regcache determined by the save_reggroup /
- restore_reggroup respectively. COOKED_READ returns zero iff the
- register's value can't be returned. */
- void save (regcache_cooked_read_ftype *cooked_read, void *src);
-
- /* Writes to regcache will go through to the target. SRC is a
+ /* Restore 'this' regcache. The set of registers restored into
+ the regcache determined by the restore_reggroup.
+ Writes to regcache will go through to the target. SRC is a
read-only register cache. */
- void restore (struct regcache *src);
+ void restore (readonly_detached_regcache *src);
void cooked_write (int regnum, const gdb_byte *buf);
void raw_collect_integer (int regnum, gdb_byte *addr, int addr_len,
bool is_signed) const;
- void raw_supply (int regnum, const void *buf);
-
- void raw_supply_integer (int regnum, const gdb_byte *addr, int addr_len,
- bool is_signed);
-
- void raw_supply_zeroed (int regnum);
-
- enum register_status get_register_status (int regnum) const;
-
- void raw_set_cached_value (int regnum, const gdb_byte *buf);
-
- void invalidate (int regnum);
-
void raw_write_part (int regnum, int offset, int len, const gdb_byte *buf);
void cooked_write_part (int regnum, int offset, int len,
void collect_regset (const struct regset *regset, int regnum,
void *buf, size_t size) const;
- void dump (ui_file *file, enum regcache_dump_what what_to_dump);
-
ptid_t ptid () const
{
return m_ptid;
static void regcache_thread_ptid_changed (ptid_t old_ptid, ptid_t new_ptid);
protected:
- regcache (gdbarch *gdbarch, const address_space *aspace_, bool readonly_p_);
+ regcache (gdbarch *gdbarch, const address_space *aspace_);
static std::forward_list<regcache *> current_regcache;
private:
makes sense, like PC or SP). */
const address_space * const m_aspace;
- /* Is this a read-only cache? A read-only cache is used for saving
- the target's register state (e.g, across an inferior function
- call or just before forcing a function return). A read-only
- cache can only be created via a constructor. The actual contents
- are determined by the save and restore methods. */
- const bool m_readonly_p;
/* If this is a read-write cache, which thread's registers is
it connected to? */
ptid_t m_ptid;
registers_changed_ptid (ptid_t ptid);
};
-/* Duplicate the contents of a register cache to a read-only register
- cache. The operation is pass-through. */
-extern struct regcache *regcache_dup (struct regcache *regcache);
+class readonly_detached_regcache : public readable_regcache
+{
+public:
+ readonly_detached_regcache (const regcache &src);
+
+ /* Create a readonly regcache by getting contents from COOKED_READ. */
+
+ readonly_detached_regcache (gdbarch *gdbarch,
+ regcache_cooked_read_ftype *cooked_read,
+ void *src)
+ : readable_regcache (gdbarch, true)
+ {
+ save (cooked_read, src);
+ }
+
+ DISABLE_COPY_AND_ASSIGN (readonly_detached_regcache);
+
+ void raw_update (int regnum) override
+ {}
+};
extern void registers_changed (void);
extern void registers_changed_ptid (ptid_t);
+/* An abstract base class for register dump. */
+
+class register_dump
+{
+public:
+ void dump (ui_file *file);
+ virtual ~register_dump () = default;
+
+protected:
+ register_dump (gdbarch *arch)
+ : m_gdbarch (arch)
+ {}
+
+ /* Dump the register REGNUM contents. If REGNUM is -1, print the
+ header. */
+ virtual void dump_reg (ui_file *file, int regnum) = 0;
+
+ gdbarch *m_gdbarch;
+};
+
#endif /* REGCACHE_H */
projects / deliverable / binutils-gdb.git / blobdiff