1959 lines
49 KiB
C
1959 lines
49 KiB
C
/* Branch trace support for GDB, the GNU debugger.
|
|
|
|
Copyright (C) 2013-2014 Free Software Foundation, Inc.
|
|
|
|
Contributed by Intel Corp. <markus.t.metzger@intel.com>
|
|
|
|
This file is part of GDB.
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>. */
|
|
|
|
#include "defs.h"
|
|
#include "record.h"
|
|
#include "gdbthread.h"
|
|
#include "target.h"
|
|
#include "gdbcmd.h"
|
|
#include "disasm.h"
|
|
#include "observer.h"
|
|
#include "exceptions.h"
|
|
#include "cli/cli-utils.h"
|
|
#include "source.h"
|
|
#include "ui-out.h"
|
|
#include "symtab.h"
|
|
#include "filenames.h"
|
|
#include "regcache.h"
|
|
#include "frame-unwind.h"
|
|
#include "hashtab.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;
|
|
|
|
/* Temporarily allow memory accesses. */
|
|
static int record_btrace_allow_memory_access;
|
|
|
|
/* Print a record-btrace debug message. Use do ... while (0) to avoid
|
|
ambiguities when used in if statements. */
|
|
|
|
#define DEBUG(msg, args...) \
|
|
do \
|
|
{ \
|
|
if (record_debug != 0) \
|
|
fprintf_unfiltered (gdb_stdlog, \
|
|
"[record-btrace] " msg "\n", ##args); \
|
|
} \
|
|
while (0)
|
|
|
|
|
|
/* Update the branch trace for the current thread and return a pointer to its
|
|
thread_info.
|
|
|
|
Throws an error if there is no thread or no trace. This function never
|
|
returns NULL. */
|
|
|
|
static struct thread_info *
|
|
require_btrace_thread (void)
|
|
{
|
|
struct thread_info *tp;
|
|
|
|
DEBUG ("require");
|
|
|
|
tp = find_thread_ptid (inferior_ptid);
|
|
if (tp == NULL)
|
|
error (_("No thread."));
|
|
|
|
btrace_fetch (tp);
|
|
|
|
if (btrace_is_empty (tp))
|
|
error (_("No trace."));
|
|
|
|
return tp;
|
|
}
|
|
|
|
/* Update the branch trace for the current thread and return a pointer to its
|
|
branch trace information struct.
|
|
|
|
Throws an error if there is no thread or no trace. This function never
|
|
returns NULL. */
|
|
|
|
static struct btrace_thread_info *
|
|
require_btrace (void)
|
|
{
|
|
struct thread_info *tp;
|
|
|
|
tp = require_btrace_thread ();
|
|
|
|
return &tp->btrace;
|
|
}
|
|
|
|
/* Enable branch tracing for one thread. Warn on errors. */
|
|
|
|
static void
|
|
record_btrace_enable_warn (struct thread_info *tp)
|
|
{
|
|
volatile struct gdb_exception error;
|
|
|
|
TRY_CATCH (error, RETURN_MASK_ERROR)
|
|
btrace_enable (tp);
|
|
|
|
if (error.message != NULL)
|
|
warning ("%s", error.message);
|
|
}
|
|
|
|
/* 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
|
|
record_btrace_auto_enable (void)
|
|
{
|
|
DEBUG ("attach thread observer");
|
|
|
|
record_btrace_thread_observer
|
|
= observer_attach_new_thread (record_btrace_enable_warn);
|
|
}
|
|
|
|
/* 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;
|
|
}
|
|
|
|
/* The to_open method of target record-btrace. */
|
|
|
|
static void
|
|
record_btrace_open (char *args, int from_tty)
|
|
{
|
|
struct cleanup *disable_chain;
|
|
struct thread_info *tp;
|
|
|
|
DEBUG ("open");
|
|
|
|
record_preopen ();
|
|
|
|
if (!target_has_execution)
|
|
error (_("The program is not being run."));
|
|
|
|
if (!target_supports_btrace ())
|
|
error (_("Target does not support branch tracing."));
|
|
|
|
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_THREADS (tp)
|
|
if (args == NULL || *args == 0 || number_is_in_list (args, tp->num))
|
|
{
|
|
btrace_enable (tp);
|
|
|
|
make_cleanup (record_btrace_disable_callback, tp);
|
|
}
|
|
|
|
record_btrace_auto_enable ();
|
|
|
|
push_target (&record_btrace_ops);
|
|
|
|
observer_notify_record_changed (current_inferior (), 1);
|
|
|
|
discard_cleanups (disable_chain);
|
|
}
|
|
|
|
/* The to_stop_recording method of target record-btrace. */
|
|
|
|
static void
|
|
record_btrace_stop_recording (struct target_ops *self)
|
|
{
|
|
struct thread_info *tp;
|
|
|
|
DEBUG ("stop recording");
|
|
|
|
record_btrace_auto_disable ();
|
|
|
|
ALL_THREADS (tp)
|
|
if (tp->btrace.target != NULL)
|
|
btrace_disable (tp);
|
|
}
|
|
|
|
/* The to_close method of target record-btrace. */
|
|
|
|
static void
|
|
record_btrace_close (struct target_ops *self)
|
|
{
|
|
struct thread_info *tp;
|
|
|
|
/* Make sure automatic recording gets disabled even if we did not stop
|
|
recording before closing the record-btrace target. */
|
|
record_btrace_auto_disable ();
|
|
|
|
/* We should have already stopped recording.
|
|
Tear down btrace in case we have not. */
|
|
ALL_THREADS (tp)
|
|
btrace_teardown (tp);
|
|
}
|
|
|
|
/* The to_info_record method of target record-btrace. */
|
|
|
|
static void
|
|
record_btrace_info (struct target_ops *self)
|
|
{
|
|
struct btrace_thread_info *btinfo;
|
|
struct thread_info *tp;
|
|
unsigned int insns, calls;
|
|
|
|
DEBUG ("info");
|
|
|
|
tp = find_thread_ptid (inferior_ptid);
|
|
if (tp == NULL)
|
|
error (_("No thread."));
|
|
|
|
btrace_fetch (tp);
|
|
|
|
insns = 0;
|
|
calls = 0;
|
|
|
|
btinfo = &tp->btrace;
|
|
|
|
if (!btrace_is_empty (tp))
|
|
{
|
|
struct btrace_call_iterator call;
|
|
struct btrace_insn_iterator insn;
|
|
|
|
btrace_call_end (&call, btinfo);
|
|
btrace_call_prev (&call, 1);
|
|
calls = btrace_call_number (&call);
|
|
|
|
btrace_insn_end (&insn, btinfo);
|
|
btrace_insn_prev (&insn, 1);
|
|
insns = btrace_insn_number (&insn);
|
|
}
|
|
|
|
printf_unfiltered (_("Recorded %u instructions in %u functions for thread "
|
|
"%d (%s).\n"), insns, calls, tp->num,
|
|
target_pid_to_str (tp->ptid));
|
|
|
|
if (btrace_is_replaying (tp))
|
|
printf_unfiltered (_("Replay in progress. At instruction %u.\n"),
|
|
btrace_insn_number (btinfo->replay));
|
|
}
|
|
|
|
/* Print an unsigned int. */
|
|
|
|
static void
|
|
ui_out_field_uint (struct ui_out *uiout, const char *fld, unsigned int val)
|
|
{
|
|
ui_out_field_fmt (uiout, fld, "%u", val);
|
|
}
|
|
|
|
/* Disassemble a section of the recorded instruction trace. */
|
|
|
|
static void
|
|
btrace_insn_history (struct ui_out *uiout,
|
|
const struct btrace_insn_iterator *begin,
|
|
const struct btrace_insn_iterator *end, int flags)
|
|
{
|
|
struct gdbarch *gdbarch;
|
|
struct btrace_insn_iterator it;
|
|
|
|
DEBUG ("itrace (0x%x): [%u; %u)", flags, btrace_insn_number (begin),
|
|
btrace_insn_number (end));
|
|
|
|
gdbarch = target_gdbarch ();
|
|
|
|
for (it = *begin; btrace_insn_cmp (&it, end) != 0; btrace_insn_next (&it, 1))
|
|
{
|
|
const struct btrace_insn *insn;
|
|
|
|
insn = btrace_insn_get (&it);
|
|
|
|
/* 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);
|
|
}
|
|
}
|
|
|
|
/* The to_insn_history method of target record-btrace. */
|
|
|
|
static void
|
|
record_btrace_insn_history (struct target_ops *self, int size, int 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");
|
|
context = abs (size);
|
|
if (context == 0)
|
|
error (_("Bad record instruction-history-size."));
|
|
|
|
btinfo = require_btrace ();
|
|
history = btinfo->insn_history;
|
|
if (history == NULL)
|
|
{
|
|
struct btrace_insn_iterator *replay;
|
|
|
|
DEBUG ("insn-history (0x%x): %d", 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 = *replay;
|
|
else
|
|
btrace_insn_end (&begin, btinfo);
|
|
|
|
/* We start from here and expand in the requested direction. Then we
|
|
expand in the other direction, as well, to fill up any remaining
|
|
context. */
|
|
end = begin;
|
|
if (size < 0)
|
|
{
|
|
/* We want the current position covered, as well. */
|
|
covered = btrace_insn_next (&end, 1);
|
|
covered += btrace_insn_prev (&begin, context - covered);
|
|
covered += btrace_insn_next (&end, context - covered);
|
|
}
|
|
else
|
|
{
|
|
covered = btrace_insn_next (&end, context);
|
|
covered += btrace_insn_prev (&begin, context - covered);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
begin = history->begin;
|
|
end = history->end;
|
|
|
|
DEBUG ("insn-history (0x%x): %d, prev: [%u; %u)", flags, size,
|
|
btrace_insn_number (&begin), btrace_insn_number (&end));
|
|
|
|
if (size < 0)
|
|
{
|
|
end = begin;
|
|
covered = btrace_insn_prev (&begin, context);
|
|
}
|
|
else
|
|
{
|
|
begin = end;
|
|
covered = btrace_insn_next (&end, context);
|
|
}
|
|
}
|
|
|
|
if (covered > 0)
|
|
btrace_insn_history (uiout, &begin, &end, flags);
|
|
else
|
|
{
|
|
if (size < 0)
|
|
printf_unfiltered (_("At the start of the branch trace record.\n"));
|
|
else
|
|
printf_unfiltered (_("At the end of the branch trace record.\n"));
|
|
}
|
|
|
|
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)
|
|
{
|
|
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");
|
|
low = from;
|
|
high = to;
|
|
|
|
DEBUG ("insn-history (0x%x): [%u; %u)", flags, low, high);
|
|
|
|
/* Check for wrap-arounds. */
|
|
if (low != from || high != to)
|
|
error (_("Bad range."));
|
|
|
|
if (high < low)
|
|
error (_("Bad range."));
|
|
|
|
btinfo = require_btrace ();
|
|
|
|
found = btrace_find_insn_by_number (&begin, btinfo, low);
|
|
if (found == 0)
|
|
error (_("Range out of bounds."));
|
|
|
|
found = btrace_find_insn_by_number (&end, btinfo, high);
|
|
if (found == 0)
|
|
{
|
|
/* Silently truncate the range. */
|
|
btrace_insn_end (&end, btinfo);
|
|
}
|
|
else
|
|
{
|
|
/* We want both begin and end to be inclusive. */
|
|
btrace_insn_next (&end, 1);
|
|
}
|
|
|
|
btrace_insn_history (uiout, &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 begin, end, context;
|
|
|
|
context = abs (size);
|
|
if (context == 0)
|
|
error (_("Bad record instruction-history-size."));
|
|
|
|
if (size < 0)
|
|
{
|
|
end = from;
|
|
|
|
if (from < context)
|
|
begin = 0;
|
|
else
|
|
begin = from - context + 1;
|
|
}
|
|
else
|
|
{
|
|
begin = from;
|
|
end = from + context - 1;
|
|
|
|
/* Check for wrap-around. */
|
|
if (end < begin)
|
|
end = ULONGEST_MAX;
|
|
}
|
|
|
|
record_btrace_insn_history_range (self, begin, end, flags);
|
|
}
|
|
|
|
/* Print the instruction number range for a function call history line. */
|
|
|
|
static void
|
|
btrace_call_history_insn_range (struct ui_out *uiout,
|
|
const struct btrace_function *bfun)
|
|
{
|
|
unsigned int begin, end, size;
|
|
|
|
size = VEC_length (btrace_insn_s, bfun->insn);
|
|
gdb_assert (size > 0);
|
|
|
|
begin = bfun->insn_offset;
|
|
end = begin + size - 1;
|
|
|
|
ui_out_field_uint (uiout, "insn begin", begin);
|
|
ui_out_text (uiout, ",");
|
|
ui_out_field_uint (uiout, "insn end", end);
|
|
}
|
|
|
|
/* Print the source line information for a function call history line. */
|
|
|
|
static void
|
|
btrace_call_history_src_line (struct ui_out *uiout,
|
|
const struct btrace_function *bfun)
|
|
{
|
|
struct symbol *sym;
|
|
int begin, end;
|
|
|
|
sym = bfun->sym;
|
|
if (sym == NULL)
|
|
return;
|
|
|
|
ui_out_field_string (uiout, "file",
|
|
symtab_to_filename_for_display (sym->symtab));
|
|
|
|
begin = bfun->lbegin;
|
|
end = bfun->lend;
|
|
|
|
if (end < begin)
|
|
return;
|
|
|
|
ui_out_text (uiout, ":");
|
|
ui_out_field_int (uiout, "min line", begin);
|
|
|
|
if (end == begin)
|
|
return;
|
|
|
|
ui_out_text (uiout, ",");
|
|
ui_out_field_int (uiout, "max line", end);
|
|
}
|
|
|
|
/* Get the name of a branch trace function. */
|
|
|
|
static const char *
|
|
btrace_get_bfun_name (const struct btrace_function *bfun)
|
|
{
|
|
struct minimal_symbol *msym;
|
|
struct symbol *sym;
|
|
|
|
if (bfun == NULL)
|
|
return "??";
|
|
|
|
msym = bfun->msym;
|
|
sym = bfun->sym;
|
|
|
|
if (sym != NULL)
|
|
return SYMBOL_PRINT_NAME (sym);
|
|
else if (msym != NULL)
|
|
return MSYMBOL_PRINT_NAME (msym);
|
|
else
|
|
return "??";
|
|
}
|
|
|
|
/* Disassemble a section of the recorded function trace. */
|
|
|
|
static void
|
|
btrace_call_history (struct ui_out *uiout,
|
|
const struct btrace_thread_info *btinfo,
|
|
const struct btrace_call_iterator *begin,
|
|
const struct btrace_call_iterator *end,
|
|
enum record_print_flag flags)
|
|
{
|
|
struct btrace_call_iterator it;
|
|
|
|
DEBUG ("ftrace (0x%x): [%u; %u)", flags, btrace_call_number (begin),
|
|
btrace_call_number (end));
|
|
|
|
for (it = *begin; btrace_call_cmp (&it, end) < 0; btrace_call_next (&it, 1))
|
|
{
|
|
const struct btrace_function *bfun;
|
|
struct minimal_symbol *msym;
|
|
struct symbol *sym;
|
|
|
|
bfun = btrace_call_get (&it);
|
|
sym = bfun->sym;
|
|
msym = bfun->msym;
|
|
|
|
/* Print the function index. */
|
|
ui_out_field_uint (uiout, "index", bfun->number);
|
|
ui_out_text (uiout, "\t");
|
|
|
|
if ((flags & RECORD_PRINT_INDENT_CALLS) != 0)
|
|
{
|
|
int level = bfun->level + btinfo->level, i;
|
|
|
|
for (i = 0; i < level; ++i)
|
|
ui_out_text (uiout, " ");
|
|
}
|
|
|
|
if (sym != NULL)
|
|
ui_out_field_string (uiout, "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", "??");
|
|
|
|
if ((flags & RECORD_PRINT_INSN_RANGE) != 0)
|
|
{
|
|
ui_out_text (uiout, _("\tinst "));
|
|
btrace_call_history_insn_range (uiout, bfun);
|
|
}
|
|
|
|
if ((flags & RECORD_PRINT_SRC_LINE) != 0)
|
|
{
|
|
ui_out_text (uiout, _("\tat "));
|
|
btrace_call_history_src_line (uiout, bfun);
|
|
}
|
|
|
|
ui_out_text (uiout, "\n");
|
|
}
|
|
}
|
|
|
|
/* The to_call_history method of target record-btrace. */
|
|
|
|
static void
|
|
record_btrace_call_history (struct target_ops *self, int size, int 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");
|
|
context = abs (size);
|
|
if (context == 0)
|
|
error (_("Bad record function-call-history-size."));
|
|
|
|
btinfo = require_btrace ();
|
|
history = btinfo->call_history;
|
|
if (history == NULL)
|
|
{
|
|
struct btrace_insn_iterator *replay;
|
|
|
|
DEBUG ("call-history (0x%x): %d", 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;
|
|
}
|
|
else
|
|
btrace_call_end (&begin, btinfo);
|
|
|
|
/* We start from here and expand in the requested direction. Then we
|
|
expand in the other direction, as well, to fill up any remaining
|
|
context. */
|
|
end = begin;
|
|
if (size < 0)
|
|
{
|
|
/* We want the current position covered, as well. */
|
|
covered = btrace_call_next (&end, 1);
|
|
covered += btrace_call_prev (&begin, context - covered);
|
|
covered += btrace_call_next (&end, context - covered);
|
|
}
|
|
else
|
|
{
|
|
covered = btrace_call_next (&end, context);
|
|
covered += btrace_call_prev (&begin, context- covered);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
begin = history->begin;
|
|
end = history->end;
|
|
|
|
DEBUG ("call-history (0x%x): %d, prev: [%u; %u)", flags, size,
|
|
btrace_call_number (&begin), btrace_call_number (&end));
|
|
|
|
if (size < 0)
|
|
{
|
|
end = begin;
|
|
covered = btrace_call_prev (&begin, context);
|
|
}
|
|
else
|
|
{
|
|
begin = end;
|
|
covered = btrace_call_next (&end, context);
|
|
}
|
|
}
|
|
|
|
if (covered > 0)
|
|
btrace_call_history (uiout, btinfo, &begin, &end, flags);
|
|
else
|
|
{
|
|
if (size < 0)
|
|
printf_unfiltered (_("At the start of the branch trace record.\n"));
|
|
else
|
|
printf_unfiltered (_("At the end of the branch trace record.\n"));
|
|
}
|
|
|
|
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)
|
|
{
|
|
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");
|
|
low = from;
|
|
high = to;
|
|
|
|
DEBUG ("call-history (0x%x): [%u; %u)", flags, low, high);
|
|
|
|
/* Check for wrap-arounds. */
|
|
if (low != from || high != to)
|
|
error (_("Bad range."));
|
|
|
|
if (high < low)
|
|
error (_("Bad range."));
|
|
|
|
btinfo = require_btrace ();
|
|
|
|
found = btrace_find_call_by_number (&begin, btinfo, low);
|
|
if (found == 0)
|
|
error (_("Range out of bounds."));
|
|
|
|
found = btrace_find_call_by_number (&end, btinfo, high);
|
|
if (found == 0)
|
|
{
|
|
/* Silently truncate the range. */
|
|
btrace_call_end (&end, btinfo);
|
|
}
|
|
else
|
|
{
|
|
/* We want both begin and end to be inclusive. */
|
|
btrace_call_next (&end, 1);
|
|
}
|
|
|
|
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 begin, end, context;
|
|
|
|
context = abs (size);
|
|
if (context == 0)
|
|
error (_("Bad record function-call-history-size."));
|
|
|
|
if (size < 0)
|
|
{
|
|
end = from;
|
|
|
|
if (from < context)
|
|
begin = 0;
|
|
else
|
|
begin = from - context + 1;
|
|
}
|
|
else
|
|
{
|
|
begin = from;
|
|
end = from + context - 1;
|
|
|
|
/* Check for wrap-around. */
|
|
if (end < begin)
|
|
end = ULONGEST_MAX;
|
|
}
|
|
|
|
record_btrace_call_history_range (self, begin, end, flags);
|
|
}
|
|
|
|
/* The to_record_is_replaying method of target record-btrace. */
|
|
|
|
static int
|
|
record_btrace_is_replaying (struct target_ops *self)
|
|
{
|
|
struct thread_info *tp;
|
|
|
|
ALL_THREADS (tp)
|
|
if (btrace_is_replaying (tp))
|
|
return 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* The to_xfer_partial method of target record-btrace. */
|
|
|
|
static enum target_xfer_status
|
|
record_btrace_xfer_partial (struct target_ops *ops, enum target_object object,
|
|
const char *annex, gdb_byte *readbuf,
|
|
const gdb_byte *writebuf, ULONGEST offset,
|
|
ULONGEST len, ULONGEST *xfered_len)
|
|
{
|
|
struct target_ops *t;
|
|
|
|
/* Filter out requests that don't make sense during replay. */
|
|
if (!record_btrace_allow_memory_access && record_btrace_is_replaying (ops))
|
|
{
|
|
switch (object)
|
|
{
|
|
case TARGET_OBJECT_MEMORY:
|
|
{
|
|
struct target_section *section;
|
|
|
|
/* We do not allow writing memory in general. */
|
|
if (writebuf != NULL)
|
|
{
|
|
*xfered_len = len;
|
|
return TARGET_XFER_UNAVAILABLE;
|
|
}
|
|
|
|
/* We allow reading readonly memory. */
|
|
section = target_section_by_addr (ops, offset);
|
|
if (section != NULL)
|
|
{
|
|
/* Check if the section we found is readonly. */
|
|
if ((bfd_get_section_flags (section->the_bfd_section->owner,
|
|
section->the_bfd_section)
|
|
& SEC_READONLY) != 0)
|
|
{
|
|
/* Truncate the request to fit into this section. */
|
|
len = min (len, section->endaddr - offset);
|
|
break;
|
|
}
|
|
}
|
|
|
|
*xfered_len = len;
|
|
return TARGET_XFER_UNAVAILABLE;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Forward the request. */
|
|
for (ops = ops->beneath; ops != NULL; ops = ops->beneath)
|
|
if (ops->to_xfer_partial != NULL)
|
|
return ops->to_xfer_partial (ops, object, annex, readbuf, writebuf,
|
|
offset, len, xfered_len);
|
|
|
|
*xfered_len = len;
|
|
return TARGET_XFER_UNAVAILABLE;
|
|
}
|
|
|
|
/* The to_insert_breakpoint method of target record-btrace. */
|
|
|
|
static int
|
|
record_btrace_insert_breakpoint (struct target_ops *ops,
|
|
struct gdbarch *gdbarch,
|
|
struct bp_target_info *bp_tgt)
|
|
{
|
|
volatile struct gdb_exception except;
|
|
int old, ret;
|
|
|
|
/* Inserting breakpoints requires accessing memory. Allow it for the
|
|
duration of this function. */
|
|
old = record_btrace_allow_memory_access;
|
|
record_btrace_allow_memory_access = 1;
|
|
|
|
ret = 0;
|
|
TRY_CATCH (except, RETURN_MASK_ALL)
|
|
ret = ops->beneath->to_insert_breakpoint (ops->beneath, gdbarch, bp_tgt);
|
|
|
|
record_btrace_allow_memory_access = old;
|
|
|
|
if (except.reason < 0)
|
|
throw_exception (except);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/* The to_remove_breakpoint method of target record-btrace. */
|
|
|
|
static int
|
|
record_btrace_remove_breakpoint (struct target_ops *ops,
|
|
struct gdbarch *gdbarch,
|
|
struct bp_target_info *bp_tgt)
|
|
{
|
|
volatile struct gdb_exception except;
|
|
int old, ret;
|
|
|
|
/* Removing breakpoints requires accessing memory. Allow it for the
|
|
duration of this function. */
|
|
old = record_btrace_allow_memory_access;
|
|
record_btrace_allow_memory_access = 1;
|
|
|
|
ret = 0;
|
|
TRY_CATCH (except, RETURN_MASK_ALL)
|
|
ret = ops->beneath->to_remove_breakpoint (ops->beneath, gdbarch, bp_tgt);
|
|
|
|
record_btrace_allow_memory_access = old;
|
|
|
|
if (except.reason < 0)
|
|
throw_exception (except);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/* The to_fetch_registers method of target record-btrace. */
|
|
|
|
static void
|
|
record_btrace_fetch_registers (struct target_ops *ops,
|
|
struct regcache *regcache, int regno)
|
|
{
|
|
struct btrace_insn_iterator *replay;
|
|
struct thread_info *tp;
|
|
|
|
tp = find_thread_ptid (inferior_ptid);
|
|
gdb_assert (tp != NULL);
|
|
|
|
replay = tp->btrace.replay;
|
|
if (replay != NULL)
|
|
{
|
|
const struct btrace_insn *insn;
|
|
struct gdbarch *gdbarch;
|
|
int pcreg;
|
|
|
|
gdbarch = get_regcache_arch (regcache);
|
|
pcreg = gdbarch_pc_regnum (gdbarch);
|
|
if (pcreg < 0)
|
|
return;
|
|
|
|
/* We can only provide the PC register. */
|
|
if (regno >= 0 && regno != pcreg)
|
|
return;
|
|
|
|
insn = btrace_insn_get (replay);
|
|
gdb_assert (insn != NULL);
|
|
|
|
regcache_raw_supply (regcache, regno, &insn->pc);
|
|
}
|
|
else
|
|
{
|
|
struct target_ops *t;
|
|
|
|
for (t = ops->beneath; t != NULL; t = t->beneath)
|
|
if (t->to_fetch_registers != NULL)
|
|
{
|
|
t->to_fetch_registers (t, regcache, regno);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* The to_store_registers method of target record-btrace. */
|
|
|
|
static void
|
|
record_btrace_store_registers (struct target_ops *ops,
|
|
struct regcache *regcache, int regno)
|
|
{
|
|
struct target_ops *t;
|
|
|
|
if (record_btrace_is_replaying (ops))
|
|
error (_("This record target does not allow writing registers."));
|
|
|
|
gdb_assert (may_write_registers != 0);
|
|
|
|
for (t = ops->beneath; t != NULL; t = t->beneath)
|
|
if (t->to_store_registers != NULL)
|
|
{
|
|
t->to_store_registers (t, regcache, regno);
|
|
return;
|
|
}
|
|
|
|
noprocess ();
|
|
}
|
|
|
|
/* The to_prepare_to_store method of target record-btrace. */
|
|
|
|
static void
|
|
record_btrace_prepare_to_store (struct target_ops *ops,
|
|
struct regcache *regcache)
|
|
{
|
|
struct target_ops *t;
|
|
|
|
if (record_btrace_is_replaying (ops))
|
|
return;
|
|
|
|
for (t = ops->beneath; t != NULL; t = t->beneath)
|
|
if (t->to_prepare_to_store != NULL)
|
|
{
|
|
t->to_prepare_to_store (t, regcache);
|
|
return;
|
|
}
|
|
}
|
|
|
|
/* The branch trace frame cache. */
|
|
|
|
struct btrace_frame_cache
|
|
{
|
|
/* The thread. */
|
|
struct thread_info *tp;
|
|
|
|
/* The frame info. */
|
|
struct frame_info *frame;
|
|
|
|
/* The branch trace function segment. */
|
|
const struct btrace_function *bfun;
|
|
};
|
|
|
|
/* A struct btrace_frame_cache hash table indexed by NEXT. */
|
|
|
|
static htab_t bfcache;
|
|
|
|
/* hash_f for htab_create_alloc of bfcache. */
|
|
|
|
static hashval_t
|
|
bfcache_hash (const void *arg)
|
|
{
|
|
const struct btrace_frame_cache *cache = arg;
|
|
|
|
return htab_hash_pointer (cache->frame);
|
|
}
|
|
|
|
/* eq_f for htab_create_alloc of bfcache. */
|
|
|
|
static int
|
|
bfcache_eq (const void *arg1, const void *arg2)
|
|
{
|
|
const struct btrace_frame_cache *cache1 = arg1;
|
|
const struct btrace_frame_cache *cache2 = arg2;
|
|
|
|
return cache1->frame == cache2->frame;
|
|
}
|
|
|
|
/* Create a new btrace frame cache. */
|
|
|
|
static struct btrace_frame_cache *
|
|
bfcache_new (struct frame_info *frame)
|
|
{
|
|
struct btrace_frame_cache *cache;
|
|
void **slot;
|
|
|
|
cache = FRAME_OBSTACK_ZALLOC (struct btrace_frame_cache);
|
|
cache->frame = frame;
|
|
|
|
slot = htab_find_slot (bfcache, cache, INSERT);
|
|
gdb_assert (*slot == NULL);
|
|
*slot = cache;
|
|
|
|
return cache;
|
|
}
|
|
|
|
/* Extract the branch trace function from a branch trace frame. */
|
|
|
|
static const struct btrace_function *
|
|
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;
|
|
|
|
pattern.frame = frame;
|
|
|
|
slot = htab_find_slot (bfcache, &pattern, NO_INSERT);
|
|
if (slot == NULL)
|
|
return NULL;
|
|
|
|
cache = *slot;
|
|
return cache->bfun;
|
|
}
|
|
|
|
/* Implement stop_reason method for record_btrace_frame_unwind. */
|
|
|
|
static enum unwind_stop_reason
|
|
record_btrace_frame_unwind_stop_reason (struct frame_info *this_frame,
|
|
void **this_cache)
|
|
{
|
|
const struct btrace_frame_cache *cache;
|
|
const struct btrace_function *bfun;
|
|
|
|
cache = *this_cache;
|
|
bfun = cache->bfun;
|
|
gdb_assert (bfun != NULL);
|
|
|
|
if (bfun->up == NULL)
|
|
return UNWIND_UNAVAILABLE;
|
|
|
|
return UNWIND_NO_REASON;
|
|
}
|
|
|
|
/* Implement this_id method for record_btrace_frame_unwind. */
|
|
|
|
static void
|
|
record_btrace_frame_this_id (struct frame_info *this_frame, void **this_cache,
|
|
struct frame_id *this_id)
|
|
{
|
|
const struct btrace_frame_cache *cache;
|
|
const struct btrace_function *bfun;
|
|
CORE_ADDR code, special;
|
|
|
|
cache = *this_cache;
|
|
|
|
bfun = cache->bfun;
|
|
gdb_assert (bfun != NULL);
|
|
|
|
while (bfun->segment.prev != NULL)
|
|
bfun = bfun->segment.prev;
|
|
|
|
code = get_frame_func (this_frame);
|
|
special = bfun->number;
|
|
|
|
*this_id = frame_id_build_unavailable_stack_special (code, special);
|
|
|
|
DEBUG ("[frame] %s id: (!stack, pc=%s, special=%s)",
|
|
btrace_get_bfun_name (cache->bfun),
|
|
core_addr_to_string_nz (this_id->code_addr),
|
|
core_addr_to_string_nz (this_id->special_addr));
|
|
}
|
|
|
|
/* Implement prev_register method for record_btrace_frame_unwind. */
|
|
|
|
static struct value *
|
|
record_btrace_frame_prev_register (struct frame_info *this_frame,
|
|
void **this_cache,
|
|
int regnum)
|
|
{
|
|
const struct btrace_frame_cache *cache;
|
|
const struct btrace_function *bfun, *caller;
|
|
const struct btrace_insn *insn;
|
|
struct gdbarch *gdbarch;
|
|
CORE_ADDR pc;
|
|
int pcreg;
|
|
|
|
gdbarch = get_frame_arch (this_frame);
|
|
pcreg = gdbarch_pc_regnum (gdbarch);
|
|
if (pcreg < 0 || regnum != pcreg)
|
|
throw_error (NOT_AVAILABLE_ERROR,
|
|
_("Registers are not available in btrace record history"));
|
|
|
|
cache = *this_cache;
|
|
bfun = cache->bfun;
|
|
gdb_assert (bfun != NULL);
|
|
|
|
caller = bfun->up;
|
|
if (caller == NULL)
|
|
throw_error (NOT_AVAILABLE_ERROR,
|
|
_("No caller in btrace record history"));
|
|
|
|
if ((bfun->flags & BFUN_UP_LINKS_TO_RET) != 0)
|
|
{
|
|
insn = VEC_index (btrace_insn_s, caller->insn, 0);
|
|
pc = insn->pc;
|
|
}
|
|
else
|
|
{
|
|
insn = VEC_last (btrace_insn_s, caller->insn);
|
|
pc = insn->pc;
|
|
|
|
pc += gdb_insn_length (gdbarch, pc);
|
|
}
|
|
|
|
DEBUG ("[frame] unwound PC in %s on level %d: %s",
|
|
btrace_get_bfun_name (bfun), bfun->level,
|
|
core_addr_to_string_nz (pc));
|
|
|
|
return frame_unwind_got_address (this_frame, regnum, pc);
|
|
}
|
|
|
|
/* Implement sniffer method for record_btrace_frame_unwind. */
|
|
|
|
static int
|
|
record_btrace_frame_sniffer (const struct frame_unwind *self,
|
|
struct frame_info *this_frame,
|
|
void **this_cache)
|
|
{
|
|
const struct btrace_function *bfun;
|
|
struct btrace_frame_cache *cache;
|
|
struct thread_info *tp;
|
|
struct frame_info *next;
|
|
|
|
/* THIS_FRAME does not contain a reference to its thread. */
|
|
tp = find_thread_ptid (inferior_ptid);
|
|
gdb_assert (tp != NULL);
|
|
|
|
bfun = NULL;
|
|
next = get_next_frame (this_frame);
|
|
if (next == NULL)
|
|
{
|
|
const struct btrace_insn_iterator *replay;
|
|
|
|
replay = tp->btrace.replay;
|
|
if (replay != NULL)
|
|
bfun = replay->function;
|
|
}
|
|
else
|
|
{
|
|
const struct btrace_function *callee;
|
|
|
|
callee = btrace_get_frame_function (next);
|
|
if (callee != NULL && (callee->flags & BFUN_UP_LINKS_TO_TAILCALL) == 0)
|
|
bfun = callee->up;
|
|
}
|
|
|
|
if (bfun == NULL)
|
|
return 0;
|
|
|
|
DEBUG ("[frame] sniffed 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 = tp;
|
|
cache->bfun = bfun;
|
|
|
|
*this_cache = cache;
|
|
return 1;
|
|
}
|
|
|
|
/* Implement sniffer method for record_btrace_tailcall_frame_unwind. */
|
|
|
|
static int
|
|
record_btrace_tailcall_frame_sniffer (const struct frame_unwind *self,
|
|
struct frame_info *this_frame,
|
|
void **this_cache)
|
|
{
|
|
const struct btrace_function *bfun, *callee;
|
|
struct btrace_frame_cache *cache;
|
|
struct frame_info *next;
|
|
|
|
next = get_next_frame (this_frame);
|
|
if (next == NULL)
|
|
return 0;
|
|
|
|
callee = btrace_get_frame_function (next);
|
|
if (callee == NULL)
|
|
return 0;
|
|
|
|
if ((callee->flags & BFUN_UP_LINKS_TO_TAILCALL) == 0)
|
|
return 0;
|
|
|
|
bfun = callee->up;
|
|
if (bfun == NULL)
|
|
return 0;
|
|
|
|
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->bfun = bfun;
|
|
|
|
*this_cache = cache;
|
|
return 1;
|
|
}
|
|
|
|
static void
|
|
record_btrace_frame_dealloc_cache (struct frame_info *self, void *this_cache)
|
|
{
|
|
struct btrace_frame_cache *cache;
|
|
void **slot;
|
|
|
|
cache = this_cache;
|
|
|
|
slot = htab_find_slot (bfcache, cache, NO_INSERT);
|
|
gdb_assert (slot != NULL);
|
|
|
|
htab_remove_elt (bfcache, cache);
|
|
}
|
|
|
|
/* btrace recording does not store previous memory content, neither the stack
|
|
frames content. Any unwinding would return errorneous results as the stack
|
|
contents no longer matches the changed PC value restored from history.
|
|
Therefore this unwinder reports any possibly unwound registers as
|
|
<unavailable>. */
|
|
|
|
const struct frame_unwind record_btrace_frame_unwind =
|
|
{
|
|
NORMAL_FRAME,
|
|
record_btrace_frame_unwind_stop_reason,
|
|
record_btrace_frame_this_id,
|
|
record_btrace_frame_prev_register,
|
|
NULL,
|
|
record_btrace_frame_sniffer,
|
|
record_btrace_frame_dealloc_cache
|
|
};
|
|
|
|
const struct frame_unwind record_btrace_tailcall_frame_unwind =
|
|
{
|
|
TAILCALL_FRAME,
|
|
record_btrace_frame_unwind_stop_reason,
|
|
record_btrace_frame_this_id,
|
|
record_btrace_frame_prev_register,
|
|
NULL,
|
|
record_btrace_tailcall_frame_sniffer,
|
|
record_btrace_frame_dealloc_cache
|
|
};
|
|
|
|
/* Implement the to_get_unwinder method. */
|
|
|
|
static const struct frame_unwind *
|
|
record_btrace_to_get_unwinder (struct target_ops *self)
|
|
{
|
|
return &record_btrace_frame_unwind;
|
|
}
|
|
|
|
/* Implement the to_get_tailcall_unwinder method. */
|
|
|
|
static const struct frame_unwind *
|
|
record_btrace_to_get_tailcall_unwinder (struct target_ops *self)
|
|
{
|
|
return &record_btrace_tailcall_frame_unwind;
|
|
}
|
|
|
|
/* Indicate that TP should be resumed according to FLAG. */
|
|
|
|
static void
|
|
record_btrace_resume_thread (struct thread_info *tp,
|
|
enum btrace_thread_flag flag)
|
|
{
|
|
struct btrace_thread_info *btinfo;
|
|
|
|
DEBUG ("resuming %d (%s): %u", tp->num, target_pid_to_str (tp->ptid), flag);
|
|
|
|
btinfo = &tp->btrace;
|
|
|
|
if ((btinfo->flags & BTHR_MOVE) != 0)
|
|
error (_("Thread already moving."));
|
|
|
|
/* Fetch the latest branch trace. */
|
|
btrace_fetch (tp);
|
|
|
|
btinfo->flags |= flag;
|
|
}
|
|
|
|
/* Find the thread to resume given a PTID. */
|
|
|
|
static struct thread_info *
|
|
record_btrace_find_resume_thread (ptid_t ptid)
|
|
{
|
|
struct thread_info *tp;
|
|
|
|
/* When asked to resume everything, we pick the current thread. */
|
|
if (ptid_equal (minus_one_ptid, ptid) || ptid_is_pid (ptid))
|
|
ptid = inferior_ptid;
|
|
|
|
return find_thread_ptid (ptid);
|
|
}
|
|
|
|
/* 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;
|
|
|
|
/* We can't start replaying without trace. */
|
|
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)
|
|
{
|
|
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_id = get_frame_id (frame);
|
|
|
|
/* Check if we need to update any stepping-related frame id's. */
|
|
upd_step_frame_id = frame_id_eq (frame_id,
|
|
tp->control.step_frame_id);
|
|
upd_step_stack_frame_id = frame_id_eq (frame_id,
|
|
tp->control.step_stack_frame_id);
|
|
|
|
/* We start replaying at the end of the branch trace. This corresponds
|
|
to the current instruction. */
|
|
replay = xmalloc (sizeof (*replay));
|
|
btrace_insn_end (replay, btinfo);
|
|
|
|
/* We're not replaying, yet. */
|
|
gdb_assert (btinfo->replay == NULL);
|
|
btinfo->replay = replay;
|
|
|
|
/* Make sure we're not using any stale registers. */
|
|
registers_changed_ptid (tp->ptid);
|
|
|
|
/* The current frame with replaying - computed via btrace unwind. */
|
|
frame = get_current_frame ();
|
|
frame_id = get_frame_id (frame);
|
|
|
|
/* Replace stepping related frames where necessary. */
|
|
if (upd_step_frame_id)
|
|
tp->control.step_frame_id = frame_id;
|
|
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)
|
|
{
|
|
xfree (btinfo->replay);
|
|
btinfo->replay = NULL;
|
|
|
|
registers_changed_ptid (tp->ptid);
|
|
|
|
throw_exception (except);
|
|
}
|
|
|
|
return replay;
|
|
}
|
|
|
|
/* Stop replaying a thread. */
|
|
|
|
static void
|
|
record_btrace_stop_replaying (struct thread_info *tp)
|
|
{
|
|
struct btrace_thread_info *btinfo;
|
|
|
|
btinfo = &tp->btrace;
|
|
|
|
xfree (btinfo->replay);
|
|
btinfo->replay = NULL;
|
|
|
|
/* Make sure we're not leaving any stale registers. */
|
|
registers_changed_ptid (tp->ptid);
|
|
}
|
|
|
|
/* 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;
|
|
|
|
DEBUG ("resume %s: %s", target_pid_to_str (ptid), step ? "step" : "cont");
|
|
|
|
tp = record_btrace_find_resume_thread (ptid);
|
|
if (tp == NULL)
|
|
error (_("Cannot find thread to resume."));
|
|
|
|
/* Stop replaying other threads if the thread to resume is not replaying. */
|
|
if (!btrace_is_replaying (tp) && execution_direction != EXEC_REVERSE)
|
|
ALL_THREADS (other)
|
|
record_btrace_stop_replaying (other);
|
|
|
|
/* As long as we're not replaying, just forward the request. */
|
|
if (!record_btrace_is_replaying (ops) && execution_direction != EXEC_REVERSE)
|
|
{
|
|
for (ops = ops->beneath; ops != NULL; ops = ops->beneath)
|
|
if (ops->to_resume != NULL)
|
|
return ops->to_resume (ops, ptid, step, signal);
|
|
|
|
error (_("Cannot find target for stepping."));
|
|
}
|
|
|
|
/* Compute the btrace thread flag for the requested move. */
|
|
if (step == 0)
|
|
flag = execution_direction == EXEC_REVERSE ? BTHR_RCONT : BTHR_CONT;
|
|
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);
|
|
|
|
/* We just indicate the resume intent here. The actual stepping happens in
|
|
record_btrace_wait below. */
|
|
}
|
|
|
|
/* 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) != 0)
|
|
return tp;
|
|
|
|
/* Otherwise, find one other thread that has been resumed. */
|
|
ALL_THREADS (tp)
|
|
if ((tp->btrace.flags & BTHR_MOVE) != 0)
|
|
return tp;
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/* Return a target_waitstatus indicating that we ran out of history. */
|
|
|
|
static struct target_waitstatus
|
|
btrace_step_no_history (void)
|
|
{
|
|
struct target_waitstatus status;
|
|
|
|
status.kind = TARGET_WAITKIND_NO_HISTORY;
|
|
|
|
return status;
|
|
}
|
|
|
|
/* Return a target_waitstatus indicating that a step finished. */
|
|
|
|
static struct target_waitstatus
|
|
btrace_step_stopped (void)
|
|
{
|
|
struct target_waitstatus status;
|
|
|
|
status.kind = TARGET_WAITKIND_STOPPED;
|
|
status.value.sig = GDB_SIGNAL_TRAP;
|
|
|
|
return status;
|
|
}
|
|
|
|
/* Clear the record histories. */
|
|
|
|
static void
|
|
record_btrace_clear_histories (struct btrace_thread_info *btinfo)
|
|
{
|
|
xfree (btinfo->insn_history);
|
|
xfree (btinfo->call_history);
|
|
|
|
btinfo->insn_history = NULL;
|
|
btinfo->call_history = NULL;
|
|
}
|
|
|
|
/* 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 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))
|
|
return btrace_step_no_history ();
|
|
|
|
btinfo = &tp->btrace;
|
|
replay = btinfo->replay;
|
|
|
|
flags = btinfo->flags & BTHR_MOVE;
|
|
btinfo->flags &= ~BTHR_MOVE;
|
|
|
|
DEBUG ("stepping %d (%s): %u", tp->num, target_pid_to_str (tp->ptid), flags);
|
|
|
|
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 ();
|
|
|
|
/* We are always able to step at least once. */
|
|
steps = btrace_insn_next (replay, 1);
|
|
gdb_assert (steps == 1);
|
|
|
|
/* 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);
|
|
|
|
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. */
|
|
steps = btrace_insn_prev (replay, 1);
|
|
if (steps == 0)
|
|
return btrace_step_no_history ();
|
|
|
|
return btrace_step_stopped ();
|
|
|
|
case BTHR_CONT:
|
|
/* We're done if we're not replaying. */
|
|
if (replay == NULL)
|
|
return btrace_step_no_history ();
|
|
|
|
inf = find_inferior_pid (ptid_get_pid (tp->ptid));
|
|
aspace = inf->aspace;
|
|
|
|
/* Determine the end of the instruction trace. */
|
|
btrace_insn_end (&end, btinfo);
|
|
|
|
for (;;)
|
|
{
|
|
const struct btrace_insn *insn;
|
|
|
|
/* We are always able to step at least once. */
|
|
steps = btrace_insn_next (replay, 1);
|
|
gdb_assert (steps == 1);
|
|
|
|
/* 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 ();
|
|
}
|
|
|
|
insn = btrace_insn_get (replay);
|
|
gdb_assert (insn);
|
|
|
|
DEBUG ("stepping %d (%s) ... %s", tp->num,
|
|
target_pid_to_str (tp->ptid),
|
|
core_addr_to_string_nz (insn->pc));
|
|
|
|
if (breakpoint_here_p (aspace, insn->pc))
|
|
return btrace_step_stopped ();
|
|
}
|
|
|
|
case BTHR_RCONT:
|
|
/* Start replaying if we're not already doing so. */
|
|
if (replay == NULL)
|
|
replay = record_btrace_start_replaying (tp);
|
|
|
|
inf = find_inferior_pid (ptid_get_pid (tp->ptid));
|
|
aspace = inf->aspace;
|
|
|
|
for (;;)
|
|
{
|
|
const struct btrace_insn *insn;
|
|
|
|
/* If we can't step any further, we're done. */
|
|
steps = btrace_insn_prev (replay, 1);
|
|
if (steps == 0)
|
|
return btrace_step_no_history ();
|
|
|
|
insn = btrace_insn_get (replay);
|
|
gdb_assert (insn);
|
|
|
|
DEBUG ("reverse-stepping %d (%s) ... %s", tp->num,
|
|
target_pid_to_str (tp->ptid),
|
|
core_addr_to_string_nz (insn->pc));
|
|
|
|
if (breakpoint_here_p (aspace, insn->pc))
|
|
return btrace_step_stopped ();
|
|
}
|
|
}
|
|
}
|
|
|
|
/* The to_wait method of target record-btrace. */
|
|
|
|
static ptid_t
|
|
record_btrace_wait (struct target_ops *ops, ptid_t ptid,
|
|
struct target_waitstatus *status, int options)
|
|
{
|
|
struct thread_info *tp, *other;
|
|
|
|
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)
|
|
{
|
|
for (ops = ops->beneath; ops != NULL; ops = ops->beneath)
|
|
if (ops->to_wait != NULL)
|
|
return ops->to_wait (ops, ptid, status, options);
|
|
|
|
error (_("Cannot find target for waiting."));
|
|
}
|
|
|
|
/* Let's find a thread to move. */
|
|
tp = record_btrace_find_thread_to_move (ptid);
|
|
if (tp == NULL)
|
|
{
|
|
DEBUG ("wait %s: no thread", target_pid_to_str (ptid));
|
|
|
|
status->kind = TARGET_WAITKIND_IGNORE;
|
|
return minus_one_ptid;
|
|
}
|
|
|
|
/* We only move a single thread. We're not able to correlate threads. */
|
|
*status = record_btrace_step_thread (tp);
|
|
|
|
/* Stop all other threads. */
|
|
if (!non_stop)
|
|
ALL_THREADS (other)
|
|
other->btrace.flags &= ~BTHR_MOVE;
|
|
|
|
/* Start record histories anew from the current position. */
|
|
record_btrace_clear_histories (&tp->btrace);
|
|
|
|
/* We moved the replay position but did not update registers. */
|
|
registers_changed_ptid (tp->ptid);
|
|
|
|
return tp->ptid;
|
|
}
|
|
|
|
/* The to_can_execute_reverse method of target record-btrace. */
|
|
|
|
static int
|
|
record_btrace_can_execute_reverse (struct target_ops *self)
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
/* The to_decr_pc_after_break method of target record-btrace. */
|
|
|
|
static CORE_ADDR
|
|
record_btrace_decr_pc_after_break (struct target_ops *ops,
|
|
struct gdbarch *gdbarch)
|
|
{
|
|
/* 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;
|
|
|
|
return ops->beneath->to_decr_pc_after_break (ops->beneath, gdbarch);
|
|
}
|
|
|
|
/* The to_find_new_threads method of target record-btrace. */
|
|
|
|
static void
|
|
record_btrace_find_new_threads (struct target_ops *ops)
|
|
{
|
|
/* Don't expect new threads if we're replaying. */
|
|
if (record_btrace_is_replaying (ops))
|
|
return;
|
|
|
|
/* Forward the request. */
|
|
for (ops = ops->beneath; ops != NULL; ops = ops->beneath)
|
|
if (ops->to_find_new_threads != NULL)
|
|
{
|
|
ops->to_find_new_threads (ops);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* The to_thread_alive method of target record-btrace. */
|
|
|
|
static int
|
|
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))
|
|
return find_thread_ptid (ptid) != NULL;
|
|
|
|
/* Forward the request. */
|
|
for (ops = ops->beneath; ops != NULL; ops = ops->beneath)
|
|
if (ops->to_thread_alive != NULL)
|
|
return ops->to_thread_alive (ops, ptid);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* Set the replay branch trace instruction iterator. If IT is NULL, replay
|
|
is stopped. */
|
|
|
|
static void
|
|
record_btrace_set_replay (struct thread_info *tp,
|
|
const struct btrace_insn_iterator *it)
|
|
{
|
|
struct btrace_thread_info *btinfo;
|
|
|
|
btinfo = &tp->btrace;
|
|
|
|
if (it == NULL || it->function == NULL)
|
|
record_btrace_stop_replaying (tp);
|
|
else
|
|
{
|
|
if (btinfo->replay == NULL)
|
|
record_btrace_start_replaying (tp);
|
|
else if (btrace_insn_cmp (btinfo->replay, it) == 0)
|
|
return;
|
|
|
|
*btinfo->replay = *it;
|
|
registers_changed_ptid (tp->ptid);
|
|
}
|
|
|
|
/* Start anew from the new replay position. */
|
|
record_btrace_clear_histories (btinfo);
|
|
}
|
|
|
|
/* The to_goto_record_begin method of target record-btrace. */
|
|
|
|
static void
|
|
record_btrace_goto_begin (struct target_ops *self)
|
|
{
|
|
struct thread_info *tp;
|
|
struct btrace_insn_iterator begin;
|
|
|
|
tp = require_btrace_thread ();
|
|
|
|
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. */
|
|
|
|
static void
|
|
record_btrace_goto_end (struct target_ops *ops)
|
|
{
|
|
struct thread_info *tp;
|
|
|
|
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. */
|
|
|
|
static void
|
|
record_btrace_goto (struct target_ops *self, ULONGEST insn)
|
|
{
|
|
struct thread_info *tp;
|
|
struct btrace_insn_iterator it;
|
|
unsigned int number;
|
|
int found;
|
|
|
|
number = insn;
|
|
|
|
/* Check for wrap-arounds. */
|
|
if (number != insn)
|
|
error (_("Instruction number out of range."));
|
|
|
|
tp = require_btrace_thread ();
|
|
|
|
found = btrace_find_insn_by_number (&it, &tp->btrace, number);
|
|
if (found == 0)
|
|
error (_("No such instruction."));
|
|
|
|
record_btrace_set_replay (tp, &it);
|
|
|
|
print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC, 1);
|
|
}
|
|
|
|
/* Initialize the record-btrace target ops. */
|
|
|
|
static void
|
|
init_record_btrace_ops (void)
|
|
{
|
|
struct target_ops *ops;
|
|
|
|
ops = &record_btrace_ops;
|
|
ops->to_shortname = "record-btrace";
|
|
ops->to_longname = "Branch tracing target";
|
|
ops->to_doc = "Collect control-flow trace and provide the execution history.";
|
|
ops->to_open = record_btrace_open;
|
|
ops->to_close = record_btrace_close;
|
|
ops->to_detach = record_detach;
|
|
ops->to_disconnect = record_disconnect;
|
|
ops->to_mourn_inferior = record_mourn_inferior;
|
|
ops->to_kill = record_kill;
|
|
ops->to_stop_recording = record_btrace_stop_recording;
|
|
ops->to_info_record = record_btrace_info;
|
|
ops->to_insn_history = record_btrace_insn_history;
|
|
ops->to_insn_history_from = record_btrace_insn_history_from;
|
|
ops->to_insn_history_range = record_btrace_insn_history_range;
|
|
ops->to_call_history = record_btrace_call_history;
|
|
ops->to_call_history_from = record_btrace_call_history_from;
|
|
ops->to_call_history_range = record_btrace_call_history_range;
|
|
ops->to_record_is_replaying = record_btrace_is_replaying;
|
|
ops->to_xfer_partial = record_btrace_xfer_partial;
|
|
ops->to_remove_breakpoint = record_btrace_remove_breakpoint;
|
|
ops->to_insert_breakpoint = record_btrace_insert_breakpoint;
|
|
ops->to_fetch_registers = record_btrace_fetch_registers;
|
|
ops->to_store_registers = record_btrace_store_registers;
|
|
ops->to_prepare_to_store = record_btrace_prepare_to_store;
|
|
ops->to_get_unwinder = &record_btrace_to_get_unwinder;
|
|
ops->to_get_tailcall_unwinder = &record_btrace_to_get_tailcall_unwinder;
|
|
ops->to_resume = record_btrace_resume;
|
|
ops->to_wait = record_btrace_wait;
|
|
ops->to_find_new_threads = record_btrace_find_new_threads;
|
|
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_stratum = record_stratum;
|
|
ops->to_magic = OPS_MAGIC;
|
|
}
|
|
|
|
/* Alias for "target record". */
|
|
|
|
static void
|
|
cmd_record_btrace_start (char *args, int from_tty)
|
|
{
|
|
if (args != NULL && *args != 0)
|
|
error (_("Invalid argument."));
|
|
|
|
execute_command ("target record-btrace", from_tty);
|
|
}
|
|
|
|
void _initialize_record_btrace (void);
|
|
|
|
/* Initialize btrace commands. */
|
|
|
|
void
|
|
_initialize_record_btrace (void)
|
|
{
|
|
add_cmd ("btrace", class_obscure, cmd_record_btrace_start,
|
|
_("Start branch trace recording."),
|
|
&record_cmdlist);
|
|
add_alias_cmd ("b", "btrace", class_obscure, 1, &record_cmdlist);
|
|
|
|
init_record_btrace_ops ();
|
|
add_target (&record_btrace_ops);
|
|
|
|
bfcache = htab_create_alloc (50, bfcache_hash, bfcache_eq, NULL,
|
|
xcalloc, xfree);
|
|
}
|