1 /* Branch trace support for GDB, the GNU debugger.
3 Copyright (C) 2013-2020 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"
34 #include "gdbsupport/rsp-low.h"
36 #include "cli/cli-utils.h"
39 /* For maintenance commands. */
40 #include "record-btrace.h"
46 /* Command lists for btrace maintenance commands. */
47 static struct cmd_list_element
*maint_btrace_cmdlist
;
48 static struct cmd_list_element
*maint_btrace_set_cmdlist
;
49 static struct cmd_list_element
*maint_btrace_show_cmdlist
;
50 static struct cmd_list_element
*maint_btrace_pt_set_cmdlist
;
51 static struct cmd_list_element
*maint_btrace_pt_show_cmdlist
;
53 /* Control whether to skip PAD packets when computing the packet history. */
54 static bool maint_btrace_pt_skip_pad
= true;
56 static void btrace_add_pc (struct thread_info
*tp
);
58 /* Print a record debug message. Use do ... while (0) to avoid ambiguities
59 when used in if statements. */
61 #define DEBUG(msg, args...) \
64 if (record_debug != 0) \
65 fprintf_unfiltered (gdb_stdlog, \
66 "[btrace] " msg "\n", ##args); \
70 #define DEBUG_FTRACE(msg, args...) DEBUG ("[ftrace] " msg, ##args)
72 /* Return the function name of a recorded function segment for printing.
73 This function never returns NULL. */
76 ftrace_print_function_name (const struct btrace_function
*bfun
)
78 struct minimal_symbol
*msym
;
85 return sym
->print_name ();
88 return msym
->print_name ();
93 /* Return the file name of a recorded function segment for printing.
94 This function never returns NULL. */
97 ftrace_print_filename (const struct btrace_function
*bfun
)
100 const char *filename
;
105 filename
= symtab_to_filename_for_display (symbol_symtab (sym
));
107 filename
= "<unknown>";
112 /* Return a string representation of the address of an instruction.
113 This function never returns NULL. */
116 ftrace_print_insn_addr (const struct btrace_insn
*insn
)
121 return core_addr_to_string_nz (insn
->pc
);
124 /* Print an ftrace debug status message. */
127 ftrace_debug (const struct btrace_function
*bfun
, const char *prefix
)
129 const char *fun
, *file
;
130 unsigned int ibegin
, iend
;
133 fun
= ftrace_print_function_name (bfun
);
134 file
= ftrace_print_filename (bfun
);
137 ibegin
= bfun
->insn_offset
;
138 iend
= ibegin
+ bfun
->insn
.size ();
140 DEBUG_FTRACE ("%s: fun = %s, file = %s, level = %d, insn = [%u; %u)",
141 prefix
, fun
, file
, level
, ibegin
, iend
);
144 /* Return the number of instructions in a given function call segment. */
147 ftrace_call_num_insn (const struct btrace_function
* bfun
)
152 /* A gap is always counted as one instruction. */
153 if (bfun
->errcode
!= 0)
156 return bfun
->insn
.size ();
159 /* Return the function segment with the given NUMBER or NULL if no such segment
160 exists. BTINFO is the branch trace information for the current thread. */
162 static struct btrace_function
*
163 ftrace_find_call_by_number (struct btrace_thread_info
*btinfo
,
166 if (number
== 0 || number
> btinfo
->functions
.size ())
169 return &btinfo
->functions
[number
- 1];
172 /* A const version of the function above. */
174 static const struct btrace_function
*
175 ftrace_find_call_by_number (const struct btrace_thread_info
*btinfo
,
178 if (number
== 0 || number
> btinfo
->functions
.size ())
181 return &btinfo
->functions
[number
- 1];
184 /* Return non-zero if BFUN does not match MFUN and FUN,
185 return zero otherwise. */
188 ftrace_function_switched (const struct btrace_function
*bfun
,
189 const struct minimal_symbol
*mfun
,
190 const struct symbol
*fun
)
192 struct minimal_symbol
*msym
;
198 /* If the minimal symbol changed, we certainly switched functions. */
199 if (mfun
!= NULL
&& msym
!= NULL
200 && strcmp (mfun
->linkage_name (), msym
->linkage_name ()) != 0)
203 /* If the symbol changed, we certainly switched functions. */
204 if (fun
!= NULL
&& sym
!= NULL
)
206 const char *bfname
, *fname
;
208 /* Check the function name. */
209 if (strcmp (fun
->linkage_name (), sym
->linkage_name ()) != 0)
212 /* Check the location of those functions, as well. */
213 bfname
= symtab_to_fullname (symbol_symtab (sym
));
214 fname
= symtab_to_fullname (symbol_symtab (fun
));
215 if (filename_cmp (fname
, bfname
) != 0)
219 /* If we lost symbol information, we switched functions. */
220 if (!(msym
== NULL
&& sym
== NULL
) && mfun
== NULL
&& fun
== NULL
)
223 /* If we gained symbol information, we switched functions. */
224 if (msym
== NULL
&& sym
== NULL
&& !(mfun
== NULL
&& fun
== NULL
))
230 /* Allocate and initialize a new branch trace function segment at the end of
232 BTINFO is the branch trace information for the current thread.
233 MFUN and FUN are the symbol information we have for this function.
234 This invalidates all struct btrace_function pointer currently held. */
236 static struct btrace_function
*
237 ftrace_new_function (struct btrace_thread_info
*btinfo
,
238 struct minimal_symbol
*mfun
,
242 unsigned int number
, insn_offset
;
244 if (btinfo
->functions
.empty ())
246 /* Start counting NUMBER and INSN_OFFSET at one. */
253 const struct btrace_function
*prev
= &btinfo
->functions
.back ();
255 number
= prev
->number
+ 1;
256 insn_offset
= prev
->insn_offset
+ ftrace_call_num_insn (prev
);
259 btinfo
->functions
.emplace_back (mfun
, fun
, number
, insn_offset
, level
);
260 return &btinfo
->functions
.back ();
263 /* Update the UP field of a function segment. */
266 ftrace_update_caller (struct btrace_function
*bfun
,
267 struct btrace_function
*caller
,
268 enum btrace_function_flag flags
)
271 ftrace_debug (bfun
, "updating caller");
273 bfun
->up
= caller
->number
;
276 ftrace_debug (bfun
, "set caller");
277 ftrace_debug (caller
, "..to");
280 /* Fix up the caller for all segments of a function. */
283 ftrace_fixup_caller (struct btrace_thread_info
*btinfo
,
284 struct btrace_function
*bfun
,
285 struct btrace_function
*caller
,
286 enum btrace_function_flag flags
)
288 unsigned int prev
, next
;
292 ftrace_update_caller (bfun
, caller
, flags
);
294 /* Update all function segments belonging to the same function. */
295 for (; prev
!= 0; prev
= bfun
->prev
)
297 bfun
= ftrace_find_call_by_number (btinfo
, prev
);
298 ftrace_update_caller (bfun
, caller
, flags
);
301 for (; next
!= 0; next
= bfun
->next
)
303 bfun
= ftrace_find_call_by_number (btinfo
, next
);
304 ftrace_update_caller (bfun
, caller
, flags
);
308 /* Add a new function segment for a call at the end of the trace.
309 BTINFO is the branch trace information for the current thread.
310 MFUN and FUN are the symbol information we have for this function. */
312 static struct btrace_function
*
313 ftrace_new_call (struct btrace_thread_info
*btinfo
,
314 struct minimal_symbol
*mfun
,
317 const unsigned int length
= btinfo
->functions
.size ();
318 struct btrace_function
*bfun
= ftrace_new_function (btinfo
, mfun
, fun
);
323 ftrace_debug (bfun
, "new call");
328 /* Add a new function segment for a tail call at the end of the trace.
329 BTINFO is the branch trace information for the current thread.
330 MFUN and FUN are the symbol information we have for this function. */
332 static struct btrace_function
*
333 ftrace_new_tailcall (struct btrace_thread_info
*btinfo
,
334 struct minimal_symbol
*mfun
,
337 const unsigned int length
= btinfo
->functions
.size ();
338 struct btrace_function
*bfun
= ftrace_new_function (btinfo
, mfun
, fun
);
342 bfun
->flags
|= BFUN_UP_LINKS_TO_TAILCALL
;
344 ftrace_debug (bfun
, "new tail call");
349 /* Return the caller of BFUN or NULL if there is none. This function skips
350 tail calls in the call chain. BTINFO is the branch trace information for
351 the current thread. */
352 static struct btrace_function
*
353 ftrace_get_caller (struct btrace_thread_info
*btinfo
,
354 struct btrace_function
*bfun
)
356 for (; bfun
!= NULL
; bfun
= ftrace_find_call_by_number (btinfo
, bfun
->up
))
357 if ((bfun
->flags
& BFUN_UP_LINKS_TO_TAILCALL
) == 0)
358 return ftrace_find_call_by_number (btinfo
, bfun
->up
);
363 /* Find the innermost caller in the back trace of BFUN with MFUN/FUN
364 symbol information. BTINFO is the branch trace information for the current
367 static struct btrace_function
*
368 ftrace_find_caller (struct btrace_thread_info
*btinfo
,
369 struct btrace_function
*bfun
,
370 struct minimal_symbol
*mfun
,
373 for (; bfun
!= NULL
; bfun
= ftrace_find_call_by_number (btinfo
, bfun
->up
))
375 /* Skip functions with incompatible symbol information. */
376 if (ftrace_function_switched (bfun
, mfun
, fun
))
379 /* This is the function segment we're looking for. */
386 /* Find the innermost caller in the back trace of BFUN, skipping all
387 function segments that do not end with a call instruction (e.g.
388 tail calls ending with a jump). BTINFO is the branch trace information for
389 the current thread. */
391 static struct btrace_function
*
392 ftrace_find_call (struct btrace_thread_info
*btinfo
,
393 struct btrace_function
*bfun
)
395 for (; bfun
!= NULL
; bfun
= ftrace_find_call_by_number (btinfo
, bfun
->up
))
398 if (bfun
->errcode
!= 0)
401 btrace_insn
&last
= bfun
->insn
.back ();
403 if (last
.iclass
== BTRACE_INSN_CALL
)
410 /* Add a continuation segment for a function into which we return at the end of
412 BTINFO is the branch trace information for the current thread.
413 MFUN and FUN are the symbol information we have for this function. */
415 static struct btrace_function
*
416 ftrace_new_return (struct btrace_thread_info
*btinfo
,
417 struct minimal_symbol
*mfun
,
420 struct btrace_function
*prev
, *bfun
, *caller
;
422 bfun
= ftrace_new_function (btinfo
, mfun
, fun
);
423 prev
= ftrace_find_call_by_number (btinfo
, bfun
->number
- 1);
425 /* It is important to start at PREV's caller. Otherwise, we might find
426 PREV itself, if PREV is a recursive function. */
427 caller
= ftrace_find_call_by_number (btinfo
, prev
->up
);
428 caller
= ftrace_find_caller (btinfo
, caller
, mfun
, fun
);
431 /* The caller of PREV is the preceding btrace function segment in this
432 function instance. */
433 gdb_assert (caller
->next
== 0);
435 caller
->next
= bfun
->number
;
436 bfun
->prev
= caller
->number
;
438 /* Maintain the function level. */
439 bfun
->level
= caller
->level
;
441 /* Maintain the call stack. */
442 bfun
->up
= caller
->up
;
443 bfun
->flags
= caller
->flags
;
445 ftrace_debug (bfun
, "new return");
449 /* We did not find a caller. This could mean that something went
450 wrong or that the call is simply not included in the trace. */
452 /* Let's search for some actual call. */
453 caller
= ftrace_find_call_by_number (btinfo
, prev
->up
);
454 caller
= ftrace_find_call (btinfo
, caller
);
457 /* There is no call in PREV's back trace. We assume that the
458 branch trace did not include it. */
460 /* Let's find the topmost function and add a new caller for it.
461 This should handle a series of initial tail calls. */
462 while (prev
->up
!= 0)
463 prev
= ftrace_find_call_by_number (btinfo
, prev
->up
);
465 bfun
->level
= prev
->level
- 1;
467 /* Fix up the call stack for PREV. */
468 ftrace_fixup_caller (btinfo
, prev
, bfun
, BFUN_UP_LINKS_TO_RET
);
470 ftrace_debug (bfun
, "new return - no caller");
474 /* There is a call in PREV's back trace to which we should have
475 returned but didn't. Let's start a new, separate back trace
476 from PREV's level. */
477 bfun
->level
= prev
->level
- 1;
479 /* We fix up the back trace for PREV but leave other function segments
480 on the same level as they are.
481 This should handle things like schedule () correctly where we're
482 switching contexts. */
483 prev
->up
= bfun
->number
;
484 prev
->flags
= BFUN_UP_LINKS_TO_RET
;
486 ftrace_debug (bfun
, "new return - unknown caller");
493 /* Add a new function segment for a function switch at the end of the trace.
494 BTINFO is the branch trace information for the current thread.
495 MFUN and FUN are the symbol information we have for this function. */
497 static struct btrace_function
*
498 ftrace_new_switch (struct btrace_thread_info
*btinfo
,
499 struct minimal_symbol
*mfun
,
502 struct btrace_function
*prev
, *bfun
;
504 /* This is an unexplained function switch. We can't really be sure about the
505 call stack, yet the best I can think of right now is to preserve it. */
506 bfun
= ftrace_new_function (btinfo
, mfun
, fun
);
507 prev
= ftrace_find_call_by_number (btinfo
, bfun
->number
- 1);
509 bfun
->flags
= prev
->flags
;
511 ftrace_debug (bfun
, "new switch");
516 /* Add a new function segment for a gap in the trace due to a decode error at
517 the end of the trace.
518 BTINFO is the branch trace information for the current thread.
519 ERRCODE is the format-specific error code. */
521 static struct btrace_function
*
522 ftrace_new_gap (struct btrace_thread_info
*btinfo
, int errcode
,
523 std::vector
<unsigned int> &gaps
)
525 struct btrace_function
*bfun
;
527 if (btinfo
->functions
.empty ())
528 bfun
= ftrace_new_function (btinfo
, NULL
, NULL
);
531 /* We hijack the previous function segment if it was empty. */
532 bfun
= &btinfo
->functions
.back ();
533 if (bfun
->errcode
!= 0 || !bfun
->insn
.empty ())
534 bfun
= ftrace_new_function (btinfo
, NULL
, NULL
);
537 bfun
->errcode
= errcode
;
538 gaps
.push_back (bfun
->number
);
540 ftrace_debug (bfun
, "new gap");
545 /* Update the current function segment at the end of the trace in BTINFO with
546 respect to the instruction at PC. This may create new function segments.
547 Return the chronologically latest function segment, never NULL. */
549 static struct btrace_function
*
550 ftrace_update_function (struct btrace_thread_info
*btinfo
, CORE_ADDR pc
)
552 struct bound_minimal_symbol bmfun
;
553 struct minimal_symbol
*mfun
;
555 struct btrace_function
*bfun
;
557 /* Try to determine the function we're in. We use both types of symbols
558 to avoid surprises when we sometimes get a full symbol and sometimes
559 only a minimal symbol. */
560 fun
= find_pc_function (pc
);
561 bmfun
= lookup_minimal_symbol_by_pc (pc
);
564 if (fun
== NULL
&& mfun
== NULL
)
565 DEBUG_FTRACE ("no symbol at %s", core_addr_to_string_nz (pc
));
567 /* If we didn't have a function, we create one. */
568 if (btinfo
->functions
.empty ())
569 return ftrace_new_function (btinfo
, mfun
, fun
);
571 /* If we had a gap before, we create a function. */
572 bfun
= &btinfo
->functions
.back ();
573 if (bfun
->errcode
!= 0)
574 return ftrace_new_function (btinfo
, mfun
, fun
);
576 /* Check the last instruction, if we have one.
577 We do this check first, since it allows us to fill in the call stack
578 links in addition to the normal flow links. */
579 btrace_insn
*last
= NULL
;
580 if (!bfun
->insn
.empty ())
581 last
= &bfun
->insn
.back ();
585 switch (last
->iclass
)
587 case BTRACE_INSN_RETURN
:
591 /* On some systems, _dl_runtime_resolve returns to the resolved
592 function instead of jumping to it. From our perspective,
593 however, this is a tailcall.
594 If we treated it as return, we wouldn't be able to find the
595 resolved function in our stack back trace. Hence, we would
596 lose the current stack back trace and start anew with an empty
597 back trace. When the resolved function returns, we would then
598 create a stack back trace with the same function names but
599 different frame id's. This will confuse stepping. */
600 fname
= ftrace_print_function_name (bfun
);
601 if (strcmp (fname
, "_dl_runtime_resolve") == 0)
602 return ftrace_new_tailcall (btinfo
, mfun
, fun
);
604 return ftrace_new_return (btinfo
, mfun
, fun
);
607 case BTRACE_INSN_CALL
:
608 /* Ignore calls to the next instruction. They are used for PIC. */
609 if (last
->pc
+ last
->size
== pc
)
612 return ftrace_new_call (btinfo
, mfun
, fun
);
614 case BTRACE_INSN_JUMP
:
618 start
= get_pc_function_start (pc
);
620 /* A jump to the start of a function is (typically) a tail call. */
622 return ftrace_new_tailcall (btinfo
, mfun
, fun
);
624 /* Some versions of _Unwind_RaiseException use an indirect
625 jump to 'return' to the exception handler of the caller
626 handling the exception instead of a return. Let's restrict
627 this heuristic to that and related functions. */
628 const char *fname
= ftrace_print_function_name (bfun
);
629 if (strncmp (fname
, "_Unwind_", strlen ("_Unwind_")) == 0)
631 struct btrace_function
*caller
632 = ftrace_find_call_by_number (btinfo
, bfun
->up
);
633 caller
= ftrace_find_caller (btinfo
, caller
, mfun
, fun
);
635 return ftrace_new_return (btinfo
, mfun
, fun
);
638 /* If we can't determine the function for PC, we treat a jump at
639 the end of the block as tail call if we're switching functions
640 and as an intra-function branch if we don't. */
641 if (start
== 0 && ftrace_function_switched (bfun
, mfun
, fun
))
642 return ftrace_new_tailcall (btinfo
, mfun
, fun
);
649 /* Check if we're switching functions for some other reason. */
650 if (ftrace_function_switched (bfun
, mfun
, fun
))
652 DEBUG_FTRACE ("switching from %s in %s at %s",
653 ftrace_print_insn_addr (last
),
654 ftrace_print_function_name (bfun
),
655 ftrace_print_filename (bfun
));
657 return ftrace_new_switch (btinfo
, mfun
, fun
);
663 /* Add the instruction at PC to BFUN's instructions. */
666 ftrace_update_insns (struct btrace_function
*bfun
, const btrace_insn
&insn
)
668 bfun
->insn
.push_back (insn
);
670 if (record_debug
> 1)
671 ftrace_debug (bfun
, "update insn");
674 /* Classify the instruction at PC. */
676 static enum btrace_insn_class
677 ftrace_classify_insn (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
679 enum btrace_insn_class iclass
;
681 iclass
= BTRACE_INSN_OTHER
;
684 if (gdbarch_insn_is_call (gdbarch
, pc
))
685 iclass
= BTRACE_INSN_CALL
;
686 else if (gdbarch_insn_is_ret (gdbarch
, pc
))
687 iclass
= BTRACE_INSN_RETURN
;
688 else if (gdbarch_insn_is_jump (gdbarch
, pc
))
689 iclass
= BTRACE_INSN_JUMP
;
691 catch (const gdb_exception_error
&error
)
698 /* Try to match the back trace at LHS to the back trace at RHS. Returns the
699 number of matching function segments or zero if the back traces do not
700 match. BTINFO is the branch trace information for the current thread. */
703 ftrace_match_backtrace (struct btrace_thread_info
*btinfo
,
704 struct btrace_function
*lhs
,
705 struct btrace_function
*rhs
)
709 for (matches
= 0; lhs
!= NULL
&& rhs
!= NULL
; ++matches
)
711 if (ftrace_function_switched (lhs
, rhs
->msym
, rhs
->sym
))
714 lhs
= ftrace_get_caller (btinfo
, lhs
);
715 rhs
= ftrace_get_caller (btinfo
, rhs
);
721 /* Add ADJUSTMENT to the level of BFUN and succeeding function segments.
722 BTINFO is the branch trace information for the current thread. */
725 ftrace_fixup_level (struct btrace_thread_info
*btinfo
,
726 struct btrace_function
*bfun
, int adjustment
)
731 DEBUG_FTRACE ("fixup level (%+d)", adjustment
);
732 ftrace_debug (bfun
, "..bfun");
736 bfun
->level
+= adjustment
;
737 bfun
= ftrace_find_call_by_number (btinfo
, bfun
->number
+ 1);
741 /* Recompute the global level offset. Traverse the function trace and compute
742 the global level offset as the negative of the minimal function level. */
745 ftrace_compute_global_level_offset (struct btrace_thread_info
*btinfo
)
752 if (btinfo
->functions
.empty ())
755 unsigned int length
= btinfo
->functions
.size() - 1;
756 for (unsigned int i
= 0; i
< length
; ++i
)
757 level
= std::min (level
, btinfo
->functions
[i
].level
);
759 /* The last function segment contains the current instruction, which is not
760 really part of the trace. If it contains just this one instruction, we
761 ignore the segment. */
762 struct btrace_function
*last
= &btinfo
->functions
.back();
763 if (last
->insn
.size () != 1)
764 level
= std::min (level
, last
->level
);
766 DEBUG_FTRACE ("setting global level offset: %d", -level
);
767 btinfo
->level
= -level
;
770 /* Connect the function segments PREV and NEXT in a bottom-to-top walk as in
771 ftrace_connect_backtrace. BTINFO is the branch trace information for the
775 ftrace_connect_bfun (struct btrace_thread_info
*btinfo
,
776 struct btrace_function
*prev
,
777 struct btrace_function
*next
)
779 DEBUG_FTRACE ("connecting...");
780 ftrace_debug (prev
, "..prev");
781 ftrace_debug (next
, "..next");
783 /* The function segments are not yet connected. */
784 gdb_assert (prev
->next
== 0);
785 gdb_assert (next
->prev
== 0);
787 prev
->next
= next
->number
;
788 next
->prev
= prev
->number
;
790 /* We may have moved NEXT to a different function level. */
791 ftrace_fixup_level (btinfo
, next
, prev
->level
- next
->level
);
793 /* If we run out of back trace for one, let's use the other's. */
796 const btrace_function_flags flags
= next
->flags
;
798 next
= ftrace_find_call_by_number (btinfo
, next
->up
);
801 DEBUG_FTRACE ("using next's callers");
802 ftrace_fixup_caller (btinfo
, prev
, next
, flags
);
805 else if (next
->up
== 0)
807 const btrace_function_flags flags
= prev
->flags
;
809 prev
= ftrace_find_call_by_number (btinfo
, prev
->up
);
812 DEBUG_FTRACE ("using prev's callers");
813 ftrace_fixup_caller (btinfo
, next
, prev
, flags
);
818 /* PREV may have a tailcall caller, NEXT can't. If it does, fixup the up
819 link to add the tail callers to NEXT's back trace.
821 This removes NEXT->UP from NEXT's back trace. It will be added back
822 when connecting NEXT and PREV's callers - provided they exist.
824 If PREV's back trace consists of a series of tail calls without an
825 actual call, there will be no further connection and NEXT's caller will
826 be removed for good. To catch this case, we handle it here and connect
827 the top of PREV's back trace to NEXT's caller. */
828 if ((prev
->flags
& BFUN_UP_LINKS_TO_TAILCALL
) != 0)
830 struct btrace_function
*caller
;
831 btrace_function_flags next_flags
, prev_flags
;
833 /* We checked NEXT->UP above so CALLER can't be NULL. */
834 caller
= ftrace_find_call_by_number (btinfo
, next
->up
);
835 next_flags
= next
->flags
;
836 prev_flags
= prev
->flags
;
838 DEBUG_FTRACE ("adding prev's tail calls to next");
840 prev
= ftrace_find_call_by_number (btinfo
, prev
->up
);
841 ftrace_fixup_caller (btinfo
, next
, prev
, prev_flags
);
843 for (; prev
!= NULL
; prev
= ftrace_find_call_by_number (btinfo
,
846 /* At the end of PREV's back trace, continue with CALLER. */
849 DEBUG_FTRACE ("fixing up link for tailcall chain");
850 ftrace_debug (prev
, "..top");
851 ftrace_debug (caller
, "..up");
853 ftrace_fixup_caller (btinfo
, prev
, caller
, next_flags
);
855 /* If we skipped any tail calls, this may move CALLER to a
856 different function level.
858 Note that changing CALLER's level is only OK because we
859 know that this is the last iteration of the bottom-to-top
860 walk in ftrace_connect_backtrace.
862 Otherwise we will fix up CALLER's level when we connect it
863 to PREV's caller in the next iteration. */
864 ftrace_fixup_level (btinfo
, caller
,
865 prev
->level
- caller
->level
- 1);
869 /* There's nothing to do if we find a real call. */
870 if ((prev
->flags
& BFUN_UP_LINKS_TO_TAILCALL
) == 0)
872 DEBUG_FTRACE ("will fix up link in next iteration");
880 /* Connect function segments on the same level in the back trace at LHS and RHS.
881 The back traces at LHS and RHS are expected to match according to
882 ftrace_match_backtrace. BTINFO is the branch trace information for the
886 ftrace_connect_backtrace (struct btrace_thread_info
*btinfo
,
887 struct btrace_function
*lhs
,
888 struct btrace_function
*rhs
)
890 while (lhs
!= NULL
&& rhs
!= NULL
)
892 struct btrace_function
*prev
, *next
;
894 gdb_assert (!ftrace_function_switched (lhs
, rhs
->msym
, rhs
->sym
));
896 /* Connecting LHS and RHS may change the up link. */
900 lhs
= ftrace_get_caller (btinfo
, lhs
);
901 rhs
= ftrace_get_caller (btinfo
, rhs
);
903 ftrace_connect_bfun (btinfo
, prev
, next
);
907 /* Bridge the gap between two function segments left and right of a gap if their
908 respective back traces match in at least MIN_MATCHES functions. BTINFO is
909 the branch trace information for the current thread.
911 Returns non-zero if the gap could be bridged, zero otherwise. */
914 ftrace_bridge_gap (struct btrace_thread_info
*btinfo
,
915 struct btrace_function
*lhs
, struct btrace_function
*rhs
,
918 struct btrace_function
*best_l
, *best_r
, *cand_l
, *cand_r
;
921 DEBUG_FTRACE ("checking gap at insn %u (req matches: %d)",
922 rhs
->insn_offset
- 1, min_matches
);
928 /* We search the back traces of LHS and RHS for valid connections and connect
929 the two function segments that give the longest combined back trace. */
931 for (cand_l
= lhs
; cand_l
!= NULL
;
932 cand_l
= ftrace_get_caller (btinfo
, cand_l
))
933 for (cand_r
= rhs
; cand_r
!= NULL
;
934 cand_r
= ftrace_get_caller (btinfo
, cand_r
))
938 matches
= ftrace_match_backtrace (btinfo
, cand_l
, cand_r
);
939 if (best_matches
< matches
)
941 best_matches
= matches
;
947 /* We need at least MIN_MATCHES matches. */
948 gdb_assert (min_matches
> 0);
949 if (best_matches
< min_matches
)
952 DEBUG_FTRACE ("..matches: %d", best_matches
);
954 /* We will fix up the level of BEST_R and succeeding function segments such
955 that BEST_R's level matches BEST_L's when we connect BEST_L to BEST_R.
957 This will ignore the level of RHS and following if BEST_R != RHS. I.e. if
958 BEST_R is a successor of RHS in the back trace of RHS (phases 1 and 3).
960 To catch this, we already fix up the level here where we can start at RHS
961 instead of at BEST_R. We will ignore the level fixup when connecting
962 BEST_L to BEST_R as they will already be on the same level. */
963 ftrace_fixup_level (btinfo
, rhs
, best_l
->level
- best_r
->level
);
965 ftrace_connect_backtrace (btinfo
, best_l
, best_r
);
970 /* Try to bridge gaps due to overflow or decode errors by connecting the
971 function segments that are separated by the gap. */
974 btrace_bridge_gaps (struct thread_info
*tp
, std::vector
<unsigned int> &gaps
)
976 struct btrace_thread_info
*btinfo
= &tp
->btrace
;
977 std::vector
<unsigned int> remaining
;
980 DEBUG ("bridge gaps");
982 /* We require a minimum amount of matches for bridging a gap. The number of
983 required matches will be lowered with each iteration.
985 The more matches the higher our confidence that the bridging is correct.
986 For big gaps or small traces, however, it may not be feasible to require a
987 high number of matches. */
988 for (min_matches
= 5; min_matches
> 0; --min_matches
)
990 /* Let's try to bridge as many gaps as we can. In some cases, we need to
991 skip a gap and revisit it again after we closed later gaps. */
992 while (!gaps
.empty ())
994 for (const unsigned int number
: gaps
)
996 struct btrace_function
*gap
, *lhs
, *rhs
;
999 gap
= ftrace_find_call_by_number (btinfo
, number
);
1001 /* We may have a sequence of gaps if we run from one error into
1002 the next as we try to re-sync onto the trace stream. Ignore
1003 all but the leftmost gap in such a sequence.
1005 Also ignore gaps at the beginning of the trace. */
1006 lhs
= ftrace_find_call_by_number (btinfo
, gap
->number
- 1);
1007 if (lhs
== NULL
|| lhs
->errcode
!= 0)
1010 /* Skip gaps to the right. */
1011 rhs
= ftrace_find_call_by_number (btinfo
, gap
->number
+ 1);
1012 while (rhs
!= NULL
&& rhs
->errcode
!= 0)
1013 rhs
= ftrace_find_call_by_number (btinfo
, rhs
->number
+ 1);
1015 /* Ignore gaps at the end of the trace. */
1019 bridged
= ftrace_bridge_gap (btinfo
, lhs
, rhs
, min_matches
);
1021 /* Keep track of gaps we were not able to bridge and try again.
1022 If we just pushed them to the end of GAPS we would risk an
1023 infinite loop in case we simply cannot bridge a gap. */
1025 remaining
.push_back (number
);
1028 /* Let's see if we made any progress. */
1029 if (remaining
.size () == gaps
.size ())
1033 gaps
.swap (remaining
);
1036 /* We get here if either GAPS is empty or if GAPS equals REMAINING. */
1043 /* We may omit this in some cases. Not sure it is worth the extra
1044 complication, though. */
1045 ftrace_compute_global_level_offset (btinfo
);
1048 /* Compute the function branch trace from BTS trace. */
1051 btrace_compute_ftrace_bts (struct thread_info
*tp
,
1052 const struct btrace_data_bts
*btrace
,
1053 std::vector
<unsigned int> &gaps
)
1055 struct btrace_thread_info
*btinfo
;
1056 struct gdbarch
*gdbarch
;
1060 gdbarch
= target_gdbarch ();
1061 btinfo
= &tp
->btrace
;
1062 blk
= btrace
->blocks
->size ();
1064 if (btinfo
->functions
.empty ())
1067 level
= -btinfo
->level
;
1075 const btrace_block
&block
= btrace
->blocks
->at (blk
);
1080 struct btrace_function
*bfun
;
1081 struct btrace_insn insn
;
1084 /* We should hit the end of the block. Warn if we went too far. */
1087 /* Indicate the gap in the trace. */
1088 bfun
= ftrace_new_gap (btinfo
, BDE_BTS_OVERFLOW
, gaps
);
1090 warning (_("Recorded trace may be corrupted at instruction "
1091 "%u (pc = %s)."), bfun
->insn_offset
- 1,
1092 core_addr_to_string_nz (pc
));
1097 bfun
= ftrace_update_function (btinfo
, pc
);
1099 /* Maintain the function level offset.
1100 For all but the last block, we do it here. */
1102 level
= std::min (level
, bfun
->level
);
1107 size
= gdb_insn_length (gdbarch
, pc
);
1109 catch (const gdb_exception_error
&error
)
1115 insn
.iclass
= ftrace_classify_insn (gdbarch
, pc
);
1118 ftrace_update_insns (bfun
, insn
);
1120 /* We're done once we pushed the instruction at the end. */
1121 if (block
.end
== pc
)
1124 /* We can't continue if we fail to compute the size. */
1127 /* Indicate the gap in the trace. We just added INSN so we're
1128 not at the beginning. */
1129 bfun
= ftrace_new_gap (btinfo
, BDE_BTS_INSN_SIZE
, gaps
);
1131 warning (_("Recorded trace may be incomplete at instruction %u "
1132 "(pc = %s)."), bfun
->insn_offset
- 1,
1133 core_addr_to_string_nz (pc
));
1140 /* Maintain the function level offset.
1141 For the last block, we do it here to not consider the last
1143 Since the last instruction corresponds to the current instruction
1144 and is not really part of the execution history, it shouldn't
1145 affect the level. */
1147 level
= std::min (level
, bfun
->level
);
1151 /* LEVEL is the minimal function level of all btrace function segments.
1152 Define the global level offset to -LEVEL so all function levels are
1153 normalized to start at zero. */
1154 btinfo
->level
= -level
;
1157 #if defined (HAVE_LIBIPT)
1159 static enum btrace_insn_class
1160 pt_reclassify_insn (enum pt_insn_class iclass
)
1165 return BTRACE_INSN_CALL
;
1168 return BTRACE_INSN_RETURN
;
1171 return BTRACE_INSN_JUMP
;
1174 return BTRACE_INSN_OTHER
;
1178 /* Return the btrace instruction flags for INSN. */
1180 static btrace_insn_flags
1181 pt_btrace_insn_flags (const struct pt_insn
&insn
)
1183 btrace_insn_flags flags
= 0;
1185 if (insn
.speculative
)
1186 flags
|= BTRACE_INSN_FLAG_SPECULATIVE
;
1191 /* Return the btrace instruction for INSN. */
1194 pt_btrace_insn (const struct pt_insn
&insn
)
1196 return {(CORE_ADDR
) insn
.ip
, (gdb_byte
) insn
.size
,
1197 pt_reclassify_insn (insn
.iclass
),
1198 pt_btrace_insn_flags (insn
)};
1201 /* Handle instruction decode events (libipt-v2). */
1204 handle_pt_insn_events (struct btrace_thread_info
*btinfo
,
1205 struct pt_insn_decoder
*decoder
,
1206 std::vector
<unsigned int> &gaps
, int status
)
1208 #if defined (HAVE_PT_INSN_EVENT)
1209 while (status
& pts_event_pending
)
1211 struct btrace_function
*bfun
;
1212 struct pt_event event
;
1215 status
= pt_insn_event (decoder
, &event
, sizeof (event
));
1225 if (event
.variant
.enabled
.resumed
== 0 && !btinfo
->functions
.empty ())
1227 bfun
= ftrace_new_gap (btinfo
, BDE_PT_DISABLED
, gaps
);
1229 pt_insn_get_offset (decoder
, &offset
);
1231 warning (_("Non-contiguous trace at instruction %u (offset = 0x%"
1232 PRIx64
")."), bfun
->insn_offset
- 1, offset
);
1238 bfun
= ftrace_new_gap (btinfo
, BDE_PT_OVERFLOW
, gaps
);
1240 pt_insn_get_offset (decoder
, &offset
);
1242 warning (_("Overflow at instruction %u (offset = 0x%" PRIx64
")."),
1243 bfun
->insn_offset
- 1, offset
);
1248 #endif /* defined (HAVE_PT_INSN_EVENT) */
1253 /* Handle events indicated by flags in INSN (libipt-v1). */
1256 handle_pt_insn_event_flags (struct btrace_thread_info
*btinfo
,
1257 struct pt_insn_decoder
*decoder
,
1258 const struct pt_insn
&insn
,
1259 std::vector
<unsigned int> &gaps
)
1261 #if defined (HAVE_STRUCT_PT_INSN_ENABLED)
1262 /* Tracing is disabled and re-enabled each time we enter the kernel. Most
1263 times, we continue from the same instruction we stopped before. This is
1264 indicated via the RESUMED instruction flag. The ENABLED instruction flag
1265 means that we continued from some other instruction. Indicate this as a
1266 trace gap except when tracing just started. */
1267 if (insn
.enabled
&& !btinfo
->functions
.empty ())
1269 struct btrace_function
*bfun
;
1272 bfun
= ftrace_new_gap (btinfo
, BDE_PT_DISABLED
, gaps
);
1274 pt_insn_get_offset (decoder
, &offset
);
1276 warning (_("Non-contiguous trace at instruction %u (offset = 0x%" PRIx64
1277 ", pc = 0x%" PRIx64
")."), bfun
->insn_offset
- 1, offset
,
1280 #endif /* defined (HAVE_STRUCT_PT_INSN_ENABLED) */
1282 #if defined (HAVE_STRUCT_PT_INSN_RESYNCED)
1283 /* Indicate trace overflows. */
1286 struct btrace_function
*bfun
;
1289 bfun
= ftrace_new_gap (btinfo
, BDE_PT_OVERFLOW
, gaps
);
1291 pt_insn_get_offset (decoder
, &offset
);
1293 warning (_("Overflow at instruction %u (offset = 0x%" PRIx64
", pc = 0x%"
1294 PRIx64
")."), bfun
->insn_offset
- 1, offset
, insn
.ip
);
1296 #endif /* defined (HAVE_STRUCT_PT_INSN_RESYNCED) */
1299 /* Add function branch trace to BTINFO using DECODER. */
1302 ftrace_add_pt (struct btrace_thread_info
*btinfo
,
1303 struct pt_insn_decoder
*decoder
,
1305 std::vector
<unsigned int> &gaps
)
1307 struct btrace_function
*bfun
;
1313 struct pt_insn insn
;
1315 status
= pt_insn_sync_forward (decoder
);
1318 if (status
!= -pte_eos
)
1319 warning (_("Failed to synchronize onto the Intel Processor "
1320 "Trace stream: %s."), pt_errstr (pt_errcode (status
)));
1326 /* Handle events from the previous iteration or synchronization. */
1327 status
= handle_pt_insn_events (btinfo
, decoder
, gaps
, status
);
1331 status
= pt_insn_next (decoder
, &insn
, sizeof(insn
));
1335 /* Handle events indicated by flags in INSN. */
1336 handle_pt_insn_event_flags (btinfo
, decoder
, insn
, gaps
);
1338 bfun
= ftrace_update_function (btinfo
, insn
.ip
);
1340 /* Maintain the function level offset. */
1341 *plevel
= std::min (*plevel
, bfun
->level
);
1343 ftrace_update_insns (bfun
, pt_btrace_insn (insn
));
1346 if (status
== -pte_eos
)
1349 /* Indicate the gap in the trace. */
1350 bfun
= ftrace_new_gap (btinfo
, status
, gaps
);
1352 pt_insn_get_offset (decoder
, &offset
);
1354 warning (_("Decode error (%d) at instruction %u (offset = 0x%" PRIx64
1355 ", pc = 0x%" PRIx64
"): %s."), status
, bfun
->insn_offset
- 1,
1356 offset
, insn
.ip
, pt_errstr (pt_errcode (status
)));
1360 /* A callback function to allow the trace decoder to read the inferior's
1364 btrace_pt_readmem_callback (gdb_byte
*buffer
, size_t size
,
1365 const struct pt_asid
*asid
, uint64_t pc
,
1368 int result
, errcode
;
1370 result
= (int) size
;
1373 errcode
= target_read_code ((CORE_ADDR
) pc
, buffer
, size
);
1375 result
= -pte_nomap
;
1377 catch (const gdb_exception_error
&error
)
1379 result
= -pte_nomap
;
1385 /* Translate the vendor from one enum to another. */
1387 static enum pt_cpu_vendor
1388 pt_translate_cpu_vendor (enum btrace_cpu_vendor vendor
)
1400 /* Finalize the function branch trace after decode. */
1402 static void btrace_finalize_ftrace_pt (struct pt_insn_decoder
*decoder
,
1403 struct thread_info
*tp
, int level
)
1405 pt_insn_free_decoder (decoder
);
1407 /* LEVEL is the minimal function level of all btrace function segments.
1408 Define the global level offset to -LEVEL so all function levels are
1409 normalized to start at zero. */
1410 tp
->btrace
.level
= -level
;
1412 /* Add a single last instruction entry for the current PC.
1413 This allows us to compute the backtrace at the current PC using both
1414 standard unwind and btrace unwind.
1415 This extra entry is ignored by all record commands. */
1419 /* Compute the function branch trace from Intel Processor Trace
1423 btrace_compute_ftrace_pt (struct thread_info
*tp
,
1424 const struct btrace_data_pt
*btrace
,
1425 std::vector
<unsigned int> &gaps
)
1427 struct btrace_thread_info
*btinfo
;
1428 struct pt_insn_decoder
*decoder
;
1429 struct pt_config config
;
1432 if (btrace
->size
== 0)
1435 btinfo
= &tp
->btrace
;
1436 if (btinfo
->functions
.empty ())
1439 level
= -btinfo
->level
;
1441 pt_config_init(&config
);
1442 config
.begin
= btrace
->data
;
1443 config
.end
= btrace
->data
+ btrace
->size
;
1445 /* We treat an unknown vendor as 'no errata'. */
1446 if (btrace
->config
.cpu
.vendor
!= CV_UNKNOWN
)
1449 = pt_translate_cpu_vendor (btrace
->config
.cpu
.vendor
);
1450 config
.cpu
.family
= btrace
->config
.cpu
.family
;
1451 config
.cpu
.model
= btrace
->config
.cpu
.model
;
1452 config
.cpu
.stepping
= btrace
->config
.cpu
.stepping
;
1454 errcode
= pt_cpu_errata (&config
.errata
, &config
.cpu
);
1456 error (_("Failed to configure the Intel Processor Trace "
1457 "decoder: %s."), pt_errstr (pt_errcode (errcode
)));
1460 decoder
= pt_insn_alloc_decoder (&config
);
1461 if (decoder
== NULL
)
1462 error (_("Failed to allocate the Intel Processor Trace decoder."));
1466 struct pt_image
*image
;
1468 image
= pt_insn_get_image(decoder
);
1470 error (_("Failed to configure the Intel Processor Trace decoder."));
1472 errcode
= pt_image_set_callback(image
, btrace_pt_readmem_callback
, NULL
);
1474 error (_("Failed to configure the Intel Processor Trace decoder: "
1475 "%s."), pt_errstr (pt_errcode (errcode
)));
1477 ftrace_add_pt (btinfo
, decoder
, &level
, gaps
);
1479 catch (const gdb_exception
&error
)
1481 /* Indicate a gap in the trace if we quit trace processing. */
1482 if (error
.reason
== RETURN_QUIT
&& !btinfo
->functions
.empty ())
1483 ftrace_new_gap (btinfo
, BDE_PT_USER_QUIT
, gaps
);
1485 btrace_finalize_ftrace_pt (decoder
, tp
, level
);
1490 btrace_finalize_ftrace_pt (decoder
, tp
, level
);
1493 #else /* defined (HAVE_LIBIPT) */
1496 btrace_compute_ftrace_pt (struct thread_info
*tp
,
1497 const struct btrace_data_pt
*btrace
,
1498 std::vector
<unsigned int> &gaps
)
1500 internal_error (__FILE__
, __LINE__
, _("Unexpected branch trace format."));
1503 #endif /* defined (HAVE_LIBIPT) */
1505 /* Compute the function branch trace from a block branch trace BTRACE for
1506 a thread given by BTINFO. If CPU is not NULL, overwrite the cpu in the
1507 branch trace configuration. This is currently only used for the PT
1511 btrace_compute_ftrace_1 (struct thread_info
*tp
,
1512 struct btrace_data
*btrace
,
1513 const struct btrace_cpu
*cpu
,
1514 std::vector
<unsigned int> &gaps
)
1516 DEBUG ("compute ftrace");
1518 switch (btrace
->format
)
1520 case BTRACE_FORMAT_NONE
:
1523 case BTRACE_FORMAT_BTS
:
1524 btrace_compute_ftrace_bts (tp
, &btrace
->variant
.bts
, gaps
);
1527 case BTRACE_FORMAT_PT
:
1528 /* Overwrite the cpu we use for enabling errata workarounds. */
1530 btrace
->variant
.pt
.config
.cpu
= *cpu
;
1532 btrace_compute_ftrace_pt (tp
, &btrace
->variant
.pt
, gaps
);
1536 internal_error (__FILE__
, __LINE__
, _("Unknown branch trace format."));
1540 btrace_finalize_ftrace (struct thread_info
*tp
, std::vector
<unsigned int> &gaps
)
1544 tp
->btrace
.ngaps
+= gaps
.size ();
1545 btrace_bridge_gaps (tp
, gaps
);
1550 btrace_compute_ftrace (struct thread_info
*tp
, struct btrace_data
*btrace
,
1551 const struct btrace_cpu
*cpu
)
1553 std::vector
<unsigned int> gaps
;
1557 btrace_compute_ftrace_1 (tp
, btrace
, cpu
, gaps
);
1559 catch (const gdb_exception
&error
)
1561 btrace_finalize_ftrace (tp
, gaps
);
1566 btrace_finalize_ftrace (tp
, gaps
);
1569 /* Add an entry for the current PC. */
1572 btrace_add_pc (struct thread_info
*tp
)
1574 struct btrace_data btrace
;
1575 struct regcache
*regcache
;
1578 regcache
= get_thread_regcache (tp
);
1579 pc
= regcache_read_pc (regcache
);
1581 btrace
.format
= BTRACE_FORMAT_BTS
;
1582 btrace
.variant
.bts
.blocks
= new std::vector
<btrace_block
>;
1584 btrace
.variant
.bts
.blocks
->emplace_back (pc
, pc
);
1586 btrace_compute_ftrace (tp
, &btrace
, NULL
);
1592 btrace_enable (struct thread_info
*tp
, const struct btrace_config
*conf
)
1594 if (tp
->btrace
.target
!= NULL
)
1595 error (_("Recording already enabled on thread %s (%s)."),
1596 print_thread_id (tp
), target_pid_to_str (tp
->ptid
).c_str ());
1598 #if !defined (HAVE_LIBIPT)
1599 if (conf
->format
== BTRACE_FORMAT_PT
)
1600 error (_("Intel Processor Trace support was disabled at compile time."));
1601 #endif /* !defined (HAVE_LIBIPT) */
1603 DEBUG ("enable thread %s (%s)", print_thread_id (tp
),
1604 target_pid_to_str (tp
->ptid
).c_str ());
1606 tp
->btrace
.target
= target_enable_btrace (tp
->ptid
, conf
);
1608 if (tp
->btrace
.target
== NULL
)
1609 error (_("Failed to enable recording on thread %s (%s)."),
1610 print_thread_id (tp
), target_pid_to_str (tp
->ptid
).c_str ());
1612 /* We need to undo the enable in case of errors. */
1615 /* Add an entry for the current PC so we start tracing from where we
1618 If we can't access TP's registers, TP is most likely running. In this
1619 case, we can't really say where tracing was enabled so it should be
1620 safe to simply skip this step.
1622 This is not relevant for BTRACE_FORMAT_PT since the trace will already
1623 start at the PC at which tracing was enabled. */
1624 if (conf
->format
!= BTRACE_FORMAT_PT
1625 && can_access_registers_thread (tp
))
1628 catch (const gdb_exception
&exception
)
1630 btrace_disable (tp
);
1638 const struct btrace_config
*
1639 btrace_conf (const struct btrace_thread_info
*btinfo
)
1641 if (btinfo
->target
== NULL
)
1644 return target_btrace_conf (btinfo
->target
);
1650 btrace_disable (struct thread_info
*tp
)
1652 struct btrace_thread_info
*btp
= &tp
->btrace
;
1654 if (btp
->target
== NULL
)
1655 error (_("Recording not enabled on thread %s (%s)."),
1656 print_thread_id (tp
), target_pid_to_str (tp
->ptid
).c_str ());
1658 DEBUG ("disable thread %s (%s)", print_thread_id (tp
),
1659 target_pid_to_str (tp
->ptid
).c_str ());
1661 target_disable_btrace (btp
->target
);
1670 btrace_teardown (struct thread_info
*tp
)
1672 struct btrace_thread_info
*btp
= &tp
->btrace
;
1674 if (btp
->target
== NULL
)
1677 DEBUG ("teardown thread %s (%s)", print_thread_id (tp
),
1678 target_pid_to_str (tp
->ptid
).c_str ());
1680 target_teardown_btrace (btp
->target
);
1686 /* Stitch branch trace in BTS format. */
1689 btrace_stitch_bts (struct btrace_data_bts
*btrace
, struct thread_info
*tp
)
1691 struct btrace_thread_info
*btinfo
;
1692 struct btrace_function
*last_bfun
;
1693 btrace_block
*first_new_block
;
1695 btinfo
= &tp
->btrace
;
1696 gdb_assert (!btinfo
->functions
.empty ());
1697 gdb_assert (!btrace
->blocks
->empty ());
1699 last_bfun
= &btinfo
->functions
.back ();
1701 /* If the existing trace ends with a gap, we just glue the traces
1702 together. We need to drop the last (i.e. chronologically first) block
1703 of the new trace, though, since we can't fill in the start address.*/
1704 if (last_bfun
->insn
.empty ())
1706 btrace
->blocks
->pop_back ();
1710 /* Beware that block trace starts with the most recent block, so the
1711 chronologically first block in the new trace is the last block in
1712 the new trace's block vector. */
1713 first_new_block
= &btrace
->blocks
->back ();
1714 const btrace_insn
&last_insn
= last_bfun
->insn
.back ();
1716 /* If the current PC at the end of the block is the same as in our current
1717 trace, there are two explanations:
1718 1. we executed the instruction and some branch brought us back.
1719 2. we have not made any progress.
1720 In the first case, the delta trace vector should contain at least two
1722 In the second case, the delta trace vector should contain exactly one
1723 entry for the partial block containing the current PC. Remove it. */
1724 if (first_new_block
->end
== last_insn
.pc
&& btrace
->blocks
->size () == 1)
1726 btrace
->blocks
->pop_back ();
1730 DEBUG ("stitching %s to %s", ftrace_print_insn_addr (&last_insn
),
1731 core_addr_to_string_nz (first_new_block
->end
));
1733 /* Do a simple sanity check to make sure we don't accidentally end up
1734 with a bad block. This should not occur in practice. */
1735 if (first_new_block
->end
< last_insn
.pc
)
1737 warning (_("Error while trying to read delta trace. Falling back to "
1742 /* We adjust the last block to start at the end of our current trace. */
1743 gdb_assert (first_new_block
->begin
== 0);
1744 first_new_block
->begin
= last_insn
.pc
;
1746 /* We simply pop the last insn so we can insert it again as part of
1747 the normal branch trace computation.
1748 Since instruction iterators are based on indices in the instructions
1749 vector, we don't leave any pointers dangling. */
1750 DEBUG ("pruning insn at %s for stitching",
1751 ftrace_print_insn_addr (&last_insn
));
1753 last_bfun
->insn
.pop_back ();
1755 /* The instructions vector may become empty temporarily if this has
1756 been the only instruction in this function segment.
1757 This violates the invariant but will be remedied shortly by
1758 btrace_compute_ftrace when we add the new trace. */
1760 /* The only case where this would hurt is if the entire trace consisted
1761 of just that one instruction. If we remove it, we might turn the now
1762 empty btrace function segment into a gap. But we don't want gaps at
1763 the beginning. To avoid this, we remove the entire old trace. */
1764 if (last_bfun
->number
== 1 && last_bfun
->insn
.empty ())
1770 /* Adjust the block trace in order to stitch old and new trace together.
1771 BTRACE is the new delta trace between the last and the current stop.
1772 TP is the traced thread.
1773 May modifx BTRACE as well as the existing trace in TP.
1774 Return 0 on success, -1 otherwise. */
1777 btrace_stitch_trace (struct btrace_data
*btrace
, struct thread_info
*tp
)
1779 /* If we don't have trace, there's nothing to do. */
1780 if (btrace
->empty ())
1783 switch (btrace
->format
)
1785 case BTRACE_FORMAT_NONE
:
1788 case BTRACE_FORMAT_BTS
:
1789 return btrace_stitch_bts (&btrace
->variant
.bts
, tp
);
1791 case BTRACE_FORMAT_PT
:
1792 /* Delta reads are not supported. */
1796 internal_error (__FILE__
, __LINE__
, _("Unknown branch trace format."));
1799 /* Clear the branch trace histories in BTINFO. */
1802 btrace_clear_history (struct btrace_thread_info
*btinfo
)
1804 xfree (btinfo
->insn_history
);
1805 xfree (btinfo
->call_history
);
1806 xfree (btinfo
->replay
);
1808 btinfo
->insn_history
= NULL
;
1809 btinfo
->call_history
= NULL
;
1810 btinfo
->replay
= NULL
;
1813 /* Clear the branch trace maintenance histories in BTINFO. */
1816 btrace_maint_clear (struct btrace_thread_info
*btinfo
)
1818 switch (btinfo
->data
.format
)
1823 case BTRACE_FORMAT_BTS
:
1824 btinfo
->maint
.variant
.bts
.packet_history
.begin
= 0;
1825 btinfo
->maint
.variant
.bts
.packet_history
.end
= 0;
1828 #if defined (HAVE_LIBIPT)
1829 case BTRACE_FORMAT_PT
:
1830 delete btinfo
->maint
.variant
.pt
.packets
;
1832 btinfo
->maint
.variant
.pt
.packets
= NULL
;
1833 btinfo
->maint
.variant
.pt
.packet_history
.begin
= 0;
1834 btinfo
->maint
.variant
.pt
.packet_history
.end
= 0;
1836 #endif /* defined (HAVE_LIBIPT) */
1843 btrace_decode_error (enum btrace_format format
, int errcode
)
1847 case BTRACE_FORMAT_BTS
:
1850 case BDE_BTS_OVERFLOW
:
1851 return _("instruction overflow");
1853 case BDE_BTS_INSN_SIZE
:
1854 return _("unknown instruction");
1861 #if defined (HAVE_LIBIPT)
1862 case BTRACE_FORMAT_PT
:
1865 case BDE_PT_USER_QUIT
:
1866 return _("trace decode cancelled");
1868 case BDE_PT_DISABLED
:
1869 return _("disabled");
1871 case BDE_PT_OVERFLOW
:
1872 return _("overflow");
1876 return pt_errstr (pt_errcode (errcode
));
1880 #endif /* defined (HAVE_LIBIPT) */
1886 return _("unknown");
1892 btrace_fetch (struct thread_info
*tp
, const struct btrace_cpu
*cpu
)
1894 struct btrace_thread_info
*btinfo
;
1895 struct btrace_target_info
*tinfo
;
1896 struct btrace_data btrace
;
1899 DEBUG ("fetch thread %s (%s)", print_thread_id (tp
),
1900 target_pid_to_str (tp
->ptid
).c_str ());
1902 btinfo
= &tp
->btrace
;
1903 tinfo
= btinfo
->target
;
1907 /* There's no way we could get new trace while replaying.
1908 On the other hand, delta trace would return a partial record with the
1909 current PC, which is the replay PC, not the last PC, as expected. */
1910 if (btinfo
->replay
!= NULL
)
1913 /* With CLI usage, TP->PTID always equals INFERIOR_PTID here. Now that we
1914 can store a gdb.Record object in Python referring to a different thread
1915 than the current one, temporarily set INFERIOR_PTID. */
1916 scoped_restore save_inferior_ptid
= make_scoped_restore (&inferior_ptid
);
1917 inferior_ptid
= tp
->ptid
;
1919 /* We should not be called on running or exited threads. */
1920 gdb_assert (can_access_registers_thread (tp
));
1922 /* Let's first try to extend the trace we already have. */
1923 if (!btinfo
->functions
.empty ())
1925 errcode
= target_read_btrace (&btrace
, tinfo
, BTRACE_READ_DELTA
);
1928 /* Success. Let's try to stitch the traces together. */
1929 errcode
= btrace_stitch_trace (&btrace
, tp
);
1933 /* We failed to read delta trace. Let's try to read new trace. */
1934 errcode
= target_read_btrace (&btrace
, tinfo
, BTRACE_READ_NEW
);
1936 /* If we got any new trace, discard what we have. */
1937 if (errcode
== 0 && !btrace
.empty ())
1941 /* If we were not able to read the trace, we start over. */
1945 errcode
= target_read_btrace (&btrace
, tinfo
, BTRACE_READ_ALL
);
1949 errcode
= target_read_btrace (&btrace
, tinfo
, BTRACE_READ_ALL
);
1951 /* If we were not able to read the branch trace, signal an error. */
1953 error (_("Failed to read branch trace."));
1955 /* Compute the trace, provided we have any. */
1956 if (!btrace
.empty ())
1958 /* Store the raw trace data. The stored data will be cleared in
1959 btrace_clear, so we always append the new trace. */
1960 btrace_data_append (&btinfo
->data
, &btrace
);
1961 btrace_maint_clear (btinfo
);
1963 btrace_clear_history (btinfo
);
1964 btrace_compute_ftrace (tp
, &btrace
, cpu
);
1971 btrace_clear (struct thread_info
*tp
)
1973 struct btrace_thread_info
*btinfo
;
1975 DEBUG ("clear thread %s (%s)", print_thread_id (tp
),
1976 target_pid_to_str (tp
->ptid
).c_str ());
1978 /* Make sure btrace frames that may hold a pointer into the branch
1979 trace data are destroyed. */
1980 reinit_frame_cache ();
1982 btinfo
= &tp
->btrace
;
1984 btinfo
->functions
.clear ();
1987 /* Must clear the maint data before - it depends on BTINFO->DATA. */
1988 btrace_maint_clear (btinfo
);
1989 btinfo
->data
.clear ();
1990 btrace_clear_history (btinfo
);
1996 btrace_free_objfile (struct objfile
*objfile
)
1998 DEBUG ("free objfile");
2000 for (thread_info
*tp
: all_non_exited_threads ())
2004 #if defined (HAVE_LIBEXPAT)
2006 /* Check the btrace document version. */
2009 check_xml_btrace_version (struct gdb_xml_parser
*parser
,
2010 const struct gdb_xml_element
*element
,
2012 std::vector
<gdb_xml_value
> &attributes
)
2015 = (const char *) xml_find_attribute (attributes
, "version")->value
.get ();
2017 if (strcmp (version
, "1.0") != 0)
2018 gdb_xml_error (parser
, _("Unsupported btrace version: \"%s\""), version
);
2021 /* Parse a btrace "block" xml record. */
2024 parse_xml_btrace_block (struct gdb_xml_parser
*parser
,
2025 const struct gdb_xml_element
*element
,
2027 std::vector
<gdb_xml_value
> &attributes
)
2029 struct btrace_data
*btrace
;
2030 ULONGEST
*begin
, *end
;
2032 btrace
= (struct btrace_data
*) user_data
;
2034 switch (btrace
->format
)
2036 case BTRACE_FORMAT_BTS
:
2039 case BTRACE_FORMAT_NONE
:
2040 btrace
->format
= BTRACE_FORMAT_BTS
;
2041 btrace
->variant
.bts
.blocks
= new std::vector
<btrace_block
>;
2045 gdb_xml_error (parser
, _("Btrace format error."));
2048 begin
= (ULONGEST
*) xml_find_attribute (attributes
, "begin")->value
.get ();
2049 end
= (ULONGEST
*) xml_find_attribute (attributes
, "end")->value
.get ();
2050 btrace
->variant
.bts
.blocks
->emplace_back (*begin
, *end
);
2053 /* Parse a "raw" xml record. */
2056 parse_xml_raw (struct gdb_xml_parser
*parser
, const char *body_text
,
2057 gdb_byte
**pdata
, size_t *psize
)
2062 len
= strlen (body_text
);
2064 gdb_xml_error (parser
, _("Bad raw data size."));
2068 gdb::unique_xmalloc_ptr
<gdb_byte
> data ((gdb_byte
*) xmalloc (size
));
2071 /* We use hex encoding - see gdbsupport/rsp-low.h. */
2079 if (hi
== 0 || lo
== 0)
2080 gdb_xml_error (parser
, _("Bad hex encoding."));
2082 *bin
++ = fromhex (hi
) * 16 + fromhex (lo
);
2086 *pdata
= data
.release ();
2090 /* Parse a btrace pt-config "cpu" xml record. */
2093 parse_xml_btrace_pt_config_cpu (struct gdb_xml_parser
*parser
,
2094 const struct gdb_xml_element
*element
,
2096 std::vector
<gdb_xml_value
> &attributes
)
2098 struct btrace_data
*btrace
;
2100 ULONGEST
*family
, *model
, *stepping
;
2103 (const char *) xml_find_attribute (attributes
, "vendor")->value
.get ();
2105 = (ULONGEST
*) xml_find_attribute (attributes
, "family")->value
.get ();
2107 = (ULONGEST
*) xml_find_attribute (attributes
, "model")->value
.get ();
2109 = (ULONGEST
*) xml_find_attribute (attributes
, "stepping")->value
.get ();
2111 btrace
= (struct btrace_data
*) user_data
;
2113 if (strcmp (vendor
, "GenuineIntel") == 0)
2114 btrace
->variant
.pt
.config
.cpu
.vendor
= CV_INTEL
;
2116 btrace
->variant
.pt
.config
.cpu
.family
= *family
;
2117 btrace
->variant
.pt
.config
.cpu
.model
= *model
;
2118 btrace
->variant
.pt
.config
.cpu
.stepping
= *stepping
;
2121 /* Parse a btrace pt "raw" xml record. */
2124 parse_xml_btrace_pt_raw (struct gdb_xml_parser
*parser
,
2125 const struct gdb_xml_element
*element
,
2126 void *user_data
, const char *body_text
)
2128 struct btrace_data
*btrace
;
2130 btrace
= (struct btrace_data
*) user_data
;
2131 parse_xml_raw (parser
, body_text
, &btrace
->variant
.pt
.data
,
2132 &btrace
->variant
.pt
.size
);
2135 /* Parse a btrace "pt" xml record. */
2138 parse_xml_btrace_pt (struct gdb_xml_parser
*parser
,
2139 const struct gdb_xml_element
*element
,
2141 std::vector
<gdb_xml_value
> &attributes
)
2143 struct btrace_data
*btrace
;
2145 btrace
= (struct btrace_data
*) user_data
;
2146 btrace
->format
= BTRACE_FORMAT_PT
;
2147 btrace
->variant
.pt
.config
.cpu
.vendor
= CV_UNKNOWN
;
2148 btrace
->variant
.pt
.data
= NULL
;
2149 btrace
->variant
.pt
.size
= 0;
2152 static const struct gdb_xml_attribute block_attributes
[] = {
2153 { "begin", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
2154 { "end", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
2155 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
2158 static const struct gdb_xml_attribute btrace_pt_config_cpu_attributes
[] = {
2159 { "vendor", GDB_XML_AF_NONE
, NULL
, NULL
},
2160 { "family", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
2161 { "model", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
2162 { "stepping", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
2163 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
2166 static const struct gdb_xml_element btrace_pt_config_children
[] = {
2167 { "cpu", btrace_pt_config_cpu_attributes
, NULL
, GDB_XML_EF_OPTIONAL
,
2168 parse_xml_btrace_pt_config_cpu
, NULL
},
2169 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
2172 static const struct gdb_xml_element btrace_pt_children
[] = {
2173 { "pt-config", NULL
, btrace_pt_config_children
, GDB_XML_EF_OPTIONAL
, NULL
,
2175 { "raw", NULL
, NULL
, GDB_XML_EF_OPTIONAL
, NULL
, parse_xml_btrace_pt_raw
},
2176 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
2179 static const struct gdb_xml_attribute btrace_attributes
[] = {
2180 { "version", GDB_XML_AF_NONE
, NULL
, NULL
},
2181 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
2184 static const struct gdb_xml_element btrace_children
[] = {
2185 { "block", block_attributes
, NULL
,
2186 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
, parse_xml_btrace_block
, NULL
},
2187 { "pt", NULL
, btrace_pt_children
, GDB_XML_EF_OPTIONAL
, parse_xml_btrace_pt
,
2189 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
2192 static const struct gdb_xml_element btrace_elements
[] = {
2193 { "btrace", btrace_attributes
, btrace_children
, GDB_XML_EF_NONE
,
2194 check_xml_btrace_version
, NULL
},
2195 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
2198 #endif /* defined (HAVE_LIBEXPAT) */
2203 parse_xml_btrace (struct btrace_data
*btrace
, const char *buffer
)
2205 #if defined (HAVE_LIBEXPAT)
2209 result
.format
= BTRACE_FORMAT_NONE
;
2211 errcode
= gdb_xml_parse_quick (_("btrace"), "btrace.dtd", btrace_elements
,
2214 error (_("Error parsing branch trace."));
2216 /* Keep parse results. */
2217 *btrace
= std::move (result
);
2219 #else /* !defined (HAVE_LIBEXPAT) */
2221 error (_("Cannot process branch trace. XML support was disabled at "
2224 #endif /* !defined (HAVE_LIBEXPAT) */
2227 #if defined (HAVE_LIBEXPAT)
2229 /* Parse a btrace-conf "bts" xml record. */
2232 parse_xml_btrace_conf_bts (struct gdb_xml_parser
*parser
,
2233 const struct gdb_xml_element
*element
,
2235 std::vector
<gdb_xml_value
> &attributes
)
2237 struct btrace_config
*conf
;
2238 struct gdb_xml_value
*size
;
2240 conf
= (struct btrace_config
*) user_data
;
2241 conf
->format
= BTRACE_FORMAT_BTS
;
2244 size
= xml_find_attribute (attributes
, "size");
2246 conf
->bts
.size
= (unsigned int) *(ULONGEST
*) size
->value
.get ();
2249 /* Parse a btrace-conf "pt" xml record. */
2252 parse_xml_btrace_conf_pt (struct gdb_xml_parser
*parser
,
2253 const struct gdb_xml_element
*element
,
2255 std::vector
<gdb_xml_value
> &attributes
)
2257 struct btrace_config
*conf
;
2258 struct gdb_xml_value
*size
;
2260 conf
= (struct btrace_config
*) user_data
;
2261 conf
->format
= BTRACE_FORMAT_PT
;
2264 size
= xml_find_attribute (attributes
, "size");
2266 conf
->pt
.size
= (unsigned int) *(ULONGEST
*) size
->value
.get ();
2269 static const struct gdb_xml_attribute btrace_conf_pt_attributes
[] = {
2270 { "size", GDB_XML_AF_OPTIONAL
, gdb_xml_parse_attr_ulongest
, NULL
},
2271 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
2274 static const struct gdb_xml_attribute btrace_conf_bts_attributes
[] = {
2275 { "size", GDB_XML_AF_OPTIONAL
, gdb_xml_parse_attr_ulongest
, NULL
},
2276 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
2279 static const struct gdb_xml_element btrace_conf_children
[] = {
2280 { "bts", btrace_conf_bts_attributes
, NULL
, GDB_XML_EF_OPTIONAL
,
2281 parse_xml_btrace_conf_bts
, NULL
},
2282 { "pt", btrace_conf_pt_attributes
, NULL
, GDB_XML_EF_OPTIONAL
,
2283 parse_xml_btrace_conf_pt
, NULL
},
2284 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
2287 static const struct gdb_xml_attribute btrace_conf_attributes
[] = {
2288 { "version", GDB_XML_AF_NONE
, NULL
, NULL
},
2289 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
2292 static const struct gdb_xml_element btrace_conf_elements
[] = {
2293 { "btrace-conf", btrace_conf_attributes
, btrace_conf_children
,
2294 GDB_XML_EF_NONE
, NULL
, NULL
},
2295 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
2298 #endif /* defined (HAVE_LIBEXPAT) */
2303 parse_xml_btrace_conf (struct btrace_config
*conf
, const char *xml
)
2305 #if defined (HAVE_LIBEXPAT)
2308 errcode
= gdb_xml_parse_quick (_("btrace-conf"), "btrace-conf.dtd",
2309 btrace_conf_elements
, xml
, conf
);
2311 error (_("Error parsing branch trace configuration."));
2313 #else /* !defined (HAVE_LIBEXPAT) */
2315 error (_("Cannot process the branch trace configuration. XML support "
2316 "was disabled at compile time."));
2318 #endif /* !defined (HAVE_LIBEXPAT) */
2323 const struct btrace_insn
*
2324 btrace_insn_get (const struct btrace_insn_iterator
*it
)
2326 const struct btrace_function
*bfun
;
2327 unsigned int index
, end
;
2329 index
= it
->insn_index
;
2330 bfun
= &it
->btinfo
->functions
[it
->call_index
];
2332 /* Check if the iterator points to a gap in the trace. */
2333 if (bfun
->errcode
!= 0)
2336 /* The index is within the bounds of this function's instruction vector. */
2337 end
= bfun
->insn
.size ();
2338 gdb_assert (0 < end
);
2339 gdb_assert (index
< end
);
2341 return &bfun
->insn
[index
];
2347 btrace_insn_get_error (const struct btrace_insn_iterator
*it
)
2349 return it
->btinfo
->functions
[it
->call_index
].errcode
;
2355 btrace_insn_number (const struct btrace_insn_iterator
*it
)
2357 return it
->btinfo
->functions
[it
->call_index
].insn_offset
+ it
->insn_index
;
2363 btrace_insn_begin (struct btrace_insn_iterator
*it
,
2364 const struct btrace_thread_info
*btinfo
)
2366 if (btinfo
->functions
.empty ())
2367 error (_("No trace."));
2369 it
->btinfo
= btinfo
;
2377 btrace_insn_end (struct btrace_insn_iterator
*it
,
2378 const struct btrace_thread_info
*btinfo
)
2380 const struct btrace_function
*bfun
;
2381 unsigned int length
;
2383 if (btinfo
->functions
.empty ())
2384 error (_("No trace."));
2386 bfun
= &btinfo
->functions
.back ();
2387 length
= bfun
->insn
.size ();
2389 /* The last function may either be a gap or it contains the current
2390 instruction, which is one past the end of the execution trace; ignore
2395 it
->btinfo
= btinfo
;
2396 it
->call_index
= bfun
->number
- 1;
2397 it
->insn_index
= length
;
2403 btrace_insn_next (struct btrace_insn_iterator
*it
, unsigned int stride
)
2405 const struct btrace_function
*bfun
;
2406 unsigned int index
, steps
;
2408 bfun
= &it
->btinfo
->functions
[it
->call_index
];
2410 index
= it
->insn_index
;
2414 unsigned int end
, space
, adv
;
2416 end
= bfun
->insn
.size ();
2418 /* An empty function segment represents a gap in the trace. We count
2419 it as one instruction. */
2422 const struct btrace_function
*next
;
2424 next
= ftrace_find_call_by_number (it
->btinfo
, bfun
->number
+ 1);
2437 gdb_assert (0 < end
);
2438 gdb_assert (index
< end
);
2440 /* Compute the number of instructions remaining in this segment. */
2441 space
= end
- index
;
2443 /* Advance the iterator as far as possible within this segment. */
2444 adv
= std::min (space
, stride
);
2449 /* Move to the next function if we're at the end of this one. */
2452 const struct btrace_function
*next
;
2454 next
= ftrace_find_call_by_number (it
->btinfo
, bfun
->number
+ 1);
2457 /* We stepped past the last function.
2459 Let's adjust the index to point to the last instruction in
2460 the previous function. */
2466 /* We now point to the first instruction in the new function. */
2471 /* We did make progress. */
2472 gdb_assert (adv
> 0);
2475 /* Update the iterator. */
2476 it
->call_index
= bfun
->number
- 1;
2477 it
->insn_index
= index
;
2485 btrace_insn_prev (struct btrace_insn_iterator
*it
, unsigned int stride
)
2487 const struct btrace_function
*bfun
;
2488 unsigned int index
, steps
;
2490 bfun
= &it
->btinfo
->functions
[it
->call_index
];
2492 index
= it
->insn_index
;
2498 /* Move to the previous function if we're at the start of this one. */
2501 const struct btrace_function
*prev
;
2503 prev
= ftrace_find_call_by_number (it
->btinfo
, bfun
->number
- 1);
2507 /* We point to one after the last instruction in the new function. */
2509 index
= bfun
->insn
.size ();
2511 /* An empty function segment represents a gap in the trace. We count
2512 it as one instruction. */
2522 /* Advance the iterator as far as possible within this segment. */
2523 adv
= std::min (index
, stride
);
2529 /* We did make progress. */
2530 gdb_assert (adv
> 0);
2533 /* Update the iterator. */
2534 it
->call_index
= bfun
->number
- 1;
2535 it
->insn_index
= index
;
2543 btrace_insn_cmp (const struct btrace_insn_iterator
*lhs
,
2544 const struct btrace_insn_iterator
*rhs
)
2546 gdb_assert (lhs
->btinfo
== rhs
->btinfo
);
2548 if (lhs
->call_index
!= rhs
->call_index
)
2549 return lhs
->call_index
- rhs
->call_index
;
2551 return lhs
->insn_index
- rhs
->insn_index
;
2557 btrace_find_insn_by_number (struct btrace_insn_iterator
*it
,
2558 const struct btrace_thread_info
*btinfo
,
2559 unsigned int number
)
2561 const struct btrace_function
*bfun
;
2562 unsigned int upper
, lower
;
2564 if (btinfo
->functions
.empty ())
2568 bfun
= &btinfo
->functions
[lower
];
2569 if (number
< bfun
->insn_offset
)
2572 upper
= btinfo
->functions
.size () - 1;
2573 bfun
= &btinfo
->functions
[upper
];
2574 if (number
>= bfun
->insn_offset
+ ftrace_call_num_insn (bfun
))
2577 /* We assume that there are no holes in the numbering. */
2580 const unsigned int average
= lower
+ (upper
- lower
) / 2;
2582 bfun
= &btinfo
->functions
[average
];
2584 if (number
< bfun
->insn_offset
)
2586 upper
= average
- 1;
2590 if (number
>= bfun
->insn_offset
+ ftrace_call_num_insn (bfun
))
2592 lower
= average
+ 1;
2599 it
->btinfo
= btinfo
;
2600 it
->call_index
= bfun
->number
- 1;
2601 it
->insn_index
= number
- bfun
->insn_offset
;
2605 /* Returns true if the recording ends with a function segment that
2606 contains only a single (i.e. the current) instruction. */
2609 btrace_ends_with_single_insn (const struct btrace_thread_info
*btinfo
)
2611 const btrace_function
*bfun
;
2613 if (btinfo
->functions
.empty ())
2616 bfun
= &btinfo
->functions
.back ();
2617 if (bfun
->errcode
!= 0)
2620 return ftrace_call_num_insn (bfun
) == 1;
2625 const struct btrace_function
*
2626 btrace_call_get (const struct btrace_call_iterator
*it
)
2628 if (it
->index
>= it
->btinfo
->functions
.size ())
2631 return &it
->btinfo
->functions
[it
->index
];
2637 btrace_call_number (const struct btrace_call_iterator
*it
)
2639 const unsigned int length
= it
->btinfo
->functions
.size ();
2641 /* If the last function segment contains only a single instruction (i.e. the
2642 current instruction), skip it. */
2643 if ((it
->index
== length
) && btrace_ends_with_single_insn (it
->btinfo
))
2646 return it
->index
+ 1;
2652 btrace_call_begin (struct btrace_call_iterator
*it
,
2653 const struct btrace_thread_info
*btinfo
)
2655 if (btinfo
->functions
.empty ())
2656 error (_("No trace."));
2658 it
->btinfo
= btinfo
;
2665 btrace_call_end (struct btrace_call_iterator
*it
,
2666 const struct btrace_thread_info
*btinfo
)
2668 if (btinfo
->functions
.empty ())
2669 error (_("No trace."));
2671 it
->btinfo
= btinfo
;
2672 it
->index
= btinfo
->functions
.size ();
2678 btrace_call_next (struct btrace_call_iterator
*it
, unsigned int stride
)
2680 const unsigned int length
= it
->btinfo
->functions
.size ();
2682 if (it
->index
+ stride
< length
- 1)
2683 /* Default case: Simply advance the iterator. */
2684 it
->index
+= stride
;
2685 else if (it
->index
+ stride
== length
- 1)
2687 /* We land exactly at the last function segment. If it contains only one
2688 instruction (i.e. the current instruction) it is not actually part of
2690 if (btrace_ends_with_single_insn (it
->btinfo
))
2693 it
->index
= length
- 1;
2697 /* We land past the last function segment and have to adjust the stride.
2698 If the last function segment contains only one instruction (i.e. the
2699 current instruction) it is not actually part of the trace. */
2700 if (btrace_ends_with_single_insn (it
->btinfo
))
2701 stride
= length
- it
->index
- 1;
2703 stride
= length
- it
->index
;
2714 btrace_call_prev (struct btrace_call_iterator
*it
, unsigned int stride
)
2716 const unsigned int length
= it
->btinfo
->functions
.size ();
2719 gdb_assert (it
->index
<= length
);
2721 if (stride
== 0 || it
->index
== 0)
2724 /* If we are at the end, the first step is a special case. If the last
2725 function segment contains only one instruction (i.e. the current
2726 instruction) it is not actually part of the trace. To be able to step
2727 over this instruction, we need at least one more function segment. */
2728 if ((it
->index
== length
) && (length
> 1))
2730 if (btrace_ends_with_single_insn (it
->btinfo
))
2731 it
->index
= length
- 2;
2733 it
->index
= length
- 1;
2739 stride
= std::min (stride
, it
->index
);
2741 it
->index
-= stride
;
2742 return steps
+ stride
;
2748 btrace_call_cmp (const struct btrace_call_iterator
*lhs
,
2749 const struct btrace_call_iterator
*rhs
)
2751 gdb_assert (lhs
->btinfo
== rhs
->btinfo
);
2752 return (int) (lhs
->index
- rhs
->index
);
2758 btrace_find_call_by_number (struct btrace_call_iterator
*it
,
2759 const struct btrace_thread_info
*btinfo
,
2760 unsigned int number
)
2762 const unsigned int length
= btinfo
->functions
.size ();
2764 if ((number
== 0) || (number
> length
))
2767 it
->btinfo
= btinfo
;
2768 it
->index
= number
- 1;
2775 btrace_set_insn_history (struct btrace_thread_info
*btinfo
,
2776 const struct btrace_insn_iterator
*begin
,
2777 const struct btrace_insn_iterator
*end
)
2779 if (btinfo
->insn_history
== NULL
)
2780 btinfo
->insn_history
= XCNEW (struct btrace_insn_history
);
2782 btinfo
->insn_history
->begin
= *begin
;
2783 btinfo
->insn_history
->end
= *end
;
2789 btrace_set_call_history (struct btrace_thread_info
*btinfo
,
2790 const struct btrace_call_iterator
*begin
,
2791 const struct btrace_call_iterator
*end
)
2793 gdb_assert (begin
->btinfo
== end
->btinfo
);
2795 if (btinfo
->call_history
== NULL
)
2796 btinfo
->call_history
= XCNEW (struct btrace_call_history
);
2798 btinfo
->call_history
->begin
= *begin
;
2799 btinfo
->call_history
->end
= *end
;
2805 btrace_is_replaying (struct thread_info
*tp
)
2807 return tp
->btrace
.replay
!= NULL
;
2813 btrace_is_empty (struct thread_info
*tp
)
2815 struct btrace_insn_iterator begin
, end
;
2816 struct btrace_thread_info
*btinfo
;
2818 btinfo
= &tp
->btrace
;
2820 if (btinfo
->functions
.empty ())
2823 btrace_insn_begin (&begin
, btinfo
);
2824 btrace_insn_end (&end
, btinfo
);
2826 return btrace_insn_cmp (&begin
, &end
) == 0;
2829 #if defined (HAVE_LIBIPT)
2831 /* Print a single packet. */
2834 pt_print_packet (const struct pt_packet
*packet
)
2836 switch (packet
->type
)
2839 printf_unfiltered (("[??: %x]"), packet
->type
);
2843 printf_unfiltered (("psb"));
2847 printf_unfiltered (("psbend"));
2851 printf_unfiltered (("pad"));
2855 printf_unfiltered (("tip %u: 0x%" PRIx64
""),
2856 packet
->payload
.ip
.ipc
,
2857 packet
->payload
.ip
.ip
);
2861 printf_unfiltered (("tip.pge %u: 0x%" PRIx64
""),
2862 packet
->payload
.ip
.ipc
,
2863 packet
->payload
.ip
.ip
);
2867 printf_unfiltered (("tip.pgd %u: 0x%" PRIx64
""),
2868 packet
->payload
.ip
.ipc
,
2869 packet
->payload
.ip
.ip
);
2873 printf_unfiltered (("fup %u: 0x%" PRIx64
""),
2874 packet
->payload
.ip
.ipc
,
2875 packet
->payload
.ip
.ip
);
2879 printf_unfiltered (("tnt-8 %u: 0x%" PRIx64
""),
2880 packet
->payload
.tnt
.bit_size
,
2881 packet
->payload
.tnt
.payload
);
2885 printf_unfiltered (("tnt-64 %u: 0x%" PRIx64
""),
2886 packet
->payload
.tnt
.bit_size
,
2887 packet
->payload
.tnt
.payload
);
2891 printf_unfiltered (("pip %" PRIx64
"%s"), packet
->payload
.pip
.cr3
,
2892 packet
->payload
.pip
.nr
? (" nr") : (""));
2896 printf_unfiltered (("tsc %" PRIx64
""), packet
->payload
.tsc
.tsc
);
2900 printf_unfiltered (("cbr %u"), packet
->payload
.cbr
.ratio
);
2904 switch (packet
->payload
.mode
.leaf
)
2907 printf_unfiltered (("mode %u"), packet
->payload
.mode
.leaf
);
2911 printf_unfiltered (("mode.exec%s%s"),
2912 packet
->payload
.mode
.bits
.exec
.csl
2914 packet
->payload
.mode
.bits
.exec
.csd
2915 ? (" cs.d") : (""));
2919 printf_unfiltered (("mode.tsx%s%s"),
2920 packet
->payload
.mode
.bits
.tsx
.intx
2922 packet
->payload
.mode
.bits
.tsx
.abrt
2923 ? (" abrt") : (""));
2929 printf_unfiltered (("ovf"));
2933 printf_unfiltered (("stop"));
2937 printf_unfiltered (("vmcs %" PRIx64
""), packet
->payload
.vmcs
.base
);
2941 printf_unfiltered (("tma %x %x"), packet
->payload
.tma
.ctc
,
2942 packet
->payload
.tma
.fc
);
2946 printf_unfiltered (("mtc %x"), packet
->payload
.mtc
.ctc
);
2950 printf_unfiltered (("cyc %" PRIx64
""), packet
->payload
.cyc
.value
);
2954 printf_unfiltered (("mnt %" PRIx64
""), packet
->payload
.mnt
.payload
);
2959 /* Decode packets into MAINT using DECODER. */
2962 btrace_maint_decode_pt (struct btrace_maint_info
*maint
,
2963 struct pt_packet_decoder
*decoder
)
2967 if (maint
->variant
.pt
.packets
== NULL
)
2968 maint
->variant
.pt
.packets
= new std::vector
<btrace_pt_packet
>;
2972 struct btrace_pt_packet packet
;
2974 errcode
= pt_pkt_sync_forward (decoder
);
2980 pt_pkt_get_offset (decoder
, &packet
.offset
);
2982 errcode
= pt_pkt_next (decoder
, &packet
.packet
,
2983 sizeof(packet
.packet
));
2987 if (maint_btrace_pt_skip_pad
== 0 || packet
.packet
.type
!= ppt_pad
)
2989 packet
.errcode
= pt_errcode (errcode
);
2990 maint
->variant
.pt
.packets
->push_back (packet
);
2994 if (errcode
== -pte_eos
)
2997 packet
.errcode
= pt_errcode (errcode
);
2998 maint
->variant
.pt
.packets
->push_back (packet
);
3000 warning (_("Error at trace offset 0x%" PRIx64
": %s."),
3001 packet
.offset
, pt_errstr (packet
.errcode
));
3004 if (errcode
!= -pte_eos
)
3005 warning (_("Failed to synchronize onto the Intel Processor Trace "
3006 "stream: %s."), pt_errstr (pt_errcode (errcode
)));
3009 /* Update the packet history in BTINFO. */
3012 btrace_maint_update_pt_packets (struct btrace_thread_info
*btinfo
)
3014 struct pt_packet_decoder
*decoder
;
3015 const struct btrace_cpu
*cpu
;
3016 struct btrace_data_pt
*pt
;
3017 struct pt_config config
;
3020 pt
= &btinfo
->data
.variant
.pt
;
3022 /* Nothing to do if there is no trace. */
3026 memset (&config
, 0, sizeof(config
));
3028 config
.size
= sizeof (config
);
3029 config
.begin
= pt
->data
;
3030 config
.end
= pt
->data
+ pt
->size
;
3032 cpu
= record_btrace_get_cpu ();
3034 cpu
= &pt
->config
.cpu
;
3036 /* We treat an unknown vendor as 'no errata'. */
3037 if (cpu
->vendor
!= CV_UNKNOWN
)
3039 config
.cpu
.vendor
= pt_translate_cpu_vendor (cpu
->vendor
);
3040 config
.cpu
.family
= cpu
->family
;
3041 config
.cpu
.model
= cpu
->model
;
3042 config
.cpu
.stepping
= cpu
->stepping
;
3044 errcode
= pt_cpu_errata (&config
.errata
, &config
.cpu
);
3046 error (_("Failed to configure the Intel Processor Trace "
3047 "decoder: %s."), pt_errstr (pt_errcode (errcode
)));
3050 decoder
= pt_pkt_alloc_decoder (&config
);
3051 if (decoder
== NULL
)
3052 error (_("Failed to allocate the Intel Processor Trace decoder."));
3056 btrace_maint_decode_pt (&btinfo
->maint
, decoder
);
3058 catch (const gdb_exception
&except
)
3060 pt_pkt_free_decoder (decoder
);
3062 if (except
.reason
< 0)
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
= btinfo
->data
.variant
.bts
.blocks
->size ();
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 (btinfo
->maint
.variant
.pt
.packets
== nullptr)
3100 btinfo
->maint
.variant
.pt
.packets
= new std::vector
<btrace_pt_packet
>;
3102 if (btinfo
->maint
.variant
.pt
.packets
->empty ())
3103 btrace_maint_update_pt_packets (btinfo
);
3106 *end
= btinfo
->maint
.variant
.pt
.packets
->size ();
3107 *from
= btinfo
->maint
.variant
.pt
.packet_history
.begin
;
3108 *to
= btinfo
->maint
.variant
.pt
.packet_history
.end
;
3110 #endif /* defined (HAVE_LIBIPT) */
3114 /* Print packets in BTINFO from BEGIN (inclusive) until END (exclusive) and
3115 update the current iterator position. */
3118 btrace_maint_print_packets (struct btrace_thread_info
*btinfo
,
3119 unsigned int begin
, unsigned int end
)
3121 switch (btinfo
->data
.format
)
3126 case BTRACE_FORMAT_BTS
:
3128 const std::vector
<btrace_block
> &blocks
3129 = *btinfo
->data
.variant
.bts
.blocks
;
3132 for (blk
= begin
; blk
< end
; ++blk
)
3134 const btrace_block
&block
= blocks
.at (blk
);
3136 printf_unfiltered ("%u\tbegin: %s, end: %s\n", blk
,
3137 core_addr_to_string_nz (block
.begin
),
3138 core_addr_to_string_nz (block
.end
));
3141 btinfo
->maint
.variant
.bts
.packet_history
.begin
= begin
;
3142 btinfo
->maint
.variant
.bts
.packet_history
.end
= end
;
3146 #if defined (HAVE_LIBIPT)
3147 case BTRACE_FORMAT_PT
:
3149 const std::vector
<btrace_pt_packet
> &packets
3150 = *btinfo
->maint
.variant
.pt
.packets
;
3153 for (pkt
= begin
; pkt
< end
; ++pkt
)
3155 const struct btrace_pt_packet
&packet
= packets
.at (pkt
);
3157 printf_unfiltered ("%u\t", pkt
);
3158 printf_unfiltered ("0x%" PRIx64
"\t", packet
.offset
);
3160 if (packet
.errcode
== pte_ok
)
3161 pt_print_packet (&packet
.packet
);
3163 printf_unfiltered ("[error: %s]", pt_errstr (packet
.errcode
));
3165 printf_unfiltered ("\n");
3168 btinfo
->maint
.variant
.pt
.packet_history
.begin
= begin
;
3169 btinfo
->maint
.variant
.pt
.packet_history
.end
= end
;
3172 #endif /* defined (HAVE_LIBIPT) */
3176 /* Read a number from an argument string. */
3179 get_uint (const char **arg
)
3181 const char *begin
, *pos
;
3183 unsigned long number
;
3186 pos
= skip_spaces (begin
);
3188 if (!isdigit (*pos
))
3189 error (_("Expected positive number, got: %s."), pos
);
3191 number
= strtoul (pos
, &end
, 10);
3192 if (number
> UINT_MAX
)
3193 error (_("Number too big."));
3195 *arg
+= (end
- begin
);
3197 return (unsigned int) number
;
3200 /* Read a context size from an argument string. */
3203 get_context_size (const char **arg
)
3205 const char *pos
= skip_spaces (*arg
);
3207 if (!isdigit (*pos
))
3208 error (_("Expected positive number, got: %s."), pos
);
3211 long result
= strtol (pos
, &end
, 10);
3216 /* Complain about junk at the end of an argument string. */
3219 no_chunk (const char *arg
)
3222 error (_("Junk after argument: %s."), arg
);
3225 /* The "maintenance btrace packet-history" command. */
3228 maint_btrace_packet_history_cmd (const char *arg
, int from_tty
)
3230 struct btrace_thread_info
*btinfo
;
3231 unsigned int size
, begin
, end
, from
, to
;
3233 thread_info
*tp
= find_thread_ptid (current_inferior (), inferior_ptid
);
3235 error (_("No thread."));
3238 btinfo
= &tp
->btrace
;
3240 btrace_maint_update_packets (btinfo
, &begin
, &end
, &from
, &to
);
3243 printf_unfiltered (_("No trace.\n"));
3247 if (arg
== NULL
|| *arg
== 0 || strcmp (arg
, "+") == 0)
3251 if (end
- from
< size
)
3255 else if (strcmp (arg
, "-") == 0)
3259 if (to
- begin
< size
)
3265 from
= get_uint (&arg
);
3267 error (_("'%u' is out of range."), from
);
3269 arg
= skip_spaces (arg
);
3272 arg
= skip_spaces (++arg
);
3277 size
= get_context_size (&arg
);
3281 if (end
- from
< size
)
3285 else if (*arg
== '-')
3288 size
= get_context_size (&arg
);
3292 /* Include the packet given as first argument. */
3296 if (to
- begin
< size
)
3302 to
= get_uint (&arg
);
3304 /* Include the packet at the second argument and silently
3305 truncate the range. */
3318 if (end
- from
< size
)
3326 btrace_maint_print_packets (btinfo
, from
, to
);
3329 /* The "maintenance btrace clear-packet-history" command. */
3332 maint_btrace_clear_packet_history_cmd (const char *args
, int from_tty
)
3334 if (args
!= NULL
&& *args
!= 0)
3335 error (_("Invalid argument."));
3337 if (inferior_ptid
== null_ptid
)
3338 error (_("No thread."));
3340 thread_info
*tp
= inferior_thread ();
3341 btrace_thread_info
*btinfo
= &tp
->btrace
;
3343 /* Must clear the maint data before - it depends on BTINFO->DATA. */
3344 btrace_maint_clear (btinfo
);
3345 btinfo
->data
.clear ();
3348 /* The "maintenance btrace clear" command. */
3351 maint_btrace_clear_cmd (const char *args
, int from_tty
)
3353 if (args
!= NULL
&& *args
!= 0)
3354 error (_("Invalid argument."));
3356 if (inferior_ptid
== null_ptid
)
3357 error (_("No thread."));
3359 thread_info
*tp
= inferior_thread ();
3363 /* The "maintenance info btrace" command. */
3366 maint_info_btrace_cmd (const char *args
, int from_tty
)
3368 struct btrace_thread_info
*btinfo
;
3369 const struct btrace_config
*conf
;
3371 if (args
!= NULL
&& *args
!= 0)
3372 error (_("Invalid argument."));
3374 if (inferior_ptid
== null_ptid
)
3375 error (_("No thread."));
3377 thread_info
*tp
= inferior_thread ();
3379 btinfo
= &tp
->btrace
;
3381 conf
= btrace_conf (btinfo
);
3383 error (_("No btrace configuration."));
3385 printf_unfiltered (_("Format: %s.\n"),
3386 btrace_format_string (conf
->format
));
3388 switch (conf
->format
)
3393 case BTRACE_FORMAT_BTS
:
3394 printf_unfiltered (_("Number of packets: %zu.\n"),
3395 btinfo
->data
.variant
.bts
.blocks
->size ());
3398 #if defined (HAVE_LIBIPT)
3399 case BTRACE_FORMAT_PT
:
3401 struct pt_version version
;
3403 version
= pt_library_version ();
3404 printf_unfiltered (_("Version: %u.%u.%u%s.\n"), version
.major
,
3405 version
.minor
, version
.build
,
3406 version
.ext
!= NULL
? version
.ext
: "");
3408 btrace_maint_update_pt_packets (btinfo
);
3409 printf_unfiltered (_("Number of packets: %zu.\n"),
3410 ((btinfo
->maint
.variant
.pt
.packets
== nullptr)
3411 ? 0 : btinfo
->maint
.variant
.pt
.packets
->size ()));
3414 #endif /* defined (HAVE_LIBIPT) */
3418 /* The "maint show btrace pt skip-pad" show value function. */
3421 show_maint_btrace_pt_skip_pad (struct ui_file
*file
, int from_tty
,
3422 struct cmd_list_element
*c
,
3425 fprintf_filtered (file
, _("Skip PAD packets is %s.\n"), value
);
3429 /* Initialize btrace maintenance commands. */
3431 void _initialize_btrace ();
3433 _initialize_btrace ()
3435 add_cmd ("btrace", class_maintenance
, maint_info_btrace_cmd
,
3436 _("Info about branch tracing data."), &maintenanceinfolist
);
3438 add_basic_prefix_cmd ("btrace", class_maintenance
,
3439 _("Branch tracing maintenance commands."),
3440 &maint_btrace_cmdlist
, "maintenance btrace ",
3441 0, &maintenancelist
);
3443 add_basic_prefix_cmd ("btrace", class_maintenance
, _("\
3444 Set branch tracing specific variables."),
3445 &maint_btrace_set_cmdlist
, "maintenance set btrace ",
3446 0, &maintenance_set_cmdlist
);
3448 add_basic_prefix_cmd ("pt", class_maintenance
, _("\
3449 Set Intel Processor Trace specific variables."),
3450 &maint_btrace_pt_set_cmdlist
,
3451 "maintenance set btrace pt ",
3452 0, &maint_btrace_set_cmdlist
);
3454 add_show_prefix_cmd ("btrace", class_maintenance
, _("\
3455 Show branch tracing specific variables."),
3456 &maint_btrace_show_cmdlist
, "maintenance show btrace ",
3457 0, &maintenance_show_cmdlist
);
3459 add_show_prefix_cmd ("pt", class_maintenance
, _("\
3460 Show Intel Processor Trace specific variables."),
3461 &maint_btrace_pt_show_cmdlist
,
3462 "maintenance show btrace pt ",
3463 0, &maint_btrace_show_cmdlist
);
3465 add_setshow_boolean_cmd ("skip-pad", class_maintenance
,
3466 &maint_btrace_pt_skip_pad
, _("\
3467 Set whether PAD packets should be skipped in the btrace packet history."), _("\
3468 Show whether PAD packets should be skipped in the btrace packet history."),_("\
3469 When enabled, PAD packets are ignored in the btrace packet history."),
3470 NULL
, show_maint_btrace_pt_skip_pad
,
3471 &maint_btrace_pt_set_cmdlist
,
3472 &maint_btrace_pt_show_cmdlist
);
3474 add_cmd ("packet-history", class_maintenance
, maint_btrace_packet_history_cmd
,
3475 _("Print the raw branch tracing data.\n\
3476 With no argument, print ten more packets after the previous ten-line print.\n\
3477 With '-' as argument print ten packets before a previous ten-line print.\n\
3478 One argument specifies the starting packet of a ten-line print.\n\
3479 Two arguments with comma between specify starting and ending packets to \
3481 Preceded with '+'/'-' the second argument specifies the distance from the \
3483 &maint_btrace_cmdlist
);
3485 add_cmd ("clear-packet-history", class_maintenance
,
3486 maint_btrace_clear_packet_history_cmd
,
3487 _("Clears the branch tracing packet history.\n\
3488 Discards the raw branch tracing data but not the execution history data."),
3489 &maint_btrace_cmdlist
);
3491 add_cmd ("clear", class_maintenance
, maint_btrace_clear_cmd
,
3492 _("Clears the branch tracing data.\n\
3493 Discards the raw branch tracing data and the execution history data.\n\
3494 The next 'record' command will fetch the branch tracing data anew."),
3495 &maint_btrace_cmdlist
);