gdb/btrace.c - gdb

Global variables defined

Functions defined

Macros defined

Source code

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

  3.    Copyright (C) 2013-2015 Free Software Foundation, Inc.

  5.    Contributed by Intel Corp. <markus.t.metzger@intel.com>

  7.    This file is part of GDB.

  9.    This program is free software; you can redistribute it and/or modify
  10.    it under the terms of the GNU General Public License as published by
  11.    the Free Software Foundation; either version 3 of the License, or
  12.    (at your option) any later version.

  14.    This program is distributed in the hope that it will be useful,
  15.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17.    GNU General Public License for more details.

  19.    You should have received a copy of the GNU General Public License
  20.    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

  22. #include "defs.h"
  23. #include "btrace.h"
  24. #include "gdbthread.h"
  25. #include "inferior.h"
  26. #include "target.h"
  27. #include "record.h"
  28. #include "symtab.h"
  29. #include "disasm.h"
  30. #include "source.h"
  31. #include "filenames.h"
  32. #include "xml-support.h"
  33. #include "regcache.h"

  35. /* Print a record debug message.  Use do ... while (0) to avoid ambiguities
  36.    when used in if statements.  */

  38. ‌#define DEBUG(msg, args...)                                                \
  39.   do                                                                        \
  40.     {                                                                        \
  41.       if (record_debug != 0)                                                \
  42.         fprintf_unfiltered (gdb_stdlog,                                        \
  43.                             "[btrace] " msg "\n", ##args);                \
  44.     }                                                                        \
  45.   while (0)

  47. ‌#define DEBUG_FTRACE(msg, args...) DEBUG ("[ftrace] " msg, ##args)

  49. /* Return the function name of a recorded function segment for printing.
  50.    This function never returns NULL.  */

  52. static const char *
  53. ‌ftrace_print_function_name (const struct btrace_function *bfun)
  54. {
  55.   struct minimal_symbol *msym;
  56.   struct symbol *sym;

  58.   msym = bfun->msym;
  59.   sym = bfun->sym;

  61.   if (sym != NULL)
  62.     return SYMBOL_PRINT_NAME (sym);

  64.   if (msym != NULL)
  65.     return MSYMBOL_PRINT_NAME (msym);

  67.   return "<unknown>";
  68. }

  70. /* Return the file name of a recorded function segment for printing.
  71.    This function never returns NULL.  */

  73. static const char *
  74. ‌ftrace_print_filename (const struct btrace_function *bfun)
  75. {
  76.   struct symbol *sym;
  77.   const char *filename;

  79.   sym = bfun->sym;

  81.   if (sym != NULL)
  82.     filename = symtab_to_filename_for_display (symbol_symtab (sym));
  83.   else
  84.     filename = "<unknown>";

  86.   return filename;
  87. }

  89. /* Return a string representation of the address of an instruction.
  90.    This function never returns NULL.  */

  92. static const char *
  93. ‌ftrace_print_insn_addr (const struct btrace_insn *insn)
  94. {
  95.   if (insn == NULL)
  96.     return "<nil>";

  98.   return core_addr_to_string_nz (insn->pc);
  99. }

  101. /* Print an ftrace debug status message.  */

  103. static void
  104. ‌ftrace_debug (const struct btrace_function *bfun, const char *prefix)
  105. {
  106.   const char *fun, *file;
  107.   unsigned int ibegin, iend;
  108.   int lbegin, lend, level;

  110.   fun = ftrace_print_function_name (bfun);
  111.   file = ftrace_print_filename (bfun);
  112.   level = bfun->level;

  114.   lbegin = bfun->lbegin;
  115.   lend = bfun->lend;

  117.   ibegin = bfun->insn_offset;
  118.   iend = ibegin + VEC_length (btrace_insn_s, bfun->insn);

  120.   DEBUG_FTRACE ("%s: fun = %s, file = %s, level = %d, lines = [%d; %d], "
  121.                 "insn = [%u; %u)", prefix, fun, file, level, lbegin, lend,
  122.                 ibegin, iend);
  123. }

  125. /* Return non-zero if BFUN does not match MFUN and FUN,
  126.    return zero otherwise.  */

  128. static int
  129. ‌ftrace_function_switched (const struct btrace_function *bfun,
  130.                           const struct minimal_symbol *mfun,
  131.                           const struct symbol *fun)
  132. {
  133.   struct minimal_symbol *msym;
  134.   struct symbol *sym;

  136.   msym = bfun->msym;
  137.   sym = bfun->sym;

  139.   /* If the minimal symbol changed, we certainly switched functions.  */
  140.   if (mfun != NULL && msym != NULL
  141.       && strcmp (MSYMBOL_LINKAGE_NAME (mfun), MSYMBOL_LINKAGE_NAME (msym)) != 0)
  142.     return 1;

  144.   /* If the symbol changed, we certainly switched functions.  */
  145.   if (fun != NULL && sym != NULL)
  146.     {
  147.       const char *bfname, *fname;

  149.       /* Check the function name.  */
  150.       if (strcmp (SYMBOL_LINKAGE_NAME (fun), SYMBOL_LINKAGE_NAME (sym)) != 0)
  151.         return 1;

  153.       /* Check the location of those functions, as well.  */
  154.       bfname = symtab_to_fullname (symbol_symtab (sym));
  155.       fname = symtab_to_fullname (symbol_symtab (fun));
  156.       if (filename_cmp (fname, bfname) != 0)
  157.         return 1;
  158.     }

  160.   /* If we lost symbol information, we switched functions.  */
  161.   if (!(msym == NULL && sym == NULL) && mfun == NULL && fun == NULL)
  162.     return 1;

  164.   /* If we gained symbol information, we switched functions.  */
  165.   if (msym == NULL && sym == NULL && !(mfun == NULL && fun == NULL))
  166.     return 1;

  168.   return 0;
  169. }

  171. /* Return non-zero if we should skip this file when generating the function
  172.    call history, zero otherwise.
  173.    We would want to do that if, say, a macro that is defined in another file
  174.    is expanded in this function.  */

  176. static int
  177. ‌ftrace_skip_file (const struct btrace_function *bfun, const char *fullname)
  178. {
  179.   struct symbol *sym;
  180.   const char *bfile;

  182.   sym = bfun->sym;
  183.   if (sym == NULL)
  184.     return 1;

  186.   bfile = symtab_to_fullname (symbol_symtab (sym));

  188.   return (filename_cmp (bfile, fullname) != 0);
  189. }

  191. /* Allocate and initialize a new branch trace function segment.
  192.    PREV is the chronologically preceding function segment.
  193.    MFUN and FUN are the symbol information we have for this function.  */

  195. static struct btrace_function *
  196. ‌ftrace_new_function (struct btrace_function *prev,
  197.                      struct minimal_symbol *mfun,
  198.                      struct symbol *fun)
  199. {
  200.   struct btrace_function *bfun;

  202.   bfun = xzalloc (sizeof (*bfun));

  204.   bfun->msym = mfun;
  205.   bfun->sym = fun;
  206.   bfun->flow.prev = prev;

  208.   /* We start with the identities of min and max, respectively.  */
  209.   bfun->lbegin = INT_MAX;
  210.   bfun->lend = INT_MIN;

  212.   if (prev == NULL)
  213.     {
  214.       /* Start counting at one.  */
  215.       bfun->number = 1;
  216.       bfun->insn_offset = 1;
  217.     }
  218.   else
  219.     {
  220.       gdb_assert (prev->flow.next == NULL);
  221.       prev->flow.next = bfun;

  223.       bfun->number = prev->number + 1;
  224.       bfun->insn_offset = (prev->insn_offset
  225.                            + VEC_length (btrace_insn_s, prev->insn));
  226.     }

  228.   return bfun;
  229. }

  231. /* Update the UP field of a function segment.  */

  233. static void
  234. ‌ftrace_update_caller (struct btrace_function *bfun,
  235.                       struct btrace_function *caller,
  236.                       enum btrace_function_flag flags)
  237. {
  238.   if (bfun->up != NULL)
  239.     ftrace_debug (bfun, "updating caller");

  241.   bfun->up = caller;
  242.   bfun->flags = flags;

  244.   ftrace_debug (bfun, "set caller");
  245. }

  247. /* Fix up the caller for all segments of a function.  */

  249. static void
  250. ‌ftrace_fixup_caller (struct btrace_function *bfun,
  251.                      struct btrace_function *caller,
  252.                      enum btrace_function_flag flags)
  253. {
  254.   struct btrace_function *prev, *next;

  256.   ftrace_update_caller (bfun, caller, flags);

  258.   /* Update all function segments belonging to the same function.  */
  259.   for (prev = bfun->segment.prev; prev != NULL; prev = prev->segment.prev)
  260.     ftrace_update_caller (prev, caller, flags);

  262.   for (next = bfun->segment.next; next != NULL; next = next->segment.next)
  263.     ftrace_update_caller (next, caller, flags);
  264. }

  266. /* Add a new function segment for a call.
  267.    CALLER is the chronologically preceding function segment.
  268.    MFUN and FUN are the symbol information we have for this function.  */

  270. static struct btrace_function *
  271. ‌ftrace_new_call (struct btrace_function *caller,
  272.                  struct minimal_symbol *mfun,
  273.                  struct symbol *fun)
  274. {
  275.   struct btrace_function *bfun;

  277.   bfun = ftrace_new_function (caller, mfun, fun);
  278.   bfun->up = caller;
  279.   bfun->level = caller->level + 1;

  281.   ftrace_debug (bfun, "new call");

  283.   return bfun;
  284. }

  286. /* Add a new function segment for a tail call.
  287.    CALLER is the chronologically preceding function segment.
  288.    MFUN and FUN are the symbol information we have for this function.  */

  290. static struct btrace_function *
  291. ‌ftrace_new_tailcall (struct btrace_function *caller,
  292.                      struct minimal_symbol *mfun,
  293.                      struct symbol *fun)
  294. {
  295.   struct btrace_function *bfun;

  297.   bfun = ftrace_new_function (caller, mfun, fun);
  298.   bfun->up = caller;
  299.   bfun->level = caller->level + 1;
  300.   bfun->flags |= BFUN_UP_LINKS_TO_TAILCALL;

  302.   ftrace_debug (bfun, "new tail call");

  304.   return bfun;
  305. }

  307. /* Find the innermost caller in the back trace of BFUN with MFUN/FUN
  308.    symbol information.  */

  310. static struct btrace_function *
  311. ‌ftrace_find_caller (struct btrace_function *bfun,
  312.                     struct minimal_symbol *mfun,
  313.                     struct symbol *fun)
  314. {
  315.   for (; bfun != NULL; bfun = bfun->up)
  316.     {
  317.       /* Skip functions with incompatible symbol information.  */
  318.       if (ftrace_function_switched (bfun, mfun, fun))
  319.         continue;

  321.       /* This is the function segment we're looking for.  */
  322.       break;
  323.     }

  325.   return bfun;
  326. }

  328. /* Find the innermost caller in the back trace of BFUN, skipping all
  329.    function segments that do not end with a call instruction (e.g.
  330.    tail calls ending with a jump).  */

  332. static struct btrace_function *
  333. ‌ftrace_find_call (struct gdbarch *gdbarch, struct btrace_function *bfun)
  334. {
  335.   for (; bfun != NULL; bfun = bfun->up)
  336.     {
  337.       struct btrace_insn *last;
  338.       CORE_ADDR pc;

  340.       /* We do not allow empty function segments.  */
  341.       gdb_assert (!VEC_empty (btrace_insn_s, bfun->insn));

  343.       last = VEC_last (btrace_insn_s, bfun->insn);
  344.       pc = last->pc;

  346.       if (gdbarch_insn_is_call (gdbarch, pc))
  347.         break;
  348.     }

  350.   return bfun;
  351. }

  353. /* Add a continuation segment for a function into which we return.
  354.    PREV is the chronologically preceding function segment.
  355.    MFUN and FUN are the symbol information we have for this function.  */

  357. static struct btrace_function *
  358. ‌ftrace_new_return (struct gdbarch *gdbarch,
  359.                    struct btrace_function *prev,
  360.                    struct minimal_symbol *mfun,
  361.                    struct symbol *fun)
  362. {
  363.   struct btrace_function *bfun, *caller;

  365.   bfun = ftrace_new_function (prev, mfun, fun);

  367.   /* It is important to start at PREV's caller.  Otherwise, we might find
  368.      PREV itself, if PREV is a recursive function.  */
  369.   caller = ftrace_find_caller (prev->up, mfun, fun);
  370.   if (caller != NULL)
  371.     {
  372.       /* The caller of PREV is the preceding btrace function segment in this
  373.          function instance.  */
  374.       gdb_assert (caller->segment.next == NULL);

  376.       caller->segment.next = bfun;
  377.       bfun->segment.prev = caller;

  379.       /* Maintain the function level.  */
  380.       bfun->level = caller->level;

  382.       /* Maintain the call stack.  */
  383.       bfun->up = caller->up;
  384.       bfun->flags = caller->flags;

  386.       ftrace_debug (bfun, "new return");
  387.     }
  388.   else
  389.     {
  390.       /* We did not find a caller.  This could mean that something went
  391.          wrong or that the call is simply not included in the trace.  */

  393.       /* Let's search for some actual call.  */
  394.       caller = ftrace_find_call (gdbarch, prev->up);
  395.       if (caller == NULL)
  396.         {
  397.           /* There is no call in PREV's back trace.  We assume that the
  398.              branch trace did not include it.  */

  400.           /* Let's find the topmost call function - this skips tail calls.  */
  401.           while (prev->up != NULL)
  402.             prev = prev->up;

  404.           /* We maintain levels for a series of returns for which we have
  405.              not seen the calls.
  406.              We start at the preceding function's level in case this has
  407.              already been a return for which we have not seen the call.
  408.              We start at level 0 otherwise, to handle tail calls correctly.  */
  409.           bfun->level = min (0, prev->level) - 1;

  411.           /* Fix up the call stack for PREV.  */
  412.           ftrace_fixup_caller (prev, bfun, BFUN_UP_LINKS_TO_RET);

  414.           ftrace_debug (bfun, "new return - no caller");
  415.         }
  416.       else
  417.         {
  418.           /* There is a call in PREV's back trace to which we should have
  419.              returned.  Let's remain at this level.  */
  420.           bfun->level = prev->level;

  422.           ftrace_debug (bfun, "new return - unknown caller");
  423.         }
  424.     }

  426.   return bfun;
  427. }

  429. /* Add a new function segment for a function switch.
  430.    PREV is the chronologically preceding function segment.
  431.    MFUN and FUN are the symbol information we have for this function.  */

  433. static struct btrace_function *
  434. ‌ftrace_new_switch (struct btrace_function *prev,
  435.                    struct minimal_symbol *mfun,
  436.                    struct symbol *fun)
  437. {
  438.   struct btrace_function *bfun;

  440.   /* This is an unexplained function switch.  The call stack will likely
  441.      be wrong at this point.  */
  442.   bfun = ftrace_new_function (prev, mfun, fun);

  444.   /* We keep the function level.  */
  445.   bfun->level = prev->level;

  447.   ftrace_debug (bfun, "new switch");

  449.   return bfun;
  450. }

  452. /* Update BFUN with respect to the instruction at PC.  This may create new
  453.    function segments.
  454.    Return the chronologically latest function segment, never NULL.  */

  456. static struct btrace_function *
  457. ‌ftrace_update_function (struct gdbarch *gdbarch,
  458.                         struct btrace_function *bfun, CORE_ADDR pc)
  459. {
  460.   struct bound_minimal_symbol bmfun;
  461.   struct minimal_symbol *mfun;
  462.   struct symbol *fun;
  463.   struct btrace_insn *last;

  465.   /* Try to determine the function we're in.  We use both types of symbols
  466.      to avoid surprises when we sometimes get a full symbol and sometimes
  467.      only a minimal symbol.  */
  468.   fun = find_pc_function (pc);
  469.   bmfun = lookup_minimal_symbol_by_pc (pc);
  470.   mfun = bmfun.minsym;

  472.   if (fun == NULL && mfun == NULL)
  473.     DEBUG_FTRACE ("no symbol at %s", core_addr_to_string_nz (pc));

  475.   /* If we didn't have a function before, we create one.  */
  476.   if (bfun == NULL)
  477.     return ftrace_new_function (bfun, mfun, fun);

  479.   /* Check the last instruction, if we have one.
  480.      We do this check first, since it allows us to fill in the call stack
  481.      links in addition to the normal flow links.  */
  482.   last = NULL;
  483.   if (!VEC_empty (btrace_insn_s, bfun->insn))
  484.     last = VEC_last (btrace_insn_s, bfun->insn);

  486.   if (last != NULL)
  487.     {
  488.       CORE_ADDR lpc;

  490.       lpc = last->pc;

  492.       /* Check for returns.  */
  493.       if (gdbarch_insn_is_ret (gdbarch, lpc))
  494.         return ftrace_new_return (gdbarch, bfun, mfun, fun);

  496.       /* Check for calls.  */
  497.       if (gdbarch_insn_is_call (gdbarch, lpc))
  498.         {
  499.           int size;

  501.           size = gdb_insn_length (gdbarch, lpc);

  503.           /* Ignore calls to the next instruction.  They are used for PIC.  */
  504.           if (lpc + size != pc)
  505.             return ftrace_new_call (bfun, mfun, fun);
  506.         }
  507.     }

  509.   /* Check if we're switching functions for some other reason.  */
  510.   if (ftrace_function_switched (bfun, mfun, fun))
  511.     {
  512.       DEBUG_FTRACE ("switching from %s in %s at %s",
  513.                     ftrace_print_insn_addr (last),
  514.                     ftrace_print_function_name (bfun),
  515.                     ftrace_print_filename (bfun));

  517.       if (last != NULL)
  518.         {
  519.           CORE_ADDR start, lpc;

  521.           start = get_pc_function_start (pc);

  523.           /* If we can't determine the function for PC, we treat a jump at
  524.              the end of the block as tail call.  */
  525.           if (start == 0)
  526.             start = pc;

  528.           lpc = last->pc;

  530.           /* Jumps indicate optimized tail calls.  */
  531.           if (start == pc && gdbarch_insn_is_jump (gdbarch, lpc))
  532.             return ftrace_new_tailcall (bfun, mfun, fun);
  533.         }

  535.       return ftrace_new_switch (bfun, mfun, fun);
  536.     }

  538.   return bfun;
  539. }

  541. /* Update BFUN's source range with respect to the instruction at PC.  */

  543. static void
  544. ‌ftrace_update_lines (struct btrace_function *bfun, CORE_ADDR pc)
  545. {
  546.   struct symtab_and_line sal;
  547.   const char *fullname;

  549.   sal = find_pc_line (pc, 0);
  550.   if (sal.symtab == NULL || sal.line == 0)
  551.     {
  552.       DEBUG_FTRACE ("no lines at %s", core_addr_to_string_nz (pc));
  553.       return;
  554.     }

  556.   /* Check if we switched files.  This could happen if, say, a macro that
  557.      is defined in another file is expanded here.  */
  558.   fullname = symtab_to_fullname (sal.symtab);
  559.   if (ftrace_skip_file (bfun, fullname))
  560.     {
  561.       DEBUG_FTRACE ("ignoring file at %s, file=%s",
  562.                     core_addr_to_string_nz (pc), fullname);
  563.       return;
  564.     }

  566.   /* Update the line range.  */
  567.   bfun->lbegin = min (bfun->lbegin, sal.line);
  568.   bfun->lend = max (bfun->lend, sal.line);

  570.   if (record_debug > 1)
  571.     ftrace_debug (bfun, "update lines");
  572. }

  574. /* Add the instruction at PC to BFUN's instructions.  */

  576. static void
  577. ‌ftrace_update_insns (struct btrace_function *bfun, CORE_ADDR pc)
  578. {
  579.   struct btrace_insn *insn;

  581.   insn = VEC_safe_push (btrace_insn_s, bfun->insn, NULL);
  582.   insn->pc = pc;

  584.   if (record_debug > 1)
  585.     ftrace_debug (bfun, "update insn");
  586. }

  588. /* Compute the function branch trace from a block branch trace BTRACE for
  589.    a thread given by BTINFO.  */

  591. static void
  592. ‌btrace_compute_ftrace (struct btrace_thread_info *btinfo,
  593.                        VEC (btrace_block_s) *btrace)
  594. {
  595.   struct btrace_function *begin, *end;
  596.   struct gdbarch *gdbarch;
  597.   unsigned int blk;
  598.   int level;

  600.   DEBUG ("compute ftrace");

  602.   gdbarch = target_gdbarch ();
  603.   begin = btinfo->begin;
  604.   end = btinfo->end;
  605.   level = begin != NULL ? -btinfo->level : INT_MAX;
  606.   blk = VEC_length (btrace_block_s, btrace);

  608.   while (blk != 0)
  609.     {
  610.       btrace_block_s *block;
  611.       CORE_ADDR pc;

  613.       blk -= 1;

  615.       block = VEC_index (btrace_block_s, btrace, blk);
  616.       pc = block->begin;

  618.       for (;;)
  619.         {
  620.           int size;

  622.           /* We should hit the end of the block.  Warn if we went too far.  */
  623.           if (block->end < pc)
  624.             {
  625.               warning (_("Recorded trace may be corrupted around %s."),
  626.                        core_addr_to_string_nz (pc));
  627.               break;
  628.             }

  630.           end = ftrace_update_function (gdbarch, end, pc);
  631.           if (begin == NULL)
  632.             begin = end;

  634.           /* Maintain the function level offset.
  635.              For all but the last block, we do it here.  */
  636.           if (blk != 0)
  637.             level = min (level, end->level);

  639.           ftrace_update_insns (end, pc);
  640.           ftrace_update_lines (end, pc);

  642.           /* We're done once we pushed the instruction at the end.  */
  643.           if (block->end == pc)
  644.             break;

  646.           size = gdb_insn_length (gdbarch, pc);

  648.           /* Make sure we terminate if we fail to compute the size.  */
  649.           if (size <= 0)
  650.             {
  651.               warning (_("Recorded trace may be incomplete around %s."),
  652.                        core_addr_to_string_nz (pc));
  653.               break;
  654.             }

  656.           pc += size;

  658.           /* Maintain the function level offset.
  659.              For the last block, we do it here to not consider the last
  660.              instruction.
  661.              Since the last instruction corresponds to the current instruction
  662.              and is not really part of the execution history, it shouldn't
  663.              affect the level.  */
  664.           if (blk == 0)
  665.             level = min (level, end->level);
  666.         }
  667.     }

  669.   btinfo->begin = begin;
  670.   btinfo->end = end;

  672.   /* LEVEL is the minimal function level of all btrace function segments.
  673.      Define the global level offset to -LEVEL so all function levels are
  674.      normalized to start at zero.  */
  675.   btinfo->level = -level;
  676. }

  678. /* Add an entry for the current PC.  */

  680. static void
  681. ‌btrace_add_pc (struct thread_info *tp)
  682. {
  683.   VEC (btrace_block_s) *btrace;
  684.   struct btrace_block *block;
  685.   struct regcache *regcache;
  686.   struct cleanup *cleanup;
  687.   CORE_ADDR pc;

  689.   regcache = get_thread_regcache (tp->ptid);
  690.   pc = regcache_read_pc (regcache);

  692.   btrace = NULL;
  693.   cleanup = make_cleanup (VEC_cleanup (btrace_block_s), &btrace);

  695.   block = VEC_safe_push (btrace_block_s, btrace, NULL);
  696.   block->begin = pc;
  697.   block->end = pc;

  699.   btrace_compute_ftrace (&tp->btrace, btrace);

  701.   do_cleanups (cleanup);
  702. }

  704. /* See btrace.h.  */

  706. void
  707. ‌btrace_enable (struct thread_info *tp)
  708. {
  709.   if (tp->btrace.target != NULL)
  710.     return;

  712.   if (!target_supports_btrace ())
  713.     error (_("Target does not support branch tracing."));

  715.   DEBUG ("enable thread %d (%s)", tp->num, target_pid_to_str (tp->ptid));

  717.   tp->btrace.target = target_enable_btrace (tp->ptid);

  719.   /* Add an entry for the current PC so we start tracing from where we
  720.      enabled it.  */
  721.   if (tp->btrace.target != NULL)
  722.     btrace_add_pc (tp);
  723. }

  725. /* See btrace.h.  */

  727. void
  728. ‌btrace_disable (struct thread_info *tp)
  729. {
  730.   struct btrace_thread_info *btp = &tp->btrace;
  731.   int errcode = 0;

  733.   if (btp->target == NULL)
  734.     return;

  736.   DEBUG ("disable thread %d (%s)", tp->num, target_pid_to_str (tp->ptid));

  738.   target_disable_btrace (btp->target);
  739.   btp->target = NULL;

  741.   btrace_clear (tp);
  742. }

  744. /* See btrace.h.  */

  746. void
  747. ‌btrace_teardown (struct thread_info *tp)
  748. {
  749.   struct btrace_thread_info *btp = &tp->btrace;
  750.   int errcode = 0;

  752.   if (btp->target == NULL)
  753.     return;

  755.   DEBUG ("teardown thread %d (%s)", tp->num, target_pid_to_str (tp->ptid));

  757.   target_teardown_btrace (btp->target);
  758.   btp->target = NULL;

  760.   btrace_clear (tp);
  761. }

  763. /* Adjust the block trace in order to stitch old and new trace together.
  764.    BTRACE is the new delta trace between the last and the current stop.
  765.    BTINFO is the old branch trace until the last stop.
  766.    May modify BTRACE as well as the existing trace in BTINFO.
  767.    Return 0 on success, -1 otherwise.  */

  769. static int
  770. ‌btrace_stitch_trace (VEC (btrace_block_s) **btrace,
  771.                      const struct btrace_thread_info *btinfo)
  772. {
  773.   struct btrace_function *last_bfun;
  774.   struct btrace_insn *last_insn;
  775.   btrace_block_s *first_new_block;

  777.   /* If we don't have trace, there's nothing to do.  */
  778.   if (VEC_empty (btrace_block_s, *btrace))
  779.     return 0;

  781.   last_bfun = btinfo->end;
  782.   gdb_assert (last_bfun != NULL);

  784.   /* Beware that block trace starts with the most recent block, so the
  785.      chronologically first block in the new trace is the last block in
  786.      the new trace's block vector.  */
  787.   first_new_block = VEC_last (btrace_block_s, *btrace);
  788.   last_insn = VEC_last (btrace_insn_s, last_bfun->insn);

  790.   /* If the current PC at the end of the block is the same as in our current
  791.      trace, there are two explanations:
  792.        1. we executed the instruction and some branch brought us back.
  793.        2. we have not made any progress.
  794.      In the first case, the delta trace vector should contain at least two
  795.      entries.
  796.      In the second case, the delta trace vector should contain exactly one
  797.      entry for the partial block containing the current PC.  Remove it.  */
  798.   if (first_new_block->end == last_insn->pc
  799.       && VEC_length (btrace_block_s, *btrace) == 1)
  800.     {
  801.       VEC_pop (btrace_block_s, *btrace);
  802.       return 0;
  803.     }

  805.   DEBUG ("stitching %s to %s", ftrace_print_insn_addr (last_insn),
  806.          core_addr_to_string_nz (first_new_block->end));

  808.   /* Do a simple sanity check to make sure we don't accidentally end up
  809.      with a bad block.  This should not occur in practice.  */
  810.   if (first_new_block->end < last_insn->pc)
  811.     {
  812.       warning (_("Error while trying to read delta trace.  Falling back to "
  813.                  "a full read."));
  814.       return -1;
  815.     }

  817.   /* We adjust the last block to start at the end of our current trace.  */
  818.   gdb_assert (first_new_block->begin == 0);
  819.   first_new_block->begin = last_insn->pc;

  821.   /* We simply pop the last insn so we can insert it again as part of
  822.      the normal branch trace computation.
  823.      Since instruction iterators are based on indices in the instructions
  824.      vector, we don't leave any pointers dangling.  */
  825.   DEBUG ("pruning insn at %s for stitching",
  826.          ftrace_print_insn_addr (last_insn));

  828.   VEC_pop (btrace_insn_s, last_bfun->insn);

  830.   /* The instructions vector may become empty temporarily if this has
  831.      been the only instruction in this function segment.
  832.      This violates the invariant but will be remedied shortly by
  833.      btrace_compute_ftrace when we add the new trace.  */
  834.   return 0;
  835. }

  837. /* Clear the branch trace histories in BTINFO.  */

  839. static void
  840. ‌btrace_clear_history (struct btrace_thread_info *btinfo)
  841. {
  842.   xfree (btinfo->insn_history);
  843.   xfree (btinfo->call_history);
  844.   xfree (btinfo->replay);

  846.   btinfo->insn_history = NULL;
  847.   btinfo->call_history = NULL;
  848.   btinfo->replay = NULL;
  849. }

  851. /* See btrace.h.  */

  853. void
  854. ‌btrace_fetch (struct thread_info *tp)
  855. {
  856.   struct btrace_thread_info *btinfo;
  857.   struct btrace_target_info *tinfo;
  858.   VEC (btrace_block_s) *btrace;
  859.   struct cleanup *cleanup;
  860.   int errcode;

  862.   DEBUG ("fetch thread %d (%s)", tp->num, target_pid_to_str (tp->ptid));

  864.   btrace = NULL;
  865.   btinfo = &tp->btrace;
  866.   tinfo = btinfo->target;
  867.   if (tinfo == NULL)
  868.     return;

  870.   /* There's no way we could get new trace while replaying.
  871.      On the other hand, delta trace would return a partial record with the
  872.      current PC, which is the replay PC, not the last PC, as expected.  */
  873.   if (btinfo->replay != NULL)
  874.     return;

  876.   cleanup = make_cleanup (VEC_cleanup (btrace_block_s), &btrace);

  878.   /* Let's first try to extend the trace we already have.  */
  879.   if (btinfo->end != NULL)
  880.     {
  881.       errcode = target_read_btrace (&btrace, tinfo, BTRACE_READ_DELTA);
  882.       if (errcode == 0)
  883.         {
  884.           /* Success.  Let's try to stitch the traces together.  */
  885.           errcode = btrace_stitch_trace (&btrace, btinfo);
  886.         }
  887.       else
  888.         {
  889.           /* We failed to read delta trace.  Let's try to read new trace.  */
  890.           errcode = target_read_btrace (&btrace, tinfo, BTRACE_READ_NEW);

  892.           /* If we got any new trace, discard what we have.  */
  893.           if (errcode == 0 && !VEC_empty (btrace_block_s, btrace))
  894.             btrace_clear (tp);
  895.         }

  897.       /* If we were not able to read the trace, we start over.  */
  898.       if (errcode != 0)
  899.         {
  900.           btrace_clear (tp);
  901.           errcode = target_read_btrace (&btrace, tinfo, BTRACE_READ_ALL);
  902.         }
  903.     }
  904.   else
  905.     errcode = target_read_btrace (&btrace, tinfo, BTRACE_READ_ALL);

  907.   /* If we were not able to read the branch trace, signal an error.  */
  908.   if (errcode != 0)
  909.     error (_("Failed to read branch trace."));

  911.   /* Compute the trace, provided we have any.  */
  912.   if (!VEC_empty (btrace_block_s, btrace))
  913.     {
  914.       btrace_clear_history (btinfo);
  915.       btrace_compute_ftrace (btinfo, btrace);
  916.     }

  918.   do_cleanups (cleanup);
  919. }

  921. /* See btrace.h.  */

  923. void
  924. ‌btrace_clear (struct thread_info *tp)
  925. {
  926.   struct btrace_thread_info *btinfo;
  927.   struct btrace_function *it, *trash;

  929.   DEBUG ("clear thread %d (%s)", tp->num, target_pid_to_str (tp->ptid));

  931.   /* Make sure btrace frames that may hold a pointer into the branch
  932.      trace data are destroyed.  */
  933.   reinit_frame_cache ();

  935.   btinfo = &tp->btrace;

  937.   it = btinfo->begin;
  938.   while (it != NULL)
  939.     {
  940.       trash = it;
  941.       it = it->flow.next;

  943.       xfree (trash);
  944.     }

  946.   btinfo->begin = NULL;
  947.   btinfo->end = NULL;

  949.   btrace_clear_history (btinfo);
  950. }

  952. /* See btrace.h.  */

  954. void
  955. ‌btrace_free_objfile (struct objfile *objfile)
  956. {
  957.   struct thread_info *tp;

  959.   DEBUG ("free objfile");

  961.   ALL_NON_EXITED_THREADS (tp)
  962.     btrace_clear (tp);
  963. }

  965. #if defined (HAVE_LIBEXPAT)

  967. /* Check the btrace document version.  */

  969. static void
  970. ‌check_xml_btrace_version (struct gdb_xml_parser *parser,
  971.                           const struct gdb_xml_element *element,
  972.                           void *user_data, VEC (gdb_xml_value_s) *attributes)
  973. {
  974.   const char *version = xml_find_attribute (attributes, "version")->value;

  976.   if (strcmp (version, "1.0") != 0)
  977.     gdb_xml_error (parser, _("Unsupported btrace version: \"%s\""), version);
  978. }

  980. /* Parse a btrace "block" xml record.  */

  982. static void
  983. ‌parse_xml_btrace_block (struct gdb_xml_parser *parser,
  984.                         const struct gdb_xml_element *element,
  985.                         void *user_data, VEC (gdb_xml_value_s) *attributes)
  986. {
  987.   VEC (btrace_block_s) **btrace;
  988.   struct btrace_block *block;
  989.   ULONGEST *begin, *end;

  991.   btrace = user_data;
  992.   block = VEC_safe_push (btrace_block_s, *btrace, NULL);

  994.   begin = xml_find_attribute (attributes, "begin")->value;
  995.   end = xml_find_attribute (attributes, "end")->value;

  997.   block->begin = *begin;
  998.   block->end = *end;
  999. }

  1001. ‌static const struct gdb_xml_attribute block_attributes[] = {
  1002.   { "begin", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
  1003.   { "end", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
  1004.   { NULL, GDB_XML_AF_NONE, NULL, NULL }
  1005. };

  1007. ‌static const struct gdb_xml_attribute btrace_attributes[] = {
  1008.   { "version", GDB_XML_AF_NONE, NULL, NULL },
  1009.   { NULL, GDB_XML_AF_NONE, NULL, NULL }
  1010. };

  1012. ‌static const struct gdb_xml_element btrace_children[] = {
  1013.   { "block", block_attributes, NULL,
  1014.     GDB_XML_EF_REPEATABLE | GDB_XML_EF_OPTIONAL, parse_xml_btrace_block, NULL },
  1015.   { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
  1016. };

  1018. ‌static const struct gdb_xml_element btrace_elements[] = {
  1019.   { "btrace", btrace_attributes, btrace_children, GDB_XML_EF_NONE,
  1020.     check_xml_btrace_version, NULL },
  1021.   { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
  1022. };

  1024. #endif /* defined (HAVE_LIBEXPAT) */

  1026. /* See btrace.h.  */

  1028. ‌VEC (btrace_block_s) *
  1029. parse_xml_btrace (const char *buffer)
  1030. {
  1031.   VEC (btrace_block_s) *btrace = NULL;
  1032.   struct cleanup *cleanup;
  1033.   int errcode;

  1035. #if defined (HAVE_LIBEXPAT)

  1037.   cleanup = make_cleanup (VEC_cleanup (btrace_block_s), &btrace);
  1038.   errcode = gdb_xml_parse_quick (_("btrace"), "btrace.dtd", btrace_elements,
  1039.                                  buffer, &btrace);
  1040.   if (errcode != 0)
  1041.     error (_("Error parsing branch trace."));

  1043.   /* Keep parse results.  */
  1044.   discard_cleanups (cleanup);

  1046. #else  /* !defined (HAVE_LIBEXPAT) */

  1048.   error (_("Cannot process branch trace.  XML parsing is not supported."));

  1050. #endif  /* !defined (HAVE_LIBEXPAT) */

  1052.   return btrace;
  1053. }

  1055. /* See btrace.h.  */

  1057. const struct btrace_insn *
  1058. ‌btrace_insn_get (const struct btrace_insn_iterator *it)
  1059. {
  1060.   const struct btrace_function *bfun;
  1061.   unsigned int index, end;

  1063.   index = it->index;
  1064.   bfun = it->function;

  1066.   /* The index is within the bounds of this function's instruction vector.  */
  1067.   end = VEC_length (btrace_insn_s, bfun->insn);
  1068.   gdb_assert (0 < end);
  1069.   gdb_assert (index < end);

  1071.   return VEC_index (btrace_insn_s, bfun->insn, index);
  1072. }

  1074. /* See btrace.h.  */

  1076. unsigned int
  1077. ‌btrace_insn_number (const struct btrace_insn_iterator *it)
  1078. {
  1079.   const struct btrace_function *bfun;

  1081.   bfun = it->function;
  1082.   return bfun->insn_offset + it->index;
  1083. }

  1085. /* See btrace.h.  */

  1087. void
  1088. ‌btrace_insn_begin (struct btrace_insn_iterator *it,
  1089.                    const struct btrace_thread_info *btinfo)
  1090. {
  1091.   const struct btrace_function *bfun;

  1093.   bfun = btinfo->begin;
  1094.   if (bfun == NULL)
  1095.     error (_("No trace."));

  1097.   it->function = bfun;
  1098.   it->index = 0;
  1099. }

  1101. /* See btrace.h.  */

  1103. void
  1104. ‌btrace_insn_end (struct btrace_insn_iterator *it,
  1105.                  const struct btrace_thread_info *btinfo)
  1106. {
  1107.   const struct btrace_function *bfun;
  1108.   unsigned int length;

  1110.   bfun = btinfo->end;
  1111.   if (bfun == NULL)
  1112.     error (_("No trace."));

  1114.   /* The last instruction in the last function is the current instruction.
  1115.      We point to it - it is one past the end of the execution trace.  */
  1116.   length = VEC_length (btrace_insn_s, bfun->insn);

  1118.   it->function = bfun;
  1119.   it->index = length - 1;
  1120. }

  1122. /* See btrace.h.  */

  1124. unsigned int
  1125. ‌btrace_insn_next (struct btrace_insn_iterator *it, unsigned int stride)
  1126. {
  1127.   const struct btrace_function *bfun;
  1128.   unsigned int index, steps;

  1130.   bfun = it->function;
  1131.   steps = 0;
  1132.   index = it->index;

  1134.   while (stride != 0)
  1135.     {
  1136.       unsigned int end, space, adv;

  1138.       end = VEC_length (btrace_insn_s, bfun->insn);

  1140.       gdb_assert (0 < end);
  1141.       gdb_assert (index < end);

  1143.       /* Compute the number of instructions remaining in this segment.  */
  1144.       space = end - index;

  1146.       /* Advance the iterator as far as possible within this segment.  */
  1147.       adv = min (space, stride);
  1148.       stride -= adv;
  1149.       index += adv;
  1150.       steps += adv;

  1152.       /* Move to the next function if we're at the end of this one.  */
  1153.       if (index == end)
  1154.         {
  1155.           const struct btrace_function *next;

  1157.           next = bfun->flow.next;
  1158.           if (next == NULL)
  1159.             {
  1160.               /* We stepped past the last function.

  1162.                  Let's adjust the index to point to the last instruction in
  1163.                  the previous function.  */
  1164.               index -= 1;
  1165.               steps -= 1;
  1166.               break;
  1167.             }

  1169.           /* We now point to the first instruction in the new function.  */
  1170.           bfun = next;
  1171.           index = 0;
  1172.         }

  1174.       /* We did make progress.  */
  1175.       gdb_assert (adv > 0);
  1176.     }

  1178.   /* Update the iterator.  */
  1179.   it->function = bfun;
  1180.   it->index = index;

  1182.   return steps;
  1183. }

  1185. /* See btrace.h.  */

  1187. unsigned int
  1188. ‌btrace_insn_prev (struct btrace_insn_iterator *it, unsigned int stride)
  1189. {
  1190.   const struct btrace_function *bfun;
  1191.   unsigned int index, steps;

  1193.   bfun = it->function;
  1194.   steps = 0;
  1195.   index = it->index;

  1197.   while (stride != 0)
  1198.     {
  1199.       unsigned int adv;

  1201.       /* Move to the previous function if we're at the start of this one.  */
  1202.       if (index == 0)
  1203.         {
  1204.           const struct btrace_function *prev;

  1206.           prev = bfun->flow.prev;
  1207.           if (prev == NULL)
  1208.             break;

  1210.           /* We point to one after the last instruction in the new function.  */
  1211.           bfun = prev;
  1212.           index = VEC_length (btrace_insn_s, bfun->insn);

  1214.           /* There is at least one instruction in this function segment.  */
  1215.           gdb_assert (index > 0);
  1216.         }

  1218.       /* Advance the iterator as far as possible within this segment.  */
  1219.       adv = min (index, stride);
  1220.       stride -= adv;
  1221.       index -= adv;
  1222.       steps += adv;

  1224.       /* We did make progress.  */
  1225.       gdb_assert (adv > 0);
  1226.     }

  1228.   /* Update the iterator.  */
  1229.   it->function = bfun;
  1230.   it->index = index;

  1232.   return steps;
  1233. }

  1235. /* See btrace.h.  */

  1237. int
  1238. ‌btrace_insn_cmp (const struct btrace_insn_iterator *lhs,
  1239.                  const struct btrace_insn_iterator *rhs)
  1240. {
  1241.   unsigned int lnum, rnum;

  1243.   lnum = btrace_insn_number (lhs);
  1244.   rnum = btrace_insn_number (rhs);

  1246.   return (int) (lnum - rnum);
  1247. }

  1249. /* See btrace.h.  */

  1251. int
  1252. ‌btrace_find_insn_by_number (struct btrace_insn_iterator *it,
  1253.                             const struct btrace_thread_info *btinfo,
  1254.                             unsigned int number)
  1255. {
  1256.   const struct btrace_function *bfun;
  1257.   unsigned int end;

  1259.   for (bfun = btinfo->end; bfun != NULL; bfun = bfun->flow.prev)
  1260.     if (bfun->insn_offset <= number)
  1261.       break;

  1263.   if (bfun == NULL)
  1264.     return 0;

  1266.   end = bfun->insn_offset + VEC_length (btrace_insn_s, bfun->insn);
  1267.   if (end <= number)
  1268.     return 0;

  1270.   it->function = bfun;
  1271.   it->index = number - bfun->insn_offset;

  1273.   return 1;
  1274. }

  1276. /* See btrace.h.  */

  1278. const struct btrace_function *
  1279. ‌btrace_call_get (const struct btrace_call_iterator *it)
  1280. {
  1281.   return it->function;
  1282. }

  1284. /* See btrace.h.  */

  1286. unsigned int
  1287. ‌btrace_call_number (const struct btrace_call_iterator *it)
  1288. {
  1289.   const struct btrace_thread_info *btinfo;
  1290.   const struct btrace_function *bfun;
  1291.   unsigned int insns;

  1293.   btinfo = it->btinfo;
  1294.   bfun = it->function;
  1295.   if (bfun != NULL)
  1296.     return bfun->number;

  1298.   /* For the end iterator, i.e. bfun == NULL, we return one more than the
  1299.      number of the last function.  */
  1300.   bfun = btinfo->end;
  1301.   insns = VEC_length (btrace_insn_s, bfun->insn);

  1303.   /* If the function contains only a single instruction (i.e. the current
  1304.      instruction), it will be skipped and its number is already the number
  1305.      we seek.  */
  1306.   if (insns == 1)
  1307.     return bfun->number;

  1309.   /* Otherwise, return one more than the number of the last function.  */
  1310.   return bfun->number + 1;
  1311. }

  1313. /* See btrace.h.  */

  1315. void
  1316. ‌btrace_call_begin (struct btrace_call_iterator *it,
  1317.                    const struct btrace_thread_info *btinfo)
  1318. {
  1319.   const struct btrace_function *bfun;

  1321.   bfun = btinfo->begin;
  1322.   if (bfun == NULL)
  1323.     error (_("No trace."));

  1325.   it->btinfo = btinfo;
  1326.   it->function = bfun;
  1327. }

  1329. /* See btrace.h.  */

  1331. void
  1332. ‌btrace_call_end (struct btrace_call_iterator *it,
  1333.                  const struct btrace_thread_info *btinfo)
  1334. {
  1335.   const struct btrace_function *bfun;

  1337.   bfun = btinfo->end;
  1338.   if (bfun == NULL)
  1339.     error (_("No trace."));

  1341.   it->btinfo = btinfo;
  1342.   it->function = NULL;
  1343. }

  1345. /* See btrace.h.  */

  1347. unsigned int
  1348. ‌btrace_call_next (struct btrace_call_iterator *it, unsigned int stride)
  1349. {
  1350.   const struct btrace_function *bfun;
  1351.   unsigned int steps;

  1353.   bfun = it->function;
  1354.   steps = 0;
  1355.   while (bfun != NULL)
  1356.     {
  1357.       const struct btrace_function *next;
  1358.       unsigned int insns;

  1360.       next = bfun->flow.next;
  1361.       if (next == NULL)
  1362.         {
  1363.           /* Ignore the last function if it only contains a single
  1364.              (i.e. the current) instruction.  */
  1365.           insns = VEC_length (btrace_insn_s, bfun->insn);
  1366.           if (insns == 1)
  1367.             steps -= 1;
  1368.         }

  1370.       if (stride == steps)
  1371.         break;

  1373.       bfun = next;
  1374.       steps += 1;
  1375.     }

  1377.   it->function = bfun;
  1378.   return steps;
  1379. }

  1381. /* See btrace.h.  */

  1383. unsigned int
  1384. ‌btrace_call_prev (struct btrace_call_iterator *it, unsigned int stride)
  1385. {
  1386.   const struct btrace_thread_info *btinfo;
  1387.   const struct btrace_function *bfun;
  1388.   unsigned int steps;

  1390.   bfun = it->function;
  1391.   steps = 0;

  1393.   if (bfun == NULL)
  1394.     {
  1395.       unsigned int insns;

  1397.       btinfo = it->btinfo;
  1398.       bfun = btinfo->end;
  1399.       if (bfun == NULL)
  1400.         return 0;

  1402.       /* Ignore the last function if it only contains a single
  1403.          (i.e. the current) instruction.  */
  1404.       insns = VEC_length (btrace_insn_s, bfun->insn);
  1405.       if (insns == 1)
  1406.         bfun = bfun->flow.prev;

  1408.       if (bfun == NULL)
  1409.         return 0;

  1411.       steps += 1;
  1412.     }

  1414.   while (steps < stride)
  1415.     {
  1416.       const struct btrace_function *prev;

  1418.       prev = bfun->flow.prev;
  1419.       if (prev == NULL)
  1420.         break;

  1422.       bfun = prev;
  1423.       steps += 1;
  1424.     }

  1426.   it->function = bfun;
  1427.   return steps;
  1428. }

  1430. /* See btrace.h.  */

  1432. int
  1433. ‌btrace_call_cmp (const struct btrace_call_iterator *lhs,
  1434.                  const struct btrace_call_iterator *rhs)
  1435. {
  1436.   unsigned int lnum, rnum;

  1438.   lnum = btrace_call_number (lhs);
  1439.   rnum = btrace_call_number (rhs);

  1441.   return (int) (lnum - rnum);
  1442. }

  1444. /* See btrace.h.  */

  1446. int
  1447. ‌btrace_find_call_by_number (struct btrace_call_iterator *it,
  1448.                             const struct btrace_thread_info *btinfo,
  1449.                             unsigned int number)
  1450. {
  1451.   const struct btrace_function *bfun;

  1453.   for (bfun = btinfo->end; bfun != NULL; bfun = bfun->flow.prev)
  1454.     {
  1455.       unsigned int bnum;

  1457.       bnum = bfun->number;
  1458.       if (number == bnum)
  1459.         {
  1460.           it->btinfo = btinfo;
  1461.           it->function = bfun;
  1462.           return 1;
  1463.         }

  1465.       /* Functions are ordered and numbered consecutively.  We could bail out
  1466.          earlier.  On the other hand, it is very unlikely that we search for
  1467.          a nonexistent function.  */
  1468.   }

  1470.   return 0;
  1471. }

  1473. /* See btrace.h.  */

  1475. void
  1476. ‌btrace_set_insn_history (struct btrace_thread_info *btinfo,
  1477.                          const struct btrace_insn_iterator *begin,
  1478.                          const struct btrace_insn_iterator *end)
  1479. {
  1480.   if (btinfo->insn_history == NULL)
  1481.     btinfo->insn_history = xzalloc (sizeof (*btinfo->insn_history));

  1483.   btinfo->insn_history->begin = *begin;
  1484.   btinfo->insn_history->end = *end;
  1485. }

  1487. /* See btrace.h.  */

  1489. void
  1490. ‌btrace_set_call_history (struct btrace_thread_info *btinfo,
  1491.                          const struct btrace_call_iterator *begin,
  1492.                          const struct btrace_call_iterator *end)
  1493. {
  1494.   gdb_assert (begin->btinfo == end->btinfo);

  1496.   if (btinfo->call_history == NULL)
  1497.     btinfo->call_history = xzalloc (sizeof (*btinfo->call_history));

  1499.   btinfo->call_history->begin = *begin;
  1500.   btinfo->call_history->end = *end;
  1501. }

  1503. /* See btrace.h.  */

  1505. int
  1506. ‌btrace_is_replaying (struct thread_info *tp)
  1507. {
  1508.   return tp->btrace.replay != NULL;
  1509. }

  1511. /* See btrace.h.  */

  1513. int
  1514. ‌btrace_is_empty (struct thread_info *tp)
  1515. {
  1516.   struct btrace_insn_iterator begin, end;
  1517.   struct btrace_thread_info *btinfo;

  1519.   btinfo = &tp->btrace;

  1521.   if (btinfo->begin == NULL)
  1522.     return 1;

  1524.   btrace_insn_begin (&begin, btinfo);
  1525.   btrace_insn_end (&end, btinfo);

  1527.   return btrace_insn_cmp (&begin, &end) == 0;
  1528. }