binutils-gdb/gdb/btrace.c

1529 lines
37 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 "btrace.h"
#include "gdbthread.h"
#include "exceptions.h"
#include "inferior.h"
#include "target.h"
#include "record.h"
#include "symtab.h"
#include "disasm.h"
#include "source.h"
#include "filenames.h"
#include "xml-support.h"
#include "regcache.h"
/* Print a record 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, \
"[btrace] " msg "\n", ##args); \
} \
while (0)
#define DEBUG_FTRACE(msg, args...) DEBUG ("[ftrace] " msg, ##args)
/* Return the function name of a recorded function segment for printing.
This function never returns NULL. */
static const char *
ftrace_print_function_name (const struct btrace_function *bfun)
{
struct minimal_symbol *msym;
struct symbol *sym;
msym = bfun->msym;
sym = bfun->sym;
if (sym != NULL)
return SYMBOL_PRINT_NAME (sym);
if (msym != NULL)
return MSYMBOL_PRINT_NAME (msym);
return "<unknown>";
}
/* Return the file name of a recorded function segment for printing.
This function never returns NULL. */
static const char *
ftrace_print_filename (const struct btrace_function *bfun)
{
struct symbol *sym;
const char *filename;
sym = bfun->sym;
if (sym != NULL)
filename = symtab_to_filename_for_display (sym->symtab);
else
filename = "<unknown>";
return filename;
}
/* Return a string representation of the address of an instruction.
This function never returns NULL. */
static const char *
ftrace_print_insn_addr (const struct btrace_insn *insn)
{
if (insn == NULL)
return "<nil>";
return core_addr_to_string_nz (insn->pc);
}
/* Print an ftrace debug status message. */
static void
ftrace_debug (const struct btrace_function *bfun, const char *prefix)
{
const char *fun, *file;
unsigned int ibegin, iend;
int lbegin, lend, level;
fun = ftrace_print_function_name (bfun);
file = ftrace_print_filename (bfun);
level = bfun->level;
lbegin = bfun->lbegin;
lend = bfun->lend;
ibegin = bfun->insn_offset;
iend = ibegin + VEC_length (btrace_insn_s, bfun->insn);
DEBUG_FTRACE ("%s: fun = %s, file = %s, level = %d, lines = [%d; %d], "
"insn = [%u; %u)", prefix, fun, file, level, lbegin, lend,
ibegin, iend);
}
/* Return non-zero if BFUN does not match MFUN and FUN,
return zero otherwise. */
static int
ftrace_function_switched (const struct btrace_function *bfun,
const struct minimal_symbol *mfun,
const struct symbol *fun)
{
struct minimal_symbol *msym;
struct symbol *sym;
msym = bfun->msym;
sym = bfun->sym;
/* If the minimal symbol changed, we certainly switched functions. */
if (mfun != NULL && msym != NULL
&& strcmp (MSYMBOL_LINKAGE_NAME (mfun), MSYMBOL_LINKAGE_NAME (msym)) != 0)
return 1;
/* If the symbol changed, we certainly switched functions. */
if (fun != NULL && sym != NULL)
{
const char *bfname, *fname;
/* Check the function name. */
if (strcmp (SYMBOL_LINKAGE_NAME (fun), SYMBOL_LINKAGE_NAME (sym)) != 0)
return 1;
/* Check the location of those functions, as well. */
bfname = symtab_to_fullname (sym->symtab);
fname = symtab_to_fullname (fun->symtab);
if (filename_cmp (fname, bfname) != 0)
return 1;
}
/* If we lost symbol information, we switched functions. */
if (!(msym == NULL && sym == NULL) && mfun == NULL && fun == NULL)
return 1;
/* If we gained symbol information, we switched functions. */
if (msym == NULL && sym == NULL && !(mfun == NULL && fun == NULL))
return 1;
return 0;
}
/* Return non-zero if we should skip this file when generating the function
call history, zero otherwise.
We would want to do that if, say, a macro that is defined in another file
is expanded in this function. */
static int
ftrace_skip_file (const struct btrace_function *bfun, const char *fullname)
{
struct symbol *sym;
const char *bfile;
sym = bfun->sym;
if (sym == NULL)
return 1;
bfile = symtab_to_fullname (sym->symtab);
return (filename_cmp (bfile, fullname) != 0);
}
/* Allocate and initialize a new branch trace function segment.
PREV is the chronologically preceding function segment.
MFUN and FUN are the symbol information we have for this function. */
static struct btrace_function *
ftrace_new_function (struct btrace_function *prev,
struct minimal_symbol *mfun,
struct symbol *fun)
{
struct btrace_function *bfun;
bfun = xzalloc (sizeof (*bfun));
bfun->msym = mfun;
bfun->sym = fun;
bfun->flow.prev = prev;
/* We start with the identities of min and max, respectively. */
bfun->lbegin = INT_MAX;
bfun->lend = INT_MIN;
if (prev == NULL)
{
/* Start counting at one. */
bfun->number = 1;
bfun->insn_offset = 1;
}
else
{
gdb_assert (prev->flow.next == NULL);
prev->flow.next = bfun;
bfun->number = prev->number + 1;
bfun->insn_offset = (prev->insn_offset
+ VEC_length (btrace_insn_s, prev->insn));
}
return bfun;
}
/* Update the UP field of a function segment. */
static void
ftrace_update_caller (struct btrace_function *bfun,
struct btrace_function *caller,
enum btrace_function_flag flags)
{
if (bfun->up != NULL)
ftrace_debug (bfun, "updating caller");
bfun->up = caller;
bfun->flags = flags;
ftrace_debug (bfun, "set caller");
}
/* Fix up the caller for all segments of a function. */
static void
ftrace_fixup_caller (struct btrace_function *bfun,
struct btrace_function *caller,
enum btrace_function_flag flags)
{
struct btrace_function *prev, *next;
ftrace_update_caller (bfun, caller, flags);
/* Update all function segments belonging to the same function. */
for (prev = bfun->segment.prev; prev != NULL; prev = prev->segment.prev)
ftrace_update_caller (prev, caller, flags);
for (next = bfun->segment.next; next != NULL; next = next->segment.next)
ftrace_update_caller (next, caller, flags);
}
/* Add a new function segment for a call.
CALLER is the chronologically preceding function segment.
MFUN and FUN are the symbol information we have for this function. */
static struct btrace_function *
ftrace_new_call (struct btrace_function *caller,
struct minimal_symbol *mfun,
struct symbol *fun)
{
struct btrace_function *bfun;
bfun = ftrace_new_function (caller, mfun, fun);
bfun->up = caller;
bfun->level = caller->level + 1;
ftrace_debug (bfun, "new call");
return bfun;
}
/* Add a new function segment for a tail call.
CALLER is the chronologically preceding function segment.
MFUN and FUN are the symbol information we have for this function. */
static struct btrace_function *
ftrace_new_tailcall (struct btrace_function *caller,
struct minimal_symbol *mfun,
struct symbol *fun)
{
struct btrace_function *bfun;
bfun = ftrace_new_function (caller, mfun, fun);
bfun->up = caller;
bfun->level = caller->level + 1;
bfun->flags |= BFUN_UP_LINKS_TO_TAILCALL;
ftrace_debug (bfun, "new tail call");
return bfun;
}
/* Find the innermost caller in the back trace of BFUN with MFUN/FUN
symbol information. */
static struct btrace_function *
ftrace_find_caller (struct btrace_function *bfun,
struct minimal_symbol *mfun,
struct symbol *fun)
{
for (; bfun != NULL; bfun = bfun->up)
{
/* Skip functions with incompatible symbol information. */
if (ftrace_function_switched (bfun, mfun, fun))
continue;
/* This is the function segment we're looking for. */
break;
}
return bfun;
}
/* Find the innermost caller in the back trace of BFUN, skipping all
function segments that do not end with a call instruction (e.g.
tail calls ending with a jump). */
static struct btrace_function *
ftrace_find_call (struct gdbarch *gdbarch, struct btrace_function *bfun)
{
for (; bfun != NULL; bfun = bfun->up)
{
struct btrace_insn *last;
CORE_ADDR pc;
/* We do not allow empty function segments. */
gdb_assert (!VEC_empty (btrace_insn_s, bfun->insn));
last = VEC_last (btrace_insn_s, bfun->insn);
pc = last->pc;
if (gdbarch_insn_is_call (gdbarch, pc))
break;
}
return bfun;
}
/* Add a continuation segment for a function into which we return.
PREV is the chronologically preceding function segment.
MFUN and FUN are the symbol information we have for this function. */
static struct btrace_function *
ftrace_new_return (struct gdbarch *gdbarch,
struct btrace_function *prev,
struct minimal_symbol *mfun,
struct symbol *fun)
{
struct btrace_function *bfun, *caller;
bfun = ftrace_new_function (prev, mfun, fun);
/* It is important to start at PREV's caller. Otherwise, we might find
PREV itself, if PREV is a recursive function. */
caller = ftrace_find_caller (prev->up, mfun, fun);
if (caller != NULL)
{
/* The caller of PREV is the preceding btrace function segment in this
function instance. */
gdb_assert (caller->segment.next == NULL);
caller->segment.next = bfun;
bfun->segment.prev = caller;
/* Maintain the function level. */
bfun->level = caller->level;
/* Maintain the call stack. */
bfun->up = caller->up;
bfun->flags = caller->flags;
ftrace_debug (bfun, "new return");
}
else
{
/* We did not find a caller. This could mean that something went
wrong or that the call is simply not included in the trace. */
/* Let's search for some actual call. */
caller = ftrace_find_call (gdbarch, prev->up);
if (caller == NULL)
{
/* There is no call in PREV's back trace. We assume that the
branch trace did not include it. */
/* Let's find the topmost call function - this skips tail calls. */
while (prev->up != NULL)
prev = prev->up;
/* We maintain levels for a series of returns for which we have
not seen the calls.
We start at the preceding function's level in case this has
already been a return for which we have not seen the call.
We start at level 0 otherwise, to handle tail calls correctly. */
bfun->level = min (0, prev->level) - 1;
/* Fix up the call stack for PREV. */
ftrace_fixup_caller (prev, bfun, BFUN_UP_LINKS_TO_RET);
ftrace_debug (bfun, "new return - no caller");
}
else
{
/* There is a call in PREV's back trace to which we should have
returned. Let's remain at this level. */
bfun->level = prev->level;
ftrace_debug (bfun, "new return - unknown caller");
}
}
return bfun;
}
/* Add a new function segment for a function switch.
PREV is the chronologically preceding function segment.
MFUN and FUN are the symbol information we have for this function. */
static struct btrace_function *
ftrace_new_switch (struct btrace_function *prev,
struct minimal_symbol *mfun,
struct symbol *fun)
{
struct btrace_function *bfun;
/* This is an unexplained function switch. The call stack will likely
be wrong at this point. */
bfun = ftrace_new_function (prev, mfun, fun);
/* We keep the function level. */
bfun->level = prev->level;
ftrace_debug (bfun, "new switch");
return bfun;
}
/* Update BFUN with respect to the instruction at PC. This may create new
function segments.
Return the chronologically latest function segment, never NULL. */
static struct btrace_function *
ftrace_update_function (struct gdbarch *gdbarch,
struct btrace_function *bfun, CORE_ADDR pc)
{
struct bound_minimal_symbol bmfun;
struct minimal_symbol *mfun;
struct symbol *fun;
struct btrace_insn *last;
/* Try to determine the function we're in. We use both types of symbols
to avoid surprises when we sometimes get a full symbol and sometimes
only a minimal symbol. */
fun = find_pc_function (pc);
bmfun = lookup_minimal_symbol_by_pc (pc);
mfun = bmfun.minsym;
if (fun == NULL && mfun == NULL)
DEBUG_FTRACE ("no symbol at %s", core_addr_to_string_nz (pc));
/* If we didn't have a function before, we create one. */
if (bfun == NULL)
return ftrace_new_function (bfun, mfun, fun);
/* Check the last instruction, if we have one.
We do this check first, since it allows us to fill in the call stack
links in addition to the normal flow links. */
last = NULL;
if (!VEC_empty (btrace_insn_s, bfun->insn))
last = VEC_last (btrace_insn_s, bfun->insn);
if (last != NULL)
{
CORE_ADDR lpc;
lpc = last->pc;
/* Check for returns. */
if (gdbarch_insn_is_ret (gdbarch, lpc))
return ftrace_new_return (gdbarch, bfun, mfun, fun);
/* Check for calls. */
if (gdbarch_insn_is_call (gdbarch, lpc))
{
int size;
size = gdb_insn_length (gdbarch, lpc);
/* Ignore calls to the next instruction. They are used for PIC. */
if (lpc + size != pc)
return ftrace_new_call (bfun, mfun, fun);
}
}
/* Check if we're switching functions for some other reason. */
if (ftrace_function_switched (bfun, mfun, fun))
{
DEBUG_FTRACE ("switching from %s in %s at %s",
ftrace_print_insn_addr (last),
ftrace_print_function_name (bfun),
ftrace_print_filename (bfun));
if (last != NULL)
{
CORE_ADDR start, lpc;
start = get_pc_function_start (pc);
/* If we can't determine the function for PC, we treat a jump at
the end of the block as tail call. */
if (start == 0)
start = pc;
lpc = last->pc;
/* Jumps indicate optimized tail calls. */
if (start == pc && gdbarch_insn_is_jump (gdbarch, lpc))
return ftrace_new_tailcall (bfun, mfun, fun);
}
return ftrace_new_switch (bfun, mfun, fun);
}
return bfun;
}
/* Update BFUN's source range with respect to the instruction at PC. */
static void
ftrace_update_lines (struct btrace_function *bfun, CORE_ADDR pc)
{
struct symtab_and_line sal;
const char *fullname;
sal = find_pc_line (pc, 0);
if (sal.symtab == NULL || sal.line == 0)
{
DEBUG_FTRACE ("no lines at %s", core_addr_to_string_nz (pc));
return;
}
/* Check if we switched files. This could happen if, say, a macro that
is defined in another file is expanded here. */
fullname = symtab_to_fullname (sal.symtab);
if (ftrace_skip_file (bfun, fullname))
{
DEBUG_FTRACE ("ignoring file at %s, file=%s",
core_addr_to_string_nz (pc), fullname);
return;
}
/* Update the line range. */
bfun->lbegin = min (bfun->lbegin, sal.line);
bfun->lend = max (bfun->lend, sal.line);
if (record_debug > 1)
ftrace_debug (bfun, "update lines");
}
/* Add the instruction at PC to BFUN's instructions. */
static void
ftrace_update_insns (struct btrace_function *bfun, CORE_ADDR pc)
{
struct btrace_insn *insn;
insn = VEC_safe_push (btrace_insn_s, bfun->insn, NULL);
insn->pc = pc;
if (record_debug > 1)
ftrace_debug (bfun, "update insn");
}
/* Compute the function branch trace from a block branch trace BTRACE for
a thread given by BTINFO. */
static void
btrace_compute_ftrace (struct btrace_thread_info *btinfo,
VEC (btrace_block_s) *btrace)
{
struct btrace_function *begin, *end;
struct gdbarch *gdbarch;
unsigned int blk;
int level;
DEBUG ("compute ftrace");
gdbarch = target_gdbarch ();
begin = btinfo->begin;
end = btinfo->end;
level = begin != NULL ? -btinfo->level : INT_MAX;
blk = VEC_length (btrace_block_s, btrace);
while (blk != 0)
{
btrace_block_s *block;
CORE_ADDR pc;
blk -= 1;
block = VEC_index (btrace_block_s, btrace, blk);
pc = block->begin;
for (;;)
{
int size;
/* We should hit the end of the block. Warn if we went too far. */
if (block->end < pc)
{
warning (_("Recorded trace may be corrupted around %s."),
core_addr_to_string_nz (pc));
break;
}
end = ftrace_update_function (gdbarch, end, pc);
if (begin == NULL)
begin = end;
/* Maintain the function level offset.
For all but the last block, we do it here. */
if (blk != 0)
level = min (level, end->level);
ftrace_update_insns (end, pc);
ftrace_update_lines (end, pc);
/* We're done once we pushed the instruction at the end. */
if (block->end == pc)
break;
size = gdb_insn_length (gdbarch, pc);
/* Make sure we terminate if we fail to compute the size. */
if (size <= 0)
{
warning (_("Recorded trace may be incomplete around %s."),
core_addr_to_string_nz (pc));
break;
}
pc += size;
/* Maintain the function level offset.
For the last block, we do it here to not consider the last
instruction.
Since the last instruction corresponds to the current instruction
and is not really part of the execution history, it shouldn't
affect the level. */
if (blk == 0)
level = min (level, end->level);
}
}
btinfo->begin = begin;
btinfo->end = end;
/* LEVEL is the minimal function level of all btrace function segments.
Define the global level offset to -LEVEL so all function levels are
normalized to start at zero. */
btinfo->level = -level;
}
/* Add an entry for the current PC. */
static void
btrace_add_pc (struct thread_info *tp)
{
VEC (btrace_block_s) *btrace;
struct btrace_block *block;
struct regcache *regcache;
struct cleanup *cleanup;
CORE_ADDR pc;
regcache = get_thread_regcache (tp->ptid);
pc = regcache_read_pc (regcache);
btrace = NULL;
cleanup = make_cleanup (VEC_cleanup (btrace_block_s), &btrace);
block = VEC_safe_push (btrace_block_s, btrace, NULL);
block->begin = pc;
block->end = pc;
btrace_compute_ftrace (&tp->btrace, btrace);
do_cleanups (cleanup);
}
/* See btrace.h. */
void
btrace_enable (struct thread_info *tp)
{
if (tp->btrace.target != NULL)
return;
if (!target_supports_btrace ())
error (_("Target does not support branch tracing."));
DEBUG ("enable thread %d (%s)", tp->num, target_pid_to_str (tp->ptid));
tp->btrace.target = target_enable_btrace (tp->ptid);
/* Add an entry for the current PC so we start tracing from where we
enabled it. */
if (tp->btrace.target != NULL)
btrace_add_pc (tp);
}
/* See btrace.h. */
void
btrace_disable (struct thread_info *tp)
{
struct btrace_thread_info *btp = &tp->btrace;
int errcode = 0;
if (btp->target == NULL)
return;
DEBUG ("disable thread %d (%s)", tp->num, target_pid_to_str (tp->ptid));
target_disable_btrace (btp->target);
btp->target = NULL;
btrace_clear (tp);
}
/* See btrace.h. */
void
btrace_teardown (struct thread_info *tp)
{
struct btrace_thread_info *btp = &tp->btrace;
int errcode = 0;
if (btp->target == NULL)
return;
DEBUG ("teardown thread %d (%s)", tp->num, target_pid_to_str (tp->ptid));
target_teardown_btrace (btp->target);
btp->target = NULL;
btrace_clear (tp);
}
/* Adjust the block trace in order to stitch old and new trace together.
BTRACE is the new delta trace between the last and the current stop.
BTINFO is the old branch trace until the last stop.
May modify BTRACE as well as the existing trace in BTINFO.
Return 0 on success, -1 otherwise. */
static int
btrace_stitch_trace (VEC (btrace_block_s) **btrace,
const struct btrace_thread_info *btinfo)
{
struct btrace_function *last_bfun;
struct btrace_insn *last_insn;
btrace_block_s *first_new_block;
/* If we don't have trace, there's nothing to do. */
if (VEC_empty (btrace_block_s, *btrace))
return 0;
last_bfun = btinfo->end;
gdb_assert (last_bfun != NULL);
/* Beware that block trace starts with the most recent block, so the
chronologically first block in the new trace is the last block in
the new trace's block vector. */
first_new_block = VEC_last (btrace_block_s, *btrace);
last_insn = VEC_last (btrace_insn_s, last_bfun->insn);
/* If the current PC at the end of the block is the same as in our current
trace, there are two explanations:
1. we executed the instruction and some branch brought us back.
2. we have not made any progress.
In the first case, the delta trace vector should contain at least two
entries.
In the second case, the delta trace vector should contain exactly one
entry for the partial block containing the current PC. Remove it. */
if (first_new_block->end == last_insn->pc
&& VEC_length (btrace_block_s, *btrace) == 1)
{
VEC_pop (btrace_block_s, *btrace);
return 0;
}
DEBUG ("stitching %s to %s", ftrace_print_insn_addr (last_insn),
core_addr_to_string_nz (first_new_block->end));
/* Do a simple sanity check to make sure we don't accidentally end up
with a bad block. This should not occur in practice. */
if (first_new_block->end < last_insn->pc)
{
warning (_("Error while trying to read delta trace. Falling back to "
"a full read."));
return -1;
}
/* We adjust the last block to start at the end of our current trace. */
gdb_assert (first_new_block->begin == 0);
first_new_block->begin = last_insn->pc;
/* We simply pop the last insn so we can insert it again as part of
the normal branch trace computation.
Since instruction iterators are based on indices in the instructions
vector, we don't leave any pointers dangling. */
DEBUG ("pruning insn at %s for stitching",
ftrace_print_insn_addr (last_insn));
VEC_pop (btrace_insn_s, last_bfun->insn);
/* The instructions vector may become empty temporarily if this has
been the only instruction in this function segment.
This violates the invariant but will be remedied shortly by
btrace_compute_ftrace when we add the new trace. */
return 0;
}
/* Clear the branch trace histories in BTINFO. */
static void
btrace_clear_history (struct btrace_thread_info *btinfo)
{
xfree (btinfo->insn_history);
xfree (btinfo->call_history);
xfree (btinfo->replay);
btinfo->insn_history = NULL;
btinfo->call_history = NULL;
btinfo->replay = NULL;
}
/* See btrace.h. */
void
btrace_fetch (struct thread_info *tp)
{
struct btrace_thread_info *btinfo;
struct btrace_target_info *tinfo;
VEC (btrace_block_s) *btrace;
struct cleanup *cleanup;
int errcode;
DEBUG ("fetch thread %d (%s)", tp->num, target_pid_to_str (tp->ptid));
btrace = NULL;
btinfo = &tp->btrace;
tinfo = btinfo->target;
if (tinfo == NULL)
return;
/* There's no way we could get new trace while replaying.
On the other hand, delta trace would return a partial record with the
current PC, which is the replay PC, not the last PC, as expected. */
if (btinfo->replay != NULL)
return;
cleanup = make_cleanup (VEC_cleanup (btrace_block_s), &btrace);
/* Let's first try to extend the trace we already have. */
if (btinfo->end != NULL)
{
errcode = target_read_btrace (&btrace, tinfo, BTRACE_READ_DELTA);
if (errcode == 0)
{
/* Success. Let's try to stitch the traces together. */
errcode = btrace_stitch_trace (&btrace, btinfo);
}
else
{
/* We failed to read delta trace. Let's try to read new trace. */
errcode = target_read_btrace (&btrace, tinfo, BTRACE_READ_NEW);
/* If we got any new trace, discard what we have. */
if (errcode == 0 && !VEC_empty (btrace_block_s, btrace))
btrace_clear (tp);
}
/* If we were not able to read the trace, we start over. */
if (errcode != 0)
{
btrace_clear (tp);
errcode = target_read_btrace (&btrace, tinfo, BTRACE_READ_ALL);
}
}
else
errcode = target_read_btrace (&btrace, tinfo, BTRACE_READ_ALL);
/* If we were not able to read the branch trace, signal an error. */
if (errcode != 0)
error (_("Failed to read branch trace."));
/* Compute the trace, provided we have any. */
if (!VEC_empty (btrace_block_s, btrace))
{
btrace_clear_history (btinfo);
btrace_compute_ftrace (btinfo, btrace);
}
do_cleanups (cleanup);
}
/* See btrace.h. */
void
btrace_clear (struct thread_info *tp)
{
struct btrace_thread_info *btinfo;
struct btrace_function *it, *trash;
DEBUG ("clear thread %d (%s)", tp->num, target_pid_to_str (tp->ptid));
/* Make sure btrace frames that may hold a pointer into the branch
trace data are destroyed. */
reinit_frame_cache ();
btinfo = &tp->btrace;
it = btinfo->begin;
while (it != NULL)
{
trash = it;
it = it->flow.next;
xfree (trash);
}
btinfo->begin = NULL;
btinfo->end = NULL;
btrace_clear_history (btinfo);
}
/* See btrace.h. */
void
btrace_free_objfile (struct objfile *objfile)
{
struct thread_info *tp;
DEBUG ("free objfile");
ALL_NON_EXITED_THREADS (tp)
btrace_clear (tp);
}
#if defined (HAVE_LIBEXPAT)
/* Check the btrace document version. */
static void
check_xml_btrace_version (struct gdb_xml_parser *parser,
const struct gdb_xml_element *element,
void *user_data, VEC (gdb_xml_value_s) *attributes)
{
const char *version = xml_find_attribute (attributes, "version")->value;
if (strcmp (version, "1.0") != 0)
gdb_xml_error (parser, _("Unsupported btrace version: \"%s\""), version);
}
/* Parse a btrace "block" xml record. */
static void
parse_xml_btrace_block (struct gdb_xml_parser *parser,
const struct gdb_xml_element *element,
void *user_data, VEC (gdb_xml_value_s) *attributes)
{
VEC (btrace_block_s) **btrace;
struct btrace_block *block;
ULONGEST *begin, *end;
btrace = user_data;
block = VEC_safe_push (btrace_block_s, *btrace, NULL);
begin = xml_find_attribute (attributes, "begin")->value;
end = xml_find_attribute (attributes, "end")->value;
block->begin = *begin;
block->end = *end;
}
static const struct gdb_xml_attribute block_attributes[] = {
{ "begin", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
{ "end", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
{ NULL, GDB_XML_AF_NONE, NULL, NULL }
};
static const struct gdb_xml_attribute btrace_attributes[] = {
{ "version", GDB_XML_AF_NONE, NULL, NULL },
{ NULL, GDB_XML_AF_NONE, NULL, NULL }
};
static const struct gdb_xml_element btrace_children[] = {
{ "block", block_attributes, NULL,
GDB_XML_EF_REPEATABLE | GDB_XML_EF_OPTIONAL, parse_xml_btrace_block, NULL },
{ NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
};
static const struct gdb_xml_element btrace_elements[] = {
{ "btrace", btrace_attributes, btrace_children, GDB_XML_EF_NONE,
check_xml_btrace_version, NULL },
{ NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
};
#endif /* defined (HAVE_LIBEXPAT) */
/* See btrace.h. */
VEC (btrace_block_s) *
parse_xml_btrace (const char *buffer)
{
VEC (btrace_block_s) *btrace = NULL;
struct cleanup *cleanup;
int errcode;
#if defined (HAVE_LIBEXPAT)
cleanup = make_cleanup (VEC_cleanup (btrace_block_s), &btrace);
errcode = gdb_xml_parse_quick (_("btrace"), "btrace.dtd", btrace_elements,
buffer, &btrace);
if (errcode != 0)
error (_("Error parsing branch trace."));
/* Keep parse results. */
discard_cleanups (cleanup);
#else /* !defined (HAVE_LIBEXPAT) */
error (_("Cannot process branch trace. XML parsing is not supported."));
#endif /* !defined (HAVE_LIBEXPAT) */
return btrace;
}
/* See btrace.h. */
const struct btrace_insn *
btrace_insn_get (const struct btrace_insn_iterator *it)
{
const struct btrace_function *bfun;
unsigned int index, end;
index = it->index;
bfun = it->function;
/* The index is within the bounds of this function's instruction vector. */
end = VEC_length (btrace_insn_s, bfun->insn);
gdb_assert (0 < end);
gdb_assert (index < end);
return VEC_index (btrace_insn_s, bfun->insn, index);
}
/* See btrace.h. */
unsigned int
btrace_insn_number (const struct btrace_insn_iterator *it)
{
const struct btrace_function *bfun;
bfun = it->function;
return bfun->insn_offset + it->index;
}
/* See btrace.h. */
void
btrace_insn_begin (struct btrace_insn_iterator *it,
const struct btrace_thread_info *btinfo)
{
const struct btrace_function *bfun;
bfun = btinfo->begin;
if (bfun == NULL)
error (_("No trace."));
it->function = bfun;
it->index = 0;
}
/* See btrace.h. */
void
btrace_insn_end (struct btrace_insn_iterator *it,
const struct btrace_thread_info *btinfo)
{
const struct btrace_function *bfun;
unsigned int length;
bfun = btinfo->end;
if (bfun == NULL)
error (_("No trace."));
/* The last instruction in the last function is the current instruction.
We point to it - it is one past the end of the execution trace. */
length = VEC_length (btrace_insn_s, bfun->insn);
it->function = bfun;
it->index = length - 1;
}
/* See btrace.h. */
unsigned int
btrace_insn_next (struct btrace_insn_iterator *it, unsigned int stride)
{
const struct btrace_function *bfun;
unsigned int index, steps;
bfun = it->function;
steps = 0;
index = it->index;
while (stride != 0)
{
unsigned int end, space, adv;
end = VEC_length (btrace_insn_s, bfun->insn);
gdb_assert (0 < end);
gdb_assert (index < end);
/* Compute the number of instructions remaining in this segment. */
space = end - index;
/* Advance the iterator as far as possible within this segment. */
adv = min (space, stride);
stride -= adv;
index += adv;
steps += adv;
/* Move to the next function if we're at the end of this one. */
if (index == end)
{
const struct btrace_function *next;
next = bfun->flow.next;
if (next == NULL)
{
/* We stepped past the last function.
Let's adjust the index to point to the last instruction in
the previous function. */
index -= 1;
steps -= 1;
break;
}
/* We now point to the first instruction in the new function. */
bfun = next;
index = 0;
}
/* We did make progress. */
gdb_assert (adv > 0);
}
/* Update the iterator. */
it->function = bfun;
it->index = index;
return steps;
}
/* See btrace.h. */
unsigned int
btrace_insn_prev (struct btrace_insn_iterator *it, unsigned int stride)
{
const struct btrace_function *bfun;
unsigned int index, steps;
bfun = it->function;
steps = 0;
index = it->index;
while (stride != 0)
{
unsigned int adv;
/* Move to the previous function if we're at the start of this one. */
if (index == 0)
{
const struct btrace_function *prev;
prev = bfun->flow.prev;
if (prev == NULL)
break;
/* We point to one after the last instruction in the new function. */
bfun = prev;
index = VEC_length (btrace_insn_s, bfun->insn);
/* There is at least one instruction in this function segment. */
gdb_assert (index > 0);
}
/* Advance the iterator as far as possible within this segment. */
adv = min (index, stride);
stride -= adv;
index -= adv;
steps += adv;
/* We did make progress. */
gdb_assert (adv > 0);
}
/* Update the iterator. */
it->function = bfun;
it->index = index;
return steps;
}
/* See btrace.h. */
int
btrace_insn_cmp (const struct btrace_insn_iterator *lhs,
const struct btrace_insn_iterator *rhs)
{
unsigned int lnum, rnum;
lnum = btrace_insn_number (lhs);
rnum = btrace_insn_number (rhs);
return (int) (lnum - rnum);
}
/* See btrace.h. */
int
btrace_find_insn_by_number (struct btrace_insn_iterator *it,
const struct btrace_thread_info *btinfo,
unsigned int number)
{
const struct btrace_function *bfun;
unsigned int end;
for (bfun = btinfo->end; bfun != NULL; bfun = bfun->flow.prev)
if (bfun->insn_offset <= number)
break;
if (bfun == NULL)
return 0;
end = bfun->insn_offset + VEC_length (btrace_insn_s, bfun->insn);
if (end <= number)
return 0;
it->function = bfun;
it->index = number - bfun->insn_offset;
return 1;
}
/* See btrace.h. */
const struct btrace_function *
btrace_call_get (const struct btrace_call_iterator *it)
{
return it->function;
}
/* See btrace.h. */
unsigned int
btrace_call_number (const struct btrace_call_iterator *it)
{
const struct btrace_thread_info *btinfo;
const struct btrace_function *bfun;
unsigned int insns;
btinfo = it->btinfo;
bfun = it->function;
if (bfun != NULL)
return bfun->number;
/* For the end iterator, i.e. bfun == NULL, we return one more than the
number of the last function. */
bfun = btinfo->end;
insns = VEC_length (btrace_insn_s, bfun->insn);
/* If the function contains only a single instruction (i.e. the current
instruction), it will be skipped and its number is already the number
we seek. */
if (insns == 1)
return bfun->number;
/* Otherwise, return one more than the number of the last function. */
return bfun->number + 1;
}
/* See btrace.h. */
void
btrace_call_begin (struct btrace_call_iterator *it,
const struct btrace_thread_info *btinfo)
{
const struct btrace_function *bfun;
bfun = btinfo->begin;
if (bfun == NULL)
error (_("No trace."));
it->btinfo = btinfo;
it->function = bfun;
}
/* See btrace.h. */
void
btrace_call_end (struct btrace_call_iterator *it,
const struct btrace_thread_info *btinfo)
{
const struct btrace_function *bfun;
bfun = btinfo->end;
if (bfun == NULL)
error (_("No trace."));
it->btinfo = btinfo;
it->function = NULL;
}
/* See btrace.h. */
unsigned int
btrace_call_next (struct btrace_call_iterator *it, unsigned int stride)
{
const struct btrace_function *bfun;
unsigned int steps;
bfun = it->function;
steps = 0;
while (bfun != NULL)
{
const struct btrace_function *next;
unsigned int insns;
next = bfun->flow.next;
if (next == NULL)
{
/* Ignore the last function if it only contains a single
(i.e. the current) instruction. */
insns = VEC_length (btrace_insn_s, bfun->insn);
if (insns == 1)
steps -= 1;
}
if (stride == steps)
break;
bfun = next;
steps += 1;
}
it->function = bfun;
return steps;
}
/* See btrace.h. */
unsigned int
btrace_call_prev (struct btrace_call_iterator *it, unsigned int stride)
{
const struct btrace_thread_info *btinfo;
const struct btrace_function *bfun;
unsigned int steps;
bfun = it->function;
steps = 0;
if (bfun == NULL)
{
unsigned int insns;
btinfo = it->btinfo;
bfun = btinfo->end;
if (bfun == NULL)
return 0;
/* Ignore the last function if it only contains a single
(i.e. the current) instruction. */
insns = VEC_length (btrace_insn_s, bfun->insn);
if (insns == 1)
bfun = bfun->flow.prev;
if (bfun == NULL)
return 0;
steps += 1;
}
while (steps < stride)
{
const struct btrace_function *prev;
prev = bfun->flow.prev;
if (prev == NULL)
break;
bfun = prev;
steps += 1;
}
it->function = bfun;
return steps;
}
/* See btrace.h. */
int
btrace_call_cmp (const struct btrace_call_iterator *lhs,
const struct btrace_call_iterator *rhs)
{
unsigned int lnum, rnum;
lnum = btrace_call_number (lhs);
rnum = btrace_call_number (rhs);
return (int) (lnum - rnum);
}
/* See btrace.h. */
int
btrace_find_call_by_number (struct btrace_call_iterator *it,
const struct btrace_thread_info *btinfo,
unsigned int number)
{
const struct btrace_function *bfun;
for (bfun = btinfo->end; bfun != NULL; bfun = bfun->flow.prev)
{
unsigned int bnum;
bnum = bfun->number;
if (number == bnum)
{
it->btinfo = btinfo;
it->function = bfun;
return 1;
}
/* Functions are ordered and numbered consecutively. We could bail out
earlier. On the other hand, it is very unlikely that we search for
a nonexistent function. */
}
return 0;
}
/* See btrace.h. */
void
btrace_set_insn_history (struct btrace_thread_info *btinfo,
const struct btrace_insn_iterator *begin,
const struct btrace_insn_iterator *end)
{
if (btinfo->insn_history == NULL)
btinfo->insn_history = xzalloc (sizeof (*btinfo->insn_history));
btinfo->insn_history->begin = *begin;
btinfo->insn_history->end = *end;
}
/* See btrace.h. */
void
btrace_set_call_history (struct btrace_thread_info *btinfo,
const struct btrace_call_iterator *begin,
const struct btrace_call_iterator *end)
{
gdb_assert (begin->btinfo == end->btinfo);
if (btinfo->call_history == NULL)
btinfo->call_history = xzalloc (sizeof (*btinfo->call_history));
btinfo->call_history->begin = *begin;
btinfo->call_history->end = *end;
}
/* See btrace.h. */
int
btrace_is_replaying (struct thread_info *tp)
{
return tp->btrace.replay != NULL;
}
/* See btrace.h. */
int
btrace_is_empty (struct thread_info *tp)
{
struct btrace_insn_iterator begin, end;
struct btrace_thread_info *btinfo;
btinfo = &tp->btrace;
if (btinfo->begin == NULL)
return 1;
btrace_insn_begin (&begin, btinfo);
btrace_insn_end (&end, btinfo);
return btrace_insn_cmp (&begin, &end) == 0;
}