/* Branch trace support for GDB, the GNU debugger.
- Copyright (C) 2013-2015 Free Software Foundation, Inc.
+ Copyright (C) 2013-2016 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 "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;
static struct cmd_list_element *set_record_btrace_bts_cmdlist;
static struct cmd_list_element *show_record_btrace_bts_cmdlist;
+/* Command lists for "set/show record btrace pt". */
+static struct cmd_list_element *set_record_btrace_pt_cmdlist;
+static struct cmd_list_element *show_record_btrace_pt_cmdlist;
+
/* Print a record-btrace debug message. Use do ... while (0) to avoid
ambiguities when used in if statements. */
static void
record_btrace_enable_warn (struct thread_info *tp)
{
- volatile struct gdb_exception error;
-
- TRY_CATCH (error, RETURN_MASK_ERROR)
- btrace_enable (tp, &record_btrace_conf);
-
- if (error.message != NULL)
- warning ("%s", error.message);
+ TRY
+ {
+ btrace_enable (tp, &record_btrace_conf);
+ }
+ CATCH (error, RETURN_MASK_ERROR)
+ {
+ warning ("%s", error.message);
+ }
+ 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;
+ struct thread_info *tp = (struct thread_info *) arg;
btrace_disable (tp);
}
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);
+ observer_notify_record_changed (current_inferior (), 1, "btrace", format);
+}
+
/* The to_open method of target record-btrace. */
static void
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);
}
- 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;
-
- observer_notify_record_changed (current_inferior (), 1);
+ record_btrace_push_target ();
discard_cleanups (disable_chain);
}
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
/* The to_async method of target record-btrace. */
static void
-record_btrace_async (struct target_ops *ops,
- void (*callback) (enum inferior_event_type event_type,
- void *context),
- void *context)
+record_btrace_async (struct target_ops *ops, int enable)
{
- if (callback != NULL)
+ 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, callback, context);
+ ops->beneath->to_async (ops->beneath, enable);
}
/* Adjusts the size and returns a human readable size suffix. */
}
}
+/* Print an Intel Processor Trace configuration. */
+
+static void
+record_btrace_print_pt_conf (const struct btrace_config_pt *conf)
+{
+ const char *suffix;
+ unsigned int size;
+
+ size = conf->size;
+ if (size > 0)
+ {
+ suffix = record_btrace_adjust_size (&size);
+ printf_unfiltered (_("Buffer size: %u%s.\n"), size, suffix);
+ }
+}
+
/* Print a branch tracing configuration. */
static void
case BTRACE_FORMAT_BTS:
record_btrace_print_bts_conf (&conf->bts);
return;
+
+ case BTRACE_FORMAT_PT:
+ record_btrace_print_pt_conf (&conf->pt);
+ return;
}
internal_error (__FILE__, __LINE__, _("Unkown branch trace format."));
}
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"),
break;
}
break;
+
+#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) */
}
ui_out_text (uiout, _("["));
ui_out_field_fmt (uiout, fld, "%u", val);
}
+/* A range of source lines. */
+
+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);
+
+ 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++)
+ {
+ if ((lines[i].pc == pc) && (lines[i].line != 0))
+ range = btrace_line_range_add (range, lines[i].line);
+ }
+
+ return range;
+}
+
+/* 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
+btrace_print_lines (struct btrace_line_range lines, struct ui_out *uiout,
+ struct cleanup **ui_item_chain, int flags)
+{
+ print_source_lines_flags psl_flags;
+ int line;
+
+ psl_flags = 0;
+ if (flags & DISASSEMBLY_FILENAME)
+ psl_flags |= PRINT_SOURCE_LINES_FILENAME;
+
+ for (line = lines.begin; line < lines.end; ++line)
+ {
+ if (*ui_item_chain != NULL)
+ do_cleanups (*ui_item_chain);
+
+ *ui_item_chain
+ = make_cleanup_ui_out_tuple_begin_end (uiout, "src_and_asm_line");
+
+ print_source_lines (lines.symtab, line, line + 1, psl_flags);
+
+ make_cleanup_ui_out_list_begin_end (uiout, "line_asm_insn");
+ }
+}
+
/* Disassemble a section of the recorded instruction trace. */
static void
const struct btrace_insn_iterator *begin,
const struct btrace_insn_iterator *end, int flags)
{
+ struct ui_file *stb;
+ struct cleanup *cleanups, *ui_item_chain;
+ struct disassemble_info di;
struct gdbarch *gdbarch;
struct btrace_insn_iterator it;
+ struct btrace_line_range last_lines;
DEBUG ("itrace (0x%x): [%u; %u)", flags, btrace_insn_number (begin),
btrace_insn_number (end));
+ flags |= DISASSEMBLY_SPECULATIVE;
+
gdbarch = target_gdbarch ();
+ stb = mem_fileopen ();
+ cleanups = make_cleanup_ui_file_delete (stb);
+ di = gdb_disassemble_info (gdbarch, stb);
+ last_lines = btrace_mk_line_range (NULL, 0, 0);
+
+ make_cleanup_ui_out_list_begin_end (uiout, "asm_insns");
+
+ /* UI_ITEM_CHAIN is a cleanup chain for the last source line and the
+ instructions corresponding to that line. */
+ ui_item_chain = NULL;
for (it = *begin; btrace_insn_cmp (&it, end) != 0; btrace_insn_next (&it, 1))
{
}
else
{
- /* Print the instruction index. */
- ui_out_field_uint (uiout, "index", btrace_insn_number (&it));
- ui_out_text (uiout, "\t");
-
- /* Disassembly with '/m' flag may not produce the expected result.
- See PR gdb/11833. */
- gdb_disassembly (gdbarch, uiout, NULL, flags, 1, insn->pc,
- insn->pc + 1);
+ struct disasm_insn dinsn;
+
+ if ((flags & DISASSEMBLY_SOURCE) != 0)
+ {
+ 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, &ui_item_chain, flags);
+ last_lines = lines;
+ }
+ else if (ui_item_chain == NULL)
+ {
+ ui_item_chain
+ = make_cleanup_ui_out_tuple_begin_end (uiout,
+ "src_and_asm_line");
+ /* No source information. */
+ make_cleanup_ui_out_list_begin_end (uiout, "line_asm_insn");
+ }
+
+ gdb_assert (ui_item_chain != NULL);
+ }
+
+ memset (&dinsn, 0, sizeof (dinsn));
+ dinsn.number = btrace_insn_number (&it);
+ dinsn.addr = insn->pc;
+
+ if ((insn->flags & BTRACE_INSN_FLAG_SPECULATIVE) != 0)
+ dinsn.is_speculative = 1;
+
+ gdb_pretty_print_insn (gdbarch, uiout, &di, &dinsn, flags, stb);
}
}
+
+ do_cleanups (cleanups);
}
/* The to_insn_history method of target record-btrace. */
ui_out_field_uint (uiout, "insn end", end);
}
+/* Compute the lowest and highest source line for the instructions in BFUN
+ and return them in PBEGIN and PEND.
+ Ignore instructions that can't be mapped to BFUN, e.g. instructions that
+ result from inlining or macro expansion. */
+
+static void
+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;
+ end = INT_MIN;
+
+ sym = bfun->sym;
+ if (sym == NULL)
+ goto out;
+
+ symtab = symbol_symtab (sym);
+
+ for (idx = 0; VEC_iterate (btrace_insn_s, bfun->insn, idx, insn); ++idx)
+ {
+ struct symtab_and_line sal;
+
+ sal = find_pc_line (insn->pc, 0);
+ if (sal.symtab != symtab || sal.line == 0)
+ continue;
+
+ begin = std::min (begin, sal.line);
+ end = std::max (end, sal.line);
+ }
+
+ out:
+ *pbegin = begin;
+ *pend = end;
+}
+
/* Print the source line information for a function call history line. */
static void
ui_out_field_string (uiout, "file",
symtab_to_filename_for_display (symbol_symtab (sym)));
- begin = bfun->lbegin;
- end = bfun->lend;
-
+ btrace_compute_src_line_range (bfun, &begin, &end);
if (end < begin)
return;
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))
/* 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, int int_flags)
{
struct btrace_thread_info *btinfo;
struct btrace_call_history *history;
struct cleanup *uiout_cleanup;
struct ui_out *uiout;
unsigned int context, covered;
+ record_print_flags flags = (enum record_print_flag) int_flags;
uiout = current_uiout;
uiout_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout,
{
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. */
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)
static void
record_btrace_call_history_range (struct target_ops *self,
- ULONGEST from, ULONGEST to, int flags)
+ ULONGEST from, ULONGEST to,
+ int int_flags)
{
struct btrace_thread_info *btinfo;
struct btrace_call_history *history;
struct ui_out *uiout;
unsigned int low, high;
int found;
+ record_print_flags flags = (enum record_print_flag) int_flags;
uiout = current_uiout;
uiout_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout,
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)
static void
record_btrace_call_history_from (struct target_ops *self,
- ULONGEST from, int size, int flags)
+ ULONGEST from, int size,
+ int int_flags)
{
ULONGEST begin, end, context;
+ record_print_flags flags = (enum record_print_flag) int_flags;
context = abs (size);
if (context == 0)
/* 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
/* 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;
}
}
struct gdbarch *gdbarch,
struct bp_target_info *bp_tgt)
{
- volatile struct gdb_exception except;
const char *old;
int ret;
replay_memory_access = replay_memory_access_read_write;
ret = 0;
- TRY_CATCH (except, RETURN_MASK_ALL)
- ret = ops->beneath->to_insert_breakpoint (ops->beneath, gdbarch, bp_tgt);
-
+ TRY
+ {
+ ret = ops->beneath->to_insert_breakpoint (ops->beneath, gdbarch, bp_tgt);
+ }
+ CATCH (except, RETURN_MASK_ALL)
+ {
+ replay_memory_access = old;
+ throw_exception (except);
+ }
+ END_CATCH
replay_memory_access = old;
- if (except.reason < 0)
- throw_exception (except);
-
return ret;
}
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)
{
- volatile struct gdb_exception except;
const char *old;
int ret;
replay_memory_access = replay_memory_access_read_write;
ret = 0;
- TRY_CATCH (except, RETURN_MASK_ALL)
- ret = ops->beneath->to_remove_breakpoint (ops->beneath, gdbarch, bp_tgt);
-
+ TRY
+ {
+ ret = ops->beneath->to_remove_breakpoint (ops->beneath, gdbarch, bp_tgt,
+ reason);
+ }
+ CATCH (except, RETURN_MASK_ALL)
+ {
+ replay_memory_access = old;
+ throw_exception (except);
+ }
+ END_CATCH
replay_memory_access = old;
- if (except.reason < 0)
- throw_exception (except);
-
return ret;
}
{
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, inferior_ptid))
+ 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, inferior_ptid))
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;
}
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);
const struct btrace_function *bfun;
CORE_ADDR code, special;
- cache = *this_cache;
+ cache = (const struct btrace_frame_cache *) *this_cache;
bfun = cache->bfun;
gdb_assert (bfun != NULL);
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);
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);
return &record_btrace_tailcall_frame_unwind;
}
+/* Return a human-readable string for FLAG. */
+
+static const char *
+btrace_thread_flag_to_str (enum btrace_thread_flag flag)
+{
+ switch (flag)
+ {
+ case BTHR_STEP:
+ return "step";
+
+ case BTHR_RSTEP:
+ return "reverse-step";
+
+ case BTHR_CONT:
+ return "cont";
+
+ case BTHR_RCONT:
+ return "reverse-cont";
+
+ case BTHR_STOP:
+ return "stop";
+ }
+
+ return "<invalid>";
+}
+
/* Indicate that TP should be resumed according to FLAG. */
static void
{
struct btrace_thread_info *btinfo;
- DEBUG ("resuming %d (%s): %u", tp->num, target_pid_to_str (tp->ptid), flag);
+ 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 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);
+
+ 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;
- /* When asked to resume everything, we pick the current thread. */
- if (ptid_equal (minus_one_ptid, ptid) || ptid_is_pid (ptid))
- ptid = 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. */
static struct btrace_insn_iterator *
record_btrace_start_replaying (struct thread_info *tp)
{
- volatile struct gdb_exception except;
struct btrace_insn_iterator *replay;
struct btrace_thread_info *btinfo;
- int executing;
btinfo = &tp->btrace;
replay = NULL;
if (btinfo->begin == NULL)
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
recompute those stored frames and fix them up so we can still detect
subroutines after we started replaying. */
- TRY_CATCH (except, RETURN_MASK_ALL)
+ 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_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. */
/* We start replaying at the end of the branch trace. This corresponds
to the current instruction. */
- replay = xmalloc (sizeof (*replay));
+ replay = XNEW (struct btrace_insn_iterator);
btrace_insn_end (replay, btinfo);
/* Skip gaps at the end of the trace. */
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. */
if (upd_step_stack_frame_id)
tp->control.step_stack_frame_id = frame_id;
}
-
- /* Restore the previous execution state. */
- set_executing (tp->ptid, executing);
-
- if (except.reason < 0)
+ CATCH (except, RETURN_MASK_ALL)
{
xfree (btinfo->replay);
btinfo->replay = NULL;
throw_exception (except);
}
+ END_CATCH
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", target_pid_to_str (ptid), step ? "step" : "cont");
+ 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 ())
{
- target_async (inferior_event_handler, 0);
+ target_async (1);
mark_async_event_handler (record_btrace_async_inferior_event_handler);
}
}
-/* Find a thread to move. */
+/* Cancel resuming TP. */
-static struct thread_info *
-record_btrace_find_thread_to_move (ptid_t ptid)
+static void
+record_btrace_cancel_resume (struct thread_info *tp)
{
- struct thread_info *tp;
+ enum btrace_thread_flag flags;
- /* First check the parameter thread. */
- tp = find_thread_ptid (ptid);
- if (tp != NULL && (tp->btrace.flags & BTHR_MOVE) != 0)
- return tp;
+ flags = tp->btrace.flags & (BTHR_MOVE | BTHR_STOP);
+ if (flags == 0)
+ return;
- /* Otherwise, find one other thread that has been resumed. */
- ALL_NON_EXITED_THREADS (tp)
- if ((tp->btrace.flags & BTHR_MOVE) != 0)
- return tp;
+ 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));
- return NULL;
+ tp->btrace.flags &= ~(BTHR_MOVE | BTHR_STOP);
+ 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 that a thread was stopped as
+ requested. */
+
+static struct target_waitstatus
+btrace_step_stopped_on_request (void)
+{
+ struct target_waitstatus status;
+
+ status.kind = TARGET_WAITKIND_STOPPED;
+ status.value.sig = GDB_SIGNAL_0;
+
+ 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->call_history = NULL;
}
-/* Step a single thread. */
+/* Check whether TP's current replay position is at a breakpoint. */
+
+static int
+record_btrace_replay_at_breakpoint (struct thread_info *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 (replay == NULL)
+ return 0;
+
+ insn = btrace_insn_get (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,
+ &btinfo->stop_reason);
+}
+
+/* Step one instruction in forward direction. */
static struct target_waitstatus
-record_btrace_step_thread (struct thread_info *tp)
+record_btrace_single_step_forward (struct thread_info *tp)
{
struct btrace_insn_iterator *replay, end;
struct btrace_thread_info *btinfo;
- struct address_space *aspace;
- struct inferior *inf;
- enum btrace_thread_flag flags;
- unsigned int steps;
- /* We can't step without an execution history. */
- if (btrace_is_empty (tp))
+ 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. */
+ 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)
+ 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;
+ struct btrace_thread_info *btinfo;
+
btinfo = &tp->btrace;
replay = btinfo->replay;
- flags = btinfo->flags & BTHR_MOVE;
- btinfo->flags &= ~BTHR_MOVE;
+ /* 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
+ {
+ unsigned int steps;
+
+ steps = btrace_insn_prev (replay, 1);
+ if (steps == 0)
+ return btrace_step_no_history ();
+ }
+ while (btrace_insn_get (replay) == NULL);
+
+ /* Check if we're stepping a breakpoint.
- DEBUG ("stepping %d (%s): %u", tp->num, target_pid_to_str (tp->ptid), flags);
+ 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_thread_info *btinfo;
+ struct target_waitstatus status;
+ enum btrace_thread_flag flags;
+
+ btinfo = &tp->btrace;
+
+ flags = btinfo->flags & (BTHR_MOVE | BTHR_STOP);
+ btinfo->flags &= ~(BTHR_MOVE | BTHR_STOP);
+
+ DEBUG ("stepping thread %s (%s): %x (%s)", print_thread_id (tp),
+ target_pid_to_str (tp->ptid), flags,
+ btrace_thread_flag_to_str (flags));
+
+ /* We can't step without an execution history. */
+ if ((flags & BTHR_MOVE) != 0 && btrace_is_empty (tp))
+ return btrace_step_no_history ();
switch (flags)
{
default:
internal_error (__FILE__, __LINE__, _("invalid stepping type."));
- 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);
+ case BTHR_STOP:
+ return btrace_step_stopped_on_request ();
- /* We stop replaying if we reached the end of the trace. */
- if (btrace_insn_cmp (replay, &end) == 0)
- record_btrace_stop_replaying (tp);
+ case BTHR_STEP:
+ 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;
- inf = find_inferior_ptid (tp->ptid);
- aspace = inf->aspace;
+ btinfo->flags |= flags;
+ return btrace_step_again ();
- /* Determine the end of the instruction trace. */
- btrace_insn_end (&end, btinfo);
+ case BTHR_RCONT:
+ status = record_btrace_single_step_backward (tp);
+ if (status.kind != TARGET_WAITKIND_SPURIOUS)
+ break;
- for (;;)
- {
- const struct btrace_insn *insn;
+ btinfo->flags |= flags;
+ return btrace_step_again ();
+ }
- /* Skip gaps during replay. */
- do
- {
- steps = btrace_insn_next (replay, 1);
- if (steps == 0)
- {
- record_btrace_stop_replaying (tp);
- return btrace_step_no_history ();
- }
+ /* 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;
- insn = btrace_insn_get (replay);
- }
- while (insn == NULL);
-
- /* 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 (breakpoint_here_p (aspace, insn->pc))
- 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. */
- inf = find_inferior_ptid (tp->ptid);
- aspace = inf->aspace;
+static void
+record_btrace_maybe_mark_async_event (const VEC (tp_t) *moving,
+ const VEC (tp_t) *no_history)
+{
+ int more_moving, more_no_history;
- for (;;)
- {
- const struct btrace_insn *insn;
+ more_moving = !VEC_empty (tp_t, moving);
+ more_no_history = !VEC_empty (tp_t, no_history);
- /* 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 (breakpoint_here_p (aspace, insn->pc))
- 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;
+ VEC (tp_t) *moving, *no_history;
+ struct thread_info *tp, *eventing;
+ struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
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)
+ moving = NULL;
+ no_history = NULL;
+
+ make_cleanup (VEC_cleanup (tp_t), &moving);
+ make_cleanup (VEC_cleanup (tp_t), &no_history);
+
+ /* Keep a work list of moving threads. */
+ ALL_NON_EXITED_THREADS (tp)
+ if (ptid_match (tp->ptid, ptid)
+ && ((tp->btrace.flags & (BTHR_MOVE | BTHR_STOP)) != 0))
+ VEC_safe_push (tp_t, moving, tp);
+
+ if (VEC_empty (tp_t, moving))
{
- DEBUG ("wait %s: no thread", target_pid_to_str (ptid));
+ *status = btrace_step_no_resumed ();
+
+ DEBUG ("wait ended by %s: %s", target_pid_to_str (null_ptid),
+ target_waitstatus_to_string (status));
- status->kind = TARGET_WAITKIND_IGNORE;
- return minus_one_ptid;
+ do_cleanups (cleanups);
+ return null_ptid;
}
- /* We only move a single thread. We're not able to correlate threads. */
- *status = record_btrace_step_thread (tp);
+ /* 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. */
+ eventing = NULL;
+ while ((eventing == NULL) && !VEC_empty (tp_t, moving))
+ {
+ unsigned int ix;
+
+ ix = 0;
+ while ((eventing == NULL) && VEC_iterate (tp_t, moving, ix, tp))
+ {
+ *status = record_btrace_step_thread (tp);
+
+ switch (status->kind)
+ {
+ case TARGET_WAITKIND_IGNORE:
+ ix++;
+ break;
+
+ case TARGET_WAITKIND_NO_HISTORY:
+ VEC_safe_push (tp_t, no_history,
+ VEC_ordered_remove (tp_t, moving, ix));
+ break;
+
+ default:
+ eventing = VEC_unordered_remove (tp_t, moving, ix);
+ break;
+ }
+ }
+ }
+
+ if (eventing == NULL)
+ {
+ /* We started with at least one moving thread. This thread must have
+ either stopped or reached the end of its execution history.
+
+ In the former case, EVENTING must not be NULL.
+ In the latter case, NO_HISTORY must not be empty. */
+ gdb_assert (!VEC_empty (tp_t, no_history));
+
+ /* We kept threads moving at the end of their execution history. Stop
+ EVENTING now that we are going to report its stop. */
+ eventing = VEC_unordered_remove (tp_t, no_history, 0);
+ eventing->btrace.flags &= ~BTHR_MOVE;
+
+ *status = btrace_step_no_history ();
+ }
+
+ 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 (!non_stop)
- ALL_NON_EXITED_THREADS (other)
- other->btrace.flags &= ~BTHR_MOVE;
+ if (!target_is_non_stop_p ())
+ 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);
+
+ DEBUG ("wait ended by thread %s (%s): %s",
+ print_thread_id (eventing),
+ target_pid_to_str (eventing->ptid),
+ target_waitstatus_to_string (status));
- return tp->ptid;
+ do_cleanups (cleanups);
+ return eventing->ptid;
}
+/* The to_stop method of target record-btrace. */
+
+static void
+record_btrace_stop (struct target_ops *ops, 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))
+ {
+ ops = ops->beneath;
+ ops->to_stop (ops, 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;
+ }
+ }
+ }
+
/* The to_can_execute_reverse method of target record-btrace. */
static int
return 1;
}
-/* The to_decr_pc_after_break method of target record-btrace. */
+/* The to_stopped_by_sw_breakpoint method of target record-btrace. */
-static CORE_ADDR
-record_btrace_decr_pc_after_break (struct target_ops *ops,
- struct gdbarch *gdbarch)
+static int
+record_btrace_stopped_by_sw_breakpoint (struct target_ops *ops)
{
- /* When replaying, we do not actually execute the breakpoint instruction
- so there is no need to adjust the PC after hitting a breakpoint. */
- if (record_btrace_is_replaying (ops))
- return 0;
+ if (record_btrace_is_replaying (ops, 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);
+}
+
+/* The to_supports_stopped_by_sw_breakpoint method of target
+ record-btrace. */
+
+static int
+record_btrace_supports_stopped_by_sw_breakpoint (struct target_ops *ops)
+{
+ if (record_btrace_is_replaying (ops, minus_one_ptid))
+ return 1;
+
+ return ops->beneath->to_supports_stopped_by_sw_breakpoint (ops->beneath);
+}
+
+/* The to_stopped_by_sw_breakpoint method of target record-btrace. */
+
+static int
+record_btrace_stopped_by_hw_breakpoint (struct target_ops *ops)
+{
+ if (record_btrace_is_replaying (ops, 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);
+}
+
+/* The to_supports_stopped_by_hw_breakpoint method of target
+ record-btrace. */
- return ops->beneath->to_decr_pc_after_break (ops->beneath, gdbarch);
+static int
+record_btrace_supports_stopped_by_hw_breakpoint (struct target_ops *ops)
+{
+ if (record_btrace_is_replaying (ops, minus_one_ptid))
+ return 1;
+
+ return ops->beneath->to_supports_stopped_by_hw_breakpoint (ops->beneath);
}
/* The to_update_thread_list method of target record-btrace. */
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. */
/* Start anew from the new replay position. */
record_btrace_clear_histories (btinfo);
+
+ 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. */
btrace_insn_begin (&begin, &tp->btrace);
record_btrace_set_replay (tp, &begin);
-
- print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC, 1);
}
/* The to_goto_record_end method of target record-btrace. */
tp = require_btrace_thread ();
record_btrace_set_replay (tp, NULL);
-
- print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC, 1);
}
/* The to_goto_record method of target record-btrace. */
error (_("No such instruction."));
record_btrace_set_replay (tp, &it);
+}
- print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC, 1);
+/* 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. */
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_from = record_btrace_call_history_from;
ops->to_call_history_range = record_btrace_call_history_range;
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_tailcall_unwinder = &record_btrace_to_get_tailcall_unwinder;
ops->to_resume = record_btrace_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_decr_pc_after_break = record_btrace_decr_pc_after_break;
+ 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;
static void
cmd_record_btrace_bts_start (char *args, int from_tty)
{
- volatile struct gdb_exception exception;
-
if (args != NULL && *args != 0)
error (_("Invalid argument."));
record_btrace_conf.format = BTRACE_FORMAT_BTS;
- TRY_CATCH (exception, RETURN_MASK_ALL)
- execute_command ("target record-btrace", from_tty);
+ TRY
+ {
+ execute_command ("target record-btrace", from_tty);
+ }
+ CATCH (exception, RETURN_MASK_ALL)
+ {
+ record_btrace_conf.format = BTRACE_FORMAT_NONE;
+ throw_exception (exception);
+ }
+ END_CATCH
+}
+
+/* Start recording in Intel Processor Trace format. */
- if (exception.error != 0)
+static void
+cmd_record_btrace_pt_start (char *args, int from_tty)
+{
+ if (args != NULL && *args != 0)
+ error (_("Invalid argument."));
+
+ record_btrace_conf.format = BTRACE_FORMAT_PT;
+
+ TRY
+ {
+ execute_command ("target record-btrace", from_tty);
+ }
+ CATCH (exception, RETURN_MASK_ALL)
{
record_btrace_conf.format = BTRACE_FORMAT_NONE;
throw_exception (exception);
}
+ END_CATCH
}
/* Alias for "target record". */
static void
cmd_record_btrace_start (char *args, int from_tty)
{
- volatile struct gdb_exception exception;
-
if (args != NULL && *args != 0)
error (_("Invalid argument."));
- record_btrace_conf.format = BTRACE_FORMAT_BTS;
-
- TRY_CATCH (exception, RETURN_MASK_ALL)
- execute_command ("target record-btrace", from_tty);
+ record_btrace_conf.format = BTRACE_FORMAT_PT;
- if (exception.error == 0)
- return;
+ TRY
+ {
+ execute_command ("target record-btrace", from_tty);
+ }
+ CATCH (exception, RETURN_MASK_ALL)
+ {
+ record_btrace_conf.format = BTRACE_FORMAT_BTS;
- record_btrace_conf.format = BTRACE_FORMAT_NONE;
- throw_exception (exception);
+ TRY
+ {
+ execute_command ("target record-btrace", from_tty);
+ }
+ CATCH (exception, RETURN_MASK_ALL)
+ {
+ record_btrace_conf.format = BTRACE_FORMAT_NONE;
+ throw_exception (exception);
+ }
+ END_CATCH
+ }
+ END_CATCH
}
/* The "set record btrace" command. */
cmd_set_record_btrace_bts (char *args, int from_tty)
{
printf_unfiltered (_("\"set record btrace bts\" must be followed "
- "by an apporpriate subcommand.\n"));
+ "by an appropriate subcommand.\n"));
help_list (set_record_btrace_bts_cmdlist, "set record btrace bts ",
all_commands, gdb_stdout);
}
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)
+{
+ printf_unfiltered (_("\"set record btrace pt\" must be followed "
+ "by an appropriate subcommand.\n"));
+ help_list (set_record_btrace_pt_cmdlist, "set record btrace pt ",
+ all_commands, gdb_stdout);
+}
+
+/* The "show record btrace pt" command. */
+
+static void
+cmd_show_record_btrace_pt (char *args, int from_tty)
+{
+ cmd_show_list (show_record_btrace_pt_cmdlist, from_tty, "");
+}
+
+/* The "record bts buffer-size" show value function. */
+
+static void
+show_record_bts_buffer_size_value (struct ui_file *file, int from_tty,
+ struct cmd_list_element *c,
+ const char *value)
+{
+ fprintf_filtered (file, _("The record/replay bts buffer size is %s.\n"),
+ value);
+}
+
+/* The "record pt buffer-size" show value function. */
+
+static void
+show_record_pt_buffer_size_value (struct ui_file *file, int from_tty,
+ struct cmd_list_element *c,
+ const char *value)
+{
+ fprintf_filtered (file, _("The record/replay pt buffer size is %s.\n"),
+ value);
+}
+
void _initialize_record_btrace (void);
/* Initialize btrace commands. */
&record_btrace_cmdlist);
add_alias_cmd ("bts", "btrace bts", class_obscure, 1, &record_cmdlist);
+ add_cmd ("pt", class_obscure, cmd_record_btrace_pt_start,
+ _("\
+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);
+
add_prefix_cmd ("btrace", class_support, cmd_set_record_btrace,
_("Set record options"), &set_record_btrace_cmdlist,
"set record btrace ", 0, &set_record_cmdlist);
Use \"info record\" to see the actual buffer size.\n\n\
Bigger buffers allow longer recording but also take more time to process \
the recorded execution trace.\n\n\
-The trace buffer size may not be changed while recording."), NULL, NULL,
+The trace buffer size may not be changed while recording."), NULL,
+ show_record_bts_buffer_size_value,
&set_record_btrace_bts_cmdlist,
&show_record_btrace_bts_cmdlist);
+ add_prefix_cmd ("pt", class_support, cmd_set_record_btrace_pt,
+ _("Set record btrace pt options"),
+ &set_record_btrace_pt_cmdlist,
+ "set record btrace pt ", 0, &set_record_btrace_cmdlist);
+
+ add_prefix_cmd ("pt", class_support, cmd_show_record_btrace_pt,
+ _("Show record btrace pt options"),
+ &show_record_btrace_pt_cmdlist,
+ "show record btrace pt ", 0, &show_record_btrace_cmdlist);
+
+ add_setshow_uinteger_cmd ("buffer-size", no_class,
+ &record_btrace_conf.pt.size,
+ _("Set the record/replay pt buffer size."),
+ _("Show the record/replay pt buffer size."), _("\
+Bigger buffers allow longer recording but also take more time to process \
+the recorded execution.\n\
+The actual buffer size may differ from the requested size. Use \"info record\" \
+to see the actual buffer size."), NULL, show_record_pt_buffer_size_value,
+ &set_record_btrace_pt_cmdlist,
+ &show_record_btrace_pt_cmdlist);
+
init_record_btrace_ops ();
add_target (&record_btrace_ops);
xcalloc, xfree);
record_btrace_conf.bts.size = 64 * 1024;
+ record_btrace_conf.pt.size = 16 * 1024;
}
projects / deliverable / binutils-gdb.git / blobdiff