+2015-02-09 Markus Metzger <markus.t.metzger@intel.com>
+
+ * btrace.c (ftrace_find_call): Skip gaps.
+ (ftrace_new_function): Initialize level.
+ (ftrace_new_call, ftrace_new_tailcall, ftrace_new_return)
+ (ftrace_new_switch): Update
+ level computation.
+ (ftrace_new_gap): New.
+ (ftrace_update_function): Create new function after gap.
+ (btrace_compute_ftrace_bts): Create gap on error.
+ (btrace_stitch_bts): Update parameters. Clear trace if it
+ becomes empty.
+ (btrace_stitch_trace): Update parameters. Update callers.
+ (btrace_clear): Reset the number of gaps.
+ (btrace_insn_get): Return NULL if the iterator points to a gap.
+ (btrace_insn_number): Return zero if the iterator points to a gap.
+ (btrace_insn_end): Allow gaps at the end.
+ (btrace_insn_next, btrace_insn_prev, btrace_insn_cmp): Handle gaps.
+ (btrace_find_insn_by_number): Assert that the found iterator does
+ not point to a gap.
+ (btrace_call_next, btrace_call_prev): Assert that the last function
+ is not a gap.
+ * btrace.h (btrace_bts_error): New.
+ (btrace_function): Update comment.
+ (btrace_function) <insn, insn_offset, number>: Update comment.
+ (btrace_function) <errcode>: New.
+ (btrace_thread_info) <ngaps>: New.
+ (btrace_thread_info) <replay>: Update comment.
+ (btrace_insn_get): Update comment.
+ * record-btrace.c (btrace_ui_out_decode_error): New.
+ (record_btrace_info): Print number of gaps.
+ (btrace_insn_history, btrace_call_history): Call
+ btrace_ui_out_decode_error for gaps.
+ (record_btrace_step_thread, record_btrace_start_replaying): Skip gaps.
+
2015-02-09 Markus Metzger <markus.t.metzger@intel.com>
* common/btrace-common.h (btrace_cpu_vendor, btrace_cpu): New.
bfun->number = prev->number + 1;
bfun->insn_offset = (prev->insn_offset
+ VEC_length (btrace_insn_s, prev->insn));
+ bfun->level = prev->level;
}
return bfun;
bfun = ftrace_new_function (caller, mfun, fun);
bfun->up = caller;
- bfun->level = caller->level + 1;
+ bfun->level += 1;
ftrace_debug (bfun, "new call");
bfun = ftrace_new_function (caller, mfun, fun);
bfun->up = caller;
- bfun->level = caller->level + 1;
+ bfun->level += 1;
bfun->flags |= BFUN_UP_LINKS_TO_TAILCALL;
ftrace_debug (bfun, "new tail call");
{
struct btrace_insn *last;
- /* We do not allow empty function segments. */
- gdb_assert (!VEC_empty (btrace_insn_s, bfun->insn));
+ /* Skip gaps. */
+ if (bfun->errcode != 0)
+ continue;
last = VEC_last (btrace_insn_s, bfun->insn);
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;
}
+/* Add a new function segment for a gap in the trace due to a decode error.
+ PREV is the chronologically preceding function segment.
+ ERRCODE is the format-specific error code. */
+
+static struct btrace_function *
+ftrace_new_gap (struct btrace_function *prev, int errcode)
+{
+ struct btrace_function *bfun;
+
+ /* We hijack prev if it was empty. */
+ if (prev != NULL && prev->errcode == 0
+ && VEC_empty (btrace_insn_s, prev->insn))
+ bfun = prev;
+ else
+ bfun = ftrace_new_function (prev, NULL, NULL);
+
+ bfun->errcode = errcode;
+
+ ftrace_debug (bfun, "new gap");
+
+ 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. */
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)
+ /* If we didn't have a function or if we had a gap before, we create one. */
+ if (bfun == NULL || bfun->errcode != 0)
return ftrace_new_function (bfun, mfun, fun);
/* Check the last instruction, if we have one.
struct btrace_thread_info *btinfo;
struct btrace_function *begin, *end;
struct gdbarch *gdbarch;
- unsigned int blk;
+ unsigned int blk, ngaps;
int level;
gdbarch = target_gdbarch ();
btinfo = &tp->btrace;
begin = btinfo->begin;
end = btinfo->end;
+ ngaps = btinfo->ngaps;
level = begin != NULL ? -btinfo->level : INT_MAX;
blk = VEC_length (btrace_block_s, btrace->blocks);
/* 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));
+ /* Indicate the gap in the trace - unless we're at the
+ beginning. */
+ if (begin != NULL)
+ {
+ warning (_("Recorded trace may be corrupted around %s."),
+ core_addr_to_string_nz (pc));
+
+ end = ftrace_new_gap (end, BDE_BTS_OVERFLOW);
+ ngaps += 1;
+ }
break;
}
{
warning (_("Recorded trace may be incomplete around %s."),
core_addr_to_string_nz (pc));
+
+ /* Indicate the gap in the trace. We just added INSN so we're
+ not at the beginning. */
+ end = ftrace_new_gap (end, BDE_BTS_INSN_SIZE);
+ ngaps += 1;
+
break;
}
btinfo->begin = begin;
btinfo->end = end;
+ btinfo->ngaps = ngaps;
/* LEVEL is the minimal function level of all btrace function segments.
Define the global level offset to -LEVEL so all function levels are
/* Stitch branch trace in BTS format. */
static int
-btrace_stitch_bts (struct btrace_data_bts *btrace,
- const struct btrace_thread_info *btinfo)
+btrace_stitch_bts (struct btrace_data_bts *btrace, struct thread_info *tp)
{
+ struct btrace_thread_info *btinfo;
struct btrace_function *last_bfun;
struct btrace_insn *last_insn;
btrace_block_s *first_new_block;
+ btinfo = &tp->btrace;
last_bfun = btinfo->end;
gdb_assert (last_bfun != NULL);
+ gdb_assert (!VEC_empty (btrace_block_s, btrace->blocks));
+
+ /* If the existing trace ends with a gap, we just glue the traces
+ together. We need to drop the last (i.e. chronologically first) block
+ of the new trace, though, since we can't fill in the start address.*/
+ if (VEC_empty (btrace_insn_s, last_bfun->insn))
+ {
+ VEC_pop (btrace_block_s, btrace->blocks);
+ return 0;
+ }
/* 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. */
- gdb_assert (!VEC_empty (btrace_block_s, btrace->blocks));
first_new_block = VEC_last (btrace_block_s, btrace->blocks);
last_insn = VEC_last (btrace_insn_s, last_bfun->insn);
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. */
+
+ /* The only case where this would hurt is if the entire trace consisted
+ of just that one instruction. If we remove it, we might turn the now
+ empty btrace function segment into a gap. But we don't want gaps at
+ the beginning. To avoid this, we remove the entire old trace. */
+ if (last_bfun == btinfo->begin && VEC_empty (btrace_insn_s, last_bfun->insn))
+ btrace_clear (tp);
+
return 0;
}
/* 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 modifx BTRACE as well as the existing trace in BTINFO.
+ TP is the traced thread.
+ May modifx BTRACE as well as the existing trace in TP.
Return 0 on success, -1 otherwise. */
static int
-btrace_stitch_trace (struct btrace_data *btrace,
- const struct btrace_thread_info *btinfo)
+btrace_stitch_trace (struct btrace_data *btrace, struct thread_info *tp)
{
/* If we don't have trace, there's nothing to do. */
if (btrace_data_empty (btrace))
return 0;
case BTRACE_FORMAT_BTS:
- return btrace_stitch_bts (&btrace->variant.bts, btinfo);
+ return btrace_stitch_bts (&btrace->variant.bts, tp);
}
internal_error (__FILE__, __LINE__, _("Unkown branch trace format."));
if (errcode == 0)
{
/* Success. Let's try to stitch the traces together. */
- errcode = btrace_stitch_trace (&btrace, btinfo);
+ errcode = btrace_stitch_trace (&btrace, tp);
}
else
{
btinfo->begin = NULL;
btinfo->end = NULL;
+ btinfo->ngaps = 0;
btrace_clear_history (btinfo);
}
index = it->index;
bfun = it->function;
+ /* Check if the iterator points to a gap in the trace. */
+ if (bfun->errcode != 0)
+ return NULL;
+
/* The index is within the bounds of this function's instruction vector. */
end = VEC_length (btrace_insn_s, bfun->insn);
gdb_assert (0 < end);
const struct btrace_function *bfun;
bfun = it->function;
+
+ /* Return zero if the iterator points to a gap in the trace. */
+ if (bfun->errcode != 0)
+ return 0;
+
return bfun->insn_offset + it->index;
}
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);
+ /* The last function may either be a gap or it contains the current
+ instruction, which is one past the end of the execution trace; ignore
+ it. */
+ if (length > 0)
+ length -= 1;
+
it->function = bfun;
- it->index = length - 1;
+ it->index = length;
}
/* See btrace.h. */
end = VEC_length (btrace_insn_s, bfun->insn);
+ /* An empty function segment represents a gap in the trace. We count
+ it as one instruction. */
+ if (end == 0)
+ {
+ const struct btrace_function *next;
+
+ next = bfun->flow.next;
+ if (next == NULL)
+ break;
+
+ stride -= 1;
+ steps += 1;
+
+ bfun = next;
+ index = 0;
+
+ continue;
+ }
+
gdb_assert (0 < end);
gdb_assert (index < end);
bfun = prev;
index = VEC_length (btrace_insn_s, bfun->insn);
- /* There is at least one instruction in this function segment. */
- gdb_assert (index > 0);
+ /* An empty function segment represents a gap in the trace. We count
+ it as one instruction. */
+ if (index == 0)
+ {
+ stride -= 1;
+ steps += 1;
+
+ continue;
+ }
}
/* Advance the iterator as far as possible within this segment. */
adv = min (index, stride);
+
stride -= adv;
index -= adv;
steps += adv;
lnum = btrace_insn_number (lhs);
rnum = btrace_insn_number (rhs);
+ /* A gap has an instruction number of zero. Things are getting more
+ complicated if gaps are involved.
+
+ We take the instruction number offset from the iterator's function.
+ This is the number of the first instruction after the gap.
+
+ This is OK as long as both lhs and rhs point to gaps. If only one of
+ them does, we need to adjust the number based on the other's regular
+ instruction number. Otherwise, a gap might compare equal to an
+ instruction. */
+
+ if (lnum == 0 && rnum == 0)
+ {
+ lnum = lhs->function->insn_offset;
+ rnum = rhs->function->insn_offset;
+ }
+ else if (lnum == 0)
+ {
+ lnum = lhs->function->insn_offset;
+
+ if (lnum == rnum)
+ lnum -= 1;
+ }
+ else if (rnum == 0)
+ {
+ rnum = rhs->function->insn_offset;
+
+ if (rnum == lnum)
+ rnum -= 1;
+ }
+
return (int) (lnum - rnum);
}
unsigned int number)
{
const struct btrace_function *bfun;
- unsigned int end;
+ unsigned int end, length;
for (bfun = btinfo->end; bfun != NULL; bfun = bfun->flow.prev)
- if (bfun->insn_offset <= number)
- break;
+ {
+ /* Skip gaps. */
+ if (bfun->errcode != 0)
+ continue;
+
+ if (bfun->insn_offset <= number)
+ break;
+ }
if (bfun == NULL)
return 0;
- end = bfun->insn_offset + VEC_length (btrace_insn_s, bfun->insn);
+ length = VEC_length (btrace_insn_s, bfun->insn);
+ gdb_assert (length > 0);
+
+ end = bfun->insn_offset + length;
if (end <= number)
return 0;
BFUN_UP_LINKS_TO_TAILCALL = (1 << 1)
};
+/* Decode errors for the BTS recording format. */
+enum btrace_bts_error
+{
+ /* The instruction trace overflowed the end of the trace block. */
+ BDE_BTS_OVERFLOW = 1,
+
+ /* The instruction size could not be determined. */
+ BDE_BTS_INSN_SIZE
+};
+
/* A branch trace function segment.
This represents a function segment in a branch trace, i.e. a consecutive
number of instructions belonging to the same function.
- We do not allow function segments without any instructions. */
+ In case of decode errors, we add an empty function segment to indicate
+ the gap in the trace.
+
+ We do not allow function segments without instructions otherwise. */
struct btrace_function
{
/* The full and minimal symbol for the function. Both may be NULL. */
struct btrace_function *up;
/* The instructions in this function segment.
- The instruction vector will never be empty. */
+ The instruction vector will be empty if the function segment
+ represents a decode error. */
VEC (btrace_insn_s) *insn;
+ /* The error code of a decode error that led to a gap.
+ Must be zero unless INSN is empty; non-zero otherwise. */
+ int errcode;
+
/* The instruction number offset for the first instruction in this
- function segment. */
+ function segment.
+ If INSN is empty this is the insn_offset of the succeding function
+ segment in control-flow order. */
unsigned int insn_offset;
- /* The function number in control-flow order. */
+ /* The function number in control-flow order.
+ If INSN is empty indicating a gap in the trace due to a decode error,
+ we still count the gap as a function. */
unsigned int number;
/* The function level in a back trace across the entire branch trace.
becomes zero. */
int level;
+ /* The number of gaps in the trace. */
+ unsigned int ngaps;
+
/* A bit-vector of btrace_thread_flag. */
enum btrace_thread_flag flags;
/* The function call history iterator. */
struct btrace_call_history *call_history;
- /* The current replay position. NULL if not replaying. */
+ /* The current replay position. NULL if not replaying.
+ Gaps are skipped during replay, so REPLAY always points to a valid
+ instruction. */
struct btrace_insn_iterator *replay;
};
extern void parse_xml_btrace_conf (struct btrace_config *conf, const char *xml);
/* Dereference a branch trace instruction iterator. Return a pointer to the
- instruction the iterator points to. */
+ instruction the iterator points to.
+ May return NULL if the iterator points to a gap in the trace. */
extern const struct btrace_insn *
btrace_insn_get (const struct btrace_insn_iterator *);
struct btrace_thread_info *btinfo;
const struct btrace_config *conf;
struct thread_info *tp;
- unsigned int insns, calls;
+ unsigned int insns, calls, gaps;
DEBUG ("info");
insns = 0;
calls = 0;
+ gaps = 0;
if (!btrace_is_empty (tp))
{
calls = btrace_call_number (&call);
btrace_insn_end (&insn, btinfo);
- btrace_insn_prev (&insn, 1);
+
insns = btrace_insn_number (&insn);
+ if (insns != 0)
+ {
+ /* The last instruction does not really belong to the trace. */
+ insns -= 1;
+ }
+ else
+ {
+ unsigned int steps;
+
+ /* Skip gaps at the end. */
+ do
+ {
+ steps = btrace_insn_prev (&insn, 1);
+ if (steps == 0)
+ break;
+
+ insns = btrace_insn_number (&insn);
+ }
+ while (insns == 0);
+ }
+
+ gaps = btinfo->ngaps;
}
- printf_unfiltered (_("Recorded %u instructions in %u functions for thread "
- "%d (%s).\n"), insns, calls, tp->num,
- target_pid_to_str (tp->ptid));
+ printf_unfiltered (_("Recorded %u instructions in %u functions (%u gaps) "
+ "for thread %d (%s).\n"), insns, calls, gaps,
+ tp->num, target_pid_to_str (tp->ptid));
if (btrace_is_replaying (tp))
printf_unfiltered (_("Replay in progress. At instruction %u.\n"),
btrace_insn_number (btinfo->replay));
}
+/* Print a decode error. */
+
+static void
+btrace_ui_out_decode_error (struct ui_out *uiout, int errcode,
+ enum btrace_format format)
+{
+ const char *errstr;
+ int is_error;
+
+ errstr = _("unknown");
+ is_error = 1;
+
+ switch (format)
+ {
+ default:
+ break;
+
+ case BTRACE_FORMAT_BTS:
+ switch (errcode)
+ {
+ default:
+ break;
+
+ case BDE_BTS_OVERFLOW:
+ errstr = _("instruction overflow");
+ break;
+
+ case BDE_BTS_INSN_SIZE:
+ errstr = _("unknown instruction");
+ break;
+ }
+ break;
+ }
+
+ ui_out_text (uiout, _("["));
+ if (is_error)
+ {
+ ui_out_text (uiout, _("decode error ("));
+ ui_out_field_int (uiout, "errcode", errcode);
+ ui_out_text (uiout, _("): "));
+ }
+ ui_out_text (uiout, errstr);
+ ui_out_text (uiout, _("]\n"));
+}
+
/* Print an unsigned int. */
static void
static void
btrace_insn_history (struct ui_out *uiout,
+ const struct btrace_thread_info *btinfo,
const struct btrace_insn_iterator *begin,
const struct btrace_insn_iterator *end, int flags)
{
insn = btrace_insn_get (&it);
- /* Print the instruction index. */
- ui_out_field_uint (uiout, "index", btrace_insn_number (&it));
- ui_out_text (uiout, "\t");
+ /* A NULL instruction indicates a gap in the trace. */
+ if (insn == NULL)
+ {
+ const struct btrace_config *conf;
+
+ conf = btrace_conf (btinfo);
- /* Disassembly with '/m' flag may not produce the expected result.
- See PR gdb/11833. */
- gdb_disassembly (gdbarch, uiout, NULL, flags, 1, insn->pc, insn->pc + 1);
+ /* We have trace so we must have a configuration. */
+ gdb_assert (conf != NULL);
+
+ btrace_ui_out_decode_error (uiout, it.function->errcode,
+ conf->format);
+ }
+ else
+ {
+ /* Print the instruction index. */
+ ui_out_field_uint (uiout, "index", btrace_insn_number (&it));
+ ui_out_text (uiout, "\t");
+
+ /* Disassembly with '/m' flag may not produce the expected result.
+ See PR gdb/11833. */
+ gdb_disassembly (gdbarch, uiout, NULL, flags, 1, insn->pc,
+ insn->pc + 1);
+ }
}
}
}
if (covered > 0)
- btrace_insn_history (uiout, &begin, &end, flags);
+ btrace_insn_history (uiout, btinfo, &begin, &end, flags);
else
{
if (size < 0)
btrace_insn_next (&end, 1);
}
- btrace_insn_history (uiout, &begin, &end, flags);
+ btrace_insn_history (uiout, btinfo, &begin, &end, flags);
btrace_set_insn_history (btinfo, &begin, &end);
do_cleanups (uiout_cleanup);
ui_out_field_uint (uiout, "index", bfun->number);
ui_out_text (uiout, "\t");
+ /* Indicate gaps in the trace. */
+ if (bfun->errcode != 0)
+ {
+ const struct btrace_config *conf;
+
+ conf = btrace_conf (btinfo);
+
+ /* We have trace so we must have a configuration. */
+ gdb_assert (conf != NULL);
+
+ btrace_ui_out_decode_error (uiout, bfun->errcode, conf->format);
+
+ continue;
+ }
+
if ((flags & RECORD_PRINT_INDENT_CALLS) != 0)
{
int level = bfun->level + btinfo->level, i;
replay = xmalloc (sizeof (*replay));
btrace_insn_end (replay, btinfo);
+ /* Skip gaps at the end of the trace. */
+ while (btrace_insn_get (replay) == NULL)
+ {
+ unsigned int steps;
+
+ steps = btrace_insn_prev (replay, 1);
+ if (steps == 0)
+ error (_("No trace."));
+ }
+
/* We're not replaying, yet. */
gdb_assert (btinfo->replay == NULL);
btinfo->replay = replay;
if (replay == NULL)
return btrace_step_no_history ();
- /* We are always able to step at least once. */
- steps = btrace_insn_next (replay, 1);
- gdb_assert (steps == 1);
+ /* Skip gaps during replay. */
+ do
+ {
+ steps = btrace_insn_next (replay, 1);
+ if (steps == 0)
+ {
+ record_btrace_stop_replaying (tp);
+ return btrace_step_no_history ();
+ }
+ }
+ while (btrace_insn_get (replay) == NULL);
/* Determine the end of the instruction trace. */
btrace_insn_end (&end, btinfo);
if (replay == NULL)
replay = record_btrace_start_replaying (tp);
- /* If we can't step any further, we reached the end of the history. */
- steps = btrace_insn_prev (replay, 1);
- if (steps == 0)
- return btrace_step_no_history ();
+ /* If we can't step any further, we reached the end of the history.
+ Skip gaps during replay. */
+ do
+ {
+ steps = btrace_insn_prev (replay, 1);
+ if (steps == 0)
+ return btrace_step_no_history ();
+
+ }
+ while (btrace_insn_get (replay) == NULL);
return btrace_step_stopped ();
{
const struct btrace_insn *insn;
- /* We are always able to step at least once. */
- steps = btrace_insn_next (replay, 1);
- gdb_assert (steps == 1);
+ /* Skip gaps during replay. */
+ do
+ {
+ steps = btrace_insn_next (replay, 1);
+ if (steps == 0)
+ {
+ record_btrace_stop_replaying (tp);
+ return btrace_step_no_history ();
+ }
+
+ insn = btrace_insn_get (replay);
+ }
+ while (insn == NULL);
/* We stop replaying if we reached the end of the trace. */
if (btrace_insn_cmp (replay, &end) == 0)
return btrace_step_no_history ();
}
- insn = btrace_insn_get (replay);
- gdb_assert (insn);
-
DEBUG ("stepping %d (%s) ... %s", tp->num,
target_pid_to_str (tp->ptid),
core_addr_to_string_nz (insn->pc));
{
const struct btrace_insn *insn;
- /* If we can't step any further, we're done. */
- steps = btrace_insn_prev (replay, 1);
- if (steps == 0)
- return btrace_step_no_history ();
+ /* If we can't step any further, we reached the end of the history.
+ Skip gaps during replay. */
+ do
+ {
+ steps = btrace_insn_prev (replay, 1);
+ if (steps == 0)
+ return btrace_step_no_history ();
- insn = btrace_insn_get (replay);
- gdb_assert (insn);
+ insn = btrace_insn_get (replay);
+ }
+ while (insn == NULL);
DEBUG ("reverse-stepping %d (%s) ... %s", tp->num,
target_pid_to_str (tp->ptid),
+2015-02-09 Markus Metzger <markus.t.metzger@intel.com>
+
+ * gdb.btrace/buffer-size.exp: Update "info record" output.
+ * gdb.btrace/delta.exp: Update "info record" output.
+ * gdb.btrace/enable.exp: Update "info record" output.
+ * gdb.btrace/finish.exp: Update "info record" output.
+ * gdb.btrace/instruction_history.exp: Update "info record" output.
+ * gdb.btrace/next.exp: Update "info record" output.
+ * gdb.btrace/nexti.exp: Update "info record" output.
+ * gdb.btrace/step.exp: Update "info record" output.
+ * gdb.btrace/stepi.exp: Update "info record" output.
+ * gdb.btrace/nohist.exp: Update "info record" output.
+
2015-02-09 Markus Metzger <markus.t.metzger@intel.com>
* gdb.btrace/buffer-size: New.
"Active record target: record-btrace" \
"Recording format: Branch Trace Store\." \
"Buffer size: 4kB\." \
- "Recorded 0 instructions in 0 functions for \[^\\\r\\\n\]*" \
+ "Recorded 0 instructions in 0 functions \\\(0 gaps\\\) for \[^\\\r\\\n\]*" \
] "\r\n"] "info record with small bts buffer"
gdb_test "record stop" ".*" "stop recording with small bts buffer"
"Active record target: record-btrace" \
"Recording format: Branch Trace Store\." \
"Buffer size: .*\." \
- "Recorded 0 instructions in 0 functions for \[^\\\r\\\n\]*" \
+ "Recorded 0 instructions in 0 functions \\\(0 gaps\\\) for \[^\\\r\\\n\]*" \
] "\r\n"] "info record with unlimited bts buffer"
gdb_test "record stop" ".*" "stop recording with unlimited bts buffer"
gdb_test "info record" [join [list \
"Active record target: record-btrace" \
"Recording format: .*" \
- "Recorded 0 instructions in 0 functions for .*" \
+ "Recorded 0 instructions in 0 functions \\\(0 gaps\\\) for .*" \
] "\r\n"]
gdb_test "record instruction-history" "No trace\."
gdb_test "record function-call-history" "No trace\."
gdb_test "info record" [join [list \
"Active record target: record-btrace" \
"Recording format: .*" \
- "Recorded 1 instructions in 1 functions for .*" \
+ "Recorded 1 instructions in 1 functions \\\(0 gaps\\\) for .*" \
] "\r\n"]
gdb_test "record instruction-history /f 1" \
"1\t 0x\[0-9a-f\]+ <\\+\[0-9\]+>:\tmov *\\\$0x0,%eax\r"
gdb_test "info record" [join [list \
"Active record target: record-btrace" \
"Recording format: .*" \
- "Recorded 1 instructions in 1 functions for .*" \
+ "Recorded 1 instructions in 1 functions \\\(0 gaps\\\) for .*" \
"Replay in progress\. At instruction 1\." \
] "\r\n"] "reverse-stepi"
gdb_test "info record" [join [list \
"Active record target: record-btrace" \
"Recording format: .*" \
- "Recorded 1 instructions in 1 functions for .*" \
+ "Recorded 1 instructions in 1 functions \\\(0 gaps\\\) for .*" \
] "\r\n"] "and back"
# no trace recorded yet
gdb_test "info record" "Active record target: record-btrace\r
.*\r
-Recorded 0 instructions in 0 functions for thread 1.*\\." "info record without trace"
+Recorded 0 instructions in 0 functions \\\(0 gaps\\\) for thread 1.*\\." "info record without trace"
# stop btrace record
gdb_test "record stop" "Process record is stopped and all execution logs are deleted\\." "record stop"
gdb_test "info record" [join [list \
"Active record target: record-btrace" \
"Recording format: .*" \
- "Recorded 40 instructions in 16 functions for .*" \
+ "Recorded 40 instructions in 16 functions \\\(0 gaps\\\) for .*" \
"Replay in progress\. At instruction $insn\." \
] "\r\n"]
}
set traced {}
set testname "determine number of recorded instructions"
gdb_test_multiple "info record" $testname {
- -re "Active record target: record-btrace\r\n.*\r\nRecorded \(\[0-9\]*\) instructions in \(\[0-9\]*\) functions for thread 1 .*\\.\r\n$gdb_prompt $" {
+ -re "Active record target: record-btrace\r\n.*\r\nRecorded \(\[0-9\]*\) instructions in \(\[0-9\]*\) functions \\\(0 gaps\\\) for thread 1 .*\\.\r\n$gdb_prompt $" {
set traced $expect_out(1,string)
pass $testname
}
gdb_test "info record" [join [list \
"Active record target: record-btrace" \
"Recording format: .*" \
- "Recorded 40 instructions in 16 functions for .*" \
+ "Recorded 40 instructions in 16 functions \\\(0 gaps\\\) for .*" \
"Replay in progress\. At instruction $insn\." \
] "\r\n"]
}
gdb_test "info record" [join [list \
"Active record target: record-btrace" \
"Recording format: .*" \
- "Recorded 40 instructions in 16 functions for \[^\\\r\\\n\]*" \
+ "Recorded 40 instructions in 16 functions \\\(0 gaps\\\) for \[^\\\r\\\n\]*" \
] "\r\n"] "next back"
# let's go somewhere where we can step some more
gdb_test "info record" [join [list \
"Active record target: record-btrace" \
"Recording format: .*" \
- "Recorded 40 instructions in 16 functions for .*" \
+ "Recorded 40 instructions in 16 functions \\\(0 gaps\\\) for .*" \
"Replay in progress\. At instruction $insn\." \
] "\r\n"]
}
gdb_test "info record" [join [list \
"Active record target: record-btrace" \
"Recording format: .*" \
- "Recorded 40 instructions in 16 functions for \[^\\\r\\\n\]*" \
+ "Recorded 40 instructions in 16 functions \\\(0 gaps\\\) for \[^\\\r\\\n\]*" \
] "\r\n"] "nexti back"
# let's go somewhere where we can step some more
gdb_test "info record" [join [list \
"Active record target: record-btrace" \
"Recording format: .*" \
- "Recorded 0 instructions in 0 functions for \[^\\\r\\\n\]*" \
+ "Recorded 0 instructions in 0 functions \\\(0 gaps\\\) for \[^\\\r\\\n\]*" \
] "\r\n"]
}
gdb_test "info record" [join [list \
"Active record target: record-btrace" \
"Recording format: .*" \
- "Recorded 40 instructions in 16 functions for .*" \
+ "Recorded 40 instructions in 16 functions \\\(0 gaps\\\) for .*" \
"Replay in progress\. At instruction $insn\." \
] "\r\n"]
}
gdb_test "info record" [join [list \
"Active record target: record-btrace" \
"Recording format: .*" \
- "Recorded 40 instructions in 16 functions for \[^\\\r\\\n\]*" \
+ "Recorded 40 instructions in 16 functions \\\(0 gaps\\\) for \[^\\\r\\\n\]*" \
] "\r\n"] "step to live"
gdb_test "info record" [join [list \
"Active record target: record-btrace" \
"Recording format: .*" \
- "Recorded 40 instructions in 16 functions for .*" \
+ "Recorded 40 instructions in 16 functions \\\(0 gaps\\\) for .*" \
"Replay in progress\. At instruction $insn\." \
] "\r\n"]
}
gdb_test "info record" [join [list \
"Active record target: record-btrace" \
"Recording format: .*" \
- "Recorded 40 instructions in 16 functions for \[^\\\r\\\n\]*" \
+ "Recorded 40 instructions in 16 functions \\\(0 gaps\\\) for \[^\\\r\\\n\]*" \
] "\r\n"] "stepi to live"
# let's step from a goto position somewhere in the middle
projects / deliverable / binutils-gdb.git / commitdiff
