regcache *backup = new regcache (get_frame_arch (this_frame), aspace);
struct cleanup *cleanups = make_cleanup_regcache_delete (backup);
- regcache_save (backup, do_frame_register_read, this_frame);
+ backup->save (do_frame_register_read, this_frame);
discard_cleanups (cleanups);
return backup;
}
Unfortunately, they don't implement it. Their lack of a formal
definition can lead to targets writing back bogus values
(arguably a bug in the target code mind). */
- /* Now copy those saved registers into the current regcache.
- Here, regcache_cpy() calls regcache_restore(). */
- regcache_cpy (get_current_regcache (), scratch);
+ /* Now copy those saved registers into the current regcache. */
+ scratch->restore_to (get_current_regcache ());
do_cleanups (cleanups);
/* We've made right mess of GDB's local state, just discard
struct value *
get_return_value (struct value *function, struct type *value_type)
{
- regcache stop_regs (regcache::readonly, *get_current_regcache ());
- struct gdbarch *gdbarch = stop_regs.arch ();
+ regcache *stop_regs = get_current_regcache ()->dup ();
+ struct gdbarch *gdbarch = stop_regs->arch ();
struct value *value;
value_type = check_typedef (value_type);
case RETURN_VALUE_ABI_RETURNS_ADDRESS:
case RETURN_VALUE_ABI_PRESERVES_ADDRESS:
value = allocate_value (value_type);
- gdbarch_return_value (gdbarch, function, value_type, &stop_regs,
+ gdbarch_return_value (gdbarch, function, value_type, stop_regs,
value_contents_raw (value), NULL);
break;
case RETURN_VALUE_STRUCT_CONVENTION:
internal_error (__FILE__, __LINE__, _("bad switch"));
}
+ delete stop_regs;
return value;
}
inf_state->stop_pc = stop_pc;
- inf_state->registers = regcache_dup (regcache);
+ inf_state->registers = regcache->dup ();
return inf_state;
}
restore_infcall_suspend_state (struct infcall_suspend_state *inf_state)
{
struct thread_info *tp = inferior_thread ();
- struct regcache *regcache = get_current_regcache ();
+ target_regcache *regcache = get_current_regcache ();
struct gdbarch *gdbarch = get_regcache_arch (regcache);
tp->suspend = inf_state->thread_suspend;
(and perhaps other times). */
if (target_has_execution)
/* NB: The register write goes through to the target. */
- regcache_cpy (regcache, inf_state->registers);
+ inf_state->registers->restore_to (regcache);
discard_infcall_suspend_state (inf_state);
}
linux_nat_switch_fork (fp->ptid);
if (fp->savedregs && fp->clobber_regs)
- regcache_cpy (get_current_regcache (), fp->savedregs);
+ fp->savedregs->restore_to (get_current_regcache ());
registers_changed ();
reinit_frame_cache ();
if (fp->savedregs)
delete fp->savedregs;
- fp->savedregs = regcache_dup (get_current_regcache ());
+ fp->savedregs = get_current_regcache ()->dup ();
fp->clobber_regs = clobber_regs;
if (clobber_regs)
struct address_space *aspace = get_frame_address_space (this_frame);
regcache *backup = new regcache (data.gdbarch, aspace);
struct cleanup *cleanups = make_cleanup_regcache_delete (backup);
- regcache_save (backup, ppu2spu_unwind_register, &data);
+ backup->save (ppu2spu_unwind_register, &data);
discard_cleanups (cleanups);
cache->frame_id = frame_id_build (base, func);
return regcache_cooked_read (regcache, regnum, buf);
}
-regcache::regcache (readonly_t, const regcache &src)
- : regcache (src.arch (), src.aspace (), true)
-{
- gdb_assert (!src.m_readonly_p);
- save (do_cooked_read, (void *) &src);
-}
-
gdbarch *
regcache::arch () const
{
}
void
-regcache_save (struct regcache *regcache,
- regcache_cooked_read_ftype *cooked_read, void *src)
-{
- regcache->save (cooked_read, src);
-}
-
-void
-regcache::save (regcache_cooked_read_ftype *cooked_read,
- void *src)
+regcache::save (regcache_cooked_read_ftype *cooked_read, void *src)
{
struct gdbarch *gdbarch = m_descr->gdbarch;
int regnum;
- /* The DST should be `read-only', if it wasn't then the save would
- end up trying to write the register values back out to the
- target. */
- gdb_assert (m_readonly_p);
/* Clear the dest. */
memset (m_registers, 0, m_descr->sizeof_cooked_registers);
memset (m_register_status, 0, m_descr->sizeof_cooked_register_status);
}
void
-regcache::restore (struct regcache *src)
+regcache::restore_to (target_regcache *dst)
{
struct gdbarch *gdbarch = m_descr->gdbarch;
int regnum;
+ gdb_assert (dst != NULL);
+ gdb_assert (dst->m_descr->gdbarch == m_descr->gdbarch);
+ gdb_assert (dst != this);
- /* The dst had better not be read-only. If it is, the `restore'
- doesn't make much sense. */
- gdb_assert (!m_readonly_p);
- gdb_assert (src->m_readonly_p);
/* Copy over any registers, being careful to only restore those that
were both saved and need to be restored. The full [0 .. gdbarch_num_regs
+ gdbarch_num_pseudo_regs) range is checked since some architectures need
{
if (gdbarch_register_reggroup_p (gdbarch, regnum, restore_reggroup))
{
- if (src->m_register_status[regnum] == REG_VALID)
- cooked_write (regnum, src->register_buffer (regnum));
+ if (m_register_status[regnum] == REG_VALID)
+ dst->cooked_write (regnum, register_buffer (regnum));
}
}
}
-void
-regcache_cpy (struct regcache *dst, struct regcache *src)
+/* Duplicate detached regcache to a detached regcache. */
+regcache*
+regcache::dup ()
{
- gdb_assert (src != NULL && dst != NULL);
- gdb_assert (src->m_descr->gdbarch == dst->m_descr->gdbarch);
- gdb_assert (src != dst);
- gdb_assert (src->m_readonly_p && !dst->m_readonly_p);
+ regcache *new_regcache = new regcache (arch (), aspace ());
+
+ memcpy (new_regcache->m_registers, m_registers,
+ m_descr->sizeof_cooked_registers);
+ memcpy (new_regcache->m_register_status, m_register_status,
+ m_descr->sizeof_cooked_register_status);
- dst->restore (src);
+ return new_regcache;
}
-struct regcache *
-regcache_dup (struct regcache *src)
+/* Duplicate a target_regcache to a detached regcache. */
+regcache*
+target_regcache::dup ()
{
- return new regcache (regcache::readonly, *src);
+ regcache *new_regcache = new regcache (arch (), aspace ());
+ new_regcache->save (do_cooked_read, (void *) this);
+ return new_regcache;
}
enum register_status
extern int register_size (struct gdbarch *gdbarch, int regnum);
-
-/* Save/restore a register cache. The set of registers saved /
- restored into the DST regcache determined by the save_reggroup /
- restore_reggroup respectively. COOKED_READ returns zero iff the
- register's value can't be returned. */
-
typedef enum register_status (regcache_cooked_read_ftype) (void *src,
int regnum,
gdb_byte *buf);
-extern void regcache_save (struct regcache *dst,
- regcache_cooked_read_ftype *cooked_read,
- void *cooked_read_context);
-
enum regcache_dump_what
{
regcache_dump_none, regcache_dump_raw,
: regcache (gdbarch, aspace_, true)
{}
- struct readonly_t {};
- static constexpr readonly_t readonly {};
-
- /* Create a readonly regcache from a non-readonly regcache. */
- regcache (readonly_t, const regcache &src);
-
regcache (const regcache &) = delete;
void operator= (const regcache &) = delete;
return m_aspace;
}
+ /* Duplicate self into a new regcache. */
+ virtual regcache* dup ();
+
+ /* Copy the register contents from a target_regcache to self.
+ All cooked registers are read and cached. */
void save (regcache_cooked_read_ftype *cooked_read, void *src);
+ /* Copy register contents to a target_regcache. All cached cooked registers
+ are also restored. */
+ void restore_to (target_regcache *dst);
+
enum register_status cooked_read (int regnum, gdb_byte *buf);
void cooked_write (int regnum, const gdb_byte *buf);
gdb_byte *register_buffer (int regnum) const;
- void restore (struct regcache *src);
-
struct regcache_descr *m_descr;
/* The address space of this register cache (for registers where it
/* Register cache status. */
signed char *m_register_status;
- /* 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 updated via the methods regcache_dup() and
- regcache_cpy(). The actual contents are determined by the
- reggroup_save and reggroup_restore methods. */
+
+ /* A read-only cache can not change it's register contents, except from
+ an target_regcache via the save () method.
+ A target_regcache cache can never be read-only. */
bool m_readonly_p;
private:
private:
- friend void
- regcache_cpy (struct regcache *dst, struct regcache *src);
};
{
public:
+ target_regcache (const target_regcache &) = delete;
+ void operator= (const target_regcache &) = delete;
+
+ /* Cannot be called on a target_regcache. */
+ void save (regcache_cooked_read_ftype *cooked_read, void *src) = delete;
+ void restore_to (target_regcache *dst) = delete;
+
+ /* Duplicate self into a new regcache. Result is not a target_regcache. */
+ regcache* dup ();
+
/* Overridden regcache methods. These versions will pass the read/write
through to the target. */
enum register_status raw_read (int regnum, gdb_byte *buf);
friend void 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);
-
-/* Writes to DEST will go through to the target. SRC is a read-only
- register cache. */
-extern void regcache_cpy (struct regcache *dest, struct regcache *src);
-
extern void registers_changed (void);
extern void registers_changed_ptid (ptid_t);
{
struct regcache *regcache;
regcache = get_thread_arch_regcache (inferior_ptid, target_gdbarch ());
- cache->regcache = regcache_dup (regcache);
+ cache->regcache = regcache->dup ();
*this_prologue_cache = cache;
return 1;
}
projects / thirdparty / binutils-gdb.git / commitdiff
