544 lines
13 KiB
C
544 lines
13 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"
|
|
|
|
/* 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)
|
|
|
|
/* Initialize the instruction iterator. */
|
|
|
|
static void
|
|
btrace_init_insn_iterator (struct btrace_thread_info *btinfo)
|
|
{
|
|
DEBUG ("init insn iterator");
|
|
|
|
btinfo->insn_iterator.begin = 1;
|
|
btinfo->insn_iterator.end = 0;
|
|
}
|
|
|
|
/* Initialize the function iterator. */
|
|
|
|
static void
|
|
btrace_init_func_iterator (struct btrace_thread_info *btinfo)
|
|
{
|
|
DEBUG ("init func iterator");
|
|
|
|
btinfo->func_iterator.begin = 1;
|
|
btinfo->func_iterator.end = 0;
|
|
}
|
|
|
|
/* Compute the instruction trace from the block trace. */
|
|
|
|
static VEC (btrace_inst_s) *
|
|
compute_itrace (VEC (btrace_block_s) *btrace)
|
|
{
|
|
VEC (btrace_inst_s) *itrace;
|
|
struct gdbarch *gdbarch;
|
|
unsigned int b;
|
|
|
|
DEBUG ("compute itrace");
|
|
|
|
itrace = NULL;
|
|
gdbarch = target_gdbarch ();
|
|
b = VEC_length (btrace_block_s, btrace);
|
|
|
|
while (b-- != 0)
|
|
{
|
|
btrace_block_s *block;
|
|
CORE_ADDR pc;
|
|
|
|
block = VEC_index (btrace_block_s, btrace, b);
|
|
pc = block->begin;
|
|
|
|
/* Add instructions for this block. */
|
|
for (;;)
|
|
{
|
|
btrace_inst_s *inst;
|
|
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."));
|
|
break;
|
|
}
|
|
|
|
inst = VEC_safe_push (btrace_inst_s, itrace, NULL);
|
|
inst->pc = 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."));
|
|
break;
|
|
}
|
|
|
|
pc += size;
|
|
}
|
|
}
|
|
|
|
return itrace;
|
|
}
|
|
|
|
/* Return the function name of a recorded function segment for printing.
|
|
This function never returns NULL. */
|
|
|
|
static const char *
|
|
ftrace_print_function_name (struct btrace_func *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 SYMBOL_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 (struct btrace_func *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;
|
|
}
|
|
|
|
/* Print an ftrace debug status message. */
|
|
|
|
static void
|
|
ftrace_debug (struct btrace_func *bfun, const char *prefix)
|
|
{
|
|
DEBUG_FTRACE ("%s: fun = %s, file = %s, lines = [%d; %d], insn = [%u; %u]",
|
|
prefix, ftrace_print_function_name (bfun),
|
|
ftrace_print_filename (bfun), bfun->lbegin, bfun->lend,
|
|
bfun->ibegin, bfun->iend);
|
|
}
|
|
|
|
/* Initialize a recorded function segment. */
|
|
|
|
static void
|
|
ftrace_init_func (struct btrace_func *bfun, struct minimal_symbol *mfun,
|
|
struct symbol *fun, unsigned int idx)
|
|
{
|
|
bfun->msym = mfun;
|
|
bfun->sym = fun;
|
|
bfun->lbegin = INT_MAX;
|
|
bfun->lend = 0;
|
|
bfun->ibegin = idx;
|
|
bfun->iend = idx;
|
|
}
|
|
|
|
/* Check whether the function has changed. */
|
|
|
|
static int
|
|
ftrace_function_switched (struct btrace_func *bfun,
|
|
struct minimal_symbol *mfun, struct symbol *fun)
|
|
{
|
|
struct minimal_symbol *msym;
|
|
struct symbol *sym;
|
|
|
|
/* The function changed if we did not have one before. */
|
|
if (bfun == NULL)
|
|
return 1;
|
|
|
|
msym = bfun->msym;
|
|
sym = bfun->sym;
|
|
|
|
/* If the minimal symbol changed, we certainly switched functions. */
|
|
if (mfun != NULL && msym != NULL
|
|
&& strcmp (SYMBOL_LINKAGE_NAME (mfun), SYMBOL_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;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* Check if we should skip this file when generating the function call
|
|
history. 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 (struct btrace_func *bfun, const char *filename)
|
|
{
|
|
struct symbol *sym;
|
|
const char *bfile;
|
|
|
|
sym = bfun->sym;
|
|
|
|
if (sym != NULL)
|
|
bfile = symtab_to_fullname (sym->symtab);
|
|
else
|
|
bfile = "";
|
|
|
|
if (filename == NULL)
|
|
filename = "";
|
|
|
|
return (filename_cmp (bfile, filename) != 0);
|
|
}
|
|
|
|
/* Compute the function trace from the instruction trace. */
|
|
|
|
static VEC (btrace_func_s) *
|
|
compute_ftrace (VEC (btrace_inst_s) *itrace)
|
|
{
|
|
VEC (btrace_func_s) *ftrace;
|
|
struct btrace_inst *binst;
|
|
struct btrace_func *bfun;
|
|
unsigned int idx;
|
|
|
|
DEBUG ("compute ftrace");
|
|
|
|
ftrace = NULL;
|
|
bfun = NULL;
|
|
|
|
for (idx = 0; VEC_iterate (btrace_inst_s, itrace, idx, binst); ++idx)
|
|
{
|
|
struct symtab_and_line sal;
|
|
struct bound_minimal_symbol mfun;
|
|
struct symbol *fun;
|
|
const char *filename;
|
|
CORE_ADDR pc;
|
|
|
|
pc = binst->pc;
|
|
|
|
/* 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);
|
|
mfun = lookup_minimal_symbol_by_pc (pc);
|
|
|
|
if (fun == NULL && mfun.minsym == NULL)
|
|
{
|
|
DEBUG_FTRACE ("no symbol at %u, pc=%s", idx,
|
|
core_addr_to_string_nz (pc));
|
|
continue;
|
|
}
|
|
|
|
/* If we're switching functions, we start over. */
|
|
if (ftrace_function_switched (bfun, mfun.minsym, fun))
|
|
{
|
|
bfun = VEC_safe_push (btrace_func_s, ftrace, NULL);
|
|
|
|
ftrace_init_func (bfun, mfun.minsym, fun, idx);
|
|
ftrace_debug (bfun, "init");
|
|
}
|
|
|
|
/* Update the instruction range. */
|
|
bfun->iend = idx;
|
|
ftrace_debug (bfun, "update insns");
|
|
|
|
/* Let's see if we have source correlation, as well. */
|
|
sal = find_pc_line (pc, 0);
|
|
if (sal.symtab == NULL || sal.line == 0)
|
|
{
|
|
DEBUG_FTRACE ("no lines at %u, pc=%s", idx,
|
|
core_addr_to_string_nz (pc));
|
|
continue;
|
|
}
|
|
|
|
/* Check if we switched files. This could happen if, say, a macro that
|
|
is defined in another file is expanded here. */
|
|
filename = symtab_to_fullname (sal.symtab);
|
|
if (ftrace_skip_file (bfun, filename))
|
|
{
|
|
DEBUG_FTRACE ("ignoring file at %u, pc=%s, file=%s", idx,
|
|
core_addr_to_string_nz (pc), filename);
|
|
continue;
|
|
}
|
|
|
|
/* Update the line range. */
|
|
bfun->lbegin = min (bfun->lbegin, sal.line);
|
|
bfun->lend = max (bfun->lend, sal.line);
|
|
ftrace_debug (bfun, "update lines");
|
|
}
|
|
|
|
return ftrace;
|
|
}
|
|
|
|
/* 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);
|
|
}
|
|
|
|
/* 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);
|
|
}
|
|
|
|
/* See btrace.h. */
|
|
|
|
void
|
|
btrace_fetch (struct thread_info *tp)
|
|
{
|
|
struct btrace_thread_info *btinfo;
|
|
VEC (btrace_block_s) *btrace;
|
|
|
|
DEBUG ("fetch thread %d (%s)", tp->num, target_pid_to_str (tp->ptid));
|
|
|
|
btinfo = &tp->btrace;
|
|
if (btinfo->target == NULL)
|
|
return;
|
|
|
|
btrace = target_read_btrace (btinfo->target, btrace_read_new);
|
|
if (VEC_empty (btrace_block_s, btrace))
|
|
return;
|
|
|
|
btrace_clear (tp);
|
|
|
|
btinfo->btrace = btrace;
|
|
btinfo->itrace = compute_itrace (btinfo->btrace);
|
|
btinfo->ftrace = compute_ftrace (btinfo->itrace);
|
|
|
|
/* Initialize branch trace iterators. */
|
|
btrace_init_insn_iterator (btinfo);
|
|
btrace_init_func_iterator (btinfo);
|
|
}
|
|
|
|
/* See btrace.h. */
|
|
|
|
void
|
|
btrace_clear (struct thread_info *tp)
|
|
{
|
|
struct btrace_thread_info *btinfo;
|
|
|
|
DEBUG ("clear thread %d (%s)", tp->num, target_pid_to_str (tp->ptid));
|
|
|
|
btinfo = &tp->btrace;
|
|
|
|
VEC_free (btrace_block_s, btinfo->btrace);
|
|
VEC_free (btrace_inst_s, btinfo->itrace);
|
|
VEC_free (btrace_func_s, btinfo->ftrace);
|
|
|
|
btinfo->btrace = NULL;
|
|
btinfo->itrace = NULL;
|
|
btinfo->ftrace = NULL;
|
|
}
|
|
|
|
/* See btrace.h. */
|
|
|
|
void
|
|
btrace_free_objfile (struct objfile *objfile)
|
|
{
|
|
struct thread_info *tp;
|
|
|
|
DEBUG ("free objfile");
|
|
|
|
ALL_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)
|
|
{
|
|
do_cleanups (cleanup);
|
|
return NULL;
|
|
}
|
|
|
|
/* 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;
|
|
}
|