/* Branch trace support for GDB, the GNU debugger.
- Copyright (C) 2013-2015 Free Software Foundation, Inc.
+ Copyright (C) 2013-2018 Free Software Foundation, Inc.
Contributed by Intel Corp. <markus.t.metzger@intel.com>
#include "defs.h"
#include "record.h"
+#include "record-btrace.h"
#include "gdbthread.h"
#include "target.h"
#include "gdbcmd.h"
#include "disasm.h"
-#include "observer.h"
+#include "observable.h"
#include "cli/cli-utils.h"
#include "source.h"
#include "ui-out.h"
#include "infrun.h"
#include "event-loop.h"
#include "inf-loop.h"
+#include "vec.h"
+#include <algorithm>
/* The target_ops of record-btrace. */
static struct target_ops record_btrace_ops;
-/* A new thread observer enabling branch tracing for the new thread. */
-static struct observer *record_btrace_thread_observer;
+/* Token associated with a new-thread observer enabling branch tracing
+ for the new thread. */
+static const gdb::observers::token record_btrace_thread_observer_token;
/* Memory access types used in set/show record btrace replay-memory-access. */
static const char replay_memory_access_read_only[] = "read-only";
if (tp == NULL)
error (_("No thread."));
+ validate_registers_access ();
+
btrace_fetch (tp);
if (btrace_is_empty (tp))
END_CATCH
}
-/* Callback function to disable branch tracing for one thread. */
-
-static void
-record_btrace_disable_callback (void *arg)
-{
- struct thread_info *tp;
-
- tp = arg;
-
- btrace_disable (tp);
-}
-
/* Enable automatic tracing of new threads. */
static void
{
DEBUG ("attach thread observer");
- record_btrace_thread_observer
- = observer_attach_new_thread (record_btrace_enable_warn);
+ gdb::observers::new_thread.attach (record_btrace_enable_warn,
+ record_btrace_thread_observer_token);
}
/* Disable automatic tracing of new threads. */
static void
record_btrace_auto_disable (void)
{
- /* The observer may have been detached, already. */
- if (record_btrace_thread_observer == NULL)
- return;
-
DEBUG ("detach thread observer");
- observer_detach_new_thread (record_btrace_thread_observer);
- record_btrace_thread_observer = NULL;
+ gdb::observers::new_thread.detach (record_btrace_thread_observer_token);
}
/* The record-btrace async event handler function. */
inferior_event_handler (INF_REG_EVENT, NULL);
}
+/* See record-btrace.h. */
+
+void
+record_btrace_push_target (void)
+{
+ const char *format;
+
+ record_btrace_auto_enable ();
+
+ push_target (&record_btrace_ops);
+
+ record_btrace_async_inferior_event_handler
+ = create_async_event_handler (record_btrace_handle_async_inferior_event,
+ NULL);
+ record_btrace_generating_corefile = 0;
+
+ format = btrace_format_short_string (record_btrace_conf.format);
+ gdb::observers::record_changed.notify (current_inferior (), 1, "btrace", format);
+}
+
+/* Disable btrace on a set of threads on scope exit. */
+
+struct scoped_btrace_disable
+{
+ scoped_btrace_disable () = default;
+
+ DISABLE_COPY_AND_ASSIGN (scoped_btrace_disable);
+
+ ~scoped_btrace_disable ()
+ {
+ for (thread_info *tp : m_threads)
+ btrace_disable (tp);
+ }
+
+ void add_thread (thread_info *thread)
+ {
+ m_threads.push_front (thread);
+ }
+
+ void discard ()
+ {
+ m_threads.clear ();
+ }
+
+private:
+ std::forward_list<thread_info *> m_threads;
+};
+
/* The to_open method of target record-btrace. */
static void
record_btrace_open (const char *args, int from_tty)
{
- struct cleanup *disable_chain;
+ /* 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."));
- if (non_stop)
- error (_("Record btrace can't debug inferior in non-stop mode."));
-
- gdb_assert (record_btrace_thread_observer == NULL);
-
- disable_chain = make_cleanup (null_cleanup, NULL);
ALL_NON_EXITED_THREADS (tp)
- if (args == NULL || *args == 0 || number_is_in_list (args, tp->num))
+ if (args == NULL || *args == 0 || number_is_in_list (args, tp->global_num))
{
btrace_enable (tp, &record_btrace_conf);
- make_cleanup (record_btrace_disable_callback, tp);
+ btrace_disable.add_thread (tp);
}
- record_btrace_auto_enable ();
+ record_btrace_push_target ();
- push_target (&record_btrace_ops);
-
- record_btrace_async_inferior_event_handler
- = create_async_event_handler (record_btrace_handle_async_inferior_event,
- NULL);
- record_btrace_generating_corefile = 0;
-
- observer_notify_record_changed (current_inferior (), 1);
-
- discard_cleanups (disable_chain);
+ btrace_disable.discard ();
}
/* The to_stop_recording method of target record-btrace. */
btrace_disable (tp);
}
+/* The to_disconnect method of target record-btrace. */
+
+static void
+record_btrace_disconnect (struct target_ops *self, const char *args,
+ int from_tty)
+{
+ struct target_ops *beneath = self->beneath;
+
+ /* Do not stop recording, just clean up GDB side. */
+ unpush_target (self);
+
+ /* Forward disconnect. */
+ beneath->to_disconnect (beneath, args, from_tty);
+}
+
/* The to_close method of target record-btrace. */
static void
}
}
-/* Print an Intel(R) Processor Trace configuration. */
+/* Print an Intel Processor Trace configuration. */
static void
record_btrace_print_pt_conf (const struct btrace_config_pt *conf)
if (tp == NULL)
error (_("No thread."));
+ validate_registers_access ();
+
btinfo = &tp->btrace;
conf = btrace_conf (btinfo);
calls = btrace_call_number (&call);
btrace_insn_end (&insn, btinfo);
-
insns = btrace_insn_number (&insn);
- if (insns != 0)
- {
- /* The last instruction does not really belong to the trace. */
- insns -= 1;
- }
- else
- {
- unsigned int steps;
-
- /* Skip gaps at the end. */
- do
- {
- steps = btrace_insn_prev (&insn, 1);
- if (steps == 0)
- break;
- insns = btrace_insn_number (&insn);
- }
- while (insns == 0);
- }
+ /* If the last instruction is not a gap, it is the current instruction
+ that is not actually part of the record. */
+ if (btrace_insn_get (&insn) != NULL)
+ insns -= 1;
gaps = btinfo->ngaps;
}
printf_unfiltered (_("Recorded %u instructions in %u functions (%u gaps) "
- "for thread %d (%s).\n"), insns, calls, gaps,
- tp->num, target_pid_to_str (tp->ptid));
+ "for thread %s (%s).\n"), insns, calls, gaps,
+ print_thread_id (tp), target_pid_to_str (tp->ptid));
if (btrace_is_replaying (tp))
printf_unfiltered (_("Replay in progress. At instruction %u.\n"),
btrace_ui_out_decode_error (struct ui_out *uiout, int errcode,
enum btrace_format format)
{
- const char *errstr;
- int is_error;
-
- errstr = _("unknown");
- is_error = 1;
+ const char *errstr = btrace_decode_error (format, errcode);
- switch (format)
+ uiout->text (_("["));
+ /* ERRCODE > 0 indicates notifications on BTRACE_FORMAT_PT. */
+ if (!(format == BTRACE_FORMAT_PT && errcode > 0))
{
- default:
- break;
+ uiout->text (_("decode error ("));
+ uiout->field_int ("errcode", errcode);
+ uiout->text (_("): "));
+ }
+ uiout->text (errstr);
+ uiout->text (_("]\n"));
+}
- case BTRACE_FORMAT_BTS:
- switch (errcode)
- {
- default:
- break;
+/* Print an unsigned int. */
- case BDE_BTS_OVERFLOW:
- errstr = _("instruction overflow");
- break;
+static void
+ui_out_field_uint (struct ui_out *uiout, const char *fld, unsigned int val)
+{
+ uiout->field_fmt (fld, "%u", val);
+}
- case BDE_BTS_INSN_SIZE:
- errstr = _("unknown instruction");
- break;
- }
- break;
+/* A range of source lines. */
-#if defined (HAVE_LIBIPT)
- case BTRACE_FORMAT_PT:
- switch (errcode)
- {
- case BDE_PT_USER_QUIT:
- is_error = 0;
- errstr = _("trace decode cancelled");
- break;
-
- case BDE_PT_DISABLED:
- is_error = 0;
- errstr = _("disabled");
- break;
-
- case BDE_PT_OVERFLOW:
- is_error = 0;
- errstr = _("overflow");
- break;
-
- default:
- if (errcode < 0)
- errstr = pt_errstr (pt_errcode (errcode));
- break;
- }
- break;
-#endif /* defined (HAVE_LIBIPT) */
+struct btrace_line_range
+{
+ /* The symtab this line is from. */
+ struct symtab *symtab;
+
+ /* The first line (inclusive). */
+ int begin;
+
+ /* The last line (exclusive). */
+ int end;
+};
+
+/* Construct a line range. */
+
+static struct btrace_line_range
+btrace_mk_line_range (struct symtab *symtab, int begin, int end)
+{
+ struct btrace_line_range range;
+
+ range.symtab = symtab;
+ range.begin = begin;
+ range.end = end;
+
+ return range;
+}
+
+/* Add a line to a line range. */
+
+static struct btrace_line_range
+btrace_line_range_add (struct btrace_line_range range, int line)
+{
+ if (range.end <= range.begin)
+ {
+ /* This is the first entry. */
+ range.begin = line;
+ range.end = line + 1;
}
+ else if (line < range.begin)
+ range.begin = line;
+ else if (range.end < line)
+ range.end = line;
+
+ return range;
+}
+
+/* Return non-zero if RANGE is empty, zero otherwise. */
+
+static int
+btrace_line_range_is_empty (struct btrace_line_range range)
+{
+ return range.end <= range.begin;
+}
+
+/* Return non-zero if LHS contains RHS, zero otherwise. */
+
+static int
+btrace_line_range_contains_range (struct btrace_line_range lhs,
+ struct btrace_line_range rhs)
+{
+ return ((lhs.symtab == rhs.symtab)
+ && (lhs.begin <= rhs.begin)
+ && (rhs.end <= lhs.end));
+}
+
+/* Find the line range associated with PC. */
+
+static struct btrace_line_range
+btrace_find_line_range (CORE_ADDR pc)
+{
+ struct btrace_line_range range;
+ struct linetable_entry *lines;
+ struct linetable *ltable;
+ struct symtab *symtab;
+ int nlines, i;
+
+ symtab = find_pc_line_symtab (pc);
+ if (symtab == NULL)
+ return btrace_mk_line_range (NULL, 0, 0);
+
+ ltable = SYMTAB_LINETABLE (symtab);
+ if (ltable == NULL)
+ return btrace_mk_line_range (symtab, 0, 0);
- ui_out_text (uiout, _("["));
- if (is_error)
+ nlines = ltable->nitems;
+ lines = ltable->item;
+ if (nlines <= 0)
+ return btrace_mk_line_range (symtab, 0, 0);
+
+ range = btrace_mk_line_range (symtab, 0, 0);
+ for (i = 0; i < nlines - 1; i++)
{
- ui_out_text (uiout, _("decode error ("));
- ui_out_field_int (uiout, "errcode", errcode);
- ui_out_text (uiout, _("): "));
+ if ((lines[i].pc == pc) && (lines[i].line != 0))
+ range = btrace_line_range_add (range, lines[i].line);
}
- ui_out_text (uiout, errstr);
- ui_out_text (uiout, _("]\n"));
+
+ return range;
}
-/* Print an unsigned int. */
+/* Print source lines in LINES to UIOUT.
+
+ UI_ITEM_CHAIN is a cleanup chain for the last source line and the
+ instructions corresponding to that source line. When printing a new source
+ line, we do the cleanups for the open chain and open a new cleanup chain for
+ the new source line. If the source line range in LINES is not empty, this
+ function will leave the cleanup chain for the last printed source line open
+ so instructions can be added to it. */
static void
-ui_out_field_uint (struct ui_out *uiout, const char *fld, unsigned int val)
+btrace_print_lines (struct btrace_line_range lines, struct ui_out *uiout,
+ gdb::optional<ui_out_emit_tuple> *src_and_asm_tuple,
+ gdb::optional<ui_out_emit_list> *asm_list,
+ gdb_disassembly_flags flags)
{
- ui_out_field_fmt (uiout, fld, "%u", val);
+ print_source_lines_flags psl_flags;
+
+ if (flags & DISASSEMBLY_FILENAME)
+ psl_flags |= PRINT_SOURCE_LINES_FILENAME;
+
+ for (int line = lines.begin; line < lines.end; ++line)
+ {
+ asm_list->reset ();
+
+ src_and_asm_tuple->emplace (uiout, "src_and_asm_line");
+
+ print_source_lines (lines.symtab, line, line + 1, psl_flags);
+
+ asm_list->emplace (uiout, "line_asm_insn");
+ }
}
/* Disassemble a section of the recorded instruction trace. */
btrace_insn_history (struct ui_out *uiout,
const struct btrace_thread_info *btinfo,
const struct btrace_insn_iterator *begin,
- const struct btrace_insn_iterator *end, int flags)
+ const struct btrace_insn_iterator *end,
+ gdb_disassembly_flags flags)
{
- struct gdbarch *gdbarch;
- struct btrace_insn_iterator it;
+ DEBUG ("itrace (0x%x): [%u; %u)", (unsigned) flags,
+ btrace_insn_number (begin), btrace_insn_number (end));
+
+ flags |= DISASSEMBLY_SPECULATIVE;
+
+ struct gdbarch *gdbarch = target_gdbarch ();
+ btrace_line_range last_lines = btrace_mk_line_range (NULL, 0, 0);
+
+ ui_out_emit_list list_emitter (uiout, "asm_insns");
- DEBUG ("itrace (0x%x): [%u; %u)", flags, btrace_insn_number (begin),
- btrace_insn_number (end));
+ gdb::optional<ui_out_emit_tuple> src_and_asm_tuple;
+ gdb::optional<ui_out_emit_list> asm_list;
- gdbarch = target_gdbarch ();
+ gdb_pretty_print_disassembler disasm (gdbarch);
- for (it = *begin; btrace_insn_cmp (&it, end) != 0; btrace_insn_next (&it, 1))
+ for (btrace_insn_iterator it = *begin; btrace_insn_cmp (&it, end) != 0;
+ btrace_insn_next (&it, 1))
{
const struct btrace_insn *insn;
/* We have trace so we must have a configuration. */
gdb_assert (conf != NULL);
- btrace_ui_out_decode_error (uiout, it.function->errcode,
+ uiout->field_fmt ("insn-number", "%u",
+ btrace_insn_number (&it));
+ uiout->text ("\t");
+
+ btrace_ui_out_decode_error (uiout, btrace_insn_get_error (&it),
conf->format);
}
else
{
- char prefix[4];
+ struct disasm_insn dinsn;
- /* We may add a speculation prefix later. We use the same space
- that is used for the pc prefix. */
- if ((flags & DISASSEMBLY_OMIT_PC) == 0)
- strncpy (prefix, pc_prefix (insn->pc), 3);
- else
+ if ((flags & DISASSEMBLY_SOURCE) != 0)
{
- prefix[0] = ' ';
- prefix[1] = ' ';
- prefix[2] = ' ';
+ struct btrace_line_range lines;
+
+ lines = btrace_find_line_range (insn->pc);
+ if (!btrace_line_range_is_empty (lines)
+ && !btrace_line_range_contains_range (last_lines, lines))
+ {
+ btrace_print_lines (lines, uiout, &src_and_asm_tuple, &asm_list,
+ flags);
+ last_lines = lines;
+ }
+ else if (!src_and_asm_tuple.has_value ())
+ {
+ gdb_assert (!asm_list.has_value ());
+
+ src_and_asm_tuple.emplace (uiout, "src_and_asm_line");
+
+ /* No source information. */
+ asm_list.emplace (uiout, "line_asm_insn");
+ }
+
+ gdb_assert (src_and_asm_tuple.has_value ());
+ gdb_assert (asm_list.has_value ());
}
- prefix[3] = 0;
- /* Print the instruction index. */
- ui_out_field_uint (uiout, "index", btrace_insn_number (&it));
- ui_out_text (uiout, "\t");
+ memset (&dinsn, 0, sizeof (dinsn));
+ dinsn.number = btrace_insn_number (&it);
+ dinsn.addr = insn->pc;
- /* Indicate speculative execution by a leading '?'. */
if ((insn->flags & BTRACE_INSN_FLAG_SPECULATIVE) != 0)
- prefix[0] = '?';
+ dinsn.is_speculative = 1;
- /* Print the prefix; we tell gdb_disassembly below to omit it. */
- ui_out_field_fmt (uiout, "prefix", "%s", prefix);
-
- /* Disassembly with '/m' flag may not produce the expected result.
- See PR gdb/11833. */
- gdb_disassembly (gdbarch, uiout, NULL, flags | DISASSEMBLY_OMIT_PC,
- 1, insn->pc, insn->pc + 1);
+ disasm.pretty_print_insn (uiout, &dinsn, flags);
}
}
}
/* The to_insn_history method of target record-btrace. */
static void
-record_btrace_insn_history (struct target_ops *self, int size, int flags)
+record_btrace_insn_history (struct target_ops *self, int size,
+ gdb_disassembly_flags flags)
{
struct btrace_thread_info *btinfo;
struct btrace_insn_history *history;
struct btrace_insn_iterator begin, end;
- struct cleanup *uiout_cleanup;
struct ui_out *uiout;
unsigned int context, covered;
uiout = current_uiout;
- uiout_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout,
- "insn history");
+ ui_out_emit_tuple tuple_emitter (uiout, "insn history");
context = abs (size);
if (context == 0)
error (_("Bad record instruction-history-size."));
{
struct btrace_insn_iterator *replay;
- DEBUG ("insn-history (0x%x): %d", flags, size);
+ DEBUG ("insn-history (0x%x): %d", (unsigned) flags, size);
/* If we're replaying, we start at the replay position. Otherwise, we
start at the tail of the trace. */
begin = history->begin;
end = history->end;
- DEBUG ("insn-history (0x%x): %d, prev: [%u; %u)", flags, size,
+ DEBUG ("insn-history (0x%x): %d, prev: [%u; %u)", (unsigned) flags, size,
btrace_insn_number (&begin), btrace_insn_number (&end));
if (size < 0)
}
btrace_set_insn_history (btinfo, &begin, &end);
- do_cleanups (uiout_cleanup);
}
/* The to_insn_history_range method of target record-btrace. */
static void
record_btrace_insn_history_range (struct target_ops *self,
- ULONGEST from, ULONGEST to, int flags)
+ ULONGEST from, ULONGEST to,
+ gdb_disassembly_flags flags)
{
struct btrace_thread_info *btinfo;
- struct btrace_insn_history *history;
struct btrace_insn_iterator begin, end;
- struct cleanup *uiout_cleanup;
struct ui_out *uiout;
unsigned int low, high;
int found;
uiout = current_uiout;
- uiout_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout,
- "insn history");
+ ui_out_emit_tuple tuple_emitter (uiout, "insn history");
low = from;
high = to;
- DEBUG ("insn-history (0x%x): [%u; %u)", flags, low, high);
+ DEBUG ("insn-history (0x%x): [%u; %u)", (unsigned) flags, low, high);
/* Check for wrap-arounds. */
if (low != from || high != to)
btrace_insn_history (uiout, btinfo, &begin, &end, flags);
btrace_set_insn_history (btinfo, &begin, &end);
-
- do_cleanups (uiout_cleanup);
}
/* The to_insn_history_from method of target record-btrace. */
static void
record_btrace_insn_history_from (struct target_ops *self,
- ULONGEST from, int size, int flags)
+ ULONGEST from, int size,
+ gdb_disassembly_flags flags)
{
ULONGEST begin, end, context;
{
unsigned int begin, end, size;
- size = VEC_length (btrace_insn_s, bfun->insn);
+ size = bfun->insn.size ();
gdb_assert (size > 0);
begin = bfun->insn_offset;
end = begin + size - 1;
ui_out_field_uint (uiout, "insn begin", begin);
- ui_out_text (uiout, ",");
+ uiout->text (",");
ui_out_field_uint (uiout, "insn end", end);
}
btrace_compute_src_line_range (const struct btrace_function *bfun,
int *pbegin, int *pend)
{
- struct btrace_insn *insn;
struct symtab *symtab;
struct symbol *sym;
- unsigned int idx;
int begin, end;
begin = INT_MAX;
symtab = symbol_symtab (sym);
- for (idx = 0; VEC_iterate (btrace_insn_s, bfun->insn, idx, insn); ++idx)
+ for (const btrace_insn &insn : bfun->insn)
{
struct symtab_and_line sal;
- sal = find_pc_line (insn->pc, 0);
+ sal = find_pc_line (insn.pc, 0);
if (sal.symtab != symtab || sal.line == 0)
continue;
- begin = min (begin, sal.line);
- end = max (end, sal.line);
+ begin = std::min (begin, sal.line);
+ end = std::max (end, sal.line);
}
out:
if (sym == NULL)
return;
- ui_out_field_string (uiout, "file",
+ uiout->field_string ("file",
symtab_to_filename_for_display (symbol_symtab (sym)));
btrace_compute_src_line_range (bfun, &begin, &end);
if (end < begin)
return;
- ui_out_text (uiout, ":");
- ui_out_field_int (uiout, "min line", begin);
+ uiout->text (":");
+ uiout->field_int ("min line", begin);
if (end == begin)
return;
- ui_out_text (uiout, ",");
- ui_out_field_int (uiout, "max line", end);
+ uiout->text (",");
+ uiout->field_int ("max line", end);
}
/* Get the name of a branch trace function. */
const struct btrace_thread_info *btinfo,
const struct btrace_call_iterator *begin,
const struct btrace_call_iterator *end,
- enum record_print_flag flags)
+ int int_flags)
{
struct btrace_call_iterator it;
+ record_print_flags flags = (enum record_print_flag) int_flags;
- DEBUG ("ftrace (0x%x): [%u; %u)", flags, btrace_call_number (begin),
+ DEBUG ("ftrace (0x%x): [%u; %u)", int_flags, btrace_call_number (begin),
btrace_call_number (end));
for (it = *begin; btrace_call_cmp (&it, end) < 0; btrace_call_next (&it, 1))
/* Print the function index. */
ui_out_field_uint (uiout, "index", bfun->number);
- ui_out_text (uiout, "\t");
+ uiout->text ("\t");
/* Indicate gaps in the trace. */
if (bfun->errcode != 0)
int level = bfun->level + btinfo->level, i;
for (i = 0; i < level; ++i)
- ui_out_text (uiout, " ");
+ uiout->text (" ");
}
if (sym != NULL)
- ui_out_field_string (uiout, "function", SYMBOL_PRINT_NAME (sym));
+ uiout->field_string ("function", SYMBOL_PRINT_NAME (sym));
else if (msym != NULL)
- ui_out_field_string (uiout, "function", MSYMBOL_PRINT_NAME (msym));
- else if (!ui_out_is_mi_like_p (uiout))
- ui_out_field_string (uiout, "function", "??");
+ uiout->field_string ("function", MSYMBOL_PRINT_NAME (msym));
+ else if (!uiout->is_mi_like_p ())
+ uiout->field_string ("function", "??");
if ((flags & RECORD_PRINT_INSN_RANGE) != 0)
{
- ui_out_text (uiout, _("\tinst "));
+ uiout->text (_("\tinst "));
btrace_call_history_insn_range (uiout, bfun);
}
if ((flags & RECORD_PRINT_SRC_LINE) != 0)
{
- ui_out_text (uiout, _("\tat "));
+ uiout->text (_("\tat "));
btrace_call_history_src_line (uiout, bfun);
}
- ui_out_text (uiout, "\n");
+ uiout->text ("\n");
}
}
/* The to_call_history method of target record-btrace. */
static void
-record_btrace_call_history (struct target_ops *self, int size, int flags)
+record_btrace_call_history (struct target_ops *self, int size,
+ record_print_flags flags)
{
struct btrace_thread_info *btinfo;
struct btrace_call_history *history;
struct btrace_call_iterator begin, end;
- struct cleanup *uiout_cleanup;
struct ui_out *uiout;
unsigned int context, covered;
uiout = current_uiout;
- uiout_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout,
- "insn history");
+ ui_out_emit_tuple tuple_emitter (uiout, "insn history");
context = abs (size);
if (context == 0)
error (_("Bad record function-call-history-size."));
{
struct btrace_insn_iterator *replay;
- DEBUG ("call-history (0x%x): %d", flags, size);
+ DEBUG ("call-history (0x%x): %d", (int) flags, size);
/* If we're replaying, we start at the replay position. Otherwise, we
start at the tail of the trace. */
replay = btinfo->replay;
if (replay != NULL)
{
- begin.function = replay->function;
begin.btinfo = btinfo;
+ begin.index = replay->call_index;
}
else
btrace_call_end (&begin, btinfo);
begin = history->begin;
end = history->end;
- DEBUG ("call-history (0x%x): %d, prev: [%u; %u)", flags, size,
+ DEBUG ("call-history (0x%x): %d, prev: [%u; %u)", (int) flags, size,
btrace_call_number (&begin), btrace_call_number (&end));
if (size < 0)
}
btrace_set_call_history (btinfo, &begin, &end);
- do_cleanups (uiout_cleanup);
}
/* The to_call_history_range method of target record-btrace. */
static void
record_btrace_call_history_range (struct target_ops *self,
- ULONGEST from, ULONGEST to, int flags)
+ ULONGEST from, ULONGEST to,
+ record_print_flags flags)
{
struct btrace_thread_info *btinfo;
- struct btrace_call_history *history;
struct btrace_call_iterator begin, end;
- struct cleanup *uiout_cleanup;
struct ui_out *uiout;
unsigned int low, high;
int found;
uiout = current_uiout;
- uiout_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout,
- "func history");
+ ui_out_emit_tuple tuple_emitter (uiout, "func history");
low = from;
high = to;
- DEBUG ("call-history (0x%x): [%u; %u)", flags, low, high);
+ DEBUG ("call-history (0x%x): [%u; %u)", (int) flags, low, high);
/* Check for wrap-arounds. */
if (low != from || high != to)
btrace_call_history (uiout, btinfo, &begin, &end, flags);
btrace_set_call_history (btinfo, &begin, &end);
-
- do_cleanups (uiout_cleanup);
}
/* The to_call_history_from method of target record-btrace. */
static void
record_btrace_call_history_from (struct target_ops *self,
- ULONGEST from, int size, int flags)
+ ULONGEST from, int size,
+ record_print_flags flags)
{
ULONGEST begin, end, context;
record_btrace_call_history_range (self, begin, end, flags);
}
+/* The to_record_method method of target record-btrace. */
+
+static enum record_method
+record_btrace_record_method (struct target_ops *self, ptid_t ptid)
+{
+ struct thread_info * const tp = find_thread_ptid (ptid);
+
+ if (tp == NULL)
+ error (_("No thread."));
+
+ if (tp->btrace.target == NULL)
+ return RECORD_METHOD_NONE;
+
+ return RECORD_METHOD_BTRACE;
+}
+
/* The to_record_is_replaying method of target record-btrace. */
static int
-record_btrace_is_replaying (struct target_ops *self)
+record_btrace_is_replaying (struct target_ops *self, ptid_t ptid)
{
struct thread_info *tp;
ALL_NON_EXITED_THREADS (tp)
- if (btrace_is_replaying (tp))
+ if (ptid_match (tp->ptid, ptid) && btrace_is_replaying (tp))
return 1;
return 0;
}
+/* The to_record_will_replay method of target record-btrace. */
+
+static int
+record_btrace_will_replay (struct target_ops *self, ptid_t ptid, int dir)
+{
+ return dir == EXEC_REVERSE || record_btrace_is_replaying (self, ptid);
+}
+
/* The to_xfer_partial method of target record-btrace. */
static enum target_xfer_status
const gdb_byte *writebuf, ULONGEST offset,
ULONGEST len, ULONGEST *xfered_len)
{
- struct target_ops *t;
-
/* 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))
+ && record_btrace_is_replaying (ops, inferior_ptid))
{
switch (object)
{
& SEC_READONLY) != 0)
{
/* Truncate the request to fit into this section. */
- len = min (len, section->endaddr - offset);
+ len = std::min (len, section->endaddr - offset);
break;
}
}
static int
record_btrace_remove_breakpoint (struct target_ops *ops,
struct gdbarch *gdbarch,
- struct bp_target_info *bp_tgt)
+ 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);
+ ret = ops->beneath->to_remove_breakpoint (ops->beneath, gdbarch, bp_tgt,
+ reason);
}
CATCH (except, RETURN_MASK_ALL)
{
struct btrace_insn_iterator *replay;
struct thread_info *tp;
- tp = find_thread_ptid (inferior_ptid);
+ tp = find_thread_ptid (regcache_get_ptid (regcache));
gdb_assert (tp != NULL);
replay = tp->btrace.replay;
struct gdbarch *gdbarch;
int pcreg;
- gdbarch = get_regcache_arch (regcache);
+ gdbarch = regcache->arch ();
pcreg = gdbarch_pc_regnum (gdbarch);
if (pcreg < 0)
return;
{
struct target_ops *t;
- if (!record_btrace_generating_corefile && record_btrace_is_replaying (ops))
- error (_("This record target does not allow writing registers."));
+ if (!record_btrace_generating_corefile
+ && record_btrace_is_replaying (ops, regcache_get_ptid (regcache)))
+ error (_("Cannot write registers while replaying."));
gdb_assert (may_write_registers != 0);
{
struct target_ops *t;
- if (!record_btrace_generating_corefile && record_btrace_is_replaying (ops))
+ if (!record_btrace_generating_corefile
+ && record_btrace_is_replaying (ops, regcache_get_ptid (regcache)))
return;
t = ops->beneath;
static hashval_t
bfcache_hash (const void *arg)
{
- const struct btrace_frame_cache *cache = arg;
+ const struct btrace_frame_cache *cache
+ = (const struct btrace_frame_cache *) arg;
return htab_hash_pointer (cache->frame);
}
static int
bfcache_eq (const void *arg1, const void *arg2)
{
- const struct btrace_frame_cache *cache1 = arg1;
- const struct btrace_frame_cache *cache2 = arg2;
+ const struct btrace_frame_cache *cache1
+ = (const struct btrace_frame_cache *) arg1;
+ const struct btrace_frame_cache *cache2
+ = (const struct btrace_frame_cache *) arg2;
return cache1->frame == cache2->frame;
}
btrace_get_frame_function (struct frame_info *frame)
{
const struct btrace_frame_cache *cache;
- const struct btrace_function *bfun;
struct btrace_frame_cache pattern;
void **slot;
if (slot == NULL)
return NULL;
- cache = *slot;
+ cache = (const struct btrace_frame_cache *) *slot;
return cache->bfun;
}
const struct btrace_frame_cache *cache;
const struct btrace_function *bfun;
- cache = *this_cache;
+ cache = (const struct btrace_frame_cache *) *this_cache;
bfun = cache->bfun;
gdb_assert (bfun != NULL);
- if (bfun->up == NULL)
+ if (bfun->up == 0)
return UNWIND_UNAVAILABLE;
return UNWIND_NO_REASON;
{
const struct btrace_frame_cache *cache;
const struct btrace_function *bfun;
+ struct btrace_call_iterator it;
CORE_ADDR code, special;
- cache = *this_cache;
+ cache = (const struct btrace_frame_cache *) *this_cache;
bfun = cache->bfun;
gdb_assert (bfun != NULL);
- while (bfun->segment.prev != NULL)
- bfun = bfun->segment.prev;
+ while (btrace_find_call_by_number (&it, &cache->tp->btrace, bfun->prev) != 0)
+ bfun = btrace_call_get (&it);
code = get_frame_func (this_frame);
special = bfun->number;
{
const struct btrace_frame_cache *cache;
const struct btrace_function *bfun, *caller;
- const struct btrace_insn *insn;
+ struct btrace_call_iterator it;
struct gdbarch *gdbarch;
CORE_ADDR pc;
int pcreg;
throw_error (NOT_AVAILABLE_ERROR,
_("Registers are not available in btrace record history"));
- cache = *this_cache;
+ cache = (const struct btrace_frame_cache *) *this_cache;
bfun = cache->bfun;
gdb_assert (bfun != NULL);
- caller = bfun->up;
- if (caller == NULL)
+ if (btrace_find_call_by_number (&it, &cache->tp->btrace, bfun->up) == 0)
throw_error (NOT_AVAILABLE_ERROR,
_("No caller in btrace record history"));
+ caller = btrace_call_get (&it);
+
if ((bfun->flags & BFUN_UP_LINKS_TO_RET) != 0)
- {
- insn = VEC_index (btrace_insn_s, caller->insn, 0);
- pc = insn->pc;
- }
+ pc = caller->insn.front ().pc;
else
{
- insn = VEC_last (btrace_insn_s, caller->insn);
- pc = insn->pc;
-
+ pc = caller->insn.back ().pc;
pc += gdb_insn_length (gdbarch, pc);
}
replay = tp->btrace.replay;
if (replay != NULL)
- bfun = replay->function;
+ bfun = &replay->btinfo->functions[replay->call_index];
}
else
{
const struct btrace_function *callee;
+ struct btrace_call_iterator it;
callee = btrace_get_frame_function (next);
- if (callee != NULL && (callee->flags & BFUN_UP_LINKS_TO_TAILCALL) == 0)
- bfun = callee->up;
+ if (callee == NULL || (callee->flags & BFUN_UP_LINKS_TO_TAILCALL) != 0)
+ return 0;
+
+ if (btrace_find_call_by_number (&it, &tp->btrace, callee->up) == 0)
+ return 0;
+
+ bfun = btrace_call_get (&it);
}
if (bfun == NULL)
{
const struct btrace_function *bfun, *callee;
struct btrace_frame_cache *cache;
+ struct btrace_call_iterator it;
struct frame_info *next;
+ struct thread_info *tinfo;
next = get_next_frame (this_frame);
if (next == NULL)
if ((callee->flags & BFUN_UP_LINKS_TO_TAILCALL) == 0)
return 0;
- bfun = callee->up;
- if (bfun == NULL)
+ tinfo = find_thread_ptid (inferior_ptid);
+ if (btrace_find_call_by_number (&it, &tinfo->btrace, callee->up) == 0)
return 0;
+ bfun = btrace_call_get (&it);
+
DEBUG ("[frame] sniffed tailcall frame for %s on level %d",
btrace_get_bfun_name (bfun), bfun->level);
/* This is our frame. Initialize the frame cache. */
cache = bfcache_new (this_frame);
- cache->tp = find_thread_ptid (inferior_ptid);
+ cache->tp = tinfo;
cache->bfun = bfun;
*this_cache = cache;
struct btrace_frame_cache *cache;
void **slot;
- cache = this_cache;
+ cache = (struct btrace_frame_cache *) this_cache;
slot = htab_find_slot (bfcache, cache, NO_INSERT);
gdb_assert (slot != NULL);
{
struct btrace_thread_info *btinfo;
- DEBUG ("resuming thread %d (%s): %x (%s)", tp->num,
+ DEBUG ("resuming thread %s (%s): %x (%s)", print_thread_id (tp),
target_pid_to_str (tp->ptid), flag, btrace_thread_flag_to_str (flag));
btinfo = &tp->btrace;
- if ((btinfo->flags & BTHR_MOVE) != 0)
- error (_("Thread already moving."));
-
/* Fetch the latest branch trace. */
btrace_fetch (tp);
- /* A resume request overwrites a preceding stop request. */
- btinfo->flags &= ~BTHR_STOP;
+ /* A resume request overwrites a preceding resume or stop request. */
+ btinfo->flags &= ~(BTHR_MOVE | BTHR_STOP);
btinfo->flags |= flag;
}
-/* Find the thread to resume given a PTID. */
+/* Get the current frame for TP. */
-static struct thread_info *
-record_btrace_find_resume_thread (ptid_t ptid)
+static struct frame_info *
+get_thread_current_frame (struct thread_info *tp)
{
- struct thread_info *tp;
+ struct frame_info *frame;
+ ptid_t old_inferior_ptid;
+ int executing;
+
+ /* Set INFERIOR_PTID, which is implicitly used by get_current_frame. */
+ old_inferior_ptid = inferior_ptid;
+ inferior_ptid = tp->ptid;
+
+ /* 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
+ 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);
- /* When asked to resume everything, we pick the current thread. */
- if (ptid_equal (minus_one_ptid, ptid) || ptid_is_pid (ptid))
- ptid = inferior_ptid;
+ frame = NULL;
+ TRY
+ {
+ frame = 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);
- return find_thread_ptid (ptid);
+ /* Restore the previous inferior_ptid. */
+ inferior_ptid = old_inferior_ptid;
+
+ return frame;
}
/* Start replaying a thread. */
{
struct btrace_insn_iterator *replay;
struct btrace_thread_info *btinfo;
- int executing;
btinfo = &tp->btrace;
replay = NULL;
/* We can't start replaying without trace. */
- if (btinfo->begin == NULL)
+ if (btinfo->functions.empty ())
return NULL;
- /* 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
- move the thread. Since we need to recompute the stack, we temporarily
- set EXECUTING to flase. */
- executing = is_executing (tp->ptid);
- set_executing (tp->ptid, 0);
-
/* GDB stores the current frame_id when stepping in order to detects steps
into subroutines.
Since frames are computed differently when we're replaying, we need to
int upd_step_frame_id, upd_step_stack_frame_id;
/* The current frame without replaying - computed via normal unwind. */
- frame = get_current_frame ();
+ frame = get_thread_current_frame (tp);
frame_id = get_frame_id (frame);
/* Check if we need to update any stepping-related frame id's. */
registers_changed_ptid (tp->ptid);
/* The current frame with replaying - computed via btrace unwind. */
- frame = get_current_frame ();
+ frame = get_thread_current_frame (tp);
frame_id = get_frame_id (frame);
/* Replace stepping related frames where necessary. */
}
CATCH (except, RETURN_MASK_ALL)
{
- /* Restore the previous execution state. */
- set_executing (tp->ptid, executing);
-
xfree (btinfo->replay);
btinfo->replay = NULL;
}
END_CATCH
- /* Restore the previous execution state. */
- set_executing (tp->ptid, executing);
-
return replay;
}
registers_changed_ptid (tp->ptid);
}
+/* Stop replaying TP if it is at the end of its execution history. */
+
+static void
+record_btrace_stop_replaying_at_end (struct thread_info *tp)
+{
+ struct btrace_insn_iterator *replay, end;
+ struct btrace_thread_info *btinfo;
+
+ btinfo = &tp->btrace;
+ replay = btinfo->replay;
+
+ if (replay == NULL)
+ return;
+
+ btrace_insn_end (&end, btinfo);
+
+ if (btrace_insn_cmp (replay, &end) == 0)
+ record_btrace_stop_replaying (tp);
+}
+
/* The to_resume method of target record-btrace. */
static void
record_btrace_resume (struct target_ops *ops, ptid_t ptid, int step,
enum gdb_signal signal)
{
- struct thread_info *tp, *other;
- enum btrace_thread_flag flag;
+ 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-" : "",
step ? "step" : "cont");
- /* Store the execution direction of the last resume. */
- record_btrace_resume_exec_dir = execution_direction;
+ /* Store the execution direction of the last resume.
- tp = record_btrace_find_resume_thread (ptid);
- if (tp == NULL)
- error (_("Cannot find thread to resume."));
+ If there is more than one to_resume call, we have to rely on infrun
+ to not change the execution direction in-between. */
+ record_btrace_resume_exec_dir = execution_direction;
- /* Stop replaying other threads if the thread to resume is not replaying. */
- if (!btrace_is_replaying (tp) && execution_direction != EXEC_REVERSE)
- ALL_NON_EXITED_THREADS (other)
- record_btrace_stop_replaying (other);
+ /* As long as we're not replaying, just forward the request.
- /* As long as we're not replaying, just forward the request. */
- if (!record_btrace_is_replaying (ops) && execution_direction != EXEC_REVERSE)
+ 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))
{
ops = ops->beneath;
- return ops->to_resume (ops, ptid, step, signal);
+ ops->to_resume (ops, ptid, step, signal);
+ return;
}
/* Compute the btrace thread flag for the requested move. */
- if (step == 0)
- flag = execution_direction == EXEC_REVERSE ? BTHR_RCONT : BTHR_CONT;
+ if (execution_direction == EXEC_REVERSE)
+ {
+ flag = step == 0 ? BTHR_RCONT : BTHR_RSTEP;
+ cflag = BTHR_RCONT;
+ }
else
- flag = execution_direction == EXEC_REVERSE ? BTHR_RSTEP : BTHR_STEP;
-
- /* At the moment, we only move a single thread. We could also move
- all threads in parallel by single-stepping each resumed thread
- until the first runs into an event.
- When we do that, we would want to continue all other threads.
- For now, just resume one thread to not confuse to_wait. */
- record_btrace_resume_thread (tp, flag);
+ {
+ flag = step == 0 ? BTHR_CONT : BTHR_STEP;
+ cflag = BTHR_CONT;
+ }
/* We just indicate the resume intent here. The actual stepping happens in
- record_btrace_wait below. */
+ record_btrace_wait below.
+
+ 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));
+
+ 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);
+ }
+ }
+ else
+ {
+ ALL_NON_EXITED_THREADS (tp)
+ if (ptid_match (tp->ptid, ptid))
+ record_btrace_resume_thread (tp, flag);
+ }
/* Async support. */
if (target_can_async_p ())
}
}
+/* The to_commit_resume method of target record-btrace. */
+
+static void
+record_btrace_commit_resume (struct target_ops *ops)
+{
+ if ((execution_direction != EXEC_REVERSE)
+ && !record_btrace_is_replaying (ops, minus_one_ptid))
+ ops->beneath->to_commit_resume (ops->beneath);
+}
+
/* Cancel resuming TP. */
static void
if (flags == 0)
return;
- DEBUG ("cancel resume thread %d (%s): %x (%s)", tp->num,
+ DEBUG ("cancel resume thread %s (%s): %x (%s)",
+ print_thread_id (tp),
target_pid_to_str (tp->ptid), flags,
btrace_thread_flag_to_str (flags));
tp->btrace.flags &= ~(BTHR_MOVE | BTHR_STOP);
-}
-
-/* Find a thread to move. */
-
-static struct thread_info *
-record_btrace_find_thread_to_move (ptid_t ptid)
-{
- struct thread_info *tp;
-
- /* First check the parameter thread. */
- tp = find_thread_ptid (ptid);
- if (tp != NULL && (tp->btrace.flags & (BTHR_MOVE | BTHR_STOP)) != 0)
- return tp;
-
- /* Otherwise, find one other thread that has been resumed. */
- ALL_NON_EXITED_THREADS (tp)
- if ((tp->btrace.flags & (BTHR_MOVE | BTHR_STOP)) != 0)
- return tp;
-
- return NULL;
+ record_btrace_stop_replaying_at_end (tp);
}
/* Return a target_waitstatus indicating that we ran out of history. */
return status;
}
+/* Return a target_waitstatus indicating a spurious stop. */
+
+static struct target_waitstatus
+btrace_step_spurious (void)
+{
+ struct target_waitstatus status;
+
+ status.kind = TARGET_WAITKIND_SPURIOUS;
+
+ return status;
+}
+
+/* Return a target_waitstatus indicating that the thread was not resumed. */
+
+static struct target_waitstatus
+btrace_step_no_resumed (void)
+{
+ struct target_waitstatus status;
+
+ status.kind = TARGET_WAITKIND_NO_RESUMED;
+
+ return status;
+}
+
+/* Return a target_waitstatus indicating that we should wait again. */
+
+static struct target_waitstatus
+btrace_step_again (void)
+{
+ struct target_waitstatus status;
+
+ status.kind = TARGET_WAITKIND_IGNORE;
+
+ return status;
+}
+
/* Clear the record histories. */
static void
&btinfo->stop_reason);
}
+/* Step one instruction in forward direction. */
+
+static struct target_waitstatus
+record_btrace_single_step_forward (struct thread_info *tp)
+{
+ struct btrace_insn_iterator *replay, end, start;
+ struct btrace_thread_info *btinfo;
+
+ btinfo = &tp->btrace;
+ replay = btinfo->replay;
+
+ /* We're done if we're not replaying. */
+ if (replay == NULL)
+ return btrace_step_no_history ();
+
+ /* Check if we're stepping a breakpoint. */
+ if (record_btrace_replay_at_breakpoint (tp))
+ return btrace_step_stopped ();
+
+ /* Skip gaps during replay. If we end up at a gap (at the end of the trace),
+ jump back to the instruction at which we started. */
+ start = *replay;
+ do
+ {
+ unsigned int steps;
+
+ /* We will bail out here if we continue stepping after reaching the end
+ of the execution history. */
+ steps = btrace_insn_next (replay, 1);
+ if (steps == 0)
+ {
+ *replay = start;
+ return btrace_step_no_history ();
+ }
+ }
+ while (btrace_insn_get (replay) == NULL);
+
+ /* Determine the end of the instruction trace. */
+ btrace_insn_end (&end, btinfo);
+
+ /* The execution trace contains (and ends with) the current instruction.
+ This instruction has not been executed, yet, so the trace really ends
+ one instruction earlier. */
+ if (btrace_insn_cmp (replay, &end) == 0)
+ return btrace_step_no_history ();
+
+ return btrace_step_spurious ();
+}
+
+/* Step one instruction in backward direction. */
+
+static struct target_waitstatus
+record_btrace_single_step_backward (struct thread_info *tp)
+{
+ struct btrace_insn_iterator *replay, start;
+ struct btrace_thread_info *btinfo;
+
+ btinfo = &tp->btrace;
+ replay = btinfo->replay;
+
+ /* Start replaying if we're not already doing so. */
+ if (replay == NULL)
+ replay = record_btrace_start_replaying (tp);
+
+ /* If we can't step any further, we reached the end of the history.
+ Skip gaps during replay. If we end up at a gap (at the beginning of
+ the trace), jump back to the instruction at which we started. */
+ start = *replay;
+ do
+ {
+ unsigned int steps;
+
+ steps = btrace_insn_prev (replay, 1);
+ if (steps == 0)
+ {
+ *replay = start;
+ return btrace_step_no_history ();
+ }
+ }
+ while (btrace_insn_get (replay) == NULL);
+
+ /* Check if we're stepping a breakpoint.
+
+ For reverse-stepping, this check is after the step. There is logic in
+ infrun.c that handles reverse-stepping separately. See, for example,
+ proceed and adjust_pc_after_break.
+
+ This code assumes that for reverse-stepping, PC points to the last
+ de-executed instruction, whereas for forward-stepping PC points to the
+ next to-be-executed instruction. */
+ if (record_btrace_replay_at_breakpoint (tp))
+ return btrace_step_stopped ();
+
+ return btrace_step_spurious ();
+}
+
/* Step a single thread. */
static struct target_waitstatus
record_btrace_step_thread (struct thread_info *tp)
{
- struct btrace_insn_iterator *replay, end;
struct btrace_thread_info *btinfo;
+ struct target_waitstatus status;
enum btrace_thread_flag flags;
- unsigned int steps;
-
btinfo = &tp->btrace;
- replay = btinfo->replay;
flags = btinfo->flags & (BTHR_MOVE | BTHR_STOP);
btinfo->flags &= ~(BTHR_MOVE | BTHR_STOP);
- DEBUG ("stepping thread %d (%s): %x (%s)", tp->num,
+ DEBUG ("stepping thread %s (%s): %x (%s)", print_thread_id (tp),
target_pid_to_str (tp->ptid), flags,
btrace_thread_flag_to_str (flags));
return btrace_step_stopped_on_request ();
case BTHR_STEP:
- /* We're done if we're not replaying. */
- if (replay == NULL)
- return btrace_step_no_history ();
-
- /* Skip gaps during replay. */
- do
- {
- steps = btrace_insn_next (replay, 1);
- if (steps == 0)
- {
- record_btrace_stop_replaying (tp);
- return btrace_step_no_history ();
- }
- }
- while (btrace_insn_get (replay) == NULL);
-
- /* Determine the end of the instruction trace. */
- btrace_insn_end (&end, btinfo);
-
- /* We stop replaying if we reached the end of the trace. */
- if (btrace_insn_cmp (replay, &end) == 0)
- record_btrace_stop_replaying (tp);
+ status = record_btrace_single_step_forward (tp);
+ if (status.kind != TARGET_WAITKIND_SPURIOUS)
+ break;
return btrace_step_stopped ();
case BTHR_RSTEP:
- /* Start replaying if we're not already doing so. */
- if (replay == NULL)
- replay = record_btrace_start_replaying (tp);
-
- /* If we can't step any further, we reached the end of the history.
- Skip gaps during replay. */
- do
- {
- steps = btrace_insn_prev (replay, 1);
- if (steps == 0)
- return btrace_step_no_history ();
-
- }
- while (btrace_insn_get (replay) == NULL);
+ status = record_btrace_single_step_backward (tp);
+ if (status.kind != TARGET_WAITKIND_SPURIOUS)
+ break;
return btrace_step_stopped ();
case BTHR_CONT:
- /* We're done if we're not replaying. */
- if (replay == NULL)
- return btrace_step_no_history ();
+ status = record_btrace_single_step_forward (tp);
+ if (status.kind != TARGET_WAITKIND_SPURIOUS)
+ break;
- /* Determine the end of the instruction trace. */
- btrace_insn_end (&end, btinfo);
+ btinfo->flags |= flags;
+ return btrace_step_again ();
- for (;;)
- {
- const struct btrace_insn *insn;
+ case BTHR_RCONT:
+ status = record_btrace_single_step_backward (tp);
+ if (status.kind != TARGET_WAITKIND_SPURIOUS)
+ break;
- /* Skip gaps during replay. */
- do
- {
- steps = btrace_insn_next (replay, 1);
- if (steps == 0)
- {
- record_btrace_stop_replaying (tp);
- return btrace_step_no_history ();
- }
+ btinfo->flags |= flags;
+ return btrace_step_again ();
+ }
- insn = btrace_insn_get (replay);
- }
- while (insn == NULL);
+ /* We keep threads moving at the end of their execution history. The to_wait
+ method will stop the thread for whom the event is reported. */
+ if (status.kind == TARGET_WAITKIND_NO_HISTORY)
+ btinfo->flags |= flags;
- /* We stop replaying if we reached the end of the trace. */
- if (btrace_insn_cmp (replay, &end) == 0)
- {
- record_btrace_stop_replaying (tp);
- return btrace_step_no_history ();
- }
+ return status;
+}
- DEBUG ("stepping %d (%s) ... %s", tp->num,
- target_pid_to_str (tp->ptid),
- core_addr_to_string_nz (insn->pc));
+/* A vector of threads. */
- if (record_btrace_replay_at_breakpoint (tp))
- return btrace_step_stopped ();
- }
+typedef struct thread_info * tp_t;
+DEF_VEC_P (tp_t);
- case BTHR_RCONT:
- /* Start replaying if we're not already doing so. */
- if (replay == NULL)
- replay = record_btrace_start_replaying (tp);
+/* Announce further events if necessary. */
- for (;;)
- {
- const struct btrace_insn *insn;
+static void
+record_btrace_maybe_mark_async_event
+ (const std::vector<thread_info *> &moving,
+ const std::vector<thread_info *> &no_history)
+{
+ bool more_moving = !moving.empty ();
+ bool more_no_history = !no_history.empty ();;
- /* If we can't step any further, we reached the end of the history.
- Skip gaps during replay. */
- do
- {
- steps = btrace_insn_prev (replay, 1);
- if (steps == 0)
- return btrace_step_no_history ();
+ if (!more_moving && !more_no_history)
+ return;
- insn = btrace_insn_get (replay);
- }
- while (insn == NULL);
+ if (more_moving)
+ DEBUG ("movers pending");
- DEBUG ("reverse-stepping %d (%s) ... %s", tp->num,
- target_pid_to_str (tp->ptid),
- core_addr_to_string_nz (insn->pc));
+ if (more_no_history)
+ DEBUG ("no-history pending");
- if (record_btrace_replay_at_breakpoint (tp))
- return btrace_step_stopped ();
- }
- }
+ mark_async_event_handler (record_btrace_async_inferior_event_handler);
}
/* The to_wait method of target record-btrace. */
record_btrace_wait (struct target_ops *ops, ptid_t ptid,
struct target_waitstatus *status, int options)
{
- struct thread_info *tp, *other;
+ 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 (!record_btrace_is_replaying (ops) && execution_direction != EXEC_REVERSE)
+ if ((execution_direction != EXEC_REVERSE)
+ && !record_btrace_is_replaying (ops, minus_one_ptid))
{
ops = ops->beneath;
return ops->to_wait (ops, ptid, status, options);
}
- /* Let's find a thread to move. */
- tp = record_btrace_find_thread_to_move (ptid);
- if (tp == NULL)
+ /* 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);
+ }
+ }
+
+ if (moving.empty ())
+ {
+ *status = btrace_step_no_resumed ();
+
+ DEBUG ("wait ended by %s: %s", target_pid_to_str (null_ptid),
+ target_waitstatus_to_string (status).c_str ());
+
+ return null_ptid;
+ }
+
+ /* Step moving threads one by one, one step each, until either one thread
+ reports an event or we run out of threads to step.
+
+ When stepping more than one thread, chances are that some threads reach
+ the end of their execution history earlier than others. If we reported
+ this immediately, all-stop on top of non-stop would stop all threads and
+ resume the same threads next time. And we would report the same thread
+ having reached the end of its execution history again.
+
+ In the worst case, this would starve the other threads. But even if other
+ threads would be allowed to make progress, this would result in far too
+ many intermediate stops.
+
+ We therefore delay the reporting of "no execution history" until we have
+ nothing else to report. By this time, all threads should have moved to
+ either the beginning or the end of their execution history. There will
+ be a single user-visible stop. */
+ struct thread_info *eventing = NULL;
+ while ((eventing == NULL) && !moving.empty ())
+ {
+ for (unsigned int ix = 0; eventing == NULL && ix < moving.size ();)
+ {
+ thread_info *tp = moving[ix];
+
+ *status = record_btrace_step_thread (tp);
+
+ switch (status->kind)
+ {
+ case TARGET_WAITKIND_IGNORE:
+ ix++;
+ break;
+
+ case TARGET_WAITKIND_NO_HISTORY:
+ no_history.push_back (ordered_remove (moving, ix));
+ break;
+
+ default:
+ eventing = unordered_remove (moving, ix);
+ break;
+ }
+ }
+ }
+
+ if (eventing == NULL)
{
- DEBUG ("wait %s: no thread", target_pid_to_str (ptid));
+ /* We started with at least one moving thread. This thread must have
+ either stopped or reached the end of its execution history.
- status->kind = TARGET_WAITKIND_IGNORE;
- return minus_one_ptid;
+ In the former case, EVENTING must not be NULL.
+ In the latter case, NO_HISTORY must not be empty. */
+ gdb_assert (!no_history.empty ());
+
+ /* We kept threads moving at the end of their execution history. Stop
+ EVENTING now that we are going to report its stop. */
+ eventing = unordered_remove (no_history, 0);
+ eventing->btrace.flags &= ~BTHR_MOVE;
+
+ *status = btrace_step_no_history ();
}
- /* We only move a single thread. We're not able to correlate threads. */
- *status = record_btrace_step_thread (tp);
+ gdb_assert (eventing != NULL);
+
+ /* We kept threads replaying at the end of their execution history. Stop
+ replaying EVENTING now that we are going to report its stop. */
+ record_btrace_stop_replaying_at_end (eventing);
/* Stop all other threads. */
if (!target_is_non_stop_p ())
- ALL_NON_EXITED_THREADS (other)
- record_btrace_cancel_resume (other);
+ {
+ thread_info *tp;
+
+ ALL_NON_EXITED_THREADS (tp)
+ record_btrace_cancel_resume (tp);
+ }
+
+ /* In async mode, we need to announce further events. */
+ if (target_is_async_p ())
+ record_btrace_maybe_mark_async_event (moving, no_history);
/* Start record histories anew from the current position. */
- record_btrace_clear_histories (&tp->btrace);
+ record_btrace_clear_histories (&eventing->btrace);
/* We moved the replay position but did not update registers. */
- registers_changed_ptid (tp->ptid);
+ registers_changed_ptid (eventing->ptid);
- return tp->ptid;
+ DEBUG ("wait ended by thread %s (%s): %s",
+ print_thread_id (eventing),
+ target_pid_to_str (eventing->ptid),
+ target_waitstatus_to_string (status).c_str ());
+
+ return eventing->ptid;
}
/* The to_stop method of target record-btrace. */
DEBUG ("stop %s", target_pid_to_str (ptid));
/* As long as we're not replaying, just forward the request. */
- if (!record_btrace_is_replaying (ops) && execution_direction != EXEC_REVERSE)
+ if ((execution_direction != EXEC_REVERSE)
+ && !record_btrace_is_replaying (ops, minus_one_ptid))
{
ops = ops->beneath;
ops->to_stop (ops, ptid);
static int
record_btrace_stopped_by_sw_breakpoint (struct target_ops *ops)
{
- if (record_btrace_is_replaying (ops))
+ if (record_btrace_is_replaying (ops, minus_one_ptid))
{
struct thread_info *tp = inferior_thread ();
static int
record_btrace_supports_stopped_by_sw_breakpoint (struct target_ops *ops)
{
- if (record_btrace_is_replaying (ops))
+ if (record_btrace_is_replaying (ops, minus_one_ptid))
return 1;
return ops->beneath->to_supports_stopped_by_sw_breakpoint (ops->beneath);
static int
record_btrace_stopped_by_hw_breakpoint (struct target_ops *ops)
{
- if (record_btrace_is_replaying (ops))
+ if (record_btrace_is_replaying (ops, minus_one_ptid))
{
struct thread_info *tp = inferior_thread ();
static int
record_btrace_supports_stopped_by_hw_breakpoint (struct target_ops *ops)
{
- if (record_btrace_is_replaying (ops))
+ if (record_btrace_is_replaying (ops, minus_one_ptid))
return 1;
return ops->beneath->to_supports_stopped_by_hw_breakpoint (ops->beneath);
record_btrace_update_thread_list (struct target_ops *ops)
{
/* We don't add or remove threads during replay. */
- if (record_btrace_is_replaying (ops))
+ if (record_btrace_is_replaying (ops, minus_one_ptid))
return;
/* Forward the request. */
record_btrace_thread_alive (struct target_ops *ops, ptid_t ptid)
{
/* We don't add or remove threads during replay. */
- if (record_btrace_is_replaying (ops))
+ if (record_btrace_is_replaying (ops, minus_one_ptid))
return find_thread_ptid (ptid) != NULL;
/* Forward the request. */
btinfo = &tp->btrace;
- if (it == NULL || it->function == NULL)
+ if (it == NULL)
record_btrace_stop_replaying (tp);
else
{
tp = require_btrace_thread ();
btrace_insn_begin (&begin, &tp->btrace);
+
+ /* Skip gaps at the beginning of the trace. */
+ while (btrace_insn_get (&begin) == NULL)
+ {
+ unsigned int steps;
+
+ steps = btrace_insn_next (&begin, 1);
+ if (steps == 0)
+ error (_("No trace."));
+ }
+
record_btrace_set_replay (tp, &begin);
}
tp = require_btrace_thread ();
found = btrace_find_insn_by_number (&it, &tp->btrace, number);
- if (found == 0)
+
+ /* Check if the instruction could not be found or is a gap. */
+ if (found == 0 || btrace_insn_get (&it) == NULL)
error (_("No such instruction."));
record_btrace_set_replay (tp, &it);
}
+/* The to_record_stop_replaying method of target record-btrace. */
+
+static void
+record_btrace_stop_replaying_all (struct target_ops *self)
+{
+ struct thread_info *tp;
+
+ ALL_NON_EXITED_THREADS (tp)
+ record_btrace_stop_replaying (tp);
+}
+
/* The to_execution_direction target method. */
static enum exec_direction_kind
ops->to_close = record_btrace_close;
ops->to_async = record_btrace_async;
ops->to_detach = record_detach;
- ops->to_disconnect = record_disconnect;
+ 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_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_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;
/* Start recording in BTS format. */
static void
-cmd_record_btrace_bts_start (char *args, int from_tty)
+cmd_record_btrace_bts_start (const char *args, int from_tty)
{
if (args != NULL && *args != 0)
error (_("Invalid argument."));
END_CATCH
}
-/* Start recording Intel(R) Processor Trace. */
+/* Start recording in Intel Processor Trace format. */
static void
-cmd_record_btrace_pt_start (char *args, int from_tty)
+cmd_record_btrace_pt_start (const char *args, int from_tty)
{
if (args != NULL && *args != 0)
error (_("Invalid argument."));
/* Alias for "target record". */
static void
-cmd_record_btrace_start (char *args, int from_tty)
+cmd_record_btrace_start (const char *args, int from_tty)
{
if (args != NULL && *args != 0)
error (_("Invalid argument."));
/* The "set record btrace" command. */
static void
-cmd_set_record_btrace (char *args, int from_tty)
+cmd_set_record_btrace (const char *args, int from_tty)
{
cmd_show_list (set_record_btrace_cmdlist, from_tty, "");
}
/* The "show record btrace" command. */
static void
-cmd_show_record_btrace (char *args, int from_tty)
+cmd_show_record_btrace (const char *args, int from_tty)
{
cmd_show_list (show_record_btrace_cmdlist, from_tty, "");
}
/* The "set record btrace bts" command. */
static void
-cmd_set_record_btrace_bts (char *args, int from_tty)
+cmd_set_record_btrace_bts (const char *args, int from_tty)
{
printf_unfiltered (_("\"set record btrace bts\" must be followed "
"by an appropriate subcommand.\n"));
/* The "show record btrace bts" command. */
static void
-cmd_show_record_btrace_bts (char *args, int from_tty)
+cmd_show_record_btrace_bts (const char *args, int from_tty)
{
cmd_show_list (show_record_btrace_bts_cmdlist, from_tty, "");
}
/* The "set record btrace pt" command. */
static void
-cmd_set_record_btrace_pt (char *args, int from_tty)
+cmd_set_record_btrace_pt (const char *args, int from_tty)
{
printf_unfiltered (_("\"set record btrace pt\" must be followed "
"by an appropriate subcommand.\n"));
/* The "show record btrace pt" command. */
static void
-cmd_show_record_btrace_pt (char *args, int from_tty)
+cmd_show_record_btrace_pt (const char *args, int from_tty)
{
cmd_show_list (show_record_btrace_pt_cmdlist, from_tty, "");
}
value);
}
-void _initialize_record_btrace (void);
-
/* Initialize btrace commands. */
void
add_cmd ("pt", class_obscure, cmd_record_btrace_pt_start,
_("\
-Start branch trace recording in Intel(R) Processor Trace format.\n\n\
+Start branch trace recording in Intel Processor Trace format.\n\n\
This format may not be available on all processors."),
&record_btrace_cmdlist);
add_alias_cmd ("pt", "btrace pt", class_obscure, 1, &record_cmdlist);