/* Branch trace support for GDB, the GNU debugger.
- Copyright (C) 2013-2017 Free Software Foundation, Inc.
+ Copyright (C) 2013-2018 Free Software Foundation, Inc.
Contributed by Intel Corp. <markus.t.metzger@intel.com>
#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"
/* 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";
/* The currently allowed replay memory access type. */
static const char *replay_memory_access = replay_memory_access_read_only;
+/* The cpu state kinds. */
+enum record_btrace_cpu_state_kind
+{
+ CS_AUTO,
+ CS_NONE,
+ CS_CPU
+};
+
+/* The current cpu state. */
+static enum record_btrace_cpu_state_kind record_btrace_cpu_state = CS_AUTO;
+
+/* The current cpu for trace decode. */
+static struct btrace_cpu record_btrace_cpu;
+
/* Command lists for "set/show record btrace". */
static struct cmd_list_element *set_record_btrace_cmdlist;
static struct cmd_list_element *show_record_btrace_cmdlist;
static struct cmd_list_element *set_record_btrace_pt_cmdlist;
static struct cmd_list_element *show_record_btrace_pt_cmdlist;
+/* Command list for "set record btrace cpu". */
+static struct cmd_list_element *set_record_btrace_cpu_cmdlist;
+
/* Print a record-btrace debug message. Use do ... while (0) to avoid
ambiguities when used in if statements. */
while (0)
+/* Return the cpu configured by the user. Returns NULL if the cpu was
+ configured as auto. */
+const struct btrace_cpu *
+record_btrace_get_cpu (void)
+{
+ switch (record_btrace_cpu_state)
+ {
+ case CS_AUTO:
+ return nullptr;
+
+ case CS_NONE:
+ record_btrace_cpu.vendor = CV_UNKNOWN;
+ /* Fall through. */
+ case CS_CPU:
+ return &record_btrace_cpu;
+ }
+
+ error (_("Internal error: bad record btrace cpu state."));
+}
+
/* Update the branch trace for the current thread and return a pointer to its
thread_info.
validate_registers_access ();
- btrace_fetch (tp);
+ btrace_fetch (tp, record_btrace_get_cpu ());
if (btrace_is_empty (tp))
error (_("No trace."));
END_CATCH
}
-/* Callback function to disable branch tracing for one thread. */
-
-static void
-record_btrace_disable_callback (void *arg)
-{
- struct thread_info *tp = (struct thread_info *) 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. */
record_btrace_generating_corefile = 0;
format = btrace_format_short_string (record_btrace_conf.format);
- observer_notify_record_changed (current_inferior (), 1, "btrace", 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."));
- 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->global_num))
{
btrace_enable (tp, &record_btrace_conf);
- make_cleanup (record_btrace_disable_callback, tp);
+ btrace_disable.add_thread (tp);
}
record_btrace_push_target ();
- discard_cleanups (disable_chain);
+ btrace_disable.discard ();
}
/* The to_stop_recording method of target record-btrace. */
if (conf != NULL)
record_btrace_print_conf (conf);
- btrace_fetch (tp);
+ btrace_fetch (tp, record_btrace_get_cpu ());
insns = 0;
calls = 0;
static void
btrace_print_lines (struct btrace_line_range lines, struct ui_out *uiout,
- struct cleanup **ui_item_chain, int flags)
+ gdb::optional<ui_out_emit_tuple> *src_and_asm_tuple,
+ gdb::optional<ui_out_emit_list> *asm_list,
+ gdb_disassembly_flags 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)
+ for (int line = lines.begin; line < lines.end; ++line)
{
- if (*ui_item_chain != NULL)
- do_cleanups (*ui_item_chain);
+ asm_list->reset ();
- *ui_item_chain
- = make_cleanup_ui_out_tuple_begin_end (uiout, "src_and_asm_line");
+ src_and_asm_tuple->emplace (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");
+ asm_list->emplace (uiout, "line_asm_insn");
}
}
const struct btrace_insn_iterator *end,
gdb_disassembly_flags flags)
{
- struct cleanup *cleanups, *ui_item_chain;
- struct gdbarch *gdbarch;
- struct btrace_insn_iterator it;
- struct btrace_line_range last_lines;
-
DEBUG ("itrace (0x%x): [%u; %u)", (unsigned) flags,
btrace_insn_number (begin), btrace_insn_number (end));
flags |= DISASSEMBLY_SPECULATIVE;
- gdbarch = target_gdbarch ();
- last_lines = btrace_mk_line_range (NULL, 0, 0);
+ struct gdbarch *gdbarch = target_gdbarch ();
+ btrace_line_range last_lines = btrace_mk_line_range (NULL, 0, 0);
- cleanups = make_cleanup_ui_out_list_begin_end (uiout, "asm_insns");
+ ui_out_emit_list list_emitter (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;
+ gdb::optional<ui_out_emit_tuple> src_and_asm_tuple;
+ gdb::optional<ui_out_emit_list> asm_list;
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;
if (!btrace_line_range_is_empty (lines)
&& !btrace_line_range_contains_range (last_lines, lines))
{
- btrace_print_lines (lines, uiout, &ui_item_chain, flags);
+ btrace_print_lines (lines, uiout, &src_and_asm_tuple, &asm_list,
+ flags);
last_lines = lines;
}
- else if (ui_item_chain == NULL)
+ else if (!src_and_asm_tuple.has_value ())
{
- ui_item_chain
- = make_cleanup_ui_out_tuple_begin_end (uiout,
- "src_and_asm_line");
+ gdb_assert (!asm_list.has_value ());
+
+ src_and_asm_tuple.emplace (uiout, "src_and_asm_line");
+
/* No source information. */
- make_cleanup_ui_out_list_begin_end (uiout, "line_asm_insn");
+ asm_list.emplace (uiout, "line_asm_insn");
}
- gdb_assert (ui_item_chain != NULL);
+ gdb_assert (src_and_asm_tuple.has_value ());
+ gdb_assert (asm_list.has_value ());
}
memset (&dinsn, 0, sizeof (dinsn));
disasm.pretty_print_insn (uiout, &dinsn, flags);
}
}
-
- do_cleanups (cleanups);
}
/* The to_insn_history method of target record-btrace. */
gdb_disassembly_flags flags)
{
struct btrace_thread_info *btinfo;
- struct btrace_insn_history *history;
struct btrace_insn_iterator begin, end;
struct ui_out *uiout;
unsigned int low, high;
/* The to_call_history method of target record-btrace. */
static void
-record_btrace_call_history (struct target_ops *self, int size, int 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 ui_out *uiout;
unsigned int context, covered;
- record_print_flags flags = (enum record_print_flag) int_flags;
uiout = current_uiout;
ui_out_emit_tuple tuple_emitter (uiout, "insn history");
{
struct btrace_insn_iterator *replay;
- DEBUG ("call-history (0x%x): %d", int_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)", int_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 int_flags)
+ record_print_flags flags)
{
struct btrace_thread_info *btinfo;
- struct btrace_call_history *history;
struct btrace_call_iterator begin, end;
struct ui_out *uiout;
unsigned int low, high;
int found;
- record_print_flags flags = (enum record_print_flag) int_flags;
uiout = current_uiout;
ui_out_emit_tuple tuple_emitter (uiout, "func history");
low = from;
high = to;
- DEBUG ("call-history (0x%x): [%u; %u)", int_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 int_flags)
+ record_print_flags flags)
{
ULONGEST begin, end, context;
- record_print_flags flags = (enum record_print_flag) int_flags;
context = abs (size);
if (context == 0)
static enum record_method
record_btrace_record_method (struct target_ops *self, ptid_t ptid)
{
- const struct btrace_config *config;
struct thread_info * const tp = find_thread_ptid (ptid);
if (tp == NULL)
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
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;
btinfo = &tp->btrace;
/* Fetch the latest branch trace. */
- btrace_fetch (tp);
+ btrace_fetch (tp, record_btrace_get_cpu ());
/* A resume request overwrites a preceding resume or stop request. */
btinfo->flags &= ~(BTHR_MOVE | BTHR_STOP);
/* Announce further events if necessary. */
static void
-record_btrace_maybe_mark_async_event (const VEC (tp_t) *moving,
- const VEC (tp_t) *no_history)
+record_btrace_maybe_mark_async_event
+ (const std::vector<thread_info *> &moving,
+ const std::vector<thread_info *> &no_history)
{
- int more_moving, more_no_history;
-
- more_moving = !VEC_empty (tp_t, moving);
- more_no_history = !VEC_empty (tp_t, no_history);
+ bool more_moving = !moving.empty ();
+ bool more_no_history = !no_history.empty ();;
if (!more_moving && !more_no_history)
return;
record_btrace_wait (struct target_ops *ops, ptid_t ptid,
struct target_waitstatus *status, int options)
{
- VEC (tp_t) *moving, *no_history;
- struct thread_info *tp, *eventing;
- struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
+ std::vector<thread_info *> moving;
+ std::vector<thread_info *> no_history;
DEBUG ("wait %s (0x%x)", target_pid_to_str (ptid), options);
return ops->to_wait (ops, ptid, status, options);
}
- 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);
+ {
+ 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 (VEC_empty (tp_t, moving))
+ 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 ());
- do_cleanups (cleanups);
return null_ptid;
}
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))
+ struct thread_info *eventing = NULL;
+ while ((eventing == NULL) && !moving.empty ())
{
- unsigned int ix;
-
- ix = 0;
- while ((eventing == NULL) && VEC_iterate (tp_t, moving, ix, tp))
+ for (unsigned int ix = 0; eventing == NULL && ix < moving.size ();)
{
+ thread_info *tp = moving[ix];
+
*status = record_btrace_step_thread (tp);
switch (status->kind)
break;
case TARGET_WAITKIND_NO_HISTORY:
- VEC_safe_push (tp_t, no_history,
- VEC_ordered_remove (tp_t, moving, ix));
+ no_history.push_back (ordered_remove (moving, ix));
break;
default:
- eventing = VEC_unordered_remove (tp_t, moving, ix);
+ eventing = unordered_remove (moving, ix);
break;
}
}
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));
+ 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 = VEC_unordered_remove (tp_t, no_history, 0);
+ eventing = unordered_remove (no_history, 0);
eventing->btrace.flags &= ~BTHR_MOVE;
*status = btrace_step_no_history ();
/* Stop all other threads. */
if (!target_is_non_stop_p ())
- ALL_NON_EXITED_THREADS (tp)
- record_btrace_cancel_resume (tp);
+ {
+ 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 ())
target_pid_to_str (eventing->ptid),
target_waitstatus_to_string (status).c_str ());
- do_cleanups (cleanups);
return eventing->ptid;
}
static void
cmd_set_record_btrace (const char *args, int from_tty)
{
- cmd_show_list (set_record_btrace_cmdlist, from_tty, "");
+ printf_unfiltered (_("\"set record btrace\" must be followed "
+ "by an appropriate subcommand.\n"));
+ help_list (set_record_btrace_cmdlist, "set record btrace ",
+ all_commands, gdb_stdout);
}
/* The "show record btrace" command. */
replay_memory_access);
}
-/* The "set record btrace bts" command. */
+/* The "set record btrace cpu none" command. */
+
+static void
+cmd_set_record_btrace_cpu_none (const char *args, int from_tty)
+{
+ if (args != nullptr && *args != 0)
+ error (_("Trailing junk: '%s'."), args);
+
+ record_btrace_cpu_state = CS_NONE;
+}
+
+/* The "set record btrace cpu auto" command. */
+
+static void
+cmd_set_record_btrace_cpu_auto (const char *args, int from_tty)
+{
+ if (args != nullptr && *args != 0)
+ error (_("Trailing junk: '%s'."), args);
+
+ record_btrace_cpu_state = CS_AUTO;
+}
+
+/* The "set record btrace cpu" command. */
+
+static void
+cmd_set_record_btrace_cpu (const char *args, int from_tty)
+{
+ if (args == nullptr)
+ args = "";
+
+ /* We use a hard-coded vendor string for now. */
+ unsigned int family, model, stepping;
+ int l1, l2, matches = sscanf (args, "intel: %u/%u%n/%u%n", &family,
+ &model, &l1, &stepping, &l2);
+ if (matches == 3)
+ {
+ if (strlen (args) != l2)
+ error (_("Trailing junk: '%s'."), args + l2);
+ }
+ else if (matches == 2)
+ {
+ if (strlen (args) != l1)
+ error (_("Trailing junk: '%s'."), args + l1);
+
+ stepping = 0;
+ }
+ else
+ error (_("Bad format. See \"help set record btrace cpu\"."));
+
+ if (USHRT_MAX < family)
+ error (_("Cpu family too big."));
+
+ if (UCHAR_MAX < model)
+ error (_("Cpu model too big."));
+
+ if (UCHAR_MAX < stepping)
+ error (_("Cpu stepping too big."));
+
+ record_btrace_cpu.vendor = CV_INTEL;
+ record_btrace_cpu.family = family;
+ record_btrace_cpu.model = model;
+ record_btrace_cpu.stepping = stepping;
+
+ record_btrace_cpu_state = CS_CPU;
+}
+
+/* The "show record btrace cpu" command. */
+
+static void
+cmd_show_record_btrace_cpu (const char *args, int from_tty)
+{
+ const char *cpu;
+
+ if (args != nullptr && *args != 0)
+ error (_("Trailing junk: '%s'."), args);
+
+ switch (record_btrace_cpu_state)
+ {
+ case CS_AUTO:
+ printf_unfiltered (_("btrace cpu is 'auto'.\n"));
+ return;
+
+ case CS_NONE:
+ printf_unfiltered (_("btrace cpu is 'none'.\n"));
+ return;
+
+ case CS_CPU:
+ switch (record_btrace_cpu.vendor)
+ {
+ case CV_INTEL:
+ if (record_btrace_cpu.stepping == 0)
+ printf_unfiltered (_("btrace cpu is 'intel: %u/%u'.\n"),
+ record_btrace_cpu.family,
+ record_btrace_cpu.model);
+ else
+ printf_unfiltered (_("btrace cpu is 'intel: %u/%u/%u'.\n"),
+ record_btrace_cpu.family,
+ record_btrace_cpu.model,
+ record_btrace_cpu.stepping);
+ return;
+ }
+ }
+
+ error (_("Internal error: bad cpu state."));
+}
+
+/* The "s record btrace bts" command. */
static void
cmd_set_record_btrace_bts (const char *args, int from_tty)
&set_record_btrace_cmdlist,
&show_record_btrace_cmdlist);
+ add_prefix_cmd ("cpu", class_support, cmd_set_record_btrace_cpu,
+ _("\
+Set the cpu to be used for trace decode.\n\n\
+The format is \"<vendor>:<identifier>\" or \"none\" or \"auto\" (default).\n\
+For vendor \"intel\" the format is \"<family>/<model>[/<stepping>]\".\n\n\
+When decoding branch trace, enable errata workarounds for the specified cpu.\n\
+The default is \"auto\", which uses the cpu on which the trace was recorded.\n\
+When GDB does not support that cpu, this option can be used to enable\n\
+workarounds for a similar cpu that GDB supports.\n\n\
+When set to \"none\", errata workarounds are disabled."),
+ &set_record_btrace_cpu_cmdlist,
+ _("set record btrace cpu "), 1,
+ &set_record_btrace_cmdlist);
+
+ add_cmd ("auto", class_support, cmd_set_record_btrace_cpu_auto, _("\
+Automatically determine the cpu to be used for trace decode."),
+ &set_record_btrace_cpu_cmdlist);
+
+ add_cmd ("none", class_support, cmd_set_record_btrace_cpu_none, _("\
+Do not enable errata workarounds for trace decode."),
+ &set_record_btrace_cpu_cmdlist);
+
+ add_cmd ("cpu", class_support, cmd_show_record_btrace_cpu, _("\
+Show the cpu to be used for trace decode."),
+ &show_record_btrace_cmdlist);
+
add_prefix_cmd ("bts", class_support, cmd_set_record_btrace_bts,
_("Set record btrace bts options"),
&set_record_btrace_bts_cmdlist,