1 /* Branch trace support for GDB, the GNU debugger.
3 Copyright (C) 2013-2017 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/>. */
24 #include "gdbthread.h"
31 #include "filenames.h"
32 #include "xml-support.h"
36 #include "cli/cli-utils.h"
42 /* Command lists for btrace maintenance commands. */
43 static struct cmd_list_element
*maint_btrace_cmdlist
;
44 static struct cmd_list_element
*maint_btrace_set_cmdlist
;
45 static struct cmd_list_element
*maint_btrace_show_cmdlist
;
46 static struct cmd_list_element
*maint_btrace_pt_set_cmdlist
;
47 static struct cmd_list_element
*maint_btrace_pt_show_cmdlist
;
49 /* Control whether to skip PAD packets when computing the packet history. */
50 static int maint_btrace_pt_skip_pad
= 1;
52 static void btrace_add_pc (struct thread_info
*tp
);
54 /* Print a record debug message. Use do ... while (0) to avoid ambiguities
55 when used in if statements. */
57 #define DEBUG(msg, args...) \
60 if (record_debug != 0) \
61 fprintf_unfiltered (gdb_stdlog, \
62 "[btrace] " msg "\n", ##args); \
66 #define DEBUG_FTRACE(msg, args...) DEBUG ("[ftrace] " msg, ##args)
68 /* Return the function name of a recorded function segment for printing.
69 This function never returns NULL. */
72 ftrace_print_function_name (const struct btrace_function
*bfun
)
74 struct minimal_symbol
*msym
;
81 return SYMBOL_PRINT_NAME (sym
);
84 return MSYMBOL_PRINT_NAME (msym
);
89 /* Return the file name of a recorded function segment for printing.
90 This function never returns NULL. */
93 ftrace_print_filename (const struct btrace_function
*bfun
)
101 filename
= symtab_to_filename_for_display (symbol_symtab (sym
));
103 filename
= "<unknown>";
108 /* Return a string representation of the address of an instruction.
109 This function never returns NULL. */
112 ftrace_print_insn_addr (const struct btrace_insn
*insn
)
117 return core_addr_to_string_nz (insn
->pc
);
120 /* Print an ftrace debug status message. */
123 ftrace_debug (const struct btrace_function
*bfun
, const char *prefix
)
125 const char *fun
, *file
;
126 unsigned int ibegin
, iend
;
129 fun
= ftrace_print_function_name (bfun
);
130 file
= ftrace_print_filename (bfun
);
133 ibegin
= bfun
->insn_offset
;
134 iend
= ibegin
+ bfun
->insn
.size ();
136 DEBUG_FTRACE ("%s: fun = %s, file = %s, level = %d, insn = [%u; %u)",
137 prefix
, fun
, file
, level
, ibegin
, iend
);
140 /* Return the number of instructions in a given function call segment. */
143 ftrace_call_num_insn (const struct btrace_function
* bfun
)
148 /* A gap is always counted as one instruction. */
149 if (bfun
->errcode
!= 0)
152 return bfun
->insn
.size ();
155 /* Return the function segment with the given NUMBER or NULL if no such segment
156 exists. BTINFO is the branch trace information for the current thread. */
158 static struct btrace_function
*
159 ftrace_find_call_by_number (struct btrace_thread_info
*btinfo
,
162 if (number
== 0 || number
> btinfo
->functions
.size ())
165 return &btinfo
->functions
[number
- 1];
168 /* A const version of the function above. */
170 static const struct btrace_function
*
171 ftrace_find_call_by_number (const struct btrace_thread_info
*btinfo
,
174 if (number
== 0 || number
> btinfo
->functions
.size ())
177 return &btinfo
->functions
[number
- 1];
180 /* Return non-zero if BFUN does not match MFUN and FUN,
181 return zero otherwise. */
184 ftrace_function_switched (const struct btrace_function
*bfun
,
185 const struct minimal_symbol
*mfun
,
186 const struct symbol
*fun
)
188 struct minimal_symbol
*msym
;
194 /* If the minimal symbol changed, we certainly switched functions. */
195 if (mfun
!= NULL
&& msym
!= NULL
196 && strcmp (MSYMBOL_LINKAGE_NAME (mfun
), MSYMBOL_LINKAGE_NAME (msym
)) != 0)
199 /* If the symbol changed, we certainly switched functions. */
200 if (fun
!= NULL
&& sym
!= NULL
)
202 const char *bfname
, *fname
;
204 /* Check the function name. */
205 if (strcmp (SYMBOL_LINKAGE_NAME (fun
), SYMBOL_LINKAGE_NAME (sym
)) != 0)
208 /* Check the location of those functions, as well. */
209 bfname
= symtab_to_fullname (symbol_symtab (sym
));
210 fname
= symtab_to_fullname (symbol_symtab (fun
));
211 if (filename_cmp (fname
, bfname
) != 0)
215 /* If we lost symbol information, we switched functions. */
216 if (!(msym
== NULL
&& sym
== NULL
) && mfun
== NULL
&& fun
== NULL
)
219 /* If we gained symbol information, we switched functions. */
220 if (msym
== NULL
&& sym
== NULL
&& !(mfun
== NULL
&& fun
== NULL
))
226 /* Allocate and initialize a new branch trace function segment at the end of
228 BTINFO is the branch trace information for the current thread.
229 MFUN and FUN are the symbol information we have for this function.
230 This invalidates all struct btrace_function pointer currently held. */
232 static struct btrace_function
*
233 ftrace_new_function (struct btrace_thread_info
*btinfo
,
234 struct minimal_symbol
*mfun
,
238 unsigned int number
, insn_offset
;
240 if (btinfo
->functions
.empty ())
242 /* Start counting NUMBER and INSN_OFFSET at one. */
249 const struct btrace_function
*prev
= &btinfo
->functions
.back ();
251 number
= prev
->number
+ 1;
252 insn_offset
= prev
->insn_offset
+ ftrace_call_num_insn (prev
);
255 btinfo
->functions
.emplace_back (mfun
, fun
, number
, insn_offset
, level
);
256 return &btinfo
->functions
.back ();
259 /* Update the UP field of a function segment. */
262 ftrace_update_caller (struct btrace_function
*bfun
,
263 struct btrace_function
*caller
,
264 enum btrace_function_flag flags
)
267 ftrace_debug (bfun
, "updating caller");
269 bfun
->up
= caller
->number
;
272 ftrace_debug (bfun
, "set caller");
273 ftrace_debug (caller
, "..to");
276 /* Fix up the caller for all segments of a function. */
279 ftrace_fixup_caller (struct btrace_thread_info
*btinfo
,
280 struct btrace_function
*bfun
,
281 struct btrace_function
*caller
,
282 enum btrace_function_flag flags
)
284 unsigned int prev
, next
;
288 ftrace_update_caller (bfun
, caller
, flags
);
290 /* Update all function segments belonging to the same function. */
291 for (; prev
!= 0; prev
= bfun
->prev
)
293 bfun
= ftrace_find_call_by_number (btinfo
, prev
);
294 ftrace_update_caller (bfun
, caller
, flags
);
297 for (; next
!= 0; next
= bfun
->next
)
299 bfun
= ftrace_find_call_by_number (btinfo
, next
);
300 ftrace_update_caller (bfun
, caller
, flags
);
304 /* Add a new function segment for a call at the end of the trace.
305 BTINFO is the branch trace information for the current thread.
306 MFUN and FUN are the symbol information we have for this function. */
308 static struct btrace_function
*
309 ftrace_new_call (struct btrace_thread_info
*btinfo
,
310 struct minimal_symbol
*mfun
,
313 const unsigned int length
= btinfo
->functions
.size ();
314 struct btrace_function
*bfun
= ftrace_new_function (btinfo
, mfun
, fun
);
319 ftrace_debug (bfun
, "new call");
324 /* Add a new function segment for a tail call at the end of the trace.
325 BTINFO is the branch trace information for the current thread.
326 MFUN and FUN are the symbol information we have for this function. */
328 static struct btrace_function
*
329 ftrace_new_tailcall (struct btrace_thread_info
*btinfo
,
330 struct minimal_symbol
*mfun
,
333 const unsigned int length
= btinfo
->functions
.size ();
334 struct btrace_function
*bfun
= ftrace_new_function (btinfo
, mfun
, fun
);
338 bfun
->flags
|= BFUN_UP_LINKS_TO_TAILCALL
;
340 ftrace_debug (bfun
, "new tail call");
345 /* Return the caller of BFUN or NULL if there is none. This function skips
346 tail calls in the call chain. BTINFO is the branch trace information for
347 the current thread. */
348 static struct btrace_function
*
349 ftrace_get_caller (struct btrace_thread_info
*btinfo
,
350 struct btrace_function
*bfun
)
352 for (; bfun
!= NULL
; bfun
= ftrace_find_call_by_number (btinfo
, bfun
->up
))
353 if ((bfun
->flags
& BFUN_UP_LINKS_TO_TAILCALL
) == 0)
354 return ftrace_find_call_by_number (btinfo
, bfun
->up
);
359 /* Find the innermost caller in the back trace of BFUN with MFUN/FUN
360 symbol information. BTINFO is the branch trace information for the current
363 static struct btrace_function
*
364 ftrace_find_caller (struct btrace_thread_info
*btinfo
,
365 struct btrace_function
*bfun
,
366 struct minimal_symbol
*mfun
,
369 for (; bfun
!= NULL
; bfun
= ftrace_find_call_by_number (btinfo
, bfun
->up
))
371 /* Skip functions with incompatible symbol information. */
372 if (ftrace_function_switched (bfun
, mfun
, fun
))
375 /* This is the function segment we're looking for. */
382 /* Find the innermost caller in the back trace of BFUN, skipping all
383 function segments that do not end with a call instruction (e.g.
384 tail calls ending with a jump). BTINFO is the branch trace information for
385 the current thread. */
387 static struct btrace_function
*
388 ftrace_find_call (struct btrace_thread_info
*btinfo
,
389 struct btrace_function
*bfun
)
391 for (; bfun
!= NULL
; bfun
= ftrace_find_call_by_number (btinfo
, bfun
->up
))
394 if (bfun
->errcode
!= 0)
397 btrace_insn
&last
= bfun
->insn
.back ();
399 if (last
.iclass
== BTRACE_INSN_CALL
)
406 /* Add a continuation segment for a function into which we return at the end of
408 BTINFO is the branch trace information for the current thread.
409 MFUN and FUN are the symbol information we have for this function. */
411 static struct btrace_function
*
412 ftrace_new_return (struct btrace_thread_info
*btinfo
,
413 struct minimal_symbol
*mfun
,
416 struct btrace_function
*prev
, *bfun
, *caller
;
418 bfun
= ftrace_new_function (btinfo
, mfun
, fun
);
419 prev
= ftrace_find_call_by_number (btinfo
, bfun
->number
- 1);
421 /* It is important to start at PREV's caller. Otherwise, we might find
422 PREV itself, if PREV is a recursive function. */
423 caller
= ftrace_find_call_by_number (btinfo
, prev
->up
);
424 caller
= ftrace_find_caller (btinfo
, caller
, mfun
, fun
);
427 /* The caller of PREV is the preceding btrace function segment in this
428 function instance. */
429 gdb_assert (caller
->next
== 0);
431 caller
->next
= bfun
->number
;
432 bfun
->prev
= caller
->number
;
434 /* Maintain the function level. */
435 bfun
->level
= caller
->level
;
437 /* Maintain the call stack. */
438 bfun
->up
= caller
->up
;
439 bfun
->flags
= caller
->flags
;
441 ftrace_debug (bfun
, "new return");
445 /* We did not find a caller. This could mean that something went
446 wrong or that the call is simply not included in the trace. */
448 /* Let's search for some actual call. */
449 caller
= ftrace_find_call_by_number (btinfo
, prev
->up
);
450 caller
= ftrace_find_call (btinfo
, caller
);
453 /* There is no call in PREV's back trace. We assume that the
454 branch trace did not include it. */
456 /* Let's find the topmost function and add a new caller for it.
457 This should handle a series of initial tail calls. */
458 while (prev
->up
!= 0)
459 prev
= ftrace_find_call_by_number (btinfo
, prev
->up
);
461 bfun
->level
= prev
->level
- 1;
463 /* Fix up the call stack for PREV. */
464 ftrace_fixup_caller (btinfo
, prev
, bfun
, BFUN_UP_LINKS_TO_RET
);
466 ftrace_debug (bfun
, "new return - no caller");
470 /* There is a call in PREV's back trace to which we should have
471 returned but didn't. Let's start a new, separate back trace
472 from PREV's level. */
473 bfun
->level
= prev
->level
- 1;
475 /* We fix up the back trace for PREV but leave other function segments
476 on the same level as they are.
477 This should handle things like schedule () correctly where we're
478 switching contexts. */
479 prev
->up
= bfun
->number
;
480 prev
->flags
= BFUN_UP_LINKS_TO_RET
;
482 ftrace_debug (bfun
, "new return - unknown caller");
489 /* Add a new function segment for a function switch at the end of the trace.
490 BTINFO is the branch trace information for the current thread.
491 MFUN and FUN are the symbol information we have for this function. */
493 static struct btrace_function
*
494 ftrace_new_switch (struct btrace_thread_info
*btinfo
,
495 struct minimal_symbol
*mfun
,
498 struct btrace_function
*prev
, *bfun
;
500 /* This is an unexplained function switch. We can't really be sure about the
501 call stack, yet the best I can think of right now is to preserve it. */
502 bfun
= ftrace_new_function (btinfo
, mfun
, fun
);
503 prev
= ftrace_find_call_by_number (btinfo
, bfun
->number
- 1);
505 bfun
->flags
= prev
->flags
;
507 ftrace_debug (bfun
, "new switch");
512 /* Add a new function segment for a gap in the trace due to a decode error at
513 the end of the trace.
514 BTINFO is the branch trace information for the current thread.
515 ERRCODE is the format-specific error code. */
517 static struct btrace_function
*
518 ftrace_new_gap (struct btrace_thread_info
*btinfo
, int errcode
,
519 std::vector
<unsigned int> &gaps
)
521 struct btrace_function
*bfun
;
523 if (btinfo
->functions
.empty ())
524 bfun
= ftrace_new_function (btinfo
, NULL
, NULL
);
527 /* We hijack the previous function segment if it was empty. */
528 bfun
= &btinfo
->functions
.back ();
529 if (bfun
->errcode
!= 0 || !bfun
->insn
.empty ())
530 bfun
= ftrace_new_function (btinfo
, NULL
, NULL
);
533 bfun
->errcode
= errcode
;
534 gaps
.push_back (bfun
->number
);
536 ftrace_debug (bfun
, "new gap");
541 /* Update the current function segment at the end of the trace in BTINFO with
542 respect to the instruction at PC. This may create new function segments.
543 Return the chronologically latest function segment, never NULL. */
545 static struct btrace_function
*
546 ftrace_update_function (struct btrace_thread_info
*btinfo
, CORE_ADDR pc
)
548 struct bound_minimal_symbol bmfun
;
549 struct minimal_symbol
*mfun
;
551 struct btrace_function
*bfun
;
553 /* Try to determine the function we're in. We use both types of symbols
554 to avoid surprises when we sometimes get a full symbol and sometimes
555 only a minimal symbol. */
556 fun
= find_pc_function (pc
);
557 bmfun
= lookup_minimal_symbol_by_pc (pc
);
560 if (fun
== NULL
&& mfun
== NULL
)
561 DEBUG_FTRACE ("no symbol at %s", core_addr_to_string_nz (pc
));
563 /* If we didn't have a function, we create one. */
564 if (btinfo
->functions
.empty ())
565 return ftrace_new_function (btinfo
, mfun
, fun
);
567 /* If we had a gap before, we create a function. */
568 bfun
= &btinfo
->functions
.back ();
569 if (bfun
->errcode
!= 0)
570 return ftrace_new_function (btinfo
, mfun
, fun
);
572 /* Check the last instruction, if we have one.
573 We do this check first, since it allows us to fill in the call stack
574 links in addition to the normal flow links. */
575 btrace_insn
*last
= NULL
;
576 if (!bfun
->insn
.empty ())
577 last
= &bfun
->insn
.back ();
581 switch (last
->iclass
)
583 case BTRACE_INSN_RETURN
:
587 /* On some systems, _dl_runtime_resolve returns to the resolved
588 function instead of jumping to it. From our perspective,
589 however, this is a tailcall.
590 If we treated it as return, we wouldn't be able to find the
591 resolved function in our stack back trace. Hence, we would
592 lose the current stack back trace and start anew with an empty
593 back trace. When the resolved function returns, we would then
594 create a stack back trace with the same function names but
595 different frame id's. This will confuse stepping. */
596 fname
= ftrace_print_function_name (bfun
);
597 if (strcmp (fname
, "_dl_runtime_resolve") == 0)
598 return ftrace_new_tailcall (btinfo
, mfun
, fun
);
600 return ftrace_new_return (btinfo
, mfun
, fun
);
603 case BTRACE_INSN_CALL
:
604 /* Ignore calls to the next instruction. They are used for PIC. */
605 if (last
->pc
+ last
->size
== pc
)
608 return ftrace_new_call (btinfo
, mfun
, fun
);
610 case BTRACE_INSN_JUMP
:
614 start
= get_pc_function_start (pc
);
616 /* A jump to the start of a function is (typically) a tail call. */
618 return ftrace_new_tailcall (btinfo
, mfun
, fun
);
620 /* If we can't determine the function for PC, we treat a jump at
621 the end of the block as tail call if we're switching functions
622 and as an intra-function branch if we don't. */
623 if (start
== 0 && ftrace_function_switched (bfun
, mfun
, fun
))
624 return ftrace_new_tailcall (btinfo
, mfun
, fun
);
631 /* Check if we're switching functions for some other reason. */
632 if (ftrace_function_switched (bfun
, mfun
, fun
))
634 DEBUG_FTRACE ("switching from %s in %s at %s",
635 ftrace_print_insn_addr (last
),
636 ftrace_print_function_name (bfun
),
637 ftrace_print_filename (bfun
));
639 return ftrace_new_switch (btinfo
, mfun
, fun
);
645 /* Add the instruction at PC to BFUN's instructions. */
648 ftrace_update_insns (struct btrace_function
*bfun
, const btrace_insn
&insn
)
650 bfun
->insn
.push_back (insn
);
652 if (record_debug
> 1)
653 ftrace_debug (bfun
, "update insn");
656 /* Classify the instruction at PC. */
658 static enum btrace_insn_class
659 ftrace_classify_insn (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
661 enum btrace_insn_class iclass
;
663 iclass
= BTRACE_INSN_OTHER
;
666 if (gdbarch_insn_is_call (gdbarch
, pc
))
667 iclass
= BTRACE_INSN_CALL
;
668 else if (gdbarch_insn_is_ret (gdbarch
, pc
))
669 iclass
= BTRACE_INSN_RETURN
;
670 else if (gdbarch_insn_is_jump (gdbarch
, pc
))
671 iclass
= BTRACE_INSN_JUMP
;
673 CATCH (error
, RETURN_MASK_ERROR
)
681 /* Try to match the back trace at LHS to the back trace at RHS. Returns the
682 number of matching function segments or zero if the back traces do not
683 match. BTINFO is the branch trace information for the current thread. */
686 ftrace_match_backtrace (struct btrace_thread_info
*btinfo
,
687 struct btrace_function
*lhs
,
688 struct btrace_function
*rhs
)
692 for (matches
= 0; lhs
!= NULL
&& rhs
!= NULL
; ++matches
)
694 if (ftrace_function_switched (lhs
, rhs
->msym
, rhs
->sym
))
697 lhs
= ftrace_get_caller (btinfo
, lhs
);
698 rhs
= ftrace_get_caller (btinfo
, rhs
);
704 /* Add ADJUSTMENT to the level of BFUN and succeeding function segments.
705 BTINFO is the branch trace information for the current thread. */
708 ftrace_fixup_level (struct btrace_thread_info
*btinfo
,
709 struct btrace_function
*bfun
, int adjustment
)
714 DEBUG_FTRACE ("fixup level (%+d)", adjustment
);
715 ftrace_debug (bfun
, "..bfun");
719 bfun
->level
+= adjustment
;
720 bfun
= ftrace_find_call_by_number (btinfo
, bfun
->number
+ 1);
724 /* Recompute the global level offset. Traverse the function trace and compute
725 the global level offset as the negative of the minimal function level. */
728 ftrace_compute_global_level_offset (struct btrace_thread_info
*btinfo
)
735 if (btinfo
->functions
.empty ())
738 unsigned int length
= btinfo
->functions
.size() - 1;
739 for (unsigned int i
= 0; i
< length
; ++i
)
740 level
= std::min (level
, btinfo
->functions
[i
].level
);
742 /* The last function segment contains the current instruction, which is not
743 really part of the trace. If it contains just this one instruction, we
744 ignore the segment. */
745 struct btrace_function
*last
= &btinfo
->functions
.back();
746 if (last
->insn
.size () != 1)
747 level
= std::min (level
, last
->level
);
749 DEBUG_FTRACE ("setting global level offset: %d", -level
);
750 btinfo
->level
= -level
;
753 /* Connect the function segments PREV and NEXT in a bottom-to-top walk as in
754 ftrace_connect_backtrace. BTINFO is the branch trace information for the
758 ftrace_connect_bfun (struct btrace_thread_info
*btinfo
,
759 struct btrace_function
*prev
,
760 struct btrace_function
*next
)
762 DEBUG_FTRACE ("connecting...");
763 ftrace_debug (prev
, "..prev");
764 ftrace_debug (next
, "..next");
766 /* The function segments are not yet connected. */
767 gdb_assert (prev
->next
== 0);
768 gdb_assert (next
->prev
== 0);
770 prev
->next
= next
->number
;
771 next
->prev
= prev
->number
;
773 /* We may have moved NEXT to a different function level. */
774 ftrace_fixup_level (btinfo
, next
, prev
->level
- next
->level
);
776 /* If we run out of back trace for one, let's use the other's. */
779 const btrace_function_flags flags
= next
->flags
;
781 next
= ftrace_find_call_by_number (btinfo
, next
->up
);
784 DEBUG_FTRACE ("using next's callers");
785 ftrace_fixup_caller (btinfo
, prev
, next
, flags
);
788 else if (next
->up
== 0)
790 const btrace_function_flags flags
= prev
->flags
;
792 prev
= ftrace_find_call_by_number (btinfo
, prev
->up
);
795 DEBUG_FTRACE ("using prev's callers");
796 ftrace_fixup_caller (btinfo
, next
, prev
, flags
);
801 /* PREV may have a tailcall caller, NEXT can't. If it does, fixup the up
802 link to add the tail callers to NEXT's back trace.
804 This removes NEXT->UP from NEXT's back trace. It will be added back
805 when connecting NEXT and PREV's callers - provided they exist.
807 If PREV's back trace consists of a series of tail calls without an
808 actual call, there will be no further connection and NEXT's caller will
809 be removed for good. To catch this case, we handle it here and connect
810 the top of PREV's back trace to NEXT's caller. */
811 if ((prev
->flags
& BFUN_UP_LINKS_TO_TAILCALL
) != 0)
813 struct btrace_function
*caller
;
814 btrace_function_flags next_flags
, prev_flags
;
816 /* We checked NEXT->UP above so CALLER can't be NULL. */
817 caller
= ftrace_find_call_by_number (btinfo
, next
->up
);
818 next_flags
= next
->flags
;
819 prev_flags
= prev
->flags
;
821 DEBUG_FTRACE ("adding prev's tail calls to next");
823 prev
= ftrace_find_call_by_number (btinfo
, prev
->up
);
824 ftrace_fixup_caller (btinfo
, next
, prev
, prev_flags
);
826 for (; prev
!= NULL
; prev
= ftrace_find_call_by_number (btinfo
,
829 /* At the end of PREV's back trace, continue with CALLER. */
832 DEBUG_FTRACE ("fixing up link for tailcall chain");
833 ftrace_debug (prev
, "..top");
834 ftrace_debug (caller
, "..up");
836 ftrace_fixup_caller (btinfo
, prev
, caller
, next_flags
);
838 /* If we skipped any tail calls, this may move CALLER to a
839 different function level.
841 Note that changing CALLER's level is only OK because we
842 know that this is the last iteration of the bottom-to-top
843 walk in ftrace_connect_backtrace.
845 Otherwise we will fix up CALLER's level when we connect it
846 to PREV's caller in the next iteration. */
847 ftrace_fixup_level (btinfo
, caller
,
848 prev
->level
- caller
->level
- 1);
852 /* There's nothing to do if we find a real call. */
853 if ((prev
->flags
& BFUN_UP_LINKS_TO_TAILCALL
) == 0)
855 DEBUG_FTRACE ("will fix up link in next iteration");
863 /* Connect function segments on the same level in the back trace at LHS and RHS.
864 The back traces at LHS and RHS are expected to match according to
865 ftrace_match_backtrace. BTINFO is the branch trace information for the
869 ftrace_connect_backtrace (struct btrace_thread_info
*btinfo
,
870 struct btrace_function
*lhs
,
871 struct btrace_function
*rhs
)
873 while (lhs
!= NULL
&& rhs
!= NULL
)
875 struct btrace_function
*prev
, *next
;
877 gdb_assert (!ftrace_function_switched (lhs
, rhs
->msym
, rhs
->sym
));
879 /* Connecting LHS and RHS may change the up link. */
883 lhs
= ftrace_get_caller (btinfo
, lhs
);
884 rhs
= ftrace_get_caller (btinfo
, rhs
);
886 ftrace_connect_bfun (btinfo
, prev
, next
);
890 /* Bridge the gap between two function segments left and right of a gap if their
891 respective back traces match in at least MIN_MATCHES functions. BTINFO is
892 the branch trace information for the current thread.
894 Returns non-zero if the gap could be bridged, zero otherwise. */
897 ftrace_bridge_gap (struct btrace_thread_info
*btinfo
,
898 struct btrace_function
*lhs
, struct btrace_function
*rhs
,
901 struct btrace_function
*best_l
, *best_r
, *cand_l
, *cand_r
;
904 DEBUG_FTRACE ("checking gap at insn %u (req matches: %d)",
905 rhs
->insn_offset
- 1, min_matches
);
911 /* We search the back traces of LHS and RHS for valid connections and connect
912 the two functon segments that give the longest combined back trace. */
914 for (cand_l
= lhs
; cand_l
!= NULL
;
915 cand_l
= ftrace_get_caller (btinfo
, cand_l
))
916 for (cand_r
= rhs
; cand_r
!= NULL
;
917 cand_r
= ftrace_get_caller (btinfo
, cand_r
))
921 matches
= ftrace_match_backtrace (btinfo
, cand_l
, cand_r
);
922 if (best_matches
< matches
)
924 best_matches
= matches
;
930 /* We need at least MIN_MATCHES matches. */
931 gdb_assert (min_matches
> 0);
932 if (best_matches
< min_matches
)
935 DEBUG_FTRACE ("..matches: %d", best_matches
);
937 /* We will fix up the level of BEST_R and succeeding function segments such
938 that BEST_R's level matches BEST_L's when we connect BEST_L to BEST_R.
940 This will ignore the level of RHS and following if BEST_R != RHS. I.e. if
941 BEST_R is a successor of RHS in the back trace of RHS (phases 1 and 3).
943 To catch this, we already fix up the level here where we can start at RHS
944 instead of at BEST_R. We will ignore the level fixup when connecting
945 BEST_L to BEST_R as they will already be on the same level. */
946 ftrace_fixup_level (btinfo
, rhs
, best_l
->level
- best_r
->level
);
948 ftrace_connect_backtrace (btinfo
, best_l
, best_r
);
953 /* Try to bridge gaps due to overflow or decode errors by connecting the
954 function segments that are separated by the gap. */
957 btrace_bridge_gaps (struct thread_info
*tp
, std::vector
<unsigned int> &gaps
)
959 struct btrace_thread_info
*btinfo
= &tp
->btrace
;
960 std::vector
<unsigned int> remaining
;
963 DEBUG ("bridge gaps");
965 /* We require a minimum amount of matches for bridging a gap. The number of
966 required matches will be lowered with each iteration.
968 The more matches the higher our confidence that the bridging is correct.
969 For big gaps or small traces, however, it may not be feasible to require a
970 high number of matches. */
971 for (min_matches
= 5; min_matches
> 0; --min_matches
)
973 /* Let's try to bridge as many gaps as we can. In some cases, we need to
974 skip a gap and revisit it again after we closed later gaps. */
975 while (!gaps
.empty ())
977 for (const unsigned int number
: gaps
)
979 struct btrace_function
*gap
, *lhs
, *rhs
;
982 gap
= ftrace_find_call_by_number (btinfo
, number
);
984 /* We may have a sequence of gaps if we run from one error into
985 the next as we try to re-sync onto the trace stream. Ignore
986 all but the leftmost gap in such a sequence.
988 Also ignore gaps at the beginning of the trace. */
989 lhs
= ftrace_find_call_by_number (btinfo
, gap
->number
- 1);
990 if (lhs
== NULL
|| lhs
->errcode
!= 0)
993 /* Skip gaps to the right. */
994 rhs
= ftrace_find_call_by_number (btinfo
, gap
->number
+ 1);
995 while (rhs
!= NULL
&& rhs
->errcode
!= 0)
996 rhs
= ftrace_find_call_by_number (btinfo
, rhs
->number
+ 1);
998 /* Ignore gaps at the end of the trace. */
1002 bridged
= ftrace_bridge_gap (btinfo
, lhs
, rhs
, min_matches
);
1004 /* Keep track of gaps we were not able to bridge and try again.
1005 If we just pushed them to the end of GAPS we would risk an
1006 infinite loop in case we simply cannot bridge a gap. */
1008 remaining
.push_back (number
);
1011 /* Let's see if we made any progress. */
1012 if (remaining
.size () == gaps
.size ())
1016 gaps
.swap (remaining
);
1019 /* We get here if either GAPS is empty or if GAPS equals REMAINING. */
1026 /* We may omit this in some cases. Not sure it is worth the extra
1027 complication, though. */
1028 ftrace_compute_global_level_offset (btinfo
);
1031 /* Compute the function branch trace from BTS trace. */
1034 btrace_compute_ftrace_bts (struct thread_info
*tp
,
1035 const struct btrace_data_bts
*btrace
,
1036 std::vector
<unsigned int> &gaps
)
1038 struct btrace_thread_info
*btinfo
;
1039 struct gdbarch
*gdbarch
;
1043 gdbarch
= target_gdbarch ();
1044 btinfo
= &tp
->btrace
;
1045 blk
= VEC_length (btrace_block_s
, btrace
->blocks
);
1047 if (btinfo
->functions
.empty ())
1050 level
= -btinfo
->level
;
1054 btrace_block_s
*block
;
1059 block
= VEC_index (btrace_block_s
, btrace
->blocks
, blk
);
1064 struct btrace_function
*bfun
;
1065 struct btrace_insn insn
;
1068 /* We should hit the end of the block. Warn if we went too far. */
1069 if (block
->end
< pc
)
1071 /* Indicate the gap in the trace. */
1072 bfun
= ftrace_new_gap (btinfo
, BDE_BTS_OVERFLOW
, gaps
);
1074 warning (_("Recorded trace may be corrupted at instruction "
1075 "%u (pc = %s)."), bfun
->insn_offset
- 1,
1076 core_addr_to_string_nz (pc
));
1081 bfun
= ftrace_update_function (btinfo
, pc
);
1083 /* Maintain the function level offset.
1084 For all but the last block, we do it here. */
1086 level
= std::min (level
, bfun
->level
);
1091 size
= gdb_insn_length (gdbarch
, pc
);
1093 CATCH (error
, RETURN_MASK_ERROR
)
1100 insn
.iclass
= ftrace_classify_insn (gdbarch
, pc
);
1103 ftrace_update_insns (bfun
, insn
);
1105 /* We're done once we pushed the instruction at the end. */
1106 if (block
->end
== pc
)
1109 /* We can't continue if we fail to compute the size. */
1112 /* Indicate the gap in the trace. We just added INSN so we're
1113 not at the beginning. */
1114 bfun
= ftrace_new_gap (btinfo
, BDE_BTS_INSN_SIZE
, gaps
);
1116 warning (_("Recorded trace may be incomplete at instruction %u "
1117 "(pc = %s)."), bfun
->insn_offset
- 1,
1118 core_addr_to_string_nz (pc
));
1125 /* Maintain the function level offset.
1126 For the last block, we do it here to not consider the last
1128 Since the last instruction corresponds to the current instruction
1129 and is not really part of the execution history, it shouldn't
1130 affect the level. */
1132 level
= std::min (level
, bfun
->level
);
1136 /* LEVEL is the minimal function level of all btrace function segments.
1137 Define the global level offset to -LEVEL so all function levels are
1138 normalized to start at zero. */
1139 btinfo
->level
= -level
;
1142 #if defined (HAVE_LIBIPT)
1144 static enum btrace_insn_class
1145 pt_reclassify_insn (enum pt_insn_class iclass
)
1150 return BTRACE_INSN_CALL
;
1153 return BTRACE_INSN_RETURN
;
1156 return BTRACE_INSN_JUMP
;
1159 return BTRACE_INSN_OTHER
;
1163 /* Return the btrace instruction flags for INSN. */
1165 static btrace_insn_flags
1166 pt_btrace_insn_flags (const struct pt_insn
&insn
)
1168 btrace_insn_flags flags
= 0;
1170 if (insn
.speculative
)
1171 flags
|= BTRACE_INSN_FLAG_SPECULATIVE
;
1176 /* Return the btrace instruction for INSN. */
1179 pt_btrace_insn (const struct pt_insn
&insn
)
1181 return {(CORE_ADDR
) insn
.ip
, (gdb_byte
) insn
.size
,
1182 pt_reclassify_insn (insn
.iclass
),
1183 pt_btrace_insn_flags (insn
)};
1186 /* Handle instruction decode events (libipt-v2). */
1189 handle_pt_insn_events (struct btrace_thread_info
*btinfo
,
1190 struct pt_insn_decoder
*decoder
,
1191 std::vector
<unsigned int> &gaps
, int status
)
1193 #if defined (HAVE_PT_INSN_EVENT)
1194 while (status
& pts_event_pending
)
1196 struct btrace_function
*bfun
;
1197 struct pt_event event
;
1200 status
= pt_insn_event (decoder
, &event
, sizeof (event
));
1210 if (event
.variant
.enabled
.resumed
== 0 && !btinfo
->functions
.empty ())
1212 bfun
= ftrace_new_gap (btinfo
, BDE_PT_DISABLED
, gaps
);
1214 pt_insn_get_offset (decoder
, &offset
);
1216 warning (_("Non-contiguous trace at instruction %u (offset = 0x%"
1217 PRIx64
")."), bfun
->insn_offset
- 1, offset
);
1223 bfun
= ftrace_new_gap (btinfo
, BDE_PT_OVERFLOW
, gaps
);
1225 pt_insn_get_offset (decoder
, &offset
);
1227 warning (_("Overflow at instruction %u (offset = 0x%" PRIx64
")."),
1228 bfun
->insn_offset
- 1, offset
);
1233 #endif /* defined (HAVE_PT_INSN_EVENT) */
1238 /* Handle events indicated by flags in INSN (libipt-v1). */
1241 handle_pt_insn_event_flags (struct btrace_thread_info
*btinfo
,
1242 struct pt_insn_decoder
*decoder
,
1243 const struct pt_insn
&insn
,
1244 std::vector
<unsigned int> &gaps
)
1246 #if defined (HAVE_STRUCT_PT_INSN_ENABLED)
1247 /* Tracing is disabled and re-enabled each time we enter the kernel. Most
1248 times, we continue from the same instruction we stopped before. This is
1249 indicated via the RESUMED instruction flag. The ENABLED instruction flag
1250 means that we continued from some other instruction. Indicate this as a
1251 trace gap except when tracing just started. */
1252 if (insn
.enabled
&& !btinfo
->functions
.empty ())
1254 struct btrace_function
*bfun
;
1257 bfun
= ftrace_new_gap (btinfo
, BDE_PT_DISABLED
, gaps
);
1259 pt_insn_get_offset (decoder
, &offset
);
1261 warning (_("Non-contiguous trace at instruction %u (offset = 0x%" PRIx64
1262 ", pc = 0x%" PRIx64
")."), bfun
->insn_offset
- 1, offset
,
1265 #endif /* defined (HAVE_STRUCT_PT_INSN_ENABLED) */
1267 #if defined (HAVE_STRUCT_PT_INSN_RESYNCED)
1268 /* Indicate trace overflows. */
1271 struct btrace_function
*bfun
;
1274 bfun
= ftrace_new_gap (btinfo
, BDE_PT_OVERFLOW
, gaps
);
1276 pt_insn_get_offset (decoder
, &offset
);
1278 warning (_("Overflow at instruction %u (offset = 0x%" PRIx64
", pc = 0x%"
1279 PRIx64
")."), bfun
->insn_offset
- 1, offset
, insn
.ip
);
1281 #endif /* defined (HAVE_STRUCT_PT_INSN_RESYNCED) */
1284 /* Add function branch trace to BTINFO using DECODER. */
1287 ftrace_add_pt (struct btrace_thread_info
*btinfo
,
1288 struct pt_insn_decoder
*decoder
,
1290 std::vector
<unsigned int> &gaps
)
1292 struct btrace_function
*bfun
;
1298 struct pt_insn insn
;
1300 status
= pt_insn_sync_forward (decoder
);
1303 if (status
!= -pte_eos
)
1304 warning (_("Failed to synchronize onto the Intel Processor "
1305 "Trace stream: %s."), pt_errstr (pt_errcode (status
)));
1311 /* Handle events from the previous iteration or synchronization. */
1312 status
= handle_pt_insn_events (btinfo
, decoder
, gaps
, status
);
1316 status
= pt_insn_next (decoder
, &insn
, sizeof(insn
));
1320 /* Handle events indicated by flags in INSN. */
1321 handle_pt_insn_event_flags (btinfo
, decoder
, insn
, gaps
);
1323 bfun
= ftrace_update_function (btinfo
, insn
.ip
);
1325 /* Maintain the function level offset. */
1326 *plevel
= std::min (*plevel
, bfun
->level
);
1328 ftrace_update_insns (bfun
, pt_btrace_insn (insn
));
1331 if (status
== -pte_eos
)
1334 /* Indicate the gap in the trace. */
1335 bfun
= ftrace_new_gap (btinfo
, status
, gaps
);
1337 pt_insn_get_offset (decoder
, &offset
);
1339 warning (_("Decode error (%d) at instruction %u (offset = 0x%" PRIx64
1340 ", pc = 0x%" PRIx64
"): %s."), status
, bfun
->insn_offset
- 1,
1341 offset
, insn
.ip
, pt_errstr (pt_errcode (status
)));
1345 /* A callback function to allow the trace decoder to read the inferior's
1349 btrace_pt_readmem_callback (gdb_byte
*buffer
, size_t size
,
1350 const struct pt_asid
*asid
, uint64_t pc
,
1353 int result
, errcode
;
1355 result
= (int) size
;
1358 errcode
= target_read_code ((CORE_ADDR
) pc
, buffer
, size
);
1360 result
= -pte_nomap
;
1362 CATCH (error
, RETURN_MASK_ERROR
)
1364 result
= -pte_nomap
;
1371 /* Translate the vendor from one enum to another. */
1373 static enum pt_cpu_vendor
1374 pt_translate_cpu_vendor (enum btrace_cpu_vendor vendor
)
1386 /* Finalize the function branch trace after decode. */
1388 static void btrace_finalize_ftrace_pt (struct pt_insn_decoder
*decoder
,
1389 struct thread_info
*tp
, int level
)
1391 pt_insn_free_decoder (decoder
);
1393 /* LEVEL is the minimal function level of all btrace function segments.
1394 Define the global level offset to -LEVEL so all function levels are
1395 normalized to start at zero. */
1396 tp
->btrace
.level
= -level
;
1398 /* Add a single last instruction entry for the current PC.
1399 This allows us to compute the backtrace at the current PC using both
1400 standard unwind and btrace unwind.
1401 This extra entry is ignored by all record commands. */
1405 /* Compute the function branch trace from Intel Processor Trace
1409 btrace_compute_ftrace_pt (struct thread_info
*tp
,
1410 const struct btrace_data_pt
*btrace
,
1411 std::vector
<unsigned int> &gaps
)
1413 struct btrace_thread_info
*btinfo
;
1414 struct pt_insn_decoder
*decoder
;
1415 struct pt_config config
;
1418 if (btrace
->size
== 0)
1421 btinfo
= &tp
->btrace
;
1422 if (btinfo
->functions
.empty ())
1425 level
= -btinfo
->level
;
1427 pt_config_init(&config
);
1428 config
.begin
= btrace
->data
;
1429 config
.end
= btrace
->data
+ btrace
->size
;
1431 config
.cpu
.vendor
= pt_translate_cpu_vendor (btrace
->config
.cpu
.vendor
);
1432 config
.cpu
.family
= btrace
->config
.cpu
.family
;
1433 config
.cpu
.model
= btrace
->config
.cpu
.model
;
1434 config
.cpu
.stepping
= btrace
->config
.cpu
.stepping
;
1436 errcode
= pt_cpu_errata (&config
.errata
, &config
.cpu
);
1438 error (_("Failed to configure the Intel Processor Trace decoder: %s."),
1439 pt_errstr (pt_errcode (errcode
)));
1441 decoder
= pt_insn_alloc_decoder (&config
);
1442 if (decoder
== NULL
)
1443 error (_("Failed to allocate the Intel Processor Trace decoder."));
1447 struct pt_image
*image
;
1449 image
= pt_insn_get_image(decoder
);
1451 error (_("Failed to configure the Intel Processor Trace decoder."));
1453 errcode
= pt_image_set_callback(image
, btrace_pt_readmem_callback
, NULL
);
1455 error (_("Failed to configure the Intel Processor Trace decoder: "
1456 "%s."), pt_errstr (pt_errcode (errcode
)));
1458 ftrace_add_pt (btinfo
, decoder
, &level
, gaps
);
1460 CATCH (error
, RETURN_MASK_ALL
)
1462 /* Indicate a gap in the trace if we quit trace processing. */
1463 if (error
.reason
== RETURN_QUIT
&& !btinfo
->functions
.empty ())
1464 ftrace_new_gap (btinfo
, BDE_PT_USER_QUIT
, gaps
);
1466 btrace_finalize_ftrace_pt (decoder
, tp
, level
);
1468 throw_exception (error
);
1472 btrace_finalize_ftrace_pt (decoder
, tp
, level
);
1475 #else /* defined (HAVE_LIBIPT) */
1478 btrace_compute_ftrace_pt (struct thread_info
*tp
,
1479 const struct btrace_data_pt
*btrace
,
1480 std::vector
<unsigned int> &gaps
)
1482 internal_error (__FILE__
, __LINE__
, _("Unexpected branch trace format."));
1485 #endif /* defined (HAVE_LIBIPT) */
1487 /* Compute the function branch trace from a block branch trace BTRACE for
1488 a thread given by BTINFO. */
1491 btrace_compute_ftrace_1 (struct thread_info
*tp
, struct btrace_data
*btrace
,
1492 std::vector
<unsigned int> &gaps
)
1494 DEBUG ("compute ftrace");
1496 switch (btrace
->format
)
1498 case BTRACE_FORMAT_NONE
:
1501 case BTRACE_FORMAT_BTS
:
1502 btrace_compute_ftrace_bts (tp
, &btrace
->variant
.bts
, gaps
);
1505 case BTRACE_FORMAT_PT
:
1506 btrace_compute_ftrace_pt (tp
, &btrace
->variant
.pt
, gaps
);
1510 internal_error (__FILE__
, __LINE__
, _("Unkown branch trace format."));
1514 btrace_finalize_ftrace (struct thread_info
*tp
, std::vector
<unsigned int> &gaps
)
1518 tp
->btrace
.ngaps
+= gaps
.size ();
1519 btrace_bridge_gaps (tp
, gaps
);
1524 btrace_compute_ftrace (struct thread_info
*tp
, struct btrace_data
*btrace
)
1526 std::vector
<unsigned int> gaps
;
1530 btrace_compute_ftrace_1 (tp
, btrace
, gaps
);
1532 CATCH (error
, RETURN_MASK_ALL
)
1534 btrace_finalize_ftrace (tp
, gaps
);
1536 throw_exception (error
);
1540 btrace_finalize_ftrace (tp
, gaps
);
1543 /* Add an entry for the current PC. */
1546 btrace_add_pc (struct thread_info
*tp
)
1548 struct btrace_data btrace
;
1549 struct btrace_block
*block
;
1550 struct regcache
*regcache
;
1551 struct cleanup
*cleanup
;
1554 regcache
= get_thread_regcache (tp
->ptid
);
1555 pc
= regcache_read_pc (regcache
);
1557 btrace_data_init (&btrace
);
1558 btrace
.format
= BTRACE_FORMAT_BTS
;
1559 btrace
.variant
.bts
.blocks
= NULL
;
1561 cleanup
= make_cleanup_btrace_data (&btrace
);
1563 block
= VEC_safe_push (btrace_block_s
, btrace
.variant
.bts
.blocks
, NULL
);
1567 btrace_compute_ftrace (tp
, &btrace
);
1569 do_cleanups (cleanup
);
1575 btrace_enable (struct thread_info
*tp
, const struct btrace_config
*conf
)
1577 if (tp
->btrace
.target
!= NULL
)
1580 #if !defined (HAVE_LIBIPT)
1581 if (conf
->format
== BTRACE_FORMAT_PT
)
1582 error (_("GDB does not support Intel Processor Trace."));
1583 #endif /* !defined (HAVE_LIBIPT) */
1585 if (!target_supports_btrace (conf
->format
))
1586 error (_("Target does not support branch tracing."));
1588 DEBUG ("enable thread %s (%s)", print_thread_id (tp
),
1589 target_pid_to_str (tp
->ptid
));
1591 tp
->btrace
.target
= target_enable_btrace (tp
->ptid
, conf
);
1593 /* We're done if we failed to enable tracing. */
1594 if (tp
->btrace
.target
== NULL
)
1597 /* We need to undo the enable in case of errors. */
1600 /* Add an entry for the current PC so we start tracing from where we
1603 If we can't access TP's registers, TP is most likely running. In this
1604 case, we can't really say where tracing was enabled so it should be
1605 safe to simply skip this step.
1607 This is not relevant for BTRACE_FORMAT_PT since the trace will already
1608 start at the PC at which tracing was enabled. */
1609 if (conf
->format
!= BTRACE_FORMAT_PT
1610 && can_access_registers_ptid (tp
->ptid
))
1613 CATCH (exception
, RETURN_MASK_ALL
)
1615 btrace_disable (tp
);
1617 throw_exception (exception
);
1624 const struct btrace_config
*
1625 btrace_conf (const struct btrace_thread_info
*btinfo
)
1627 if (btinfo
->target
== NULL
)
1630 return target_btrace_conf (btinfo
->target
);
1636 btrace_disable (struct thread_info
*tp
)
1638 struct btrace_thread_info
*btp
= &tp
->btrace
;
1640 if (btp
->target
== NULL
)
1643 DEBUG ("disable thread %s (%s)", print_thread_id (tp
),
1644 target_pid_to_str (tp
->ptid
));
1646 target_disable_btrace (btp
->target
);
1655 btrace_teardown (struct thread_info
*tp
)
1657 struct btrace_thread_info
*btp
= &tp
->btrace
;
1659 if (btp
->target
== NULL
)
1662 DEBUG ("teardown thread %s (%s)", print_thread_id (tp
),
1663 target_pid_to_str (tp
->ptid
));
1665 target_teardown_btrace (btp
->target
);
1671 /* Stitch branch trace in BTS format. */
1674 btrace_stitch_bts (struct btrace_data_bts
*btrace
, struct thread_info
*tp
)
1676 struct btrace_thread_info
*btinfo
;
1677 struct btrace_function
*last_bfun
;
1678 btrace_block_s
*first_new_block
;
1680 btinfo
= &tp
->btrace
;
1681 gdb_assert (!btinfo
->functions
.empty ());
1682 gdb_assert (!VEC_empty (btrace_block_s
, btrace
->blocks
));
1684 last_bfun
= &btinfo
->functions
.back ();
1686 /* If the existing trace ends with a gap, we just glue the traces
1687 together. We need to drop the last (i.e. chronologically first) block
1688 of the new trace, though, since we can't fill in the start address.*/
1689 if (last_bfun
->insn
.empty ())
1691 VEC_pop (btrace_block_s
, btrace
->blocks
);
1695 /* Beware that block trace starts with the most recent block, so the
1696 chronologically first block in the new trace is the last block in
1697 the new trace's block vector. */
1698 first_new_block
= VEC_last (btrace_block_s
, btrace
->blocks
);
1699 const btrace_insn
&last_insn
= last_bfun
->insn
.back ();
1701 /* If the current PC at the end of the block is the same as in our current
1702 trace, there are two explanations:
1703 1. we executed the instruction and some branch brought us back.
1704 2. we have not made any progress.
1705 In the first case, the delta trace vector should contain at least two
1707 In the second case, the delta trace vector should contain exactly one
1708 entry for the partial block containing the current PC. Remove it. */
1709 if (first_new_block
->end
== last_insn
.pc
1710 && VEC_length (btrace_block_s
, btrace
->blocks
) == 1)
1712 VEC_pop (btrace_block_s
, btrace
->blocks
);
1716 DEBUG ("stitching %s to %s", ftrace_print_insn_addr (&last_insn
),
1717 core_addr_to_string_nz (first_new_block
->end
));
1719 /* Do a simple sanity check to make sure we don't accidentally end up
1720 with a bad block. This should not occur in practice. */
1721 if (first_new_block
->end
< last_insn
.pc
)
1723 warning (_("Error while trying to read delta trace. Falling back to "
1728 /* We adjust the last block to start at the end of our current trace. */
1729 gdb_assert (first_new_block
->begin
== 0);
1730 first_new_block
->begin
= last_insn
.pc
;
1732 /* We simply pop the last insn so we can insert it again as part of
1733 the normal branch trace computation.
1734 Since instruction iterators are based on indices in the instructions
1735 vector, we don't leave any pointers dangling. */
1736 DEBUG ("pruning insn at %s for stitching",
1737 ftrace_print_insn_addr (&last_insn
));
1739 last_bfun
->insn
.pop_back ();
1741 /* The instructions vector may become empty temporarily if this has
1742 been the only instruction in this function segment.
1743 This violates the invariant but will be remedied shortly by
1744 btrace_compute_ftrace when we add the new trace. */
1746 /* The only case where this would hurt is if the entire trace consisted
1747 of just that one instruction. If we remove it, we might turn the now
1748 empty btrace function segment into a gap. But we don't want gaps at
1749 the beginning. To avoid this, we remove the entire old trace. */
1750 if (last_bfun
->number
== 1 && last_bfun
->insn
.empty ())
1756 /* Adjust the block trace in order to stitch old and new trace together.
1757 BTRACE is the new delta trace between the last and the current stop.
1758 TP is the traced thread.
1759 May modifx BTRACE as well as the existing trace in TP.
1760 Return 0 on success, -1 otherwise. */
1763 btrace_stitch_trace (struct btrace_data
*btrace
, struct thread_info
*tp
)
1765 /* If we don't have trace, there's nothing to do. */
1766 if (btrace_data_empty (btrace
))
1769 switch (btrace
->format
)
1771 case BTRACE_FORMAT_NONE
:
1774 case BTRACE_FORMAT_BTS
:
1775 return btrace_stitch_bts (&btrace
->variant
.bts
, tp
);
1777 case BTRACE_FORMAT_PT
:
1778 /* Delta reads are not supported. */
1782 internal_error (__FILE__
, __LINE__
, _("Unkown branch trace format."));
1785 /* Clear the branch trace histories in BTINFO. */
1788 btrace_clear_history (struct btrace_thread_info
*btinfo
)
1790 xfree (btinfo
->insn_history
);
1791 xfree (btinfo
->call_history
);
1792 xfree (btinfo
->replay
);
1794 btinfo
->insn_history
= NULL
;
1795 btinfo
->call_history
= NULL
;
1796 btinfo
->replay
= NULL
;
1799 /* Clear the branch trace maintenance histories in BTINFO. */
1802 btrace_maint_clear (struct btrace_thread_info
*btinfo
)
1804 switch (btinfo
->data
.format
)
1809 case BTRACE_FORMAT_BTS
:
1810 btinfo
->maint
.variant
.bts
.packet_history
.begin
= 0;
1811 btinfo
->maint
.variant
.bts
.packet_history
.end
= 0;
1814 #if defined (HAVE_LIBIPT)
1815 case BTRACE_FORMAT_PT
:
1816 xfree (btinfo
->maint
.variant
.pt
.packets
);
1818 btinfo
->maint
.variant
.pt
.packets
= NULL
;
1819 btinfo
->maint
.variant
.pt
.packet_history
.begin
= 0;
1820 btinfo
->maint
.variant
.pt
.packet_history
.end
= 0;
1822 #endif /* defined (HAVE_LIBIPT) */
1829 btrace_decode_error (enum btrace_format format
, int errcode
)
1833 case BTRACE_FORMAT_BTS
:
1836 case BDE_BTS_OVERFLOW
:
1837 return _("instruction overflow");
1839 case BDE_BTS_INSN_SIZE
:
1840 return _("unknown instruction");
1847 #if defined (HAVE_LIBIPT)
1848 case BTRACE_FORMAT_PT
:
1851 case BDE_PT_USER_QUIT
:
1852 return _("trace decode cancelled");
1854 case BDE_PT_DISABLED
:
1855 return _("disabled");
1857 case BDE_PT_OVERFLOW
:
1858 return _("overflow");
1862 return pt_errstr (pt_errcode (errcode
));
1866 #endif /* defined (HAVE_LIBIPT) */
1872 return _("unknown");
1878 btrace_fetch (struct thread_info
*tp
)
1880 struct btrace_thread_info
*btinfo
;
1881 struct btrace_target_info
*tinfo
;
1882 struct btrace_data btrace
;
1883 struct cleanup
*cleanup
;
1886 DEBUG ("fetch thread %s (%s)", print_thread_id (tp
),
1887 target_pid_to_str (tp
->ptid
));
1889 btinfo
= &tp
->btrace
;
1890 tinfo
= btinfo
->target
;
1894 /* There's no way we could get new trace while replaying.
1895 On the other hand, delta trace would return a partial record with the
1896 current PC, which is the replay PC, not the last PC, as expected. */
1897 if (btinfo
->replay
!= NULL
)
1900 /* With CLI usage, TP->PTID always equals INFERIOR_PTID here. Now that we
1901 can store a gdb.Record object in Python referring to a different thread
1902 than the current one, temporarily set INFERIOR_PTID. */
1903 scoped_restore save_inferior_ptid
= make_scoped_restore (&inferior_ptid
);
1904 inferior_ptid
= tp
->ptid
;
1906 /* We should not be called on running or exited threads. */
1907 gdb_assert (can_access_registers_ptid (tp
->ptid
));
1909 btrace_data_init (&btrace
);
1910 cleanup
= make_cleanup_btrace_data (&btrace
);
1912 /* Let's first try to extend the trace we already have. */
1913 if (!btinfo
->functions
.empty ())
1915 errcode
= target_read_btrace (&btrace
, tinfo
, BTRACE_READ_DELTA
);
1918 /* Success. Let's try to stitch the traces together. */
1919 errcode
= btrace_stitch_trace (&btrace
, tp
);
1923 /* We failed to read delta trace. Let's try to read new trace. */
1924 errcode
= target_read_btrace (&btrace
, tinfo
, BTRACE_READ_NEW
);
1926 /* If we got any new trace, discard what we have. */
1927 if (errcode
== 0 && !btrace_data_empty (&btrace
))
1931 /* If we were not able to read the trace, we start over. */
1935 errcode
= target_read_btrace (&btrace
, tinfo
, BTRACE_READ_ALL
);
1939 errcode
= target_read_btrace (&btrace
, tinfo
, BTRACE_READ_ALL
);
1941 /* If we were not able to read the branch trace, signal an error. */
1943 error (_("Failed to read branch trace."));
1945 /* Compute the trace, provided we have any. */
1946 if (!btrace_data_empty (&btrace
))
1948 /* Store the raw trace data. The stored data will be cleared in
1949 btrace_clear, so we always append the new trace. */
1950 btrace_data_append (&btinfo
->data
, &btrace
);
1951 btrace_maint_clear (btinfo
);
1953 btrace_clear_history (btinfo
);
1954 btrace_compute_ftrace (tp
, &btrace
);
1957 do_cleanups (cleanup
);
1963 btrace_clear (struct thread_info
*tp
)
1965 struct btrace_thread_info
*btinfo
;
1967 DEBUG ("clear thread %s (%s)", print_thread_id (tp
),
1968 target_pid_to_str (tp
->ptid
));
1970 /* Make sure btrace frames that may hold a pointer into the branch
1971 trace data are destroyed. */
1972 reinit_frame_cache ();
1974 btinfo
= &tp
->btrace
;
1976 btinfo
->functions
.clear ();
1979 /* Must clear the maint data before - it depends on BTINFO->DATA. */
1980 btrace_maint_clear (btinfo
);
1981 btrace_data_clear (&btinfo
->data
);
1982 btrace_clear_history (btinfo
);
1988 btrace_free_objfile (struct objfile
*objfile
)
1990 struct thread_info
*tp
;
1992 DEBUG ("free objfile");
1994 ALL_NON_EXITED_THREADS (tp
)
1998 #if defined (HAVE_LIBEXPAT)
2000 /* Check the btrace document version. */
2003 check_xml_btrace_version (struct gdb_xml_parser
*parser
,
2004 const struct gdb_xml_element
*element
,
2005 void *user_data
, VEC (gdb_xml_value_s
) *attributes
)
2008 = (const char *) xml_find_attribute (attributes
, "version")->value
;
2010 if (strcmp (version
, "1.0") != 0)
2011 gdb_xml_error (parser
, _("Unsupported btrace version: \"%s\""), version
);
2014 /* Parse a btrace "block" xml record. */
2017 parse_xml_btrace_block (struct gdb_xml_parser
*parser
,
2018 const struct gdb_xml_element
*element
,
2019 void *user_data
, VEC (gdb_xml_value_s
) *attributes
)
2021 struct btrace_data
*btrace
;
2022 struct btrace_block
*block
;
2023 ULONGEST
*begin
, *end
;
2025 btrace
= (struct btrace_data
*) user_data
;
2027 switch (btrace
->format
)
2029 case BTRACE_FORMAT_BTS
:
2032 case BTRACE_FORMAT_NONE
:
2033 btrace
->format
= BTRACE_FORMAT_BTS
;
2034 btrace
->variant
.bts
.blocks
= NULL
;
2038 gdb_xml_error (parser
, _("Btrace format error."));
2041 begin
= (ULONGEST
*) xml_find_attribute (attributes
, "begin")->value
;
2042 end
= (ULONGEST
*) xml_find_attribute (attributes
, "end")->value
;
2044 block
= VEC_safe_push (btrace_block_s
, btrace
->variant
.bts
.blocks
, NULL
);
2045 block
->begin
= *begin
;
2049 /* Parse a "raw" xml record. */
2052 parse_xml_raw (struct gdb_xml_parser
*parser
, const char *body_text
,
2053 gdb_byte
**pdata
, size_t *psize
)
2055 struct cleanup
*cleanup
;
2056 gdb_byte
*data
, *bin
;
2059 len
= strlen (body_text
);
2061 gdb_xml_error (parser
, _("Bad raw data size."));
2065 bin
= data
= (gdb_byte
*) xmalloc (size
);
2066 cleanup
= make_cleanup (xfree
, data
);
2068 /* We use hex encoding - see common/rsp-low.h. */
2076 if (hi
== 0 || lo
== 0)
2077 gdb_xml_error (parser
, _("Bad hex encoding."));
2079 *bin
++ = fromhex (hi
) * 16 + fromhex (lo
);
2083 discard_cleanups (cleanup
);
2089 /* Parse a btrace pt-config "cpu" xml record. */
2092 parse_xml_btrace_pt_config_cpu (struct gdb_xml_parser
*parser
,
2093 const struct gdb_xml_element
*element
,
2095 VEC (gdb_xml_value_s
) *attributes
)
2097 struct btrace_data
*btrace
;
2099 ULONGEST
*family
, *model
, *stepping
;
2101 vendor
= (const char *) xml_find_attribute (attributes
, "vendor")->value
;
2102 family
= (ULONGEST
*) xml_find_attribute (attributes
, "family")->value
;
2103 model
= (ULONGEST
*) xml_find_attribute (attributes
, "model")->value
;
2104 stepping
= (ULONGEST
*) xml_find_attribute (attributes
, "stepping")->value
;
2106 btrace
= (struct btrace_data
*) user_data
;
2108 if (strcmp (vendor
, "GenuineIntel") == 0)
2109 btrace
->variant
.pt
.config
.cpu
.vendor
= CV_INTEL
;
2111 btrace
->variant
.pt
.config
.cpu
.family
= *family
;
2112 btrace
->variant
.pt
.config
.cpu
.model
= *model
;
2113 btrace
->variant
.pt
.config
.cpu
.stepping
= *stepping
;
2116 /* Parse a btrace pt "raw" xml record. */
2119 parse_xml_btrace_pt_raw (struct gdb_xml_parser
*parser
,
2120 const struct gdb_xml_element
*element
,
2121 void *user_data
, const char *body_text
)
2123 struct btrace_data
*btrace
;
2125 btrace
= (struct btrace_data
*) user_data
;
2126 parse_xml_raw (parser
, body_text
, &btrace
->variant
.pt
.data
,
2127 &btrace
->variant
.pt
.size
);
2130 /* Parse a btrace "pt" xml record. */
2133 parse_xml_btrace_pt (struct gdb_xml_parser
*parser
,
2134 const struct gdb_xml_element
*element
,
2135 void *user_data
, VEC (gdb_xml_value_s
) *attributes
)
2137 struct btrace_data
*btrace
;
2139 btrace
= (struct btrace_data
*) user_data
;
2140 btrace
->format
= BTRACE_FORMAT_PT
;
2141 btrace
->variant
.pt
.config
.cpu
.vendor
= CV_UNKNOWN
;
2142 btrace
->variant
.pt
.data
= NULL
;
2143 btrace
->variant
.pt
.size
= 0;
2146 static const struct gdb_xml_attribute block_attributes
[] = {
2147 { "begin", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
2148 { "end", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
2149 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
2152 static const struct gdb_xml_attribute btrace_pt_config_cpu_attributes
[] = {
2153 { "vendor", GDB_XML_AF_NONE
, NULL
, NULL
},
2154 { "family", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
2155 { "model", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
2156 { "stepping", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
2157 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
2160 static const struct gdb_xml_element btrace_pt_config_children
[] = {
2161 { "cpu", btrace_pt_config_cpu_attributes
, NULL
, GDB_XML_EF_OPTIONAL
,
2162 parse_xml_btrace_pt_config_cpu
, NULL
},
2163 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
2166 static const struct gdb_xml_element btrace_pt_children
[] = {
2167 { "pt-config", NULL
, btrace_pt_config_children
, GDB_XML_EF_OPTIONAL
, NULL
,
2169 { "raw", NULL
, NULL
, GDB_XML_EF_OPTIONAL
, NULL
, parse_xml_btrace_pt_raw
},
2170 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
2173 static const struct gdb_xml_attribute btrace_attributes
[] = {
2174 { "version", GDB_XML_AF_NONE
, NULL
, NULL
},
2175 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
2178 static const struct gdb_xml_element btrace_children
[] = {
2179 { "block", block_attributes
, NULL
,
2180 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
, parse_xml_btrace_block
, NULL
},
2181 { "pt", NULL
, btrace_pt_children
, GDB_XML_EF_OPTIONAL
, parse_xml_btrace_pt
,
2183 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
2186 static const struct gdb_xml_element btrace_elements
[] = {
2187 { "btrace", btrace_attributes
, btrace_children
, GDB_XML_EF_NONE
,
2188 check_xml_btrace_version
, NULL
},
2189 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
2192 #endif /* defined (HAVE_LIBEXPAT) */
2197 parse_xml_btrace (struct btrace_data
*btrace
, const char *buffer
)
2199 struct cleanup
*cleanup
;
2202 #if defined (HAVE_LIBEXPAT)
2204 btrace
->format
= BTRACE_FORMAT_NONE
;
2206 cleanup
= make_cleanup_btrace_data (btrace
);
2207 errcode
= gdb_xml_parse_quick (_("btrace"), "btrace.dtd", btrace_elements
,
2210 error (_("Error parsing branch trace."));
2212 /* Keep parse results. */
2213 discard_cleanups (cleanup
);
2215 #else /* !defined (HAVE_LIBEXPAT) */
2217 error (_("Cannot process branch trace. XML parsing is not supported."));
2219 #endif /* !defined (HAVE_LIBEXPAT) */
2222 #if defined (HAVE_LIBEXPAT)
2224 /* Parse a btrace-conf "bts" xml record. */
2227 parse_xml_btrace_conf_bts (struct gdb_xml_parser
*parser
,
2228 const struct gdb_xml_element
*element
,
2229 void *user_data
, VEC (gdb_xml_value_s
) *attributes
)
2231 struct btrace_config
*conf
;
2232 struct gdb_xml_value
*size
;
2234 conf
= (struct btrace_config
*) user_data
;
2235 conf
->format
= BTRACE_FORMAT_BTS
;
2238 size
= xml_find_attribute (attributes
, "size");
2240 conf
->bts
.size
= (unsigned int) *(ULONGEST
*) size
->value
;
2243 /* Parse a btrace-conf "pt" xml record. */
2246 parse_xml_btrace_conf_pt (struct gdb_xml_parser
*parser
,
2247 const struct gdb_xml_element
*element
,
2248 void *user_data
, VEC (gdb_xml_value_s
) *attributes
)
2250 struct btrace_config
*conf
;
2251 struct gdb_xml_value
*size
;
2253 conf
= (struct btrace_config
*) user_data
;
2254 conf
->format
= BTRACE_FORMAT_PT
;
2257 size
= xml_find_attribute (attributes
, "size");
2259 conf
->pt
.size
= (unsigned int) *(ULONGEST
*) size
->value
;
2262 static const struct gdb_xml_attribute btrace_conf_pt_attributes
[] = {
2263 { "size", GDB_XML_AF_OPTIONAL
, gdb_xml_parse_attr_ulongest
, NULL
},
2264 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
2267 static const struct gdb_xml_attribute btrace_conf_bts_attributes
[] = {
2268 { "size", GDB_XML_AF_OPTIONAL
, gdb_xml_parse_attr_ulongest
, NULL
},
2269 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
2272 static const struct gdb_xml_element btrace_conf_children
[] = {
2273 { "bts", btrace_conf_bts_attributes
, NULL
, GDB_XML_EF_OPTIONAL
,
2274 parse_xml_btrace_conf_bts
, NULL
},
2275 { "pt", btrace_conf_pt_attributes
, NULL
, GDB_XML_EF_OPTIONAL
,
2276 parse_xml_btrace_conf_pt
, NULL
},
2277 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
2280 static const struct gdb_xml_attribute btrace_conf_attributes
[] = {
2281 { "version", GDB_XML_AF_NONE
, NULL
, NULL
},
2282 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
2285 static const struct gdb_xml_element btrace_conf_elements
[] = {
2286 { "btrace-conf", btrace_conf_attributes
, btrace_conf_children
,
2287 GDB_XML_EF_NONE
, NULL
, NULL
},
2288 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
2291 #endif /* defined (HAVE_LIBEXPAT) */
2296 parse_xml_btrace_conf (struct btrace_config
*conf
, const char *xml
)
2300 #if defined (HAVE_LIBEXPAT)
2302 errcode
= gdb_xml_parse_quick (_("btrace-conf"), "btrace-conf.dtd",
2303 btrace_conf_elements
, xml
, conf
);
2305 error (_("Error parsing branch trace configuration."));
2307 #else /* !defined (HAVE_LIBEXPAT) */
2309 error (_("XML parsing is not supported."));
2311 #endif /* !defined (HAVE_LIBEXPAT) */
2316 const struct btrace_insn
*
2317 btrace_insn_get (const struct btrace_insn_iterator
*it
)
2319 const struct btrace_function
*bfun
;
2320 unsigned int index
, end
;
2322 index
= it
->insn_index
;
2323 bfun
= &it
->btinfo
->functions
[it
->call_index
];
2325 /* Check if the iterator points to a gap in the trace. */
2326 if (bfun
->errcode
!= 0)
2329 /* The index is within the bounds of this function's instruction vector. */
2330 end
= bfun
->insn
.size ();
2331 gdb_assert (0 < end
);
2332 gdb_assert (index
< end
);
2334 return &bfun
->insn
[index
];
2340 btrace_insn_get_error (const struct btrace_insn_iterator
*it
)
2342 return it
->btinfo
->functions
[it
->call_index
].errcode
;
2348 btrace_insn_number (const struct btrace_insn_iterator
*it
)
2350 return it
->btinfo
->functions
[it
->call_index
].insn_offset
+ it
->insn_index
;
2356 btrace_insn_begin (struct btrace_insn_iterator
*it
,
2357 const struct btrace_thread_info
*btinfo
)
2359 if (btinfo
->functions
.empty ())
2360 error (_("No trace."));
2362 it
->btinfo
= btinfo
;
2370 btrace_insn_end (struct btrace_insn_iterator
*it
,
2371 const struct btrace_thread_info
*btinfo
)
2373 const struct btrace_function
*bfun
;
2374 unsigned int length
;
2376 if (btinfo
->functions
.empty ())
2377 error (_("No trace."));
2379 bfun
= &btinfo
->functions
.back ();
2380 length
= bfun
->insn
.size ();
2382 /* The last function may either be a gap or it contains the current
2383 instruction, which is one past the end of the execution trace; ignore
2388 it
->btinfo
= btinfo
;
2389 it
->call_index
= bfun
->number
- 1;
2390 it
->insn_index
= length
;
2396 btrace_insn_next (struct btrace_insn_iterator
*it
, unsigned int stride
)
2398 const struct btrace_function
*bfun
;
2399 unsigned int index
, steps
;
2401 bfun
= &it
->btinfo
->functions
[it
->call_index
];
2403 index
= it
->insn_index
;
2407 unsigned int end
, space
, adv
;
2409 end
= bfun
->insn
.size ();
2411 /* An empty function segment represents a gap in the trace. We count
2412 it as one instruction. */
2415 const struct btrace_function
*next
;
2417 next
= ftrace_find_call_by_number (it
->btinfo
, bfun
->number
+ 1);
2430 gdb_assert (0 < end
);
2431 gdb_assert (index
< end
);
2433 /* Compute the number of instructions remaining in this segment. */
2434 space
= end
- index
;
2436 /* Advance the iterator as far as possible within this segment. */
2437 adv
= std::min (space
, stride
);
2442 /* Move to the next function if we're at the end of this one. */
2445 const struct btrace_function
*next
;
2447 next
= ftrace_find_call_by_number (it
->btinfo
, bfun
->number
+ 1);
2450 /* We stepped past the last function.
2452 Let's adjust the index to point to the last instruction in
2453 the previous function. */
2459 /* We now point to the first instruction in the new function. */
2464 /* We did make progress. */
2465 gdb_assert (adv
> 0);
2468 /* Update the iterator. */
2469 it
->call_index
= bfun
->number
- 1;
2470 it
->insn_index
= index
;
2478 btrace_insn_prev (struct btrace_insn_iterator
*it
, unsigned int stride
)
2480 const struct btrace_function
*bfun
;
2481 unsigned int index
, steps
;
2483 bfun
= &it
->btinfo
->functions
[it
->call_index
];
2485 index
= it
->insn_index
;
2491 /* Move to the previous function if we're at the start of this one. */
2494 const struct btrace_function
*prev
;
2496 prev
= ftrace_find_call_by_number (it
->btinfo
, bfun
->number
- 1);
2500 /* We point to one after the last instruction in the new function. */
2502 index
= bfun
->insn
.size ();
2504 /* An empty function segment represents a gap in the trace. We count
2505 it as one instruction. */
2515 /* Advance the iterator as far as possible within this segment. */
2516 adv
= std::min (index
, stride
);
2522 /* We did make progress. */
2523 gdb_assert (adv
> 0);
2526 /* Update the iterator. */
2527 it
->call_index
= bfun
->number
- 1;
2528 it
->insn_index
= index
;
2536 btrace_insn_cmp (const struct btrace_insn_iterator
*lhs
,
2537 const struct btrace_insn_iterator
*rhs
)
2539 gdb_assert (lhs
->btinfo
== rhs
->btinfo
);
2541 if (lhs
->call_index
!= rhs
->call_index
)
2542 return lhs
->call_index
- rhs
->call_index
;
2544 return lhs
->insn_index
- rhs
->insn_index
;
2550 btrace_find_insn_by_number (struct btrace_insn_iterator
*it
,
2551 const struct btrace_thread_info
*btinfo
,
2552 unsigned int number
)
2554 const struct btrace_function
*bfun
;
2555 unsigned int upper
, lower
;
2557 if (btinfo
->functions
.empty ())
2561 bfun
= &btinfo
->functions
[lower
];
2562 if (number
< bfun
->insn_offset
)
2565 upper
= btinfo
->functions
.size () - 1;
2566 bfun
= &btinfo
->functions
[upper
];
2567 if (number
>= bfun
->insn_offset
+ ftrace_call_num_insn (bfun
))
2570 /* We assume that there are no holes in the numbering. */
2573 const unsigned int average
= lower
+ (upper
- lower
) / 2;
2575 bfun
= &btinfo
->functions
[average
];
2577 if (number
< bfun
->insn_offset
)
2579 upper
= average
- 1;
2583 if (number
>= bfun
->insn_offset
+ ftrace_call_num_insn (bfun
))
2585 lower
= average
+ 1;
2592 it
->btinfo
= btinfo
;
2593 it
->call_index
= bfun
->number
- 1;
2594 it
->insn_index
= number
- bfun
->insn_offset
;
2598 /* Returns true if the recording ends with a function segment that
2599 contains only a single (i.e. the current) instruction. */
2602 btrace_ends_with_single_insn (const struct btrace_thread_info
*btinfo
)
2604 const btrace_function
*bfun
;
2606 if (btinfo
->functions
.empty ())
2609 bfun
= &btinfo
->functions
.back ();
2610 if (bfun
->errcode
!= 0)
2613 return ftrace_call_num_insn (bfun
) == 1;
2618 const struct btrace_function
*
2619 btrace_call_get (const struct btrace_call_iterator
*it
)
2621 if (it
->index
>= it
->btinfo
->functions
.size ())
2624 return &it
->btinfo
->functions
[it
->index
];
2630 btrace_call_number (const struct btrace_call_iterator
*it
)
2632 const unsigned int length
= it
->btinfo
->functions
.size ();
2634 /* If the last function segment contains only a single instruction (i.e. the
2635 current instruction), skip it. */
2636 if ((it
->index
== length
) && btrace_ends_with_single_insn (it
->btinfo
))
2639 return it
->index
+ 1;
2645 btrace_call_begin (struct btrace_call_iterator
*it
,
2646 const struct btrace_thread_info
*btinfo
)
2648 if (btinfo
->functions
.empty ())
2649 error (_("No trace."));
2651 it
->btinfo
= btinfo
;
2658 btrace_call_end (struct btrace_call_iterator
*it
,
2659 const struct btrace_thread_info
*btinfo
)
2661 if (btinfo
->functions
.empty ())
2662 error (_("No trace."));
2664 it
->btinfo
= btinfo
;
2665 it
->index
= btinfo
->functions
.size ();
2671 btrace_call_next (struct btrace_call_iterator
*it
, unsigned int stride
)
2673 const unsigned int length
= it
->btinfo
->functions
.size ();
2675 if (it
->index
+ stride
< length
- 1)
2676 /* Default case: Simply advance the iterator. */
2677 it
->index
+= stride
;
2678 else if (it
->index
+ stride
== length
- 1)
2680 /* We land exactly at the last function segment. If it contains only one
2681 instruction (i.e. the current instruction) it is not actually part of
2683 if (btrace_ends_with_single_insn (it
->btinfo
))
2686 it
->index
= length
- 1;
2690 /* We land past the last function segment and have to adjust the stride.
2691 If the last function segment contains only one instruction (i.e. the
2692 current instruction) it is not actually part of the trace. */
2693 if (btrace_ends_with_single_insn (it
->btinfo
))
2694 stride
= length
- it
->index
- 1;
2696 stride
= length
- it
->index
;
2707 btrace_call_prev (struct btrace_call_iterator
*it
, unsigned int stride
)
2709 const unsigned int length
= it
->btinfo
->functions
.size ();
2712 gdb_assert (it
->index
<= length
);
2714 if (stride
== 0 || it
->index
== 0)
2717 /* If we are at the end, the first step is a special case. If the last
2718 function segment contains only one instruction (i.e. the current
2719 instruction) it is not actually part of the trace. To be able to step
2720 over this instruction, we need at least one more function segment. */
2721 if ((it
->index
== length
) && (length
> 1))
2723 if (btrace_ends_with_single_insn (it
->btinfo
))
2724 it
->index
= length
- 2;
2726 it
->index
= length
- 1;
2732 stride
= std::min (stride
, it
->index
);
2734 it
->index
-= stride
;
2735 return steps
+ stride
;
2741 btrace_call_cmp (const struct btrace_call_iterator
*lhs
,
2742 const struct btrace_call_iterator
*rhs
)
2744 gdb_assert (lhs
->btinfo
== rhs
->btinfo
);
2745 return (int) (lhs
->index
- rhs
->index
);
2751 btrace_find_call_by_number (struct btrace_call_iterator
*it
,
2752 const struct btrace_thread_info
*btinfo
,
2753 unsigned int number
)
2755 const unsigned int length
= btinfo
->functions
.size ();
2757 if ((number
== 0) || (number
> length
))
2760 it
->btinfo
= btinfo
;
2761 it
->index
= number
- 1;
2768 btrace_set_insn_history (struct btrace_thread_info
*btinfo
,
2769 const struct btrace_insn_iterator
*begin
,
2770 const struct btrace_insn_iterator
*end
)
2772 if (btinfo
->insn_history
== NULL
)
2773 btinfo
->insn_history
= XCNEW (struct btrace_insn_history
);
2775 btinfo
->insn_history
->begin
= *begin
;
2776 btinfo
->insn_history
->end
= *end
;
2782 btrace_set_call_history (struct btrace_thread_info
*btinfo
,
2783 const struct btrace_call_iterator
*begin
,
2784 const struct btrace_call_iterator
*end
)
2786 gdb_assert (begin
->btinfo
== end
->btinfo
);
2788 if (btinfo
->call_history
== NULL
)
2789 btinfo
->call_history
= XCNEW (struct btrace_call_history
);
2791 btinfo
->call_history
->begin
= *begin
;
2792 btinfo
->call_history
->end
= *end
;
2798 btrace_is_replaying (struct thread_info
*tp
)
2800 return tp
->btrace
.replay
!= NULL
;
2806 btrace_is_empty (struct thread_info
*tp
)
2808 struct btrace_insn_iterator begin
, end
;
2809 struct btrace_thread_info
*btinfo
;
2811 btinfo
= &tp
->btrace
;
2813 if (btinfo
->functions
.empty ())
2816 btrace_insn_begin (&begin
, btinfo
);
2817 btrace_insn_end (&end
, btinfo
);
2819 return btrace_insn_cmp (&begin
, &end
) == 0;
2822 /* Forward the cleanup request. */
2825 do_btrace_data_cleanup (void *arg
)
2827 btrace_data_fini ((struct btrace_data
*) arg
);
2833 make_cleanup_btrace_data (struct btrace_data
*data
)
2835 return make_cleanup (do_btrace_data_cleanup
, data
);
2838 #if defined (HAVE_LIBIPT)
2840 /* Print a single packet. */
2843 pt_print_packet (const struct pt_packet
*packet
)
2845 switch (packet
->type
)
2848 printf_unfiltered (("[??: %x]"), packet
->type
);
2852 printf_unfiltered (("psb"));
2856 printf_unfiltered (("psbend"));
2860 printf_unfiltered (("pad"));
2864 printf_unfiltered (("tip %u: 0x%" PRIx64
""),
2865 packet
->payload
.ip
.ipc
,
2866 packet
->payload
.ip
.ip
);
2870 printf_unfiltered (("tip.pge %u: 0x%" PRIx64
""),
2871 packet
->payload
.ip
.ipc
,
2872 packet
->payload
.ip
.ip
);
2876 printf_unfiltered (("tip.pgd %u: 0x%" PRIx64
""),
2877 packet
->payload
.ip
.ipc
,
2878 packet
->payload
.ip
.ip
);
2882 printf_unfiltered (("fup %u: 0x%" PRIx64
""),
2883 packet
->payload
.ip
.ipc
,
2884 packet
->payload
.ip
.ip
);
2888 printf_unfiltered (("tnt-8 %u: 0x%" PRIx64
""),
2889 packet
->payload
.tnt
.bit_size
,
2890 packet
->payload
.tnt
.payload
);
2894 printf_unfiltered (("tnt-64 %u: 0x%" PRIx64
""),
2895 packet
->payload
.tnt
.bit_size
,
2896 packet
->payload
.tnt
.payload
);
2900 printf_unfiltered (("pip %" PRIx64
"%s"), packet
->payload
.pip
.cr3
,
2901 packet
->payload
.pip
.nr
? (" nr") : (""));
2905 printf_unfiltered (("tsc %" PRIx64
""), packet
->payload
.tsc
.tsc
);
2909 printf_unfiltered (("cbr %u"), packet
->payload
.cbr
.ratio
);
2913 switch (packet
->payload
.mode
.leaf
)
2916 printf_unfiltered (("mode %u"), packet
->payload
.mode
.leaf
);
2920 printf_unfiltered (("mode.exec%s%s"),
2921 packet
->payload
.mode
.bits
.exec
.csl
2923 packet
->payload
.mode
.bits
.exec
.csd
2924 ? (" cs.d") : (""));
2928 printf_unfiltered (("mode.tsx%s%s"),
2929 packet
->payload
.mode
.bits
.tsx
.intx
2931 packet
->payload
.mode
.bits
.tsx
.abrt
2932 ? (" abrt") : (""));
2938 printf_unfiltered (("ovf"));
2942 printf_unfiltered (("stop"));
2946 printf_unfiltered (("vmcs %" PRIx64
""), packet
->payload
.vmcs
.base
);
2950 printf_unfiltered (("tma %x %x"), packet
->payload
.tma
.ctc
,
2951 packet
->payload
.tma
.fc
);
2955 printf_unfiltered (("mtc %x"), packet
->payload
.mtc
.ctc
);
2959 printf_unfiltered (("cyc %" PRIx64
""), packet
->payload
.cyc
.value
);
2963 printf_unfiltered (("mnt %" PRIx64
""), packet
->payload
.mnt
.payload
);
2968 /* Decode packets into MAINT using DECODER. */
2971 btrace_maint_decode_pt (struct btrace_maint_info
*maint
,
2972 struct pt_packet_decoder
*decoder
)
2978 struct btrace_pt_packet packet
;
2980 errcode
= pt_pkt_sync_forward (decoder
);
2986 pt_pkt_get_offset (decoder
, &packet
.offset
);
2988 errcode
= pt_pkt_next (decoder
, &packet
.packet
,
2989 sizeof(packet
.packet
));
2993 if (maint_btrace_pt_skip_pad
== 0 || packet
.packet
.type
!= ppt_pad
)
2995 packet
.errcode
= pt_errcode (errcode
);
2996 VEC_safe_push (btrace_pt_packet_s
, maint
->variant
.pt
.packets
,
3001 if (errcode
== -pte_eos
)
3004 packet
.errcode
= pt_errcode (errcode
);
3005 VEC_safe_push (btrace_pt_packet_s
, maint
->variant
.pt
.packets
,
3008 warning (_("Error at trace offset 0x%" PRIx64
": %s."),
3009 packet
.offset
, pt_errstr (packet
.errcode
));
3012 if (errcode
!= -pte_eos
)
3013 warning (_("Failed to synchronize onto the Intel Processor Trace "
3014 "stream: %s."), pt_errstr (pt_errcode (errcode
)));
3017 /* Update the packet history in BTINFO. */
3020 btrace_maint_update_pt_packets (struct btrace_thread_info
*btinfo
)
3022 struct pt_packet_decoder
*decoder
;
3023 struct btrace_data_pt
*pt
;
3024 struct pt_config config
;
3027 pt
= &btinfo
->data
.variant
.pt
;
3029 /* Nothing to do if there is no trace. */
3033 memset (&config
, 0, sizeof(config
));
3035 config
.size
= sizeof (config
);
3036 config
.begin
= pt
->data
;
3037 config
.end
= pt
->data
+ pt
->size
;
3039 config
.cpu
.vendor
= pt_translate_cpu_vendor (pt
->config
.cpu
.vendor
);
3040 config
.cpu
.family
= pt
->config
.cpu
.family
;
3041 config
.cpu
.model
= pt
->config
.cpu
.model
;
3042 config
.cpu
.stepping
= pt
->config
.cpu
.stepping
;
3044 errcode
= pt_cpu_errata (&config
.errata
, &config
.cpu
);
3046 error (_("Failed to configure the Intel Processor Trace decoder: %s."),
3047 pt_errstr (pt_errcode (errcode
)));
3049 decoder
= pt_pkt_alloc_decoder (&config
);
3050 if (decoder
== NULL
)
3051 error (_("Failed to allocate the Intel Processor Trace decoder."));
3055 btrace_maint_decode_pt (&btinfo
->maint
, decoder
);
3057 CATCH (except
, RETURN_MASK_ALL
)
3059 pt_pkt_free_decoder (decoder
);
3061 if (except
.reason
< 0)
3062 throw_exception (except
);
3066 pt_pkt_free_decoder (decoder
);
3069 #endif /* !defined (HAVE_LIBIPT) */
3071 /* Update the packet maintenance information for BTINFO and store the
3072 low and high bounds into BEGIN and END, respectively.
3073 Store the current iterator state into FROM and TO. */
3076 btrace_maint_update_packets (struct btrace_thread_info
*btinfo
,
3077 unsigned int *begin
, unsigned int *end
,
3078 unsigned int *from
, unsigned int *to
)
3080 switch (btinfo
->data
.format
)
3089 case BTRACE_FORMAT_BTS
:
3090 /* Nothing to do - we operate directly on BTINFO->DATA. */
3092 *end
= VEC_length (btrace_block_s
, btinfo
->data
.variant
.bts
.blocks
);
3093 *from
= btinfo
->maint
.variant
.bts
.packet_history
.begin
;
3094 *to
= btinfo
->maint
.variant
.bts
.packet_history
.end
;
3097 #if defined (HAVE_LIBIPT)
3098 case BTRACE_FORMAT_PT
:
3099 if (VEC_empty (btrace_pt_packet_s
, btinfo
->maint
.variant
.pt
.packets
))
3100 btrace_maint_update_pt_packets (btinfo
);
3103 *end
= VEC_length (btrace_pt_packet_s
, btinfo
->maint
.variant
.pt
.packets
);
3104 *from
= btinfo
->maint
.variant
.pt
.packet_history
.begin
;
3105 *to
= btinfo
->maint
.variant
.pt
.packet_history
.end
;
3107 #endif /* defined (HAVE_LIBIPT) */
3111 /* Print packets in BTINFO from BEGIN (inclusive) until END (exclusive) and
3112 update the current iterator position. */
3115 btrace_maint_print_packets (struct btrace_thread_info
*btinfo
,
3116 unsigned int begin
, unsigned int end
)
3118 switch (btinfo
->data
.format
)
3123 case BTRACE_FORMAT_BTS
:
3125 VEC (btrace_block_s
) *blocks
;
3128 blocks
= btinfo
->data
.variant
.bts
.blocks
;
3129 for (blk
= begin
; blk
< end
; ++blk
)
3131 const btrace_block_s
*block
;
3133 block
= VEC_index (btrace_block_s
, blocks
, blk
);
3135 printf_unfiltered ("%u\tbegin: %s, end: %s\n", blk
,
3136 core_addr_to_string_nz (block
->begin
),
3137 core_addr_to_string_nz (block
->end
));
3140 btinfo
->maint
.variant
.bts
.packet_history
.begin
= begin
;
3141 btinfo
->maint
.variant
.bts
.packet_history
.end
= end
;
3145 #if defined (HAVE_LIBIPT)
3146 case BTRACE_FORMAT_PT
:
3148 VEC (btrace_pt_packet_s
) *packets
;
3151 packets
= btinfo
->maint
.variant
.pt
.packets
;
3152 for (pkt
= begin
; pkt
< end
; ++pkt
)
3154 const struct btrace_pt_packet
*packet
;
3156 packet
= VEC_index (btrace_pt_packet_s
, packets
, pkt
);
3158 printf_unfiltered ("%u\t", pkt
);
3159 printf_unfiltered ("0x%" PRIx64
"\t", packet
->offset
);
3161 if (packet
->errcode
== pte_ok
)
3162 pt_print_packet (&packet
->packet
);
3164 printf_unfiltered ("[error: %s]", pt_errstr (packet
->errcode
));
3166 printf_unfiltered ("\n");
3169 btinfo
->maint
.variant
.pt
.packet_history
.begin
= begin
;
3170 btinfo
->maint
.variant
.pt
.packet_history
.end
= end
;
3173 #endif /* defined (HAVE_LIBIPT) */
3177 /* Read a number from an argument string. */
3180 get_uint (const char **arg
)
3182 const char *begin
, *pos
;
3184 unsigned long number
;
3187 pos
= skip_spaces (begin
);
3189 if (!isdigit (*pos
))
3190 error (_("Expected positive number, got: %s."), pos
);
3192 number
= strtoul (pos
, &end
, 10);
3193 if (number
> UINT_MAX
)
3194 error (_("Number too big."));
3196 *arg
+= (end
- begin
);
3198 return (unsigned int) number
;
3201 /* Read a context size from an argument string. */
3204 get_context_size (const char **arg
)
3206 const char *pos
= skip_spaces (*arg
);
3208 if (!isdigit (*pos
))
3209 error (_("Expected positive number, got: %s."), pos
);
3212 long result
= strtol (pos
, &end
, 10);
3217 /* Complain about junk at the end of an argument string. */
3220 no_chunk (const char *arg
)
3223 error (_("Junk after argument: %s."), arg
);
3226 /* The "maintenance btrace packet-history" command. */
3229 maint_btrace_packet_history_cmd (const char *arg
, int from_tty
)
3231 struct btrace_thread_info
*btinfo
;
3232 struct thread_info
*tp
;
3233 unsigned int size
, begin
, end
, from
, to
;
3235 tp
= find_thread_ptid (inferior_ptid
);
3237 error (_("No thread."));
3240 btinfo
= &tp
->btrace
;
3242 btrace_maint_update_packets (btinfo
, &begin
, &end
, &from
, &to
);
3245 printf_unfiltered (_("No trace.\n"));
3249 if (arg
== NULL
|| *arg
== 0 || strcmp (arg
, "+") == 0)
3253 if (end
- from
< size
)
3257 else if (strcmp (arg
, "-") == 0)
3261 if (to
- begin
< size
)
3267 from
= get_uint (&arg
);
3269 error (_("'%u' is out of range."), from
);
3271 arg
= skip_spaces (arg
);
3274 arg
= skip_spaces (++arg
);
3279 size
= get_context_size (&arg
);
3283 if (end
- from
< size
)
3287 else if (*arg
== '-')
3290 size
= get_context_size (&arg
);
3294 /* Include the packet given as first argument. */
3298 if (to
- begin
< size
)
3304 to
= get_uint (&arg
);
3306 /* Include the packet at the second argument and silently
3307 truncate the range. */
3320 if (end
- from
< size
)
3328 btrace_maint_print_packets (btinfo
, from
, to
);
3331 /* The "maintenance btrace clear-packet-history" command. */
3334 maint_btrace_clear_packet_history_cmd (const char *args
, int from_tty
)
3336 struct btrace_thread_info
*btinfo
;
3337 struct thread_info
*tp
;
3339 if (args
!= NULL
&& *args
!= 0)
3340 error (_("Invalid argument."));
3342 tp
= find_thread_ptid (inferior_ptid
);
3344 error (_("No thread."));
3346 btinfo
= &tp
->btrace
;
3348 /* Must clear the maint data before - it depends on BTINFO->DATA. */
3349 btrace_maint_clear (btinfo
);
3350 btrace_data_clear (&btinfo
->data
);
3353 /* The "maintenance btrace clear" command. */
3356 maint_btrace_clear_cmd (const char *args
, int from_tty
)
3358 struct thread_info
*tp
;
3360 if (args
!= NULL
&& *args
!= 0)
3361 error (_("Invalid argument."));
3363 tp
= find_thread_ptid (inferior_ptid
);
3365 error (_("No thread."));
3370 /* The "maintenance btrace" command. */
3373 maint_btrace_cmd (const char *args
, int from_tty
)
3375 help_list (maint_btrace_cmdlist
, "maintenance btrace ", all_commands
,
3379 /* The "maintenance set btrace" command. */
3382 maint_btrace_set_cmd (const char *args
, int from_tty
)
3384 help_list (maint_btrace_set_cmdlist
, "maintenance set btrace ", all_commands
,
3388 /* The "maintenance show btrace" command. */
3391 maint_btrace_show_cmd (const char *args
, int from_tty
)
3393 help_list (maint_btrace_show_cmdlist
, "maintenance show btrace ",
3394 all_commands
, gdb_stdout
);
3397 /* The "maintenance set btrace pt" command. */
3400 maint_btrace_pt_set_cmd (const char *args
, int from_tty
)
3402 help_list (maint_btrace_pt_set_cmdlist
, "maintenance set btrace pt ",
3403 all_commands
, gdb_stdout
);
3406 /* The "maintenance show btrace pt" command. */
3409 maint_btrace_pt_show_cmd (const char *args
, int from_tty
)
3411 help_list (maint_btrace_pt_show_cmdlist
, "maintenance show btrace pt ",
3412 all_commands
, gdb_stdout
);
3415 /* The "maintenance info btrace" command. */
3418 maint_info_btrace_cmd (const char *args
, int from_tty
)
3420 struct btrace_thread_info
*btinfo
;
3421 struct thread_info
*tp
;
3422 const struct btrace_config
*conf
;
3424 if (args
!= NULL
&& *args
!= 0)
3425 error (_("Invalid argument."));
3427 tp
= find_thread_ptid (inferior_ptid
);
3429 error (_("No thread."));
3431 btinfo
= &tp
->btrace
;
3433 conf
= btrace_conf (btinfo
);
3435 error (_("No btrace configuration."));
3437 printf_unfiltered (_("Format: %s.\n"),
3438 btrace_format_string (conf
->format
));
3440 switch (conf
->format
)
3445 case BTRACE_FORMAT_BTS
:
3446 printf_unfiltered (_("Number of packets: %u.\n"),
3447 VEC_length (btrace_block_s
,
3448 btinfo
->data
.variant
.bts
.blocks
));
3451 #if defined (HAVE_LIBIPT)
3452 case BTRACE_FORMAT_PT
:
3454 struct pt_version version
;
3456 version
= pt_library_version ();
3457 printf_unfiltered (_("Version: %u.%u.%u%s.\n"), version
.major
,
3458 version
.minor
, version
.build
,
3459 version
.ext
!= NULL
? version
.ext
: "");
3461 btrace_maint_update_pt_packets (btinfo
);
3462 printf_unfiltered (_("Number of packets: %u.\n"),
3463 VEC_length (btrace_pt_packet_s
,
3464 btinfo
->maint
.variant
.pt
.packets
));
3467 #endif /* defined (HAVE_LIBIPT) */
3471 /* The "maint show btrace pt skip-pad" show value function. */
3474 show_maint_btrace_pt_skip_pad (struct ui_file
*file
, int from_tty
,
3475 struct cmd_list_element
*c
,
3478 fprintf_filtered (file
, _("Skip PAD packets is %s.\n"), value
);
3482 /* Initialize btrace maintenance commands. */
3485 _initialize_btrace (void)
3487 add_cmd ("btrace", class_maintenance
, maint_info_btrace_cmd
,
3488 _("Info about branch tracing data."), &maintenanceinfolist
);
3490 add_prefix_cmd ("btrace", class_maintenance
, maint_btrace_cmd
,
3491 _("Branch tracing maintenance commands."),
3492 &maint_btrace_cmdlist
, "maintenance btrace ",
3493 0, &maintenancelist
);
3495 add_prefix_cmd ("btrace", class_maintenance
, maint_btrace_set_cmd
, _("\
3496 Set branch tracing specific variables."),
3497 &maint_btrace_set_cmdlist
, "maintenance set btrace ",
3498 0, &maintenance_set_cmdlist
);
3500 add_prefix_cmd ("pt", class_maintenance
, maint_btrace_pt_set_cmd
, _("\
3501 Set Intel Processor Trace specific variables."),
3502 &maint_btrace_pt_set_cmdlist
, "maintenance set btrace pt ",
3503 0, &maint_btrace_set_cmdlist
);
3505 add_prefix_cmd ("btrace", class_maintenance
, maint_btrace_show_cmd
, _("\
3506 Show branch tracing specific variables."),
3507 &maint_btrace_show_cmdlist
, "maintenance show btrace ",
3508 0, &maintenance_show_cmdlist
);
3510 add_prefix_cmd ("pt", class_maintenance
, maint_btrace_pt_show_cmd
, _("\
3511 Show Intel Processor Trace specific variables."),
3512 &maint_btrace_pt_show_cmdlist
, "maintenance show btrace pt ",
3513 0, &maint_btrace_show_cmdlist
);
3515 add_setshow_boolean_cmd ("skip-pad", class_maintenance
,
3516 &maint_btrace_pt_skip_pad
, _("\
3517 Set whether PAD packets should be skipped in the btrace packet history."), _("\
3518 Show whether PAD packets should be skipped in the btrace packet history."),_("\
3519 When enabled, PAD packets are ignored in the btrace packet history."),
3520 NULL
, show_maint_btrace_pt_skip_pad
,
3521 &maint_btrace_pt_set_cmdlist
,
3522 &maint_btrace_pt_show_cmdlist
);
3524 add_cmd ("packet-history", class_maintenance
, maint_btrace_packet_history_cmd
,
3525 _("Print the raw branch tracing data.\n\
3526 With no argument, print ten more packets after the previous ten-line print.\n\
3527 With '-' as argument print ten packets before a previous ten-line print.\n\
3528 One argument specifies the starting packet of a ten-line print.\n\
3529 Two arguments with comma between specify starting and ending packets to \
3531 Preceded with '+'/'-' the second argument specifies the distance from the \
3533 &maint_btrace_cmdlist
);
3535 add_cmd ("clear-packet-history", class_maintenance
,
3536 maint_btrace_clear_packet_history_cmd
,
3537 _("Clears the branch tracing packet history.\n\
3538 Discards the raw branch tracing data but not the execution history data.\n\
3540 &maint_btrace_cmdlist
);
3542 add_cmd ("clear", class_maintenance
, maint_btrace_clear_cmd
,
3543 _("Clears the branch tracing data.\n\
3544 Discards the raw branch tracing data and the execution history data.\n\
3545 The next 'record' command will fetch the branch tracing data anew.\n\
3547 &maint_btrace_cmdlist
);