mirror of
https://sourceware.org/git/binutils-gdb.git
synced 2024-12-01 14:03:56 +08:00
d41f6d8ea2
This commit makes all source files under gdb/ that include headers from gdb/ include either defs.h or server.h before any other code. This ensures that definitions and macros from the two config.h files are always in place for our code. An exception has been made for gdb/gdbserver/gdbreplay.c which seems to be a special case. gdb/ 2014-07-30 Gary Benson <gbenson@redhat.com> * btrace.c: Include defs.h. * common/ptid.c: Include defs.h or server.h as appropriate. * nat/mips-linux-watch.c: Likewise. gdb/gdbserver/ 2014-07-30 Gary Benson <gbenson@redhat.com> * hostio-errno.c: Move server.h to top of includes list. * inferiors.c: Likewise. * linux-x86-low.c: Likewise. * notif.c: Include server.h.
1530 lines
37 KiB
C
1530 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 "defs.h"
|
|
#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;
|
|
}
|