#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."));
{
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. */
if (!target_has_execution)
error (_("The program is not being run."));
- gdb_assert (record_btrace_thread_observer == NULL);
-
ALL_NON_EXITED_THREADS (tp)
if (args == NULL || *args == 0 || number_is_in_list (args, tp->global_num))
{
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, gdb_disassembly_flags 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. */
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);
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,