1 /* Branch trace support for GDB, the GNU debugger.
3 Copyright (C) 2013-2018 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"
38 /* For maintenance commands. */
39 #include "record-btrace.h"
45 /* Command lists for btrace maintenance commands. */
46 static struct cmd_list_element *maint_btrace_cmdlist;
47 static struct cmd_list_element *maint_btrace_set_cmdlist;
48 static struct cmd_list_element *maint_btrace_show_cmdlist;
49 static struct cmd_list_element *maint_btrace_pt_set_cmdlist;
50 static struct cmd_list_element *maint_btrace_pt_show_cmdlist;
52 /* Control whether to skip PAD packets when computing the packet history. */
53 static int maint_btrace_pt_skip_pad = 1;
55 static void btrace_add_pc (struct thread_info *tp);
57 /* Print a record debug message. Use do ... while (0) to avoid ambiguities
58 when used in if statements. */
60 #define DEBUG(msg, args...) \
63 if (record_debug != 0) \
64 fprintf_unfiltered (gdb_stdlog, \
65 "[btrace] " msg "\n", ##args); \
69 #define DEBUG_FTRACE(msg, args...) DEBUG ("[ftrace] " msg, ##args)
71 /* Return the function name of a recorded function segment for printing.
72 This function never returns NULL. */
75 ftrace_print_function_name (const struct btrace_function *bfun)
77 struct minimal_symbol *msym;
84 return SYMBOL_PRINT_NAME (sym);
87 return MSYMBOL_PRINT_NAME (msym);
92 /* Return the file name of a recorded function segment for printing.
93 This function never returns NULL. */
96 ftrace_print_filename (const struct btrace_function *bfun)
104 filename = symtab_to_filename_for_display (symbol_symtab (sym));
106 filename = "<unknown>";
111 /* Return a string representation of the address of an instruction.
112 This function never returns NULL. */
115 ftrace_print_insn_addr (const struct btrace_insn *insn)
120 return core_addr_to_string_nz (insn->pc);
123 /* Print an ftrace debug status message. */
126 ftrace_debug (const struct btrace_function *bfun, const char *prefix)
128 const char *fun, *file;
129 unsigned int ibegin, iend;
132 fun = ftrace_print_function_name (bfun);
133 file = ftrace_print_filename (bfun);
136 ibegin = bfun->insn_offset;
137 iend = ibegin + bfun->insn.size ();
139 DEBUG_FTRACE ("%s: fun = %s, file = %s, level = %d, insn = [%u; %u)",
140 prefix, fun, file, level, ibegin, iend);
143 /* Return the number of instructions in a given function call segment. */
146 ftrace_call_num_insn (const struct btrace_function* bfun)
151 /* A gap is always counted as one instruction. */
152 if (bfun->errcode != 0)
155 return bfun->insn.size ();
158 /* Return the function segment with the given NUMBER or NULL if no such segment
159 exists. BTINFO is the branch trace information for the current thread. */
161 static struct btrace_function *
162 ftrace_find_call_by_number (struct btrace_thread_info *btinfo,
165 if (number == 0 || number > btinfo->functions.size ())
168 return &btinfo->functions[number - 1];
171 /* A const version of the function above. */
173 static const struct btrace_function *
174 ftrace_find_call_by_number (const struct btrace_thread_info *btinfo,
177 if (number == 0 || number > btinfo->functions.size ())
180 return &btinfo->functions[number - 1];
183 /* Return non-zero if BFUN does not match MFUN and FUN,
184 return zero otherwise. */
187 ftrace_function_switched (const struct btrace_function *bfun,
188 const struct minimal_symbol *mfun,
189 const struct symbol *fun)
191 struct minimal_symbol *msym;
197 /* If the minimal symbol changed, we certainly switched functions. */
198 if (mfun != NULL && msym != NULL
199 && strcmp (MSYMBOL_LINKAGE_NAME (mfun), MSYMBOL_LINKAGE_NAME (msym)) != 0)
202 /* If the symbol changed, we certainly switched functions. */
203 if (fun != NULL && sym != NULL)
205 const char *bfname, *fname;
207 /* Check the function name. */
208 if (strcmp (SYMBOL_LINKAGE_NAME (fun), SYMBOL_LINKAGE_NAME (sym)) != 0)
211 /* Check the location of those functions, as well. */
212 bfname = symtab_to_fullname (symbol_symtab (sym));
213 fname = symtab_to_fullname (symbol_symtab (fun));
214 if (filename_cmp (fname, bfname) != 0)
218 /* If we lost symbol information, we switched functions. */
219 if (!(msym == NULL && sym == NULL) && mfun == NULL && fun == NULL)
222 /* If we gained symbol information, we switched functions. */
223 if (msym == NULL && sym == NULL && !(mfun == NULL && fun == NULL))
229 /* Allocate and initialize a new branch trace function segment at the end of
231 BTINFO is the branch trace information for the current thread.
232 MFUN and FUN are the symbol information we have for this function.
233 This invalidates all struct btrace_function pointer currently held. */
235 static struct btrace_function *
236 ftrace_new_function (struct btrace_thread_info *btinfo,
237 struct minimal_symbol *mfun,
241 unsigned int number, insn_offset;
243 if (btinfo->functions.empty ())
245 /* Start counting NUMBER and INSN_OFFSET at one. */
252 const struct btrace_function *prev = &btinfo->functions.back ();
254 number = prev->number + 1;
255 insn_offset = prev->insn_offset + ftrace_call_num_insn (prev);
258 btinfo->functions.emplace_back (mfun, fun, number, insn_offset, level);
259 return &btinfo->functions.back ();
262 /* Update the UP field of a function segment. */
265 ftrace_update_caller (struct btrace_function *bfun,
266 struct btrace_function *caller,
267 enum btrace_function_flag flags)
270 ftrace_debug (bfun, "updating caller");
272 bfun->up = caller->number;
275 ftrace_debug (bfun, "set caller");
276 ftrace_debug (caller, "..to");
279 /* Fix up the caller for all segments of a function. */
282 ftrace_fixup_caller (struct btrace_thread_info *btinfo,
283 struct btrace_function *bfun,
284 struct btrace_function *caller,
285 enum btrace_function_flag flags)
287 unsigned int prev, next;
291 ftrace_update_caller (bfun, caller, flags);
293 /* Update all function segments belonging to the same function. */
294 for (; prev != 0; prev = bfun->prev)
296 bfun = ftrace_find_call_by_number (btinfo, prev);
297 ftrace_update_caller (bfun, caller, flags);
300 for (; next != 0; next = bfun->next)
302 bfun = ftrace_find_call_by_number (btinfo, next);
303 ftrace_update_caller (bfun, caller, flags);
307 /* Add a new function segment for a call at the end of the trace.
308 BTINFO is the branch trace information for the current thread.
309 MFUN and FUN are the symbol information we have for this function. */
311 static struct btrace_function *
312 ftrace_new_call (struct btrace_thread_info *btinfo,
313 struct minimal_symbol *mfun,
316 const unsigned int length = btinfo->functions.size ();
317 struct btrace_function *bfun = ftrace_new_function (btinfo, mfun, fun);
322 ftrace_debug (bfun, "new call");
327 /* Add a new function segment for a tail call at the end of the trace.
328 BTINFO is the branch trace information for the current thread.
329 MFUN and FUN are the symbol information we have for this function. */
331 static struct btrace_function *
332 ftrace_new_tailcall (struct btrace_thread_info *btinfo,
333 struct minimal_symbol *mfun,
336 const unsigned int length = btinfo->functions.size ();
337 struct btrace_function *bfun = ftrace_new_function (btinfo, mfun, fun);
341 bfun->flags |= BFUN_UP_LINKS_TO_TAILCALL;
343 ftrace_debug (bfun, "new tail call");
348 /* Return the caller of BFUN or NULL if there is none. This function skips
349 tail calls in the call chain. BTINFO is the branch trace information for
350 the current thread. */
351 static struct btrace_function *
352 ftrace_get_caller (struct btrace_thread_info *btinfo,
353 struct btrace_function *bfun)
355 for (; bfun != NULL; bfun = ftrace_find_call_by_number (btinfo, bfun->up))
356 if ((bfun->flags & BFUN_UP_LINKS_TO_TAILCALL) == 0)
357 return ftrace_find_call_by_number (btinfo, bfun->up);
362 /* Find the innermost caller in the back trace of BFUN with MFUN/FUN
363 symbol information. BTINFO is the branch trace information for the current
366 static struct btrace_function *
367 ftrace_find_caller (struct btrace_thread_info *btinfo,
368 struct btrace_function *bfun,
369 struct minimal_symbol *mfun,
372 for (; bfun != NULL; bfun = ftrace_find_call_by_number (btinfo, bfun->up))
374 /* Skip functions with incompatible symbol information. */
375 if (ftrace_function_switched (bfun, mfun, fun))
378 /* This is the function segment we're looking for. */
385 /* Find the innermost caller in the back trace of BFUN, skipping all
386 function segments that do not end with a call instruction (e.g.
387 tail calls ending with a jump). BTINFO is the branch trace information for
388 the current thread. */
390 static struct btrace_function *
391 ftrace_find_call (struct btrace_thread_info *btinfo,
392 struct btrace_function *bfun)
394 for (; bfun != NULL; bfun = ftrace_find_call_by_number (btinfo, bfun->up))
397 if (bfun->errcode != 0)
400 btrace_insn &last = bfun->insn.back ();
402 if (last.iclass == BTRACE_INSN_CALL)
409 /* Add a continuation segment for a function into which we return at the end of
411 BTINFO is the branch trace information for the current thread.
412 MFUN and FUN are the symbol information we have for this function. */
414 static struct btrace_function *
415 ftrace_new_return (struct btrace_thread_info *btinfo,
416 struct minimal_symbol *mfun,
419 struct btrace_function *prev, *bfun, *caller;
421 bfun = ftrace_new_function (btinfo, mfun, fun);
422 prev = ftrace_find_call_by_number (btinfo, bfun->number - 1);
424 /* It is important to start at PREV's caller. Otherwise, we might find
425 PREV itself, if PREV is a recursive function. */
426 caller = ftrace_find_call_by_number (btinfo, prev->up);
427 caller = ftrace_find_caller (btinfo, caller, mfun, fun);
430 /* The caller of PREV is the preceding btrace function segment in this
431 function instance. */
432 gdb_assert (caller->next == 0);
434 caller->next = bfun->number;
435 bfun->prev = caller->number;
437 /* Maintain the function level. */
438 bfun->level = caller->level;
440 /* Maintain the call stack. */
441 bfun->up = caller->up;
442 bfun->flags = caller->flags;
444 ftrace_debug (bfun, "new return");
448 /* We did not find a caller. This could mean that something went
449 wrong or that the call is simply not included in the trace. */
451 /* Let's search for some actual call. */
452 caller = ftrace_find_call_by_number (btinfo, prev->up);
453 caller = ftrace_find_call (btinfo, caller);
456 /* There is no call in PREV's back trace. We assume that the
457 branch trace did not include it. */
459 /* Let's find the topmost function and add a new caller for it.
460 This should handle a series of initial tail calls. */
461 while (prev->up != 0)
462 prev = ftrace_find_call_by_number (btinfo, prev->up);
464 bfun->level = prev->level - 1;
466 /* Fix up the call stack for PREV. */
467 ftrace_fixup_caller (btinfo, prev, bfun, BFUN_UP_LINKS_TO_RET);
469 ftrace_debug (bfun, "new return - no caller");
473 /* There is a call in PREV's back trace to which we should have
474 returned but didn't. Let's start a new, separate back trace
475 from PREV's level. */
476 bfun->level = prev->level - 1;
478 /* We fix up the back trace for PREV but leave other function segments
479 on the same level as they are.
480 This should handle things like schedule () correctly where we're
481 switching contexts. */
482 prev->up = bfun->number;
483 prev->flags = BFUN_UP_LINKS_TO_RET;
485 ftrace_debug (bfun, "new return - unknown caller");
492 /* Add a new function segment for a function switch at the end of the trace.
493 BTINFO is the branch trace information for the current thread.
494 MFUN and FUN are the symbol information we have for this function. */
496 static struct btrace_function *
497 ftrace_new_switch (struct btrace_thread_info *btinfo,
498 struct minimal_symbol *mfun,
501 struct btrace_function *prev, *bfun;
503 /* This is an unexplained function switch. We can't really be sure about the
504 call stack, yet the best I can think of right now is to preserve it. */
505 bfun = ftrace_new_function (btinfo, mfun, fun);
506 prev = ftrace_find_call_by_number (btinfo, bfun->number - 1);
508 bfun->flags = prev->flags;
510 ftrace_debug (bfun, "new switch");
515 /* Add a new function segment for a gap in the trace due to a decode error at
516 the end of the trace.
517 BTINFO is the branch trace information for the current thread.
518 ERRCODE is the format-specific error code. */
520 static struct btrace_function *
521 ftrace_new_gap (struct btrace_thread_info *btinfo, int errcode,
522 std::vector<unsigned int> &gaps)
524 struct btrace_function *bfun;
526 if (btinfo->functions.empty ())
527 bfun = ftrace_new_function (btinfo, NULL, NULL);
530 /* We hijack the previous function segment if it was empty. */
531 bfun = &btinfo->functions.back ();
532 if (bfun->errcode != 0 || !bfun->insn.empty ())
533 bfun = ftrace_new_function (btinfo, NULL, NULL);
536 bfun->errcode = errcode;
537 gaps.push_back (bfun->number);
539 ftrace_debug (bfun, "new gap");
544 /* Update the current function segment at the end of the trace in BTINFO with
545 respect to the instruction at PC. This may create new function segments.
546 Return the chronologically latest function segment, never NULL. */
548 static struct btrace_function *
549 ftrace_update_function (struct btrace_thread_info *btinfo, CORE_ADDR pc)
551 struct bound_minimal_symbol bmfun;
552 struct minimal_symbol *mfun;
554 struct btrace_function *bfun;
556 /* Try to determine the function we're in. We use both types of symbols
557 to avoid surprises when we sometimes get a full symbol and sometimes
558 only a minimal symbol. */
559 fun = find_pc_function (pc);
560 bmfun = lookup_minimal_symbol_by_pc (pc);
563 if (fun == NULL && mfun == NULL)
564 DEBUG_FTRACE ("no symbol at %s", core_addr_to_string_nz (pc));
566 /* If we didn't have a function, we create one. */
567 if (btinfo->functions.empty ())
568 return ftrace_new_function (btinfo, mfun, fun);
570 /* If we had a gap before, we create a function. */
571 bfun = &btinfo->functions.back ();
572 if (bfun->errcode != 0)
573 return ftrace_new_function (btinfo, mfun, fun);
575 /* Check the last instruction, if we have one.
576 We do this check first, since it allows us to fill in the call stack
577 links in addition to the normal flow links. */
578 btrace_insn *last = NULL;
579 if (!bfun->insn.empty ())
580 last = &bfun->insn.back ();
584 switch (last->iclass)
586 case BTRACE_INSN_RETURN:
590 /* On some systems, _dl_runtime_resolve returns to the resolved
591 function instead of jumping to it. From our perspective,
592 however, this is a tailcall.
593 If we treated it as return, we wouldn't be able to find the
594 resolved function in our stack back trace. Hence, we would
595 lose the current stack back trace and start anew with an empty
596 back trace. When the resolved function returns, we would then
597 create a stack back trace with the same function names but
598 different frame id's. This will confuse stepping. */
599 fname = ftrace_print_function_name (bfun);
600 if (strcmp (fname, "_dl_runtime_resolve") == 0)
601 return ftrace_new_tailcall (btinfo, mfun, fun);
603 return ftrace_new_return (btinfo, mfun, fun);
606 case BTRACE_INSN_CALL:
607 /* Ignore calls to the next instruction. They are used for PIC. */
608 if (last->pc + last->size == pc)
611 return ftrace_new_call (btinfo, mfun, fun);
613 case BTRACE_INSN_JUMP:
617 start = get_pc_function_start (pc);
619 /* A jump to the start of a function is (typically) a tail call. */
621 return ftrace_new_tailcall (btinfo, mfun, fun);
623 /* Some versions of _Unwind_RaiseException use an indirect
624 jump to 'return' to the exception handler of the caller
625 handling the exception instead of a return. Let's restrict
626 this heuristic to that and related functions. */
627 const char *fname = ftrace_print_function_name (bfun);
628 if (strncmp (fname, "_Unwind_", strlen ("_Unwind_")) == 0)
630 struct btrace_function *caller
631 = ftrace_find_call_by_number (btinfo, bfun->up);
632 caller = ftrace_find_caller (btinfo, caller, mfun, fun);
634 return ftrace_new_return (btinfo, mfun, fun);
637 /* If we can't determine the function for PC, we treat a jump at
638 the end of the block as tail call if we're switching functions
639 and as an intra-function branch if we don't. */
640 if (start == 0 && ftrace_function_switched (bfun, mfun, fun))
641 return ftrace_new_tailcall (btinfo, mfun, fun);
648 /* Check if we're switching functions for some other reason. */
649 if (ftrace_function_switched (bfun, mfun, fun))
651 DEBUG_FTRACE ("switching from %s in %s at %s",
652 ftrace_print_insn_addr (last),
653 ftrace_print_function_name (bfun),
654 ftrace_print_filename (bfun));
656 return ftrace_new_switch (btinfo, mfun, fun);
662 /* Add the instruction at PC to BFUN's instructions. */
665 ftrace_update_insns (struct btrace_function *bfun, const btrace_insn &insn)
667 bfun->insn.push_back (insn);
669 if (record_debug > 1)
670 ftrace_debug (bfun, "update insn");
673 /* Classify the instruction at PC. */
675 static enum btrace_insn_class
676 ftrace_classify_insn (struct gdbarch *gdbarch, CORE_ADDR pc)
678 enum btrace_insn_class iclass;
680 iclass = BTRACE_INSN_OTHER;
683 if (gdbarch_insn_is_call (gdbarch, pc))
684 iclass = BTRACE_INSN_CALL;
685 else if (gdbarch_insn_is_ret (gdbarch, pc))
686 iclass = BTRACE_INSN_RETURN;
687 else if (gdbarch_insn_is_jump (gdbarch, pc))
688 iclass = BTRACE_INSN_JUMP;
690 CATCH (error, RETURN_MASK_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 functon 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 = VEC_length (btrace_block_s, btrace->blocks);
1064 if (btinfo->functions.empty ())
1067 level = -btinfo->level;
1071 btrace_block_s *block;
1076 block = VEC_index (btrace_block_s, btrace->blocks, blk);
1081 struct btrace_function *bfun;
1082 struct btrace_insn insn;
1085 /* We should hit the end of the block. Warn if we went too far. */
1086 if (block->end < pc)
1088 /* Indicate the gap in the trace. */
1089 bfun = ftrace_new_gap (btinfo, BDE_BTS_OVERFLOW, gaps);
1091 warning (_("Recorded trace may be corrupted at instruction "
1092 "%u (pc = %s)."), bfun->insn_offset - 1,
1093 core_addr_to_string_nz (pc));
1098 bfun = ftrace_update_function (btinfo, pc);
1100 /* Maintain the function level offset.
1101 For all but the last block, we do it here. */
1103 level = std::min (level, bfun->level);
1108 size = gdb_insn_length (gdbarch, pc);
1110 CATCH (error, RETURN_MASK_ERROR)
1117 insn.iclass = ftrace_classify_insn (gdbarch, pc);
1120 ftrace_update_insns (bfun, insn);
1122 /* We're done once we pushed the instruction at the end. */
1123 if (block->end == pc)
1126 /* We can't continue if we fail to compute the size. */
1129 /* Indicate the gap in the trace. We just added INSN so we're
1130 not at the beginning. */
1131 bfun = ftrace_new_gap (btinfo, BDE_BTS_INSN_SIZE, gaps);
1133 warning (_("Recorded trace may be incomplete at instruction %u "
1134 "(pc = %s)."), bfun->insn_offset - 1,
1135 core_addr_to_string_nz (pc));
1142 /* Maintain the function level offset.
1143 For the last block, we do it here to not consider the last
1145 Since the last instruction corresponds to the current instruction
1146 and is not really part of the execution history, it shouldn't
1147 affect the level. */
1149 level = std::min (level, bfun->level);
1153 /* LEVEL is the minimal function level of all btrace function segments.
1154 Define the global level offset to -LEVEL so all function levels are
1155 normalized to start at zero. */
1156 btinfo->level = -level;
1159 #if defined (HAVE_LIBIPT)
1161 static enum btrace_insn_class
1162 pt_reclassify_insn (enum pt_insn_class iclass)
1167 return BTRACE_INSN_CALL;
1170 return BTRACE_INSN_RETURN;
1173 return BTRACE_INSN_JUMP;
1176 return BTRACE_INSN_OTHER;
1180 /* Return the btrace instruction flags for INSN. */
1182 static btrace_insn_flags
1183 pt_btrace_insn_flags (const struct pt_insn &insn)
1185 btrace_insn_flags flags = 0;
1187 if (insn.speculative)
1188 flags |= BTRACE_INSN_FLAG_SPECULATIVE;
1193 /* Return the btrace instruction for INSN. */
1196 pt_btrace_insn (const struct pt_insn &insn)
1198 return {(CORE_ADDR) insn.ip, (gdb_byte) insn.size,
1199 pt_reclassify_insn (insn.iclass),
1200 pt_btrace_insn_flags (insn)};
1203 /* Handle instruction decode events (libipt-v2). */
1206 handle_pt_insn_events (struct btrace_thread_info *btinfo,
1207 struct pt_insn_decoder *decoder,
1208 std::vector<unsigned int> &gaps, int status)
1210 #if defined (HAVE_PT_INSN_EVENT)
1211 while (status & pts_event_pending)
1213 struct btrace_function *bfun;
1214 struct pt_event event;
1217 status = pt_insn_event (decoder, &event, sizeof (event));
1227 if (event.variant.enabled.resumed == 0 && !btinfo->functions.empty ())
1229 bfun = ftrace_new_gap (btinfo, BDE_PT_DISABLED, gaps);
1231 pt_insn_get_offset (decoder, &offset);
1233 warning (_("Non-contiguous trace at instruction %u (offset = 0x%"
1234 PRIx64 ")."), bfun->insn_offset - 1, offset);
1240 bfun = ftrace_new_gap (btinfo, BDE_PT_OVERFLOW, gaps);
1242 pt_insn_get_offset (decoder, &offset);
1244 warning (_("Overflow at instruction %u (offset = 0x%" PRIx64 ")."),
1245 bfun->insn_offset - 1, offset);
1250 #endif /* defined (HAVE_PT_INSN_EVENT) */
1255 /* Handle events indicated by flags in INSN (libipt-v1). */
1258 handle_pt_insn_event_flags (struct btrace_thread_info *btinfo,
1259 struct pt_insn_decoder *decoder,
1260 const struct pt_insn &insn,
1261 std::vector<unsigned int> &gaps)
1263 #if defined (HAVE_STRUCT_PT_INSN_ENABLED)
1264 /* Tracing is disabled and re-enabled each time we enter the kernel. Most
1265 times, we continue from the same instruction we stopped before. This is
1266 indicated via the RESUMED instruction flag. The ENABLED instruction flag
1267 means that we continued from some other instruction. Indicate this as a
1268 trace gap except when tracing just started. */
1269 if (insn.enabled && !btinfo->functions.empty ())
1271 struct btrace_function *bfun;
1274 bfun = ftrace_new_gap (btinfo, BDE_PT_DISABLED, gaps);
1276 pt_insn_get_offset (decoder, &offset);
1278 warning (_("Non-contiguous trace at instruction %u (offset = 0x%" PRIx64
1279 ", pc = 0x%" PRIx64 ")."), bfun->insn_offset - 1, offset,
1282 #endif /* defined (HAVE_STRUCT_PT_INSN_ENABLED) */
1284 #if defined (HAVE_STRUCT_PT_INSN_RESYNCED)
1285 /* Indicate trace overflows. */
1288 struct btrace_function *bfun;
1291 bfun = ftrace_new_gap (btinfo, BDE_PT_OVERFLOW, gaps);
1293 pt_insn_get_offset (decoder, &offset);
1295 warning (_("Overflow at instruction %u (offset = 0x%" PRIx64 ", pc = 0x%"
1296 PRIx64 ")."), bfun->insn_offset - 1, offset, insn.ip);
1298 #endif /* defined (HAVE_STRUCT_PT_INSN_RESYNCED) */
1301 /* Add function branch trace to BTINFO using DECODER. */
1304 ftrace_add_pt (struct btrace_thread_info *btinfo,
1305 struct pt_insn_decoder *decoder,
1307 std::vector<unsigned int> &gaps)
1309 struct btrace_function *bfun;
1315 struct pt_insn insn;
1317 status = pt_insn_sync_forward (decoder);
1320 if (status != -pte_eos)
1321 warning (_("Failed to synchronize onto the Intel Processor "
1322 "Trace stream: %s."), pt_errstr (pt_errcode (status)));
1328 /* Handle events from the previous iteration or synchronization. */
1329 status = handle_pt_insn_events (btinfo, decoder, gaps, status);
1333 status = pt_insn_next (decoder, &insn, sizeof(insn));
1337 /* Handle events indicated by flags in INSN. */
1338 handle_pt_insn_event_flags (btinfo, decoder, insn, gaps);
1340 bfun = ftrace_update_function (btinfo, insn.ip);
1342 /* Maintain the function level offset. */
1343 *plevel = std::min (*plevel, bfun->level);
1345 ftrace_update_insns (bfun, pt_btrace_insn (insn));
1348 if (status == -pte_eos)
1351 /* Indicate the gap in the trace. */
1352 bfun = ftrace_new_gap (btinfo, status, gaps);
1354 pt_insn_get_offset (decoder, &offset);
1356 warning (_("Decode error (%d) at instruction %u (offset = 0x%" PRIx64
1357 ", pc = 0x%" PRIx64 "): %s."), status, bfun->insn_offset - 1,
1358 offset, insn.ip, pt_errstr (pt_errcode (status)));
1362 /* A callback function to allow the trace decoder to read the inferior's
1366 btrace_pt_readmem_callback (gdb_byte *buffer, size_t size,
1367 const struct pt_asid *asid, uint64_t pc,
1370 int result, errcode;
1372 result = (int) size;
1375 errcode = target_read_code ((CORE_ADDR) pc, buffer, size);
1377 result = -pte_nomap;
1379 CATCH (error, RETURN_MASK_ERROR)
1381 result = -pte_nomap;
1388 /* Translate the vendor from one enum to another. */
1390 static enum pt_cpu_vendor
1391 pt_translate_cpu_vendor (enum btrace_cpu_vendor vendor)
1403 /* Finalize the function branch trace after decode. */
1405 static void btrace_finalize_ftrace_pt (struct pt_insn_decoder *decoder,
1406 struct thread_info *tp, int level)
1408 pt_insn_free_decoder (decoder);
1410 /* LEVEL is the minimal function level of all btrace function segments.
1411 Define the global level offset to -LEVEL so all function levels are
1412 normalized to start at zero. */
1413 tp->btrace.level = -level;
1415 /* Add a single last instruction entry for the current PC.
1416 This allows us to compute the backtrace at the current PC using both
1417 standard unwind and btrace unwind.
1418 This extra entry is ignored by all record commands. */
1422 /* Compute the function branch trace from Intel Processor Trace
1426 btrace_compute_ftrace_pt (struct thread_info *tp,
1427 const struct btrace_data_pt *btrace,
1428 std::vector<unsigned int> &gaps)
1430 struct btrace_thread_info *btinfo;
1431 struct pt_insn_decoder *decoder;
1432 struct pt_config config;
1435 if (btrace->size == 0)
1438 btinfo = &tp->btrace;
1439 if (btinfo->functions.empty ())
1442 level = -btinfo->level;
1444 pt_config_init(&config);
1445 config.begin = btrace->data;
1446 config.end = btrace->data + btrace->size;
1448 /* We treat an unknown vendor as 'no errata'. */
1449 if (btrace->config.cpu.vendor != CV_UNKNOWN)
1452 = pt_translate_cpu_vendor (btrace->config.cpu.vendor);
1453 config.cpu.family = btrace->config.cpu.family;
1454 config.cpu.model = btrace->config.cpu.model;
1455 config.cpu.stepping = btrace->config.cpu.stepping;
1457 errcode = pt_cpu_errata (&config.errata, &config.cpu);
1459 error (_("Failed to configure the Intel Processor Trace "
1460 "decoder: %s."), pt_errstr (pt_errcode (errcode)));
1463 decoder = pt_insn_alloc_decoder (&config);
1464 if (decoder == NULL)
1465 error (_("Failed to allocate the Intel Processor Trace decoder."));
1469 struct pt_image *image;
1471 image = pt_insn_get_image(decoder);
1473 error (_("Failed to configure the Intel Processor Trace decoder."));
1475 errcode = pt_image_set_callback(image, btrace_pt_readmem_callback, NULL);
1477 error (_("Failed to configure the Intel Processor Trace decoder: "
1478 "%s."), pt_errstr (pt_errcode (errcode)));
1480 ftrace_add_pt (btinfo, decoder, &level, gaps);
1482 CATCH (error, RETURN_MASK_ALL)
1484 /* Indicate a gap in the trace if we quit trace processing. */
1485 if (error.reason == RETURN_QUIT && !btinfo->functions.empty ())
1486 ftrace_new_gap (btinfo, BDE_PT_USER_QUIT, gaps);
1488 btrace_finalize_ftrace_pt (decoder, tp, level);
1490 throw_exception (error);
1494 btrace_finalize_ftrace_pt (decoder, tp, level);
1497 #else /* defined (HAVE_LIBIPT) */
1500 btrace_compute_ftrace_pt (struct thread_info *tp,
1501 const struct btrace_data_pt *btrace,
1502 std::vector<unsigned int> &gaps)
1504 internal_error (__FILE__, __LINE__, _("Unexpected branch trace format."));
1507 #endif /* defined (HAVE_LIBIPT) */
1509 /* Compute the function branch trace from a block branch trace BTRACE for
1510 a thread given by BTINFO. If CPU is not NULL, overwrite the cpu in the
1511 branch trace configuration. This is currently only used for the PT
1515 btrace_compute_ftrace_1 (struct thread_info *tp,
1516 struct btrace_data *btrace,
1517 const struct btrace_cpu *cpu,
1518 std::vector<unsigned int> &gaps)
1520 DEBUG ("compute ftrace");
1522 switch (btrace->format)
1524 case BTRACE_FORMAT_NONE:
1527 case BTRACE_FORMAT_BTS:
1528 btrace_compute_ftrace_bts (tp, &btrace->variant.bts, gaps);
1531 case BTRACE_FORMAT_PT:
1532 /* Overwrite the cpu we use for enabling errata workarounds. */
1534 btrace->variant.pt.config.cpu = *cpu;
1536 btrace_compute_ftrace_pt (tp, &btrace->variant.pt, gaps);
1540 internal_error (__FILE__, __LINE__, _("Unkown branch trace format."));
1544 btrace_finalize_ftrace (struct thread_info *tp, std::vector<unsigned int> &gaps)
1548 tp->btrace.ngaps += gaps.size ();
1549 btrace_bridge_gaps (tp, gaps);
1554 btrace_compute_ftrace (struct thread_info *tp, struct btrace_data *btrace,
1555 const struct btrace_cpu *cpu)
1557 std::vector<unsigned int> gaps;
1561 btrace_compute_ftrace_1 (tp, btrace, cpu, gaps);
1563 CATCH (error, RETURN_MASK_ALL)
1565 btrace_finalize_ftrace (tp, gaps);
1567 throw_exception (error);
1571 btrace_finalize_ftrace (tp, gaps);
1574 /* Add an entry for the current PC. */
1577 btrace_add_pc (struct thread_info *tp)
1579 struct btrace_data btrace;
1580 struct btrace_block *block;
1581 struct regcache *regcache;
1584 regcache = get_thread_regcache (tp);
1585 pc = regcache_read_pc (regcache);
1587 btrace.format = BTRACE_FORMAT_BTS;
1588 btrace.variant.bts.blocks = NULL;
1590 block = VEC_safe_push (btrace_block_s, btrace.variant.bts.blocks, NULL);
1594 btrace_compute_ftrace (tp, &btrace, NULL);
1600 btrace_enable (struct thread_info *tp, const struct btrace_config *conf)
1602 if (tp->btrace.target != NULL)
1605 #if !defined (HAVE_LIBIPT)
1606 if (conf->format == BTRACE_FORMAT_PT)
1607 error (_("Intel Processor Trace support was disabled at compile time."));
1608 #endif /* !defined (HAVE_LIBIPT) */
1610 DEBUG ("enable thread %s (%s)", print_thread_id (tp),
1611 target_pid_to_str (tp->ptid));
1613 tp->btrace.target = target_enable_btrace (tp->ptid, conf);
1615 /* We're done if we failed to enable tracing. */
1616 if (tp->btrace.target == NULL)
1619 /* We need to undo the enable in case of errors. */
1622 /* Add an entry for the current PC so we start tracing from where we
1625 If we can't access TP's registers, TP is most likely running. In this
1626 case, we can't really say where tracing was enabled so it should be
1627 safe to simply skip this step.
1629 This is not relevant for BTRACE_FORMAT_PT since the trace will already
1630 start at the PC at which tracing was enabled. */
1631 if (conf->format != BTRACE_FORMAT_PT
1632 && can_access_registers_thread (tp))
1635 CATCH (exception, RETURN_MASK_ALL)
1637 btrace_disable (tp);
1639 throw_exception (exception);
1646 const struct btrace_config *
1647 btrace_conf (const struct btrace_thread_info *btinfo)
1649 if (btinfo->target == NULL)
1652 return target_btrace_conf (btinfo->target);
1658 btrace_disable (struct thread_info *tp)
1660 struct btrace_thread_info *btp = &tp->btrace;
1662 if (btp->target == NULL)
1665 DEBUG ("disable thread %s (%s)", print_thread_id (tp),
1666 target_pid_to_str (tp->ptid));
1668 target_disable_btrace (btp->target);
1677 btrace_teardown (struct thread_info *tp)
1679 struct btrace_thread_info *btp = &tp->btrace;
1681 if (btp->target == NULL)
1684 DEBUG ("teardown thread %s (%s)", print_thread_id (tp),
1685 target_pid_to_str (tp->ptid));
1687 target_teardown_btrace (btp->target);
1693 /* Stitch branch trace in BTS format. */
1696 btrace_stitch_bts (struct btrace_data_bts *btrace, struct thread_info *tp)
1698 struct btrace_thread_info *btinfo;
1699 struct btrace_function *last_bfun;
1700 btrace_block_s *first_new_block;
1702 btinfo = &tp->btrace;
1703 gdb_assert (!btinfo->functions.empty ());
1704 gdb_assert (!VEC_empty (btrace_block_s, btrace->blocks));
1706 last_bfun = &btinfo->functions.back ();
1708 /* If the existing trace ends with a gap, we just glue the traces
1709 together. We need to drop the last (i.e. chronologically first) block
1710 of the new trace, though, since we can't fill in the start address.*/
1711 if (last_bfun->insn.empty ())
1713 VEC_pop (btrace_block_s, btrace->blocks);
1717 /* Beware that block trace starts with the most recent block, so the
1718 chronologically first block in the new trace is the last block in
1719 the new trace's block vector. */
1720 first_new_block = VEC_last (btrace_block_s, btrace->blocks);
1721 const btrace_insn &last_insn = last_bfun->insn.back ();
1723 /* If the current PC at the end of the block is the same as in our current
1724 trace, there are two explanations:
1725 1. we executed the instruction and some branch brought us back.
1726 2. we have not made any progress.
1727 In the first case, the delta trace vector should contain at least two
1729 In the second case, the delta trace vector should contain exactly one
1730 entry for the partial block containing the current PC. Remove it. */
1731 if (first_new_block->end == last_insn.pc
1732 && VEC_length (btrace_block_s, btrace->blocks) == 1)
1734 VEC_pop (btrace_block_s, btrace->blocks);
1738 DEBUG ("stitching %s to %s", ftrace_print_insn_addr (&last_insn),
1739 core_addr_to_string_nz (first_new_block->end));
1741 /* Do a simple sanity check to make sure we don't accidentally end up
1742 with a bad block. This should not occur in practice. */
1743 if (first_new_block->end < last_insn.pc)
1745 warning (_("Error while trying to read delta trace. Falling back to "
1750 /* We adjust the last block to start at the end of our current trace. */
1751 gdb_assert (first_new_block->begin == 0);
1752 first_new_block->begin = last_insn.pc;
1754 /* We simply pop the last insn so we can insert it again as part of
1755 the normal branch trace computation.
1756 Since instruction iterators are based on indices in the instructions
1757 vector, we don't leave any pointers dangling. */
1758 DEBUG ("pruning insn at %s for stitching",
1759 ftrace_print_insn_addr (&last_insn));
1761 last_bfun->insn.pop_back ();
1763 /* The instructions vector may become empty temporarily if this has
1764 been the only instruction in this function segment.
1765 This violates the invariant but will be remedied shortly by
1766 btrace_compute_ftrace when we add the new trace. */
1768 /* The only case where this would hurt is if the entire trace consisted
1769 of just that one instruction. If we remove it, we might turn the now
1770 empty btrace function segment into a gap. But we don't want gaps at
1771 the beginning. To avoid this, we remove the entire old trace. */
1772 if (last_bfun->number == 1 && last_bfun->insn.empty ())
1778 /* Adjust the block trace in order to stitch old and new trace together.
1779 BTRACE is the new delta trace between the last and the current stop.
1780 TP is the traced thread.
1781 May modifx BTRACE as well as the existing trace in TP.
1782 Return 0 on success, -1 otherwise. */
1785 btrace_stitch_trace (struct btrace_data *btrace, struct thread_info *tp)
1787 /* If we don't have trace, there's nothing to do. */
1788 if (btrace->empty ())
1791 switch (btrace->format)
1793 case BTRACE_FORMAT_NONE:
1796 case BTRACE_FORMAT_BTS:
1797 return btrace_stitch_bts (&btrace->variant.bts, tp);
1799 case BTRACE_FORMAT_PT:
1800 /* Delta reads are not supported. */
1804 internal_error (__FILE__, __LINE__, _("Unkown branch trace format."));
1807 /* Clear the branch trace histories in BTINFO. */
1810 btrace_clear_history (struct btrace_thread_info *btinfo)
1812 xfree (btinfo->insn_history);
1813 xfree (btinfo->call_history);
1814 xfree (btinfo->replay);
1816 btinfo->insn_history = NULL;
1817 btinfo->call_history = NULL;
1818 btinfo->replay = NULL;
1821 /* Clear the branch trace maintenance histories in BTINFO. */
1824 btrace_maint_clear (struct btrace_thread_info *btinfo)
1826 switch (btinfo->data.format)
1831 case BTRACE_FORMAT_BTS:
1832 btinfo->maint.variant.bts.packet_history.begin = 0;
1833 btinfo->maint.variant.bts.packet_history.end = 0;
1836 #if defined (HAVE_LIBIPT)
1837 case BTRACE_FORMAT_PT:
1838 xfree (btinfo->maint.variant.pt.packets);
1840 btinfo->maint.variant.pt.packets = NULL;
1841 btinfo->maint.variant.pt.packet_history.begin = 0;
1842 btinfo->maint.variant.pt.packet_history.end = 0;
1844 #endif /* defined (HAVE_LIBIPT) */
1851 btrace_decode_error (enum btrace_format format, int errcode)
1855 case BTRACE_FORMAT_BTS:
1858 case BDE_BTS_OVERFLOW:
1859 return _("instruction overflow");
1861 case BDE_BTS_INSN_SIZE:
1862 return _("unknown instruction");
1869 #if defined (HAVE_LIBIPT)
1870 case BTRACE_FORMAT_PT:
1873 case BDE_PT_USER_QUIT:
1874 return _("trace decode cancelled");
1876 case BDE_PT_DISABLED:
1877 return _("disabled");
1879 case BDE_PT_OVERFLOW:
1880 return _("overflow");
1884 return pt_errstr (pt_errcode (errcode));
1888 #endif /* defined (HAVE_LIBIPT) */
1894 return _("unknown");
1900 btrace_fetch (struct thread_info *tp, const struct btrace_cpu *cpu)
1902 struct btrace_thread_info *btinfo;
1903 struct btrace_target_info *tinfo;
1904 struct btrace_data btrace;
1907 DEBUG ("fetch thread %s (%s)", print_thread_id (tp),
1908 target_pid_to_str (tp->ptid));
1910 btinfo = &tp->btrace;
1911 tinfo = btinfo->target;
1915 /* There's no way we could get new trace while replaying.
1916 On the other hand, delta trace would return a partial record with the
1917 current PC, which is the replay PC, not the last PC, as expected. */
1918 if (btinfo->replay != NULL)
1921 /* With CLI usage, TP->PTID always equals INFERIOR_PTID here. Now that we
1922 can store a gdb.Record object in Python referring to a different thread
1923 than the current one, temporarily set INFERIOR_PTID. */
1924 scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid);
1925 inferior_ptid = tp->ptid;
1927 /* We should not be called on running or exited threads. */
1928 gdb_assert (can_access_registers_thread (tp));
1930 /* Let's first try to extend the trace we already have. */
1931 if (!btinfo->functions.empty ())
1933 errcode = target_read_btrace (&btrace, tinfo, BTRACE_READ_DELTA);
1936 /* Success. Let's try to stitch the traces together. */
1937 errcode = btrace_stitch_trace (&btrace, tp);
1941 /* We failed to read delta trace. Let's try to read new trace. */
1942 errcode = target_read_btrace (&btrace, tinfo, BTRACE_READ_NEW);
1944 /* If we got any new trace, discard what we have. */
1945 if (errcode == 0 && !btrace.empty ())
1949 /* If we were not able to read the trace, we start over. */
1953 errcode = target_read_btrace (&btrace, tinfo, BTRACE_READ_ALL);
1957 errcode = target_read_btrace (&btrace, tinfo, BTRACE_READ_ALL);
1959 /* If we were not able to read the branch trace, signal an error. */
1961 error (_("Failed to read branch trace."));
1963 /* Compute the trace, provided we have any. */
1964 if (!btrace.empty ())
1966 /* Store the raw trace data. The stored data will be cleared in
1967 btrace_clear, so we always append the new trace. */
1968 btrace_data_append (&btinfo->data, &btrace);
1969 btrace_maint_clear (btinfo);
1971 btrace_clear_history (btinfo);
1972 btrace_compute_ftrace (tp, &btrace, cpu);
1979 btrace_clear (struct thread_info *tp)
1981 struct btrace_thread_info *btinfo;
1983 DEBUG ("clear thread %s (%s)", print_thread_id (tp),
1984 target_pid_to_str (tp->ptid));
1986 /* Make sure btrace frames that may hold a pointer into the branch
1987 trace data are destroyed. */
1988 reinit_frame_cache ();
1990 btinfo = &tp->btrace;
1992 btinfo->functions.clear ();
1995 /* Must clear the maint data before - it depends on BTINFO->DATA. */
1996 btrace_maint_clear (btinfo);
1997 btinfo->data.clear ();
1998 btrace_clear_history (btinfo);
2004 btrace_free_objfile (struct objfile *objfile)
2006 struct thread_info *tp;
2008 DEBUG ("free objfile");
2010 ALL_NON_EXITED_THREADS (tp)
2014 #if defined (HAVE_LIBEXPAT)
2016 /* Check the btrace document version. */
2019 check_xml_btrace_version (struct gdb_xml_parser *parser,
2020 const struct gdb_xml_element *element,
2022 std::vector<gdb_xml_value> &attributes)
2025 = (const char *) xml_find_attribute (attributes, "version")->value.get ();
2027 if (strcmp (version, "1.0") != 0)
2028 gdb_xml_error (parser, _("Unsupported btrace version: \"%s\""), version);
2031 /* Parse a btrace "block" xml record. */
2034 parse_xml_btrace_block (struct gdb_xml_parser *parser,
2035 const struct gdb_xml_element *element,
2037 std::vector<gdb_xml_value> &attributes)
2039 struct btrace_data *btrace;
2040 struct btrace_block *block;
2041 ULONGEST *begin, *end;
2043 btrace = (struct btrace_data *) user_data;
2045 switch (btrace->format)
2047 case BTRACE_FORMAT_BTS:
2050 case BTRACE_FORMAT_NONE:
2051 btrace->format = BTRACE_FORMAT_BTS;
2052 btrace->variant.bts.blocks = NULL;
2056 gdb_xml_error (parser, _("Btrace format error."));
2059 begin = (ULONGEST *) xml_find_attribute (attributes, "begin")->value.get ();
2060 end = (ULONGEST *) xml_find_attribute (attributes, "end")->value.get ();
2062 block = VEC_safe_push (btrace_block_s, btrace->variant.bts.blocks, NULL);
2063 block->begin = *begin;
2067 /* Parse a "raw" xml record. */
2070 parse_xml_raw (struct gdb_xml_parser *parser, const char *body_text,
2071 gdb_byte **pdata, size_t *psize)
2076 len = strlen (body_text);
2078 gdb_xml_error (parser, _("Bad raw data size."));
2082 gdb::unique_xmalloc_ptr<gdb_byte> data ((gdb_byte *) xmalloc (size));
2085 /* We use hex encoding - see common/rsp-low.h. */
2093 if (hi == 0 || lo == 0)
2094 gdb_xml_error (parser, _("Bad hex encoding."));
2096 *bin++ = fromhex (hi) * 16 + fromhex (lo);
2100 *pdata = data.release ();
2104 /* Parse a btrace pt-config "cpu" xml record. */
2107 parse_xml_btrace_pt_config_cpu (struct gdb_xml_parser *parser,
2108 const struct gdb_xml_element *element,
2110 std::vector<gdb_xml_value> &attributes)
2112 struct btrace_data *btrace;
2114 ULONGEST *family, *model, *stepping;
2117 (const char *) xml_find_attribute (attributes, "vendor")->value.get ();
2119 = (ULONGEST *) xml_find_attribute (attributes, "family")->value.get ();
2121 = (ULONGEST *) xml_find_attribute (attributes, "model")->value.get ();
2123 = (ULONGEST *) xml_find_attribute (attributes, "stepping")->value.get ();
2125 btrace = (struct btrace_data *) user_data;
2127 if (strcmp (vendor, "GenuineIntel") == 0)
2128 btrace->variant.pt.config.cpu.vendor = CV_INTEL;
2130 btrace->variant.pt.config.cpu.family = *family;
2131 btrace->variant.pt.config.cpu.model = *model;
2132 btrace->variant.pt.config.cpu.stepping = *stepping;
2135 /* Parse a btrace pt "raw" xml record. */
2138 parse_xml_btrace_pt_raw (struct gdb_xml_parser *parser,
2139 const struct gdb_xml_element *element,
2140 void *user_data, const char *body_text)
2142 struct btrace_data *btrace;
2144 btrace = (struct btrace_data *) user_data;
2145 parse_xml_raw (parser, body_text, &btrace->variant.pt.data,
2146 &btrace->variant.pt.size);
2149 /* Parse a btrace "pt" xml record. */
2152 parse_xml_btrace_pt (struct gdb_xml_parser *parser,
2153 const struct gdb_xml_element *element,
2155 std::vector<gdb_xml_value> &attributes)
2157 struct btrace_data *btrace;
2159 btrace = (struct btrace_data *) user_data;
2160 btrace->format = BTRACE_FORMAT_PT;
2161 btrace->variant.pt.config.cpu.vendor = CV_UNKNOWN;
2162 btrace->variant.pt.data = NULL;
2163 btrace->variant.pt.size = 0;
2166 static const struct gdb_xml_attribute block_attributes[] = {
2167 { "begin", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
2168 { "end", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
2169 { NULL, GDB_XML_AF_NONE, NULL, NULL }
2172 static const struct gdb_xml_attribute btrace_pt_config_cpu_attributes[] = {
2173 { "vendor", GDB_XML_AF_NONE, NULL, NULL },
2174 { "family", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
2175 { "model", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
2176 { "stepping", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
2177 { NULL, GDB_XML_AF_NONE, NULL, NULL }
2180 static const struct gdb_xml_element btrace_pt_config_children[] = {
2181 { "cpu", btrace_pt_config_cpu_attributes, NULL, GDB_XML_EF_OPTIONAL,
2182 parse_xml_btrace_pt_config_cpu, NULL },
2183 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
2186 static const struct gdb_xml_element btrace_pt_children[] = {
2187 { "pt-config", NULL, btrace_pt_config_children, GDB_XML_EF_OPTIONAL, NULL,
2189 { "raw", NULL, NULL, GDB_XML_EF_OPTIONAL, NULL, parse_xml_btrace_pt_raw },
2190 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
2193 static const struct gdb_xml_attribute btrace_attributes[] = {
2194 { "version", GDB_XML_AF_NONE, NULL, NULL },
2195 { NULL, GDB_XML_AF_NONE, NULL, NULL }
2198 static const struct gdb_xml_element btrace_children[] = {
2199 { "block", block_attributes, NULL,
2200 GDB_XML_EF_REPEATABLE | GDB_XML_EF_OPTIONAL, parse_xml_btrace_block, NULL },
2201 { "pt", NULL, btrace_pt_children, GDB_XML_EF_OPTIONAL, parse_xml_btrace_pt,
2203 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
2206 static const struct gdb_xml_element btrace_elements[] = {
2207 { "btrace", btrace_attributes, btrace_children, GDB_XML_EF_NONE,
2208 check_xml_btrace_version, NULL },
2209 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
2212 #endif /* defined (HAVE_LIBEXPAT) */
2217 parse_xml_btrace (struct btrace_data *btrace, const char *buffer)
2219 #if defined (HAVE_LIBEXPAT)
2223 result.format = BTRACE_FORMAT_NONE;
2225 errcode = gdb_xml_parse_quick (_("btrace"), "btrace.dtd", btrace_elements,
2228 error (_("Error parsing branch trace."));
2230 /* Keep parse results. */
2231 *btrace = std::move (result);
2233 #else /* !defined (HAVE_LIBEXPAT) */
2235 error (_("Cannot process branch trace. XML support was disabled at "
2238 #endif /* !defined (HAVE_LIBEXPAT) */
2241 #if defined (HAVE_LIBEXPAT)
2243 /* Parse a btrace-conf "bts" xml record. */
2246 parse_xml_btrace_conf_bts (struct gdb_xml_parser *parser,
2247 const struct gdb_xml_element *element,
2249 std::vector<gdb_xml_value> &attributes)
2251 struct btrace_config *conf;
2252 struct gdb_xml_value *size;
2254 conf = (struct btrace_config *) user_data;
2255 conf->format = BTRACE_FORMAT_BTS;
2258 size = xml_find_attribute (attributes, "size");
2260 conf->bts.size = (unsigned int) *(ULONGEST *) size->value.get ();
2263 /* Parse a btrace-conf "pt" xml record. */
2266 parse_xml_btrace_conf_pt (struct gdb_xml_parser *parser,
2267 const struct gdb_xml_element *element,
2269 std::vector<gdb_xml_value> &attributes)
2271 struct btrace_config *conf;
2272 struct gdb_xml_value *size;
2274 conf = (struct btrace_config *) user_data;
2275 conf->format = BTRACE_FORMAT_PT;
2278 size = xml_find_attribute (attributes, "size");
2280 conf->pt.size = (unsigned int) *(ULONGEST *) size->value.get ();
2283 static const struct gdb_xml_attribute btrace_conf_pt_attributes[] = {
2284 { "size", GDB_XML_AF_OPTIONAL, gdb_xml_parse_attr_ulongest, NULL },
2285 { NULL, GDB_XML_AF_NONE, NULL, NULL }
2288 static const struct gdb_xml_attribute btrace_conf_bts_attributes[] = {
2289 { "size", GDB_XML_AF_OPTIONAL, gdb_xml_parse_attr_ulongest, NULL },
2290 { NULL, GDB_XML_AF_NONE, NULL, NULL }
2293 static const struct gdb_xml_element btrace_conf_children[] = {
2294 { "bts", btrace_conf_bts_attributes, NULL, GDB_XML_EF_OPTIONAL,
2295 parse_xml_btrace_conf_bts, NULL },
2296 { "pt", btrace_conf_pt_attributes, NULL, GDB_XML_EF_OPTIONAL,
2297 parse_xml_btrace_conf_pt, NULL },
2298 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
2301 static const struct gdb_xml_attribute btrace_conf_attributes[] = {
2302 { "version", GDB_XML_AF_NONE, NULL, NULL },
2303 { NULL, GDB_XML_AF_NONE, NULL, NULL }
2306 static const struct gdb_xml_element btrace_conf_elements[] = {
2307 { "btrace-conf", btrace_conf_attributes, btrace_conf_children,
2308 GDB_XML_EF_NONE, NULL, NULL },
2309 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
2312 #endif /* defined (HAVE_LIBEXPAT) */
2317 parse_xml_btrace_conf (struct btrace_config *conf, const char *xml)
2319 #if defined (HAVE_LIBEXPAT)
2322 errcode = gdb_xml_parse_quick (_("btrace-conf"), "btrace-conf.dtd",
2323 btrace_conf_elements, xml, conf);
2325 error (_("Error parsing branch trace configuration."));
2327 #else /* !defined (HAVE_LIBEXPAT) */
2329 error (_("Cannot process the branch trace configuration. XML support "
2330 "was disabled at compile time."));
2332 #endif /* !defined (HAVE_LIBEXPAT) */
2337 const struct btrace_insn *
2338 btrace_insn_get (const struct btrace_insn_iterator *it)
2340 const struct btrace_function *bfun;
2341 unsigned int index, end;
2343 index = it->insn_index;
2344 bfun = &it->btinfo->functions[it->call_index];
2346 /* Check if the iterator points to a gap in the trace. */
2347 if (bfun->errcode != 0)
2350 /* The index is within the bounds of this function's instruction vector. */
2351 end = bfun->insn.size ();
2352 gdb_assert (0 < end);
2353 gdb_assert (index < end);
2355 return &bfun->insn[index];
2361 btrace_insn_get_error (const struct btrace_insn_iterator *it)
2363 return it->btinfo->functions[it->call_index].errcode;
2369 btrace_insn_number (const struct btrace_insn_iterator *it)
2371 return it->btinfo->functions[it->call_index].insn_offset + it->insn_index;
2377 btrace_insn_begin (struct btrace_insn_iterator *it,
2378 const struct btrace_thread_info *btinfo)
2380 if (btinfo->functions.empty ())
2381 error (_("No trace."));
2383 it->btinfo = btinfo;
2391 btrace_insn_end (struct btrace_insn_iterator *it,
2392 const struct btrace_thread_info *btinfo)
2394 const struct btrace_function *bfun;
2395 unsigned int length;
2397 if (btinfo->functions.empty ())
2398 error (_("No trace."));
2400 bfun = &btinfo->functions.back ();
2401 length = bfun->insn.size ();
2403 /* The last function may either be a gap or it contains the current
2404 instruction, which is one past the end of the execution trace; ignore
2409 it->btinfo = btinfo;
2410 it->call_index = bfun->number - 1;
2411 it->insn_index = length;
2417 btrace_insn_next (struct btrace_insn_iterator *it, unsigned int stride)
2419 const struct btrace_function *bfun;
2420 unsigned int index, steps;
2422 bfun = &it->btinfo->functions[it->call_index];
2424 index = it->insn_index;
2428 unsigned int end, space, adv;
2430 end = bfun->insn.size ();
2432 /* An empty function segment represents a gap in the trace. We count
2433 it as one instruction. */
2436 const struct btrace_function *next;
2438 next = ftrace_find_call_by_number (it->btinfo, bfun->number + 1);
2451 gdb_assert (0 < end);
2452 gdb_assert (index < end);
2454 /* Compute the number of instructions remaining in this segment. */
2455 space = end - index;
2457 /* Advance the iterator as far as possible within this segment. */
2458 adv = std::min (space, stride);
2463 /* Move to the next function if we're at the end of this one. */
2466 const struct btrace_function *next;
2468 next = ftrace_find_call_by_number (it->btinfo, bfun->number + 1);
2471 /* We stepped past the last function.
2473 Let's adjust the index to point to the last instruction in
2474 the previous function. */
2480 /* We now point to the first instruction in the new function. */
2485 /* We did make progress. */
2486 gdb_assert (adv > 0);
2489 /* Update the iterator. */
2490 it->call_index = bfun->number - 1;
2491 it->insn_index = index;
2499 btrace_insn_prev (struct btrace_insn_iterator *it, unsigned int stride)
2501 const struct btrace_function *bfun;
2502 unsigned int index, steps;
2504 bfun = &it->btinfo->functions[it->call_index];
2506 index = it->insn_index;
2512 /* Move to the previous function if we're at the start of this one. */
2515 const struct btrace_function *prev;
2517 prev = ftrace_find_call_by_number (it->btinfo, bfun->number - 1);
2521 /* We point to one after the last instruction in the new function. */
2523 index = bfun->insn.size ();
2525 /* An empty function segment represents a gap in the trace. We count
2526 it as one instruction. */
2536 /* Advance the iterator as far as possible within this segment. */
2537 adv = std::min (index, stride);
2543 /* We did make progress. */
2544 gdb_assert (adv > 0);
2547 /* Update the iterator. */
2548 it->call_index = bfun->number - 1;
2549 it->insn_index = index;
2557 btrace_insn_cmp (const struct btrace_insn_iterator *lhs,
2558 const struct btrace_insn_iterator *rhs)
2560 gdb_assert (lhs->btinfo == rhs->btinfo);
2562 if (lhs->call_index != rhs->call_index)
2563 return lhs->call_index - rhs->call_index;
2565 return lhs->insn_index - rhs->insn_index;
2571 btrace_find_insn_by_number (struct btrace_insn_iterator *it,
2572 const struct btrace_thread_info *btinfo,
2573 unsigned int number)
2575 const struct btrace_function *bfun;
2576 unsigned int upper, lower;
2578 if (btinfo->functions.empty ())
2582 bfun = &btinfo->functions[lower];
2583 if (number < bfun->insn_offset)
2586 upper = btinfo->functions.size () - 1;
2587 bfun = &btinfo->functions[upper];
2588 if (number >= bfun->insn_offset + ftrace_call_num_insn (bfun))
2591 /* We assume that there are no holes in the numbering. */
2594 const unsigned int average = lower + (upper - lower) / 2;
2596 bfun = &btinfo->functions[average];
2598 if (number < bfun->insn_offset)
2600 upper = average - 1;
2604 if (number >= bfun->insn_offset + ftrace_call_num_insn (bfun))
2606 lower = average + 1;
2613 it->btinfo = btinfo;
2614 it->call_index = bfun->number - 1;
2615 it->insn_index = number - bfun->insn_offset;
2619 /* Returns true if the recording ends with a function segment that
2620 contains only a single (i.e. the current) instruction. */
2623 btrace_ends_with_single_insn (const struct btrace_thread_info *btinfo)
2625 const btrace_function *bfun;
2627 if (btinfo->functions.empty ())
2630 bfun = &btinfo->functions.back ();
2631 if (bfun->errcode != 0)
2634 return ftrace_call_num_insn (bfun) == 1;
2639 const struct btrace_function *
2640 btrace_call_get (const struct btrace_call_iterator *it)
2642 if (it->index >= it->btinfo->functions.size ())
2645 return &it->btinfo->functions[it->index];
2651 btrace_call_number (const struct btrace_call_iterator *it)
2653 const unsigned int length = it->btinfo->functions.size ();
2655 /* If the last function segment contains only a single instruction (i.e. the
2656 current instruction), skip it. */
2657 if ((it->index == length) && btrace_ends_with_single_insn (it->btinfo))
2660 return it->index + 1;
2666 btrace_call_begin (struct btrace_call_iterator *it,
2667 const struct btrace_thread_info *btinfo)
2669 if (btinfo->functions.empty ())
2670 error (_("No trace."));
2672 it->btinfo = btinfo;
2679 btrace_call_end (struct btrace_call_iterator *it,
2680 const struct btrace_thread_info *btinfo)
2682 if (btinfo->functions.empty ())
2683 error (_("No trace."));
2685 it->btinfo = btinfo;
2686 it->index = btinfo->functions.size ();
2692 btrace_call_next (struct btrace_call_iterator *it, unsigned int stride)
2694 const unsigned int length = it->btinfo->functions.size ();
2696 if (it->index + stride < length - 1)
2697 /* Default case: Simply advance the iterator. */
2698 it->index += stride;
2699 else if (it->index + stride == length - 1)
2701 /* We land exactly at the last function segment. If it contains only one
2702 instruction (i.e. the current instruction) it is not actually part of
2704 if (btrace_ends_with_single_insn (it->btinfo))
2707 it->index = length - 1;
2711 /* We land past the last function segment and have to adjust the stride.
2712 If the last function segment contains only one instruction (i.e. the
2713 current instruction) it is not actually part of the trace. */
2714 if (btrace_ends_with_single_insn (it->btinfo))
2715 stride = length - it->index - 1;
2717 stride = length - it->index;
2728 btrace_call_prev (struct btrace_call_iterator *it, unsigned int stride)
2730 const unsigned int length = it->btinfo->functions.size ();
2733 gdb_assert (it->index <= length);
2735 if (stride == 0 || it->index == 0)
2738 /* If we are at the end, the first step is a special case. If the last
2739 function segment contains only one instruction (i.e. the current
2740 instruction) it is not actually part of the trace. To be able to step
2741 over this instruction, we need at least one more function segment. */
2742 if ((it->index == length) && (length > 1))
2744 if (btrace_ends_with_single_insn (it->btinfo))
2745 it->index = length - 2;
2747 it->index = length - 1;
2753 stride = std::min (stride, it->index);
2755 it->index -= stride;
2756 return steps + stride;
2762 btrace_call_cmp (const struct btrace_call_iterator *lhs,
2763 const struct btrace_call_iterator *rhs)
2765 gdb_assert (lhs->btinfo == rhs->btinfo);
2766 return (int) (lhs->index - rhs->index);
2772 btrace_find_call_by_number (struct btrace_call_iterator *it,
2773 const struct btrace_thread_info *btinfo,
2774 unsigned int number)
2776 const unsigned int length = btinfo->functions.size ();
2778 if ((number == 0) || (number > length))
2781 it->btinfo = btinfo;
2782 it->index = number - 1;
2789 btrace_set_insn_history (struct btrace_thread_info *btinfo,
2790 const struct btrace_insn_iterator *begin,
2791 const struct btrace_insn_iterator *end)
2793 if (btinfo->insn_history == NULL)
2794 btinfo->insn_history = XCNEW (struct btrace_insn_history);
2796 btinfo->insn_history->begin = *begin;
2797 btinfo->insn_history->end = *end;
2803 btrace_set_call_history (struct btrace_thread_info *btinfo,
2804 const struct btrace_call_iterator *begin,
2805 const struct btrace_call_iterator *end)
2807 gdb_assert (begin->btinfo == end->btinfo);
2809 if (btinfo->call_history == NULL)
2810 btinfo->call_history = XCNEW (struct btrace_call_history);
2812 btinfo->call_history->begin = *begin;
2813 btinfo->call_history->end = *end;
2819 btrace_is_replaying (struct thread_info *tp)
2821 return tp->btrace.replay != NULL;
2827 btrace_is_empty (struct thread_info *tp)
2829 struct btrace_insn_iterator begin, end;
2830 struct btrace_thread_info *btinfo;
2832 btinfo = &tp->btrace;
2834 if (btinfo->functions.empty ())
2837 btrace_insn_begin (&begin, btinfo);
2838 btrace_insn_end (&end, btinfo);
2840 return btrace_insn_cmp (&begin, &end) == 0;
2843 #if defined (HAVE_LIBIPT)
2845 /* Print a single packet. */
2848 pt_print_packet (const struct pt_packet *packet)
2850 switch (packet->type)
2853 printf_unfiltered (("[??: %x]"), packet->type);
2857 printf_unfiltered (("psb"));
2861 printf_unfiltered (("psbend"));
2865 printf_unfiltered (("pad"));
2869 printf_unfiltered (("tip %u: 0x%" PRIx64 ""),
2870 packet->payload.ip.ipc,
2871 packet->payload.ip.ip);
2875 printf_unfiltered (("tip.pge %u: 0x%" PRIx64 ""),
2876 packet->payload.ip.ipc,
2877 packet->payload.ip.ip);
2881 printf_unfiltered (("tip.pgd %u: 0x%" PRIx64 ""),
2882 packet->payload.ip.ipc,
2883 packet->payload.ip.ip);
2887 printf_unfiltered (("fup %u: 0x%" PRIx64 ""),
2888 packet->payload.ip.ipc,
2889 packet->payload.ip.ip);
2893 printf_unfiltered (("tnt-8 %u: 0x%" PRIx64 ""),
2894 packet->payload.tnt.bit_size,
2895 packet->payload.tnt.payload);
2899 printf_unfiltered (("tnt-64 %u: 0x%" PRIx64 ""),
2900 packet->payload.tnt.bit_size,
2901 packet->payload.tnt.payload);
2905 printf_unfiltered (("pip %" PRIx64 "%s"), packet->payload.pip.cr3,
2906 packet->payload.pip.nr ? (" nr") : (""));
2910 printf_unfiltered (("tsc %" PRIx64 ""), packet->payload.tsc.tsc);
2914 printf_unfiltered (("cbr %u"), packet->payload.cbr.ratio);
2918 switch (packet->payload.mode.leaf)
2921 printf_unfiltered (("mode %u"), packet->payload.mode.leaf);
2925 printf_unfiltered (("mode.exec%s%s"),
2926 packet->payload.mode.bits.exec.csl
2928 packet->payload.mode.bits.exec.csd
2929 ? (" cs.d") : (""));
2933 printf_unfiltered (("mode.tsx%s%s"),
2934 packet->payload.mode.bits.tsx.intx
2936 packet->payload.mode.bits.tsx.abrt
2937 ? (" abrt") : (""));
2943 printf_unfiltered (("ovf"));
2947 printf_unfiltered (("stop"));
2951 printf_unfiltered (("vmcs %" PRIx64 ""), packet->payload.vmcs.base);
2955 printf_unfiltered (("tma %x %x"), packet->payload.tma.ctc,
2956 packet->payload.tma.fc);
2960 printf_unfiltered (("mtc %x"), packet->payload.mtc.ctc);
2964 printf_unfiltered (("cyc %" PRIx64 ""), packet->payload.cyc.value);
2968 printf_unfiltered (("mnt %" PRIx64 ""), packet->payload.mnt.payload);
2973 /* Decode packets into MAINT using DECODER. */
2976 btrace_maint_decode_pt (struct btrace_maint_info *maint,
2977 struct pt_packet_decoder *decoder)
2983 struct btrace_pt_packet packet;
2985 errcode = pt_pkt_sync_forward (decoder);
2991 pt_pkt_get_offset (decoder, &packet.offset);
2993 errcode = pt_pkt_next (decoder, &packet.packet,
2994 sizeof(packet.packet));
2998 if (maint_btrace_pt_skip_pad == 0 || packet.packet.type != ppt_pad)
3000 packet.errcode = pt_errcode (errcode);
3001 VEC_safe_push (btrace_pt_packet_s, maint->variant.pt.packets,
3006 if (errcode == -pte_eos)
3009 packet.errcode = pt_errcode (errcode);
3010 VEC_safe_push (btrace_pt_packet_s, maint->variant.pt.packets,
3013 warning (_("Error at trace offset 0x%" PRIx64 ": %s."),
3014 packet.offset, pt_errstr (packet.errcode));
3017 if (errcode != -pte_eos)
3018 warning (_("Failed to synchronize onto the Intel Processor Trace "
3019 "stream: %s."), pt_errstr (pt_errcode (errcode)));
3022 /* Update the packet history in BTINFO. */
3025 btrace_maint_update_pt_packets (struct btrace_thread_info *btinfo)
3027 struct pt_packet_decoder *decoder;
3028 const struct btrace_cpu *cpu;
3029 struct btrace_data_pt *pt;
3030 struct pt_config config;
3033 pt = &btinfo->data.variant.pt;
3035 /* Nothing to do if there is no trace. */
3039 memset (&config, 0, sizeof(config));
3041 config.size = sizeof (config);
3042 config.begin = pt->data;
3043 config.end = pt->data + pt->size;
3045 cpu = record_btrace_get_cpu ();
3047 cpu = &pt->config.cpu;
3049 /* We treat an unknown vendor as 'no errata'. */
3050 if (cpu->vendor != CV_UNKNOWN)
3052 config.cpu.vendor = pt_translate_cpu_vendor (cpu->vendor);
3053 config.cpu.family = cpu->family;
3054 config.cpu.model = cpu->model;
3055 config.cpu.stepping = cpu->stepping;
3057 errcode = pt_cpu_errata (&config.errata, &config.cpu);
3059 error (_("Failed to configure the Intel Processor Trace "
3060 "decoder: %s."), pt_errstr (pt_errcode (errcode)));
3063 decoder = pt_pkt_alloc_decoder (&config);
3064 if (decoder == NULL)
3065 error (_("Failed to allocate the Intel Processor Trace decoder."));
3069 btrace_maint_decode_pt (&btinfo->maint, decoder);
3071 CATCH (except, RETURN_MASK_ALL)
3073 pt_pkt_free_decoder (decoder);
3075 if (except.reason < 0)
3076 throw_exception (except);
3080 pt_pkt_free_decoder (decoder);
3083 #endif /* !defined (HAVE_LIBIPT) */
3085 /* Update the packet maintenance information for BTINFO and store the
3086 low and high bounds into BEGIN and END, respectively.
3087 Store the current iterator state into FROM and TO. */
3090 btrace_maint_update_packets (struct btrace_thread_info *btinfo,
3091 unsigned int *begin, unsigned int *end,
3092 unsigned int *from, unsigned int *to)
3094 switch (btinfo->data.format)
3103 case BTRACE_FORMAT_BTS:
3104 /* Nothing to do - we operate directly on BTINFO->DATA. */
3106 *end = VEC_length (btrace_block_s, btinfo->data.variant.bts.blocks);
3107 *from = btinfo->maint.variant.bts.packet_history.begin;
3108 *to = btinfo->maint.variant.bts.packet_history.end;
3111 #if defined (HAVE_LIBIPT)
3112 case BTRACE_FORMAT_PT:
3113 if (VEC_empty (btrace_pt_packet_s, btinfo->maint.variant.pt.packets))
3114 btrace_maint_update_pt_packets (btinfo);
3117 *end = VEC_length (btrace_pt_packet_s, btinfo->maint.variant.pt.packets);
3118 *from = btinfo->maint.variant.pt.packet_history.begin;
3119 *to = btinfo->maint.variant.pt.packet_history.end;
3121 #endif /* defined (HAVE_LIBIPT) */
3125 /* Print packets in BTINFO from BEGIN (inclusive) until END (exclusive) and
3126 update the current iterator position. */
3129 btrace_maint_print_packets (struct btrace_thread_info *btinfo,
3130 unsigned int begin, unsigned int end)
3132 switch (btinfo->data.format)
3137 case BTRACE_FORMAT_BTS:
3139 VEC (btrace_block_s) *blocks;
3142 blocks = btinfo->data.variant.bts.blocks;
3143 for (blk = begin; blk < end; ++blk)
3145 const btrace_block_s *block;
3147 block = VEC_index (btrace_block_s, blocks, blk);
3149 printf_unfiltered ("%u\tbegin: %s, end: %s\n", blk,
3150 core_addr_to_string_nz (block->begin),
3151 core_addr_to_string_nz (block->end));
3154 btinfo->maint.variant.bts.packet_history.begin = begin;
3155 btinfo->maint.variant.bts.packet_history.end = end;
3159 #if defined (HAVE_LIBIPT)
3160 case BTRACE_FORMAT_PT:
3162 VEC (btrace_pt_packet_s) *packets;
3165 packets = btinfo->maint.variant.pt.packets;
3166 for (pkt = begin; pkt < end; ++pkt)
3168 const struct btrace_pt_packet *packet;
3170 packet = VEC_index (btrace_pt_packet_s, packets, pkt);
3172 printf_unfiltered ("%u\t", pkt);
3173 printf_unfiltered ("0x%" PRIx64 "\t", packet->offset);
3175 if (packet->errcode == pte_ok)
3176 pt_print_packet (&packet->packet);
3178 printf_unfiltered ("[error: %s]", pt_errstr (packet->errcode));
3180 printf_unfiltered ("\n");
3183 btinfo->maint.variant.pt.packet_history.begin = begin;
3184 btinfo->maint.variant.pt.packet_history.end = end;
3187 #endif /* defined (HAVE_LIBIPT) */
3191 /* Read a number from an argument string. */
3194 get_uint (const char **arg)
3196 const char *begin, *pos;
3198 unsigned long number;
3201 pos = skip_spaces (begin);
3203 if (!isdigit (*pos))
3204 error (_("Expected positive number, got: %s."), pos);
3206 number = strtoul (pos, &end, 10);
3207 if (number > UINT_MAX)
3208 error (_("Number too big."));
3210 *arg += (end - begin);
3212 return (unsigned int) number;
3215 /* Read a context size from an argument string. */
3218 get_context_size (const char **arg)
3220 const char *pos = skip_spaces (*arg);
3222 if (!isdigit (*pos))
3223 error (_("Expected positive number, got: %s."), pos);
3226 long result = strtol (pos, &end, 10);
3231 /* Complain about junk at the end of an argument string. */
3234 no_chunk (const char *arg)
3237 error (_("Junk after argument: %s."), arg);
3240 /* The "maintenance btrace packet-history" command. */
3243 maint_btrace_packet_history_cmd (const char *arg, int from_tty)
3245 struct btrace_thread_info *btinfo;
3246 unsigned int size, begin, end, from, to;
3248 thread_info *tp = find_thread_ptid (inferior_ptid);
3250 error (_("No thread."));
3253 btinfo = &tp->btrace;
3255 btrace_maint_update_packets (btinfo, &begin, &end, &from, &to);
3258 printf_unfiltered (_("No trace.\n"));
3262 if (arg == NULL || *arg == 0 || strcmp (arg, "+") == 0)
3266 if (end - from < size)
3270 else if (strcmp (arg, "-") == 0)
3274 if (to - begin < size)
3280 from = get_uint (&arg);
3282 error (_("'%u' is out of range."), from);
3284 arg = skip_spaces (arg);
3287 arg = skip_spaces (++arg);
3292 size = get_context_size (&arg);
3296 if (end - from < size)
3300 else if (*arg == '-')
3303 size = get_context_size (&arg);
3307 /* Include the packet given as first argument. */
3311 if (to - begin < size)
3317 to = get_uint (&arg);
3319 /* Include the packet at the second argument and silently
3320 truncate the range. */
3333 if (end - from < size)
3341 btrace_maint_print_packets (btinfo, from, to);
3344 /* The "maintenance btrace clear-packet-history" command. */
3347 maint_btrace_clear_packet_history_cmd (const char *args, int from_tty)
3349 if (args != NULL && *args != 0)
3350 error (_("Invalid argument."));
3352 if (inferior_ptid == null_ptid)
3353 error (_("No thread."));
3355 thread_info *tp = inferior_thread ();
3356 btrace_thread_info *btinfo = &tp->btrace;
3358 /* Must clear the maint data before - it depends on BTINFO->DATA. */
3359 btrace_maint_clear (btinfo);
3360 btinfo->data.clear ();
3363 /* The "maintenance btrace clear" command. */
3366 maint_btrace_clear_cmd (const char *args, int from_tty)
3368 if (args != NULL && *args != 0)
3369 error (_("Invalid argument."));
3371 if (inferior_ptid == null_ptid)
3372 error (_("No thread."));
3374 thread_info *tp = inferior_thread ();
3378 /* The "maintenance btrace" command. */
3381 maint_btrace_cmd (const char *args, int from_tty)
3383 help_list (maint_btrace_cmdlist, "maintenance btrace ", all_commands,
3387 /* The "maintenance set btrace" command. */
3390 maint_btrace_set_cmd (const char *args, int from_tty)
3392 help_list (maint_btrace_set_cmdlist, "maintenance set btrace ", all_commands,
3396 /* The "maintenance show btrace" command. */
3399 maint_btrace_show_cmd (const char *args, int from_tty)
3401 help_list (maint_btrace_show_cmdlist, "maintenance show btrace ",
3402 all_commands, gdb_stdout);
3405 /* The "maintenance set btrace pt" command. */
3408 maint_btrace_pt_set_cmd (const char *args, int from_tty)
3410 help_list (maint_btrace_pt_set_cmdlist, "maintenance set btrace pt ",
3411 all_commands, gdb_stdout);
3414 /* The "maintenance show btrace pt" command. */
3417 maint_btrace_pt_show_cmd (const char *args, int from_tty)
3419 help_list (maint_btrace_pt_show_cmdlist, "maintenance show btrace pt ",
3420 all_commands, gdb_stdout);
3423 /* The "maintenance info btrace" command. */
3426 maint_info_btrace_cmd (const char *args, int from_tty)
3428 struct btrace_thread_info *btinfo;
3429 const struct btrace_config *conf;
3431 if (args != NULL && *args != 0)
3432 error (_("Invalid argument."));
3434 if (inferior_ptid == null_ptid)
3435 error (_("No thread."));
3437 thread_info *tp = inferior_thread ();
3439 btinfo = &tp->btrace;
3441 conf = btrace_conf (btinfo);
3443 error (_("No btrace configuration."));
3445 printf_unfiltered (_("Format: %s.\n"),
3446 btrace_format_string (conf->format));
3448 switch (conf->format)
3453 case BTRACE_FORMAT_BTS:
3454 printf_unfiltered (_("Number of packets: %u.\n"),
3455 VEC_length (btrace_block_s,
3456 btinfo->data.variant.bts.blocks));
3459 #if defined (HAVE_LIBIPT)
3460 case BTRACE_FORMAT_PT:
3462 struct pt_version version;
3464 version = pt_library_version ();
3465 printf_unfiltered (_("Version: %u.%u.%u%s.\n"), version.major,
3466 version.minor, version.build,
3467 version.ext != NULL ? version.ext : "");
3469 btrace_maint_update_pt_packets (btinfo);
3470 printf_unfiltered (_("Number of packets: %u.\n"),
3471 VEC_length (btrace_pt_packet_s,
3472 btinfo->maint.variant.pt.packets));
3475 #endif /* defined (HAVE_LIBIPT) */
3479 /* The "maint show btrace pt skip-pad" show value function. */
3482 show_maint_btrace_pt_skip_pad (struct ui_file *file, int from_tty,
3483 struct cmd_list_element *c,
3486 fprintf_filtered (file, _("Skip PAD packets is %s.\n"), value);
3490 /* Initialize btrace maintenance commands. */
3493 _initialize_btrace (void)
3495 add_cmd ("btrace", class_maintenance, maint_info_btrace_cmd,
3496 _("Info about branch tracing data."), &maintenanceinfolist);
3498 add_prefix_cmd ("btrace", class_maintenance, maint_btrace_cmd,
3499 _("Branch tracing maintenance commands."),
3500 &maint_btrace_cmdlist, "maintenance btrace ",
3501 0, &maintenancelist);
3503 add_prefix_cmd ("btrace", class_maintenance, maint_btrace_set_cmd, _("\
3504 Set branch tracing specific variables."),
3505 &maint_btrace_set_cmdlist, "maintenance set btrace ",
3506 0, &maintenance_set_cmdlist);
3508 add_prefix_cmd ("pt", class_maintenance, maint_btrace_pt_set_cmd, _("\
3509 Set Intel Processor Trace specific variables."),
3510 &maint_btrace_pt_set_cmdlist, "maintenance set btrace pt ",
3511 0, &maint_btrace_set_cmdlist);
3513 add_prefix_cmd ("btrace", class_maintenance, maint_btrace_show_cmd, _("\
3514 Show branch tracing specific variables."),
3515 &maint_btrace_show_cmdlist, "maintenance show btrace ",
3516 0, &maintenance_show_cmdlist);
3518 add_prefix_cmd ("pt", class_maintenance, maint_btrace_pt_show_cmd, _("\
3519 Show Intel Processor Trace specific variables."),
3520 &maint_btrace_pt_show_cmdlist, "maintenance show btrace pt ",
3521 0, &maint_btrace_show_cmdlist);
3523 add_setshow_boolean_cmd ("skip-pad", class_maintenance,
3524 &maint_btrace_pt_skip_pad, _("\
3525 Set whether PAD packets should be skipped in the btrace packet history."), _("\
3526 Show whether PAD packets should be skipped in the btrace packet history."),_("\
3527 When enabled, PAD packets are ignored in the btrace packet history."),
3528 NULL, show_maint_btrace_pt_skip_pad,
3529 &maint_btrace_pt_set_cmdlist,
3530 &maint_btrace_pt_show_cmdlist);
3532 add_cmd ("packet-history", class_maintenance, maint_btrace_packet_history_cmd,
3533 _("Print the raw branch tracing data.\n\
3534 With no argument, print ten more packets after the previous ten-line print.\n\
3535 With '-' as argument print ten packets before a previous ten-line print.\n\
3536 One argument specifies the starting packet of a ten-line print.\n\
3537 Two arguments with comma between specify starting and ending packets to \
3539 Preceded with '+'/'-' the second argument specifies the distance from the \
3541 &maint_btrace_cmdlist);
3543 add_cmd ("clear-packet-history", class_maintenance,
3544 maint_btrace_clear_packet_history_cmd,
3545 _("Clears the branch tracing packet history.\n\
3546 Discards the raw branch tracing data but not the execution history data.\n\
3548 &maint_btrace_cmdlist);
3550 add_cmd ("clear", class_maintenance, maint_btrace_clear_cmd,
3551 _("Clears the branch tracing data.\n\
3552 Discards the raw branch tracing data and the execution history data.\n\
3553 The next 'record' command will fetch the branch tracing data anew.\n\
3555 &maint_btrace_cmdlist);