#include "event-loop.h"
#include "inf-loop.h"
#include "vec.h"
+#include "inferior.h"
#include <algorithm>
+static const target_info record_btrace_target_info = {
+ "record-btrace",
+ N_("Branch tracing target"),
+ N_("Collect control-flow trace and provide the execution history.")
+};
+
/* The target_ops of record-btrace. */
-static struct target_ops record_btrace_ops;
+
+class record_btrace_target final : public target_ops
+{
+public:
+ const target_info &info () const override
+ { return record_btrace_target_info; }
+
+ strata stratum () const override { return record_stratum; }
+
+ void close () override;
+ void async (int) override;
+
+ void detach (inferior *inf, int from_tty) override
+ { record_detach (this, inf, from_tty); }
+
+ void disconnect (const char *, int) override;
+
+ void mourn_inferior () override
+ { record_mourn_inferior (this); }
+
+ void kill () override
+ { record_kill (this); }
+
+ enum record_method record_method (ptid_t ptid) override;
+
+ void stop_recording () override;
+ void info_record () override;
+
+ void insn_history (int size, gdb_disassembly_flags flags) override;
+ void insn_history_from (ULONGEST from, int size,
+ gdb_disassembly_flags flags) override;
+ void insn_history_range (ULONGEST begin, ULONGEST end,
+ gdb_disassembly_flags flags) override;
+ void call_history (int size, record_print_flags flags) override;
+ void call_history_from (ULONGEST begin, int size, record_print_flags flags)
+ override;
+ void call_history_range (ULONGEST begin, ULONGEST end, record_print_flags flags)
+ override;
+
+ bool record_is_replaying (ptid_t ptid) override;
+ bool record_will_replay (ptid_t ptid, int dir) override;
+ void record_stop_replaying () override;
+
+ enum target_xfer_status xfer_partial (enum target_object object,
+ const char *annex,
+ gdb_byte *readbuf,
+ const gdb_byte *writebuf,
+ ULONGEST offset, ULONGEST len,
+ ULONGEST *xfered_len) override;
+
+ int insert_breakpoint (struct gdbarch *,
+ struct bp_target_info *) override;
+ int remove_breakpoint (struct gdbarch *, struct bp_target_info *,
+ enum remove_bp_reason) override;
+
+ void fetch_registers (struct regcache *, int) override;
+
+ void store_registers (struct regcache *, int) override;
+ void prepare_to_store (struct regcache *) override;
+
+ const struct frame_unwind *get_unwinder () override;
+
+ const struct frame_unwind *get_tailcall_unwinder () override;
+
+ void commit_resume () override;
+ void resume (ptid_t, int, enum gdb_signal) override;
+ ptid_t wait (ptid_t, struct target_waitstatus *, int) override;
+
+ void stop (ptid_t) override;
+ void update_thread_list () override;
+ bool thread_alive (ptid_t ptid) override;
+ void goto_record_begin () override;
+ void goto_record_end () override;
+ void goto_record (ULONGEST insn) override;
+
+ bool can_execute_reverse () override;
+
+ bool stopped_by_sw_breakpoint () override;
+ bool supports_stopped_by_sw_breakpoint () override;
+
+ bool stopped_by_hw_breakpoint () override;
+ bool supports_stopped_by_hw_breakpoint () override;
+
+ enum exec_direction_kind execution_direction () override;
+ void prepare_to_generate_core () override;
+ void done_generating_core () override;
+};
+
+static record_btrace_target record_btrace_ops;
+
+/* Initialize the record-btrace target ops. */
/* Token associated with a new-thread observer enabling branch tracing
for the new thread. */
static struct thread_info *
require_btrace_thread (void)
{
- struct thread_info *tp;
-
DEBUG ("require");
- tp = find_thread_ptid (inferior_ptid);
- if (tp == NULL)
+ if (inferior_ptid == null_ptid)
error (_("No thread."));
+ thread_info *tp = inferior_thread ();
+
validate_registers_access ();
btrace_fetch (tp, record_btrace_get_cpu ());
std::forward_list<thread_info *> m_threads;
};
-/* The to_open method of target record-btrace. */
+/* Open target record-btrace. */
static void
-record_btrace_open (const char *args, int from_tty)
+record_btrace_target_open (const char *args, int from_tty)
{
/* If we fail to enable btrace for one thread, disable it for the threads for
which it was successfully enabled. */
scoped_btrace_disable btrace_disable;
- struct thread_info *tp;
DEBUG ("open");
if (!target_has_execution)
error (_("The program is not being run."));
- ALL_NON_EXITED_THREADS (tp)
+ for (thread_info *tp : all_non_exited_threads ())
if (args == NULL || *args == 0 || number_is_in_list (args, tp->global_num))
{
btrace_enable (tp, &record_btrace_conf);
btrace_disable.discard ();
}
-/* The to_stop_recording method of target record-btrace. */
+/* The stop_recording method of target record-btrace. */
-static void
-record_btrace_stop_recording (struct target_ops *self)
+void
+record_btrace_target::stop_recording ()
{
- struct thread_info *tp;
-
DEBUG ("stop recording");
record_btrace_auto_disable ();
- ALL_NON_EXITED_THREADS (tp)
+ for (thread_info *tp : all_non_exited_threads ())
if (tp->btrace.target != NULL)
btrace_disable (tp);
}
-/* The to_disconnect method of target record-btrace. */
+/* The disconnect method of target record-btrace. */
-static void
-record_btrace_disconnect (struct target_ops *self, const char *args,
- int from_tty)
+void
+record_btrace_target::disconnect (const char *args,
+ int from_tty)
{
- struct target_ops *beneath = self->beneath;
+ struct target_ops *beneath = this->beneath ();
/* Do not stop recording, just clean up GDB side. */
- unpush_target (self);
+ unpush_target (this);
/* Forward disconnect. */
- beneath->to_disconnect (beneath, args, from_tty);
+ beneath->disconnect (args, from_tty);
}
-/* The to_close method of target record-btrace. */
+/* The close method of target record-btrace. */
-static void
-record_btrace_close (struct target_ops *self)
+void
+record_btrace_target::close ()
{
- struct thread_info *tp;
-
if (record_btrace_async_inferior_event_handler != NULL)
delete_async_event_handler (&record_btrace_async_inferior_event_handler);
/* We should have already stopped recording.
Tear down btrace in case we have not. */
- ALL_NON_EXITED_THREADS (tp)
+ for (thread_info *tp : all_non_exited_threads ())
btrace_teardown (tp);
}
-/* The to_async method of target record-btrace. */
+/* The async method of target record-btrace. */
-static void
-record_btrace_async (struct target_ops *ops, int enable)
+void
+record_btrace_target::async (int enable)
{
if (enable)
mark_async_event_handler (record_btrace_async_inferior_event_handler);
else
clear_async_event_handler (record_btrace_async_inferior_event_handler);
- ops->beneath->to_async (ops->beneath, enable);
+ this->beneath ()->async (enable);
}
/* Adjusts the size and returns a human readable size suffix. */
internal_error (__FILE__, __LINE__, _("Unkown branch trace format."));
}
-/* The to_info_record method of target record-btrace. */
+/* The info_record method of target record-btrace. */
-static void
-record_btrace_info (struct target_ops *self)
+void
+record_btrace_target::info_record ()
{
struct btrace_thread_info *btinfo;
const struct btrace_config *conf;
btinfo = &tp->btrace;
- conf = btrace_conf (btinfo);
+ conf = ::btrace_conf (btinfo);
if (conf != NULL)
record_btrace_print_conf (conf);
}
}
-/* The to_insn_history method of target record-btrace. */
+/* The insn_history method of target record-btrace. */
-static void
-record_btrace_insn_history (struct target_ops *self, int size,
- gdb_disassembly_flags flags)
+void
+record_btrace_target::insn_history (int size, gdb_disassembly_flags flags)
{
struct btrace_thread_info *btinfo;
struct btrace_insn_history *history;
btrace_set_insn_history (btinfo, &begin, &end);
}
-/* The to_insn_history_range method of target record-btrace. */
+/* The insn_history_range method of target record-btrace. */
-static void
-record_btrace_insn_history_range (struct target_ops *self,
- ULONGEST from, ULONGEST to,
- gdb_disassembly_flags flags)
+void
+record_btrace_target::insn_history_range (ULONGEST from, ULONGEST to,
+ gdb_disassembly_flags flags)
{
struct btrace_thread_info *btinfo;
struct btrace_insn_iterator begin, end;
btrace_set_insn_history (btinfo, &begin, &end);
}
-/* The to_insn_history_from method of target record-btrace. */
+/* The insn_history_from method of target record-btrace. */
-static void
-record_btrace_insn_history_from (struct target_ops *self,
- ULONGEST from, int size,
- gdb_disassembly_flags flags)
+void
+record_btrace_target::insn_history_from (ULONGEST from, int size,
+ gdb_disassembly_flags flags)
{
ULONGEST begin, end, context;
end = ULONGEST_MAX;
}
- record_btrace_insn_history_range (self, begin, end, flags);
+ insn_history_range (begin, end, flags);
}
/* Print the instruction number range for a function call history line. */
}
}
-/* The to_call_history method of target record-btrace. */
+/* The call_history method of target record-btrace. */
-static void
-record_btrace_call_history (struct target_ops *self, int size,
- record_print_flags flags)
+void
+record_btrace_target::call_history (int size, record_print_flags flags)
{
struct btrace_thread_info *btinfo;
struct btrace_call_history *history;
btrace_set_call_history (btinfo, &begin, &end);
}
-/* The to_call_history_range method of target record-btrace. */
+/* The call_history_range method of target record-btrace. */
-static void
-record_btrace_call_history_range (struct target_ops *self,
- ULONGEST from, ULONGEST to,
- record_print_flags flags)
+void
+record_btrace_target::call_history_range (ULONGEST from, ULONGEST to,
+ record_print_flags flags)
{
struct btrace_thread_info *btinfo;
struct btrace_call_iterator begin, end;
btrace_set_call_history (btinfo, &begin, &end);
}
-/* The to_call_history_from method of target record-btrace. */
+/* The call_history_from method of target record-btrace. */
-static void
-record_btrace_call_history_from (struct target_ops *self,
- ULONGEST from, int size,
- record_print_flags flags)
+void
+record_btrace_target::call_history_from (ULONGEST from, int size,
+ record_print_flags flags)
{
ULONGEST begin, end, context;
end = ULONGEST_MAX;
}
- record_btrace_call_history_range (self, begin, end, flags);
+ call_history_range ( begin, end, flags);
}
-/* The to_record_method method of target record-btrace. */
+/* The record_method method of target record-btrace. */
-static enum record_method
-record_btrace_record_method (struct target_ops *self, ptid_t ptid)
+enum record_method
+record_btrace_target::record_method (ptid_t ptid)
{
struct thread_info * const tp = find_thread_ptid (ptid);
return RECORD_METHOD_BTRACE;
}
-/* The to_record_is_replaying method of target record-btrace. */
+/* The record_is_replaying method of target record-btrace. */
-static int
-record_btrace_is_replaying (struct target_ops *self, ptid_t ptid)
+bool
+record_btrace_target::record_is_replaying (ptid_t ptid)
{
- struct thread_info *tp;
+ for (thread_info *tp : all_non_exited_threads (ptid))
+ if (btrace_is_replaying (tp))
+ return true;
- ALL_NON_EXITED_THREADS (tp)
- if (ptid_match (tp->ptid, ptid) && btrace_is_replaying (tp))
- return 1;
-
- return 0;
+ return false;
}
-/* The to_record_will_replay method of target record-btrace. */
+/* The record_will_replay method of target record-btrace. */
-static int
-record_btrace_will_replay (struct target_ops *self, ptid_t ptid, int dir)
+bool
+record_btrace_target::record_will_replay (ptid_t ptid, int dir)
{
- return dir == EXEC_REVERSE || record_btrace_is_replaying (self, ptid);
+ return dir == EXEC_REVERSE || record_is_replaying (ptid);
}
-/* The to_xfer_partial method of target record-btrace. */
+/* The xfer_partial method of target record-btrace. */
-static enum target_xfer_status
-record_btrace_xfer_partial (struct target_ops *ops, enum target_object object,
- const char *annex, gdb_byte *readbuf,
- const gdb_byte *writebuf, ULONGEST offset,
- ULONGEST len, ULONGEST *xfered_len)
+enum target_xfer_status
+record_btrace_target::xfer_partial (enum target_object object,
+ const char *annex, gdb_byte *readbuf,
+ const gdb_byte *writebuf, ULONGEST offset,
+ ULONGEST len, ULONGEST *xfered_len)
{
/* Filter out requests that don't make sense during replay. */
if (replay_memory_access == replay_memory_access_read_only
&& !record_btrace_generating_corefile
- && record_btrace_is_replaying (ops, inferior_ptid))
+ && record_is_replaying (inferior_ptid))
{
switch (object)
{
}
/* We allow reading readonly memory. */
- section = target_section_by_addr (ops, offset);
+ section = target_section_by_addr (this, offset);
if (section != NULL)
{
/* Check if the section we found is readonly. */
}
/* Forward the request. */
- ops = ops->beneath;
- return ops->to_xfer_partial (ops, object, annex, readbuf, writebuf,
- offset, len, xfered_len);
+ return this->beneath ()->xfer_partial (object, annex, readbuf, writebuf,
+ offset, len, xfered_len);
}
-/* The to_insert_breakpoint method of target record-btrace. */
+/* The insert_breakpoint method of target record-btrace. */
-static int
-record_btrace_insert_breakpoint (struct target_ops *ops,
- struct gdbarch *gdbarch,
- struct bp_target_info *bp_tgt)
+int
+record_btrace_target::insert_breakpoint (struct gdbarch *gdbarch,
+ struct bp_target_info *bp_tgt)
{
const char *old;
int ret;
ret = 0;
TRY
{
- ret = ops->beneath->to_insert_breakpoint (ops->beneath, gdbarch, bp_tgt);
+ ret = this->beneath ()->insert_breakpoint (gdbarch, bp_tgt);
}
CATCH (except, RETURN_MASK_ALL)
{
return ret;
}
-/* The to_remove_breakpoint method of target record-btrace. */
+/* The remove_breakpoint method of target record-btrace. */
-static int
-record_btrace_remove_breakpoint (struct target_ops *ops,
- struct gdbarch *gdbarch,
- struct bp_target_info *bp_tgt,
- enum remove_bp_reason reason)
+int
+record_btrace_target::remove_breakpoint (struct gdbarch *gdbarch,
+ struct bp_target_info *bp_tgt,
+ enum remove_bp_reason reason)
{
const char *old;
int ret;
ret = 0;
TRY
{
- ret = ops->beneath->to_remove_breakpoint (ops->beneath, gdbarch, bp_tgt,
- reason);
+ ret = this->beneath ()->remove_breakpoint (gdbarch, bp_tgt, reason);
}
CATCH (except, RETURN_MASK_ALL)
{
return ret;
}
-/* The to_fetch_registers method of target record-btrace. */
+/* The fetch_registers method of target record-btrace. */
-static void
-record_btrace_fetch_registers (struct target_ops *ops,
- struct regcache *regcache, int regno)
+void
+record_btrace_target::fetch_registers (struct regcache *regcache, int regno)
{
struct btrace_insn_iterator *replay;
struct thread_info *tp;
- tp = find_thread_ptid (regcache_get_ptid (regcache));
+ tp = find_thread_ptid (regcache->ptid ());
gdb_assert (tp != NULL);
replay = tp->btrace.replay;
insn = btrace_insn_get (replay);
gdb_assert (insn != NULL);
- regcache_raw_supply (regcache, regno, &insn->pc);
+ regcache->raw_supply (regno, &insn->pc);
}
else
- {
- struct target_ops *t = ops->beneath;
-
- t->to_fetch_registers (t, regcache, regno);
- }
+ this->beneath ()->fetch_registers (regcache, regno);
}
-/* The to_store_registers method of target record-btrace. */
+/* The store_registers method of target record-btrace. */
-static void
-record_btrace_store_registers (struct target_ops *ops,
- struct regcache *regcache, int regno)
+void
+record_btrace_target::store_registers (struct regcache *regcache, int regno)
{
- struct target_ops *t;
-
if (!record_btrace_generating_corefile
- && record_btrace_is_replaying (ops, regcache_get_ptid (regcache)))
+ && record_is_replaying (regcache->ptid ()))
error (_("Cannot write registers while replaying."));
gdb_assert (may_write_registers != 0);
- t = ops->beneath;
- t->to_store_registers (t, regcache, regno);
+ this->beneath ()->store_registers (regcache, regno);
}
-/* The to_prepare_to_store method of target record-btrace. */
+/* The prepare_to_store method of target record-btrace. */
-static void
-record_btrace_prepare_to_store (struct target_ops *ops,
- struct regcache *regcache)
+void
+record_btrace_target::prepare_to_store (struct regcache *regcache)
{
- struct target_ops *t;
-
if (!record_btrace_generating_corefile
- && record_btrace_is_replaying (ops, regcache_get_ptid (regcache)))
+ && record_is_replaying (regcache->ptid ()))
return;
- t = ops->beneath;
- t->to_prepare_to_store (t, regcache);
+ this->beneath ()->prepare_to_store (regcache);
}
/* The branch trace frame cache. */
struct frame_info *next;
/* THIS_FRAME does not contain a reference to its thread. */
- tp = find_thread_ptid (inferior_ptid);
- gdb_assert (tp != NULL);
+ tp = inferior_thread ();
bfun = NULL;
next = get_next_frame (this_frame);
if ((callee->flags & BFUN_UP_LINKS_TO_TAILCALL) == 0)
return 0;
- tinfo = find_thread_ptid (inferior_ptid);
+ tinfo = inferior_thread ();
if (btrace_find_call_by_number (&it, &tinfo->btrace, callee->up) == 0)
return 0;
record_btrace_frame_dealloc_cache
};
-/* Implement the to_get_unwinder method. */
+/* Implement the get_unwinder method. */
-static const struct frame_unwind *
-record_btrace_to_get_unwinder (struct target_ops *self)
+const struct frame_unwind *
+record_btrace_target::get_unwinder ()
{
return &record_btrace_frame_unwind;
}
-/* Implement the to_get_tailcall_unwinder method. */
+/* Implement the get_tailcall_unwinder method. */
-static const struct frame_unwind *
-record_btrace_to_get_tailcall_unwinder (struct target_ops *self)
+const struct frame_unwind *
+record_btrace_target::get_tailcall_unwinder ()
{
return &record_btrace_tailcall_frame_unwind;
}
/* Get the current frame for TP. */
-static struct frame_info *
-get_thread_current_frame (struct thread_info *tp)
+static struct frame_id
+get_thread_current_frame_id (struct thread_info *tp)
{
- struct frame_info *frame;
- ptid_t old_inferior_ptid;
+ struct frame_id id;
int executing;
- /* Set INFERIOR_PTID, which is implicitly used by get_current_frame. */
- old_inferior_ptid = inferior_ptid;
- inferior_ptid = tp->ptid;
+ /* Set current thread, which is implicitly used by
+ get_current_frame. */
+ scoped_restore_current_thread restore_thread;
+
+ switch_to_thread (tp);
/* Clear the executing flag to allow changes to the current frame.
We are not actually running, yet. We just started a reverse execution
command or a record goto command.
For the latter, EXECUTING is false and this has no effect.
- For the former, EXECUTING is true and we're in to_wait, about to
+ For the former, EXECUTING is true and we're in wait, about to
move the thread. Since we need to recompute the stack, we temporarily
set EXECUTING to flase. */
- executing = is_executing (inferior_ptid);
- set_executing (inferior_ptid, 0);
+ executing = tp->executing;
+ set_executing (inferior_ptid, false);
- frame = NULL;
+ id = null_frame_id;
TRY
{
- frame = get_current_frame ();
+ id = get_frame_id (get_current_frame ());
}
CATCH (except, RETURN_MASK_ALL)
{
/* Restore the previous execution state. */
set_executing (inferior_ptid, executing);
- /* Restore the previous inferior_ptid. */
- inferior_ptid = old_inferior_ptid;
-
throw_exception (except);
}
END_CATCH
/* Restore the previous execution state. */
set_executing (inferior_ptid, executing);
- /* Restore the previous inferior_ptid. */
- inferior_ptid = old_inferior_ptid;
-
- return frame;
+ return id;
}
/* Start replaying a thread. */
subroutines after we started replaying. */
TRY
{
- struct frame_info *frame;
struct frame_id frame_id;
int upd_step_frame_id, upd_step_stack_frame_id;
/* The current frame without replaying - computed via normal unwind. */
- frame = get_thread_current_frame (tp);
- frame_id = get_frame_id (frame);
+ frame_id = get_thread_current_frame_id (tp);
/* Check if we need to update any stepping-related frame id's. */
upd_step_frame_id = frame_id_eq (frame_id,
btinfo->replay = replay;
/* Make sure we're not using any stale registers. */
- registers_changed_ptid (tp->ptid);
+ registers_changed_thread (tp);
/* The current frame with replaying - computed via btrace unwind. */
- frame = get_thread_current_frame (tp);
- frame_id = get_frame_id (frame);
+ frame_id = get_thread_current_frame_id (tp);
/* Replace stepping related frames where necessary. */
if (upd_step_frame_id)
xfree (btinfo->replay);
btinfo->replay = NULL;
- registers_changed_ptid (tp->ptid);
+ registers_changed_thread (tp);
throw_exception (except);
}
btinfo->replay = NULL;
/* Make sure we're not leaving any stale registers. */
- registers_changed_ptid (tp->ptid);
+ registers_changed_thread (tp);
}
/* Stop replaying TP if it is at the end of its execution history. */
record_btrace_stop_replaying (tp);
}
-/* The to_resume method of target record-btrace. */
+/* The resume method of target record-btrace. */
-static void
-record_btrace_resume (struct target_ops *ops, ptid_t ptid, int step,
- enum gdb_signal signal)
+void
+record_btrace_target::resume (ptid_t ptid, int step, enum gdb_signal signal)
{
- struct thread_info *tp;
enum btrace_thread_flag flag, cflag;
DEBUG ("resume %s: %s%s", target_pid_to_str (ptid),
- execution_direction == EXEC_REVERSE ? "reverse-" : "",
+ ::execution_direction == EXEC_REVERSE ? "reverse-" : "",
step ? "step" : "cont");
/* Store the execution direction of the last resume.
- If there is more than one to_resume call, we have to rely on infrun
+ If there is more than one resume call, we have to rely on infrun
to not change the execution direction in-between. */
- record_btrace_resume_exec_dir = execution_direction;
+ record_btrace_resume_exec_dir = ::execution_direction;
/* As long as we're not replaying, just forward the request.
For non-stop targets this means that no thread is replaying. In order to
make progress, we may need to explicitly move replaying threads to the end
of their execution history. */
- if ((execution_direction != EXEC_REVERSE)
- && !record_btrace_is_replaying (ops, minus_one_ptid))
+ if ((::execution_direction != EXEC_REVERSE)
+ && !record_is_replaying (minus_one_ptid))
{
- ops = ops->beneath;
- ops->to_resume (ops, ptid, step, signal);
+ this->beneath ()->resume (ptid, step, signal);
return;
}
/* Compute the btrace thread flag for the requested move. */
- if (execution_direction == EXEC_REVERSE)
+ if (::execution_direction == EXEC_REVERSE)
{
flag = step == 0 ? BTHR_RCONT : BTHR_RSTEP;
cflag = BTHR_RCONT;
For all-stop targets, we only step INFERIOR_PTID and continue others. */
if (!target_is_non_stop_p ())
{
- gdb_assert (ptid_match (inferior_ptid, ptid));
+ gdb_assert (inferior_ptid.matches (ptid));
- ALL_NON_EXITED_THREADS (tp)
- if (ptid_match (tp->ptid, ptid))
- {
- if (ptid_match (tp->ptid, inferior_ptid))
- record_btrace_resume_thread (tp, flag);
- else
- record_btrace_resume_thread (tp, cflag);
- }
+ for (thread_info *tp : all_non_exited_threads (ptid))
+ {
+ if (tp->ptid.matches (inferior_ptid))
+ record_btrace_resume_thread (tp, flag);
+ else
+ record_btrace_resume_thread (tp, cflag);
+ }
}
else
{
- ALL_NON_EXITED_THREADS (tp)
- if (ptid_match (tp->ptid, ptid))
- record_btrace_resume_thread (tp, flag);
+ for (thread_info *tp : all_non_exited_threads (ptid))
+ record_btrace_resume_thread (tp, flag);
}
/* Async support. */
}
}
-/* The to_commit_resume method of target record-btrace. */
+/* The commit_resume method of target record-btrace. */
-static void
-record_btrace_commit_resume (struct target_ops *ops)
+void
+record_btrace_target::commit_resume ()
{
- if ((execution_direction != EXEC_REVERSE)
- && !record_btrace_is_replaying (ops, minus_one_ptid))
- ops->beneath->to_commit_resume (ops->beneath);
+ if ((::execution_direction != EXEC_REVERSE)
+ && !record_is_replaying (minus_one_ptid))
+ beneath ()->commit_resume ();
}
/* Cancel resuming TP. */
struct btrace_insn_iterator *replay;
struct btrace_thread_info *btinfo;
const struct btrace_insn *insn;
- struct inferior *inf;
btinfo = &tp->btrace;
replay = btinfo->replay;
if (insn == NULL)
return 0;
- inf = find_inferior_ptid (tp->ptid);
- if (inf == NULL)
- return 0;
-
- return record_check_stopped_by_breakpoint (inf->aspace, insn->pc,
+ return record_check_stopped_by_breakpoint (tp->inf->aspace, insn->pc,
&btinfo->stop_reason);
}
return btrace_step_again ();
}
- /* We keep threads moving at the end of their execution history. The to_wait
+ /* We keep threads moving at the end of their execution history. The wait
method will stop the thread for whom the event is reported. */
if (status.kind == TARGET_WAITKIND_NO_HISTORY)
btinfo->flags |= flags;
return status;
}
-/* A vector of threads. */
-
-typedef struct thread_info * tp_t;
-DEF_VEC_P (tp_t);
-
/* Announce further events if necessary. */
static void
mark_async_event_handler (record_btrace_async_inferior_event_handler);
}
-/* The to_wait method of target record-btrace. */
+/* The wait method of target record-btrace. */
-static ptid_t
-record_btrace_wait (struct target_ops *ops, ptid_t ptid,
- struct target_waitstatus *status, int options)
+ptid_t
+record_btrace_target::wait (ptid_t ptid, struct target_waitstatus *status,
+ int options)
{
std::vector<thread_info *> moving;
std::vector<thread_info *> no_history;
DEBUG ("wait %s (0x%x)", target_pid_to_str (ptid), options);
/* As long as we're not replaying, just forward the request. */
- if ((execution_direction != EXEC_REVERSE)
- && !record_btrace_is_replaying (ops, minus_one_ptid))
+ if ((::execution_direction != EXEC_REVERSE)
+ && !record_is_replaying (minus_one_ptid))
{
- ops = ops->beneath;
- return ops->to_wait (ops, ptid, status, options);
+ return this->beneath ()->wait (ptid, status, options);
}
/* Keep a work list of moving threads. */
- {
- thread_info *tp;
-
- ALL_NON_EXITED_THREADS (tp)
- {
- if (ptid_match (tp->ptid, ptid)
- && ((tp->btrace.flags & (BTHR_MOVE | BTHR_STOP)) != 0))
- moving.push_back (tp);
- }
- }
+ for (thread_info *tp : all_non_exited_threads (ptid))
+ if ((tp->btrace.flags & (BTHR_MOVE | BTHR_STOP)) != 0)
+ moving.push_back (tp);
if (moving.empty ())
{
/* Stop all other threads. */
if (!target_is_non_stop_p ())
{
- thread_info *tp;
-
- ALL_NON_EXITED_THREADS (tp)
+ for (thread_info *tp : all_non_exited_threads ())
record_btrace_cancel_resume (tp);
}
record_btrace_clear_histories (&eventing->btrace);
/* We moved the replay position but did not update registers. */
- registers_changed_ptid (eventing->ptid);
+ registers_changed_thread (eventing);
DEBUG ("wait ended by thread %s (%s): %s",
print_thread_id (eventing),
return eventing->ptid;
}
-/* The to_stop method of target record-btrace. */
+/* The stop method of target record-btrace. */
-static void
-record_btrace_stop (struct target_ops *ops, ptid_t ptid)
+void
+record_btrace_target::stop (ptid_t ptid)
{
DEBUG ("stop %s", target_pid_to_str (ptid));
/* As long as we're not replaying, just forward the request. */
- if ((execution_direction != EXEC_REVERSE)
- && !record_btrace_is_replaying (ops, minus_one_ptid))
+ if ((::execution_direction != EXEC_REVERSE)
+ && !record_is_replaying (minus_one_ptid))
{
- ops = ops->beneath;
- ops->to_stop (ops, ptid);
+ this->beneath ()->stop (ptid);
}
else
{
- struct thread_info *tp;
-
- ALL_NON_EXITED_THREADS (tp)
- if (ptid_match (tp->ptid, ptid))
- {
- tp->btrace.flags &= ~BTHR_MOVE;
- tp->btrace.flags |= BTHR_STOP;
- }
+ for (thread_info *tp : all_non_exited_threads (ptid))
+ {
+ tp->btrace.flags &= ~BTHR_MOVE;
+ tp->btrace.flags |= BTHR_STOP;
+ }
}
}
-/* The to_can_execute_reverse method of target record-btrace. */
+/* The can_execute_reverse method of target record-btrace. */
-static int
-record_btrace_can_execute_reverse (struct target_ops *self)
+bool
+record_btrace_target::can_execute_reverse ()
{
- return 1;
+ return true;
}
-/* The to_stopped_by_sw_breakpoint method of target record-btrace. */
+/* The stopped_by_sw_breakpoint method of target record-btrace. */
-static int
-record_btrace_stopped_by_sw_breakpoint (struct target_ops *ops)
+bool
+record_btrace_target::stopped_by_sw_breakpoint ()
{
- if (record_btrace_is_replaying (ops, minus_one_ptid))
+ if (record_is_replaying (minus_one_ptid))
{
struct thread_info *tp = inferior_thread ();
return tp->btrace.stop_reason == TARGET_STOPPED_BY_SW_BREAKPOINT;
}
- return ops->beneath->to_stopped_by_sw_breakpoint (ops->beneath);
+ return this->beneath ()->stopped_by_sw_breakpoint ();
}
-/* The to_supports_stopped_by_sw_breakpoint method of target
+/* The supports_stopped_by_sw_breakpoint method of target
record-btrace. */
-static int
-record_btrace_supports_stopped_by_sw_breakpoint (struct target_ops *ops)
+bool
+record_btrace_target::supports_stopped_by_sw_breakpoint ()
{
- if (record_btrace_is_replaying (ops, minus_one_ptid))
- return 1;
+ if (record_is_replaying (minus_one_ptid))
+ return true;
- return ops->beneath->to_supports_stopped_by_sw_breakpoint (ops->beneath);
+ return this->beneath ()->supports_stopped_by_sw_breakpoint ();
}
-/* The to_stopped_by_sw_breakpoint method of target record-btrace. */
+/* The stopped_by_sw_breakpoint method of target record-btrace. */
-static int
-record_btrace_stopped_by_hw_breakpoint (struct target_ops *ops)
+bool
+record_btrace_target::stopped_by_hw_breakpoint ()
{
- if (record_btrace_is_replaying (ops, minus_one_ptid))
+ if (record_is_replaying (minus_one_ptid))
{
struct thread_info *tp = inferior_thread ();
return tp->btrace.stop_reason == TARGET_STOPPED_BY_HW_BREAKPOINT;
}
- return ops->beneath->to_stopped_by_hw_breakpoint (ops->beneath);
+ return this->beneath ()->stopped_by_hw_breakpoint ();
}
-/* The to_supports_stopped_by_hw_breakpoint method of target
+/* The supports_stopped_by_hw_breakpoint method of target
record-btrace. */
-static int
-record_btrace_supports_stopped_by_hw_breakpoint (struct target_ops *ops)
+bool
+record_btrace_target::supports_stopped_by_hw_breakpoint ()
{
- if (record_btrace_is_replaying (ops, minus_one_ptid))
- return 1;
+ if (record_is_replaying (minus_one_ptid))
+ return true;
- return ops->beneath->to_supports_stopped_by_hw_breakpoint (ops->beneath);
+ return this->beneath ()->supports_stopped_by_hw_breakpoint ();
}
-/* The to_update_thread_list method of target record-btrace. */
+/* The update_thread_list method of target record-btrace. */
-static void
-record_btrace_update_thread_list (struct target_ops *ops)
+void
+record_btrace_target::update_thread_list ()
{
/* We don't add or remove threads during replay. */
- if (record_btrace_is_replaying (ops, minus_one_ptid))
+ if (record_is_replaying (minus_one_ptid))
return;
/* Forward the request. */
- ops = ops->beneath;
- ops->to_update_thread_list (ops);
+ this->beneath ()->update_thread_list ();
}
-/* The to_thread_alive method of target record-btrace. */
+/* The thread_alive method of target record-btrace. */
-static int
-record_btrace_thread_alive (struct target_ops *ops, ptid_t ptid)
+bool
+record_btrace_target::thread_alive (ptid_t ptid)
{
/* We don't add or remove threads during replay. */
- if (record_btrace_is_replaying (ops, minus_one_ptid))
- return find_thread_ptid (ptid) != NULL;
+ if (record_is_replaying (minus_one_ptid))
+ return true;
/* Forward the request. */
- ops = ops->beneath;
- return ops->to_thread_alive (ops, ptid);
+ return this->beneath ()->thread_alive (ptid);
}
/* Set the replay branch trace instruction iterator. If IT is NULL, replay
return;
*btinfo->replay = *it;
- registers_changed_ptid (tp->ptid);
+ registers_changed_thread (tp);
}
/* Start anew from the new replay position. */
record_btrace_clear_histories (btinfo);
- stop_pc = regcache_read_pc (get_current_regcache ());
+ inferior_thread ()->suspend.stop_pc
+ = regcache_read_pc (get_current_regcache ());
print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC, 1);
}
-/* The to_goto_record_begin method of target record-btrace. */
+/* The goto_record_begin method of target record-btrace. */
-static void
-record_btrace_goto_begin (struct target_ops *self)
+void
+record_btrace_target::goto_record_begin ()
{
struct thread_info *tp;
struct btrace_insn_iterator begin;
record_btrace_set_replay (tp, &begin);
}
-/* The to_goto_record_end method of target record-btrace. */
+/* The goto_record_end method of target record-btrace. */
-static void
-record_btrace_goto_end (struct target_ops *ops)
+void
+record_btrace_target::goto_record_end ()
{
struct thread_info *tp;
record_btrace_set_replay (tp, NULL);
}
-/* The to_goto_record method of target record-btrace. */
+/* The goto_record method of target record-btrace. */
-static void
-record_btrace_goto (struct target_ops *self, ULONGEST insn)
+void
+record_btrace_target::goto_record (ULONGEST insn)
{
struct thread_info *tp;
struct btrace_insn_iterator it;
record_btrace_set_replay (tp, &it);
}
-/* The to_record_stop_replaying method of target record-btrace. */
+/* The record_stop_replaying method of target record-btrace. */
-static void
-record_btrace_stop_replaying_all (struct target_ops *self)
+void
+record_btrace_target::record_stop_replaying ()
{
- struct thread_info *tp;
-
- ALL_NON_EXITED_THREADS (tp)
+ for (thread_info *tp : all_non_exited_threads ())
record_btrace_stop_replaying (tp);
}
-/* The to_execution_direction target method. */
+/* The execution_direction target method. */
-static enum exec_direction_kind
-record_btrace_execution_direction (struct target_ops *self)
+enum exec_direction_kind
+record_btrace_target::execution_direction ()
{
return record_btrace_resume_exec_dir;
}
-/* The to_prepare_to_generate_core target method. */
+/* The prepare_to_generate_core target method. */
-static void
-record_btrace_prepare_to_generate_core (struct target_ops *self)
+void
+record_btrace_target::prepare_to_generate_core ()
{
record_btrace_generating_corefile = 1;
}
-/* The to_done_generating_core target method. */
+/* The done_generating_core target method. */
-static void
-record_btrace_done_generating_core (struct target_ops *self)
+void
+record_btrace_target::done_generating_core ()
{
record_btrace_generating_corefile = 0;
}
-/* Initialize the record-btrace target ops. */
-
-static void
-init_record_btrace_ops (void)
-{
- struct target_ops *ops;
-
- ops = &record_btrace_ops;
- ops->to_shortname = "record-btrace";
- ops->to_longname = "Branch tracing target";
- ops->to_doc = "Collect control-flow trace and provide the execution history.";
- ops->to_open = record_btrace_open;
- ops->to_close = record_btrace_close;
- ops->to_async = record_btrace_async;
- ops->to_detach = record_detach;
- ops->to_disconnect = record_btrace_disconnect;
- ops->to_mourn_inferior = record_mourn_inferior;
- ops->to_kill = record_kill;
- ops->to_stop_recording = record_btrace_stop_recording;
- ops->to_info_record = record_btrace_info;
- ops->to_insn_history = record_btrace_insn_history;
- ops->to_insn_history_from = record_btrace_insn_history_from;
- ops->to_insn_history_range = record_btrace_insn_history_range;
- ops->to_call_history = record_btrace_call_history;
- ops->to_call_history_from = record_btrace_call_history_from;
- ops->to_call_history_range = record_btrace_call_history_range;
- ops->to_record_method = record_btrace_record_method;
- ops->to_record_is_replaying = record_btrace_is_replaying;
- ops->to_record_will_replay = record_btrace_will_replay;
- ops->to_record_stop_replaying = record_btrace_stop_replaying_all;
- ops->to_xfer_partial = record_btrace_xfer_partial;
- ops->to_remove_breakpoint = record_btrace_remove_breakpoint;
- ops->to_insert_breakpoint = record_btrace_insert_breakpoint;
- ops->to_fetch_registers = record_btrace_fetch_registers;
- ops->to_store_registers = record_btrace_store_registers;
- ops->to_prepare_to_store = record_btrace_prepare_to_store;
- ops->to_get_unwinder = &record_btrace_to_get_unwinder;
- ops->to_get_tailcall_unwinder = &record_btrace_to_get_tailcall_unwinder;
- ops->to_resume = record_btrace_resume;
- ops->to_commit_resume = record_btrace_commit_resume;
- ops->to_wait = record_btrace_wait;
- ops->to_stop = record_btrace_stop;
- ops->to_update_thread_list = record_btrace_update_thread_list;
- ops->to_thread_alive = record_btrace_thread_alive;
- ops->to_goto_record_begin = record_btrace_goto_begin;
- ops->to_goto_record_end = record_btrace_goto_end;
- ops->to_goto_record = record_btrace_goto;
- ops->to_can_execute_reverse = record_btrace_can_execute_reverse;
- ops->to_stopped_by_sw_breakpoint = record_btrace_stopped_by_sw_breakpoint;
- ops->to_supports_stopped_by_sw_breakpoint
- = record_btrace_supports_stopped_by_sw_breakpoint;
- ops->to_stopped_by_hw_breakpoint = record_btrace_stopped_by_hw_breakpoint;
- ops->to_supports_stopped_by_hw_breakpoint
- = record_btrace_supports_stopped_by_hw_breakpoint;
- ops->to_execution_direction = record_btrace_execution_direction;
- ops->to_prepare_to_generate_core = record_btrace_prepare_to_generate_core;
- ops->to_done_generating_core = record_btrace_done_generating_core;
- ops->to_stratum = record_stratum;
- ops->to_magic = OPS_MAGIC;
-}
-
/* Start recording in BTS format. */
static void
{
execute_command ("target record-btrace", from_tty);
}
- CATCH (exception, RETURN_MASK_ALL)
+ CATCH (ex, RETURN_MASK_ALL)
{
record_btrace_conf.format = BTRACE_FORMAT_NONE;
- throw_exception (exception);
+ throw_exception (ex);
}
END_CATCH
}
static void
cmd_show_record_btrace_cpu (const char *args, int from_tty)
{
- const char *cpu;
-
if (args != nullptr && *args != 0)
error (_("Trailing junk: '%s'."), args);
add_prefix_cmd ("cpu", class_support, cmd_set_record_btrace_cpu,
_("\
Set the cpu to be used for trace decode.\n\n\
-The format is \"<vendor>:<identifier>\" or \"none\" or \"auto\" (default).\n\
-For vendor \"intel\" the format is \"<family>/<model>[/<stepping>]\".\n\n\
+The format is \"VENDOR:IDENTIFIER\" or \"none\" or \"auto\" (default).\n\
+For vendor \"intel\" the format is \"FAMILY/MODEL[/STEPPING]\".\n\n\
When decoding branch trace, enable errata workarounds for the specified cpu.\n\
The default is \"auto\", which uses the cpu on which the trace was recorded.\n\
When GDB does not support that cpu, this option can be used to enable\n\
&set_record_btrace_pt_cmdlist,
&show_record_btrace_pt_cmdlist);
- init_record_btrace_ops ();
- add_target (&record_btrace_ops);
+ add_target (record_btrace_target_info, record_btrace_target_open);
bfcache = htab_create_alloc (50, bfcache_hash, bfcache_eq, NULL,
xcalloc, xfree);
projects / deliverable / binutils-gdb.git / blobdiff