/home/stan/gdb/src/gdb/btrace.c

Go to the documentation of this file.

/* Branch trace support for GDB, the GNU debugger.

   Copyright (C) 2013 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;
}