+2018-02-21 Yao Qi <yao.qi@linaro.org>
+
+ * jit.c (struct jit_unwind_private) <regcache>: Change its type to
+ reg_buffer_rw *.
+ (jit_unwind_reg_set_impl): Call raw_supply.
+ (jit_frame_sniffer): Use reg_buffer_rw.
+ * record-full.c (record_full_core_regbuf): Change its type.
+ (record_full_core_open_1): Use reg_buffer_rw.
+ (record_full_close): Likewise.
+ (record_full_core_fetch_registers): Use regcache->raw_supply.
+ (record_full_core_store_registers): Likewise.
+ * regcache.c (regcache::get_register_status): Move it to
+ reg_buffer.
+ (regcache_raw_set_cached_value): Remove.
+ (regcache::raw_set_cached_value): Remove.
+ (regcache::raw_write): Call raw_supply.
+ (regcache::raw_supply): Move it to reg_buffer_rw.
+ * regcache.h (regcache_raw_set_cached_value): Remove.
+ (reg_buffer_rw): New class.
+
2018-02-21 Yao Qi <yao.qi@linaro.org>
* dummy-frame.c (dummy_frame_cache) <prev_regcache>: Use
{
/* Cached register values. See jit_frame_sniffer to see how this
works. */
- struct regcache *regcache;
+ detached_regcache *regcache;
/* The frame being unwound. */
struct frame_info *this_frame;
return;
}
- regcache_raw_set_cached_value (priv->regcache, gdb_reg, value->value);
+ priv->regcache->raw_supply (gdb_reg, value->value);
value->free (value);
}
struct jit_unwind_private *priv_data;
struct gdb_unwind_callbacks callbacks;
struct gdb_reader_funcs *funcs;
- struct gdbarch *gdbarch;
callbacks.reg_get = jit_unwind_reg_get_impl;
callbacks.reg_set = jit_unwind_reg_set_impl;
gdb_assert (!*cache);
- gdbarch = get_frame_arch (this_frame);
-
*cache = XCNEW (struct jit_unwind_private);
priv_data = (struct jit_unwind_private *) *cache;
- priv_data->regcache = new regcache (gdbarch);
+ /* Take a snapshot of current regcache. */
+ priv_data->regcache = new detached_regcache (get_frame_arch (this_frame),
+ true);
priv_data->this_frame = this_frame;
callbacks.priv_data = priv_data;
};
/* Record buf with core target. */
-static gdb_byte *record_full_core_regbuf = NULL;
+static detached_regcache *record_full_core_regbuf = NULL;
static struct target_section *record_full_core_start;
static struct target_section *record_full_core_end;
static struct record_full_core_buf_entry *record_full_core_buf_list = NULL;
/* Get record_full_core_regbuf. */
target_fetch_registers (regcache, -1);
- record_full_core_regbuf = (gdb_byte *) xmalloc (MAX_REGISTER_SIZE * regnum);
+ record_full_core_regbuf = new detached_regcache (regcache->arch (), false);
+
for (i = 0; i < regnum; i ++)
- regcache_raw_collect (regcache, i,
- record_full_core_regbuf + MAX_REGISTER_SIZE * i);
+ record_full_core_regbuf->raw_supply (i, *regcache);
/* Get record_full_core_start and record_full_core_end. */
if (build_section_table (core_bfd, &record_full_core_start,
&record_full_core_end))
{
- xfree (record_full_core_regbuf);
+ delete record_full_core_regbuf;
record_full_core_regbuf = NULL;
error (_("\"%s\": Can't find sections: %s"),
bfd_get_filename (core_bfd), bfd_errmsg (bfd_get_error ()));
/* Release record_full_core_regbuf. */
if (record_full_core_regbuf)
{
- xfree (record_full_core_regbuf);
+ delete record_full_core_regbuf;
record_full_core_regbuf = NULL;
}
int i;
for (i = 0; i < num; i ++)
- regcache_raw_supply (regcache, i,
- record_full_core_regbuf + MAX_REGISTER_SIZE * i);
+ regcache->raw_supply (i, *record_full_core_regbuf);
}
else
- regcache_raw_supply (regcache, regno,
- record_full_core_regbuf + MAX_REGISTER_SIZE * regno);
+ regcache->raw_supply (regno, *record_full_core_regbuf);
}
/* "to_prepare_to_store" method for prec over corefile. */
int regno)
{
if (record_full_gdb_operation_disable)
- regcache_raw_collect (regcache, regno,
- record_full_core_regbuf + MAX_REGISTER_SIZE * regno);
+ record_full_core_regbuf->raw_supply (regno, *regcache);
else
error (_("You can't do that without a process to debug."));
}
/* The register buffers. A read-only register cache can hold the
full [0 .. gdbarch_num_regs + gdbarch_num_pseudo_regs) while a
read/write register cache can only hold [0 .. gdbarch_num_regs). */
- : readable_regcache (gdbarch, readonly_p_),
+ : detached_regcache (gdbarch, readonly_p_),
m_aspace (aspace_), m_readonly_p (readonly_p_)
{
m_ptid = minus_one_ptid;
}
enum register_status
-regcache::get_register_status (int regnum) const
+reg_buffer::get_register_status (int regnum) const
{
- gdb_assert (regnum >= 0);
- if (m_readonly_p)
- gdb_assert (regnum < m_descr->nr_cooked_registers);
- else
- gdb_assert (regnum < num_raw_registers ());
+ assert_regnum (regnum);
return (enum register_status) m_register_status[regnum];
}
regcache->cooked_write (regnum, val);
}
-/* See regcache.h. */
-
-void
-regcache_raw_set_cached_value (struct regcache *regcache, int regnum,
- const gdb_byte *buf)
-{
- regcache->raw_set_cached_value (regnum, buf);
-}
-
-void
-regcache::raw_set_cached_value (int regnum, const gdb_byte *buf)
-{
- memcpy (register_buffer (regnum), buf,
- m_descr->sizeof_register[regnum]);
- m_register_status[regnum] = REG_VALID;
-}
-
void
regcache_raw_write (struct regcache *regcache, int regnum,
const gdb_byte *buf)
return;
target_prepare_to_store (this);
- raw_set_cached_value (regnum, buf);
+ raw_supply (regnum, buf);
/* Invalidate the register after it is written, in case of a
failure. */
}
void
-regcache::raw_supply (int regnum, const void *buf)
+detached_regcache::raw_supply (int regnum, const void *buf)
{
void *regbuf;
size_t size;
assert_regnum (regnum);
- gdb_assert (!m_readonly_p);
regbuf = register_buffer (regnum);
size = m_descr->sizeof_register[regnum];
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. */
/* 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;
signed char *m_register_status;
friend class regcache;
+ friend class detached_regcache;
};
/* An abstract class which only has methods doing read. */
bool is_raw);
};
+/* Buffer of registers, can be read and written. */
+
+class detached_regcache : public readable_regcache
+{
+public:
+ detached_regcache (gdbarch *gdbarch, bool has_pseudo)
+ : readable_regcache (gdbarch, has_pseudo)
+ {}
+
+ void raw_supply (int regnum, const void *buf);
+
+ void raw_supply (int regnum, const reg_buffer &src)
+ {
+ raw_supply (regnum, src.register_buffer (regnum));
+ }
+
+ void raw_update (int regnum) override
+ {}
+
+ DISABLE_COPY_AND_ASSIGN (detached_regcache);
+};
+
class readonly_detached_regcache;
/* The register cache for storing raw register values. */
-class regcache : public readable_regcache
+class regcache : public detached_regcache
{
public:
regcache (gdbarch *gdbarch)
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);
projects / binutils-gdb.git / commitdiff