1 /* Branch trace support for GDB, the GNU debugger.
3 Copyright (C) 2013-2017 Free Software Foundation, Inc.
5 Contributed by Intel Corp. <markus.t.metzger@intel.com>
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "gdbthread.h"
31 #include "filenames.h"
32 #include "xml-support.h"
36 #include "cli/cli-utils.h"
42 /* Command lists for btrace maintenance commands. */
43 static struct cmd_list_element
*maint_btrace_cmdlist
;
44 static struct cmd_list_element
*maint_btrace_set_cmdlist
;
45 static struct cmd_list_element
*maint_btrace_show_cmdlist
;
46 static struct cmd_list_element
*maint_btrace_pt_set_cmdlist
;
47 static struct cmd_list_element
*maint_btrace_pt_show_cmdlist
;
49 /* Control whether to skip PAD packets when computing the packet history. */
50 static int maint_btrace_pt_skip_pad
= 1;
52 /* A vector of function segments. */
53 typedef struct btrace_function
* bfun_s
;
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 SYMBOL_PRINT_NAME (sym
);
88 return MSYMBOL_PRINT_NAME (msym
);
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
+ VEC_length (btrace_insn_s
, bfun
->insn
);
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 VEC_length (btrace_insn_s
, bfun
->insn
);
159 /* Return non-zero if BFUN does not match MFUN and FUN,
160 return zero otherwise. */
163 ftrace_function_switched (const struct btrace_function
*bfun
,
164 const struct minimal_symbol
*mfun
,
165 const struct symbol
*fun
)
167 struct minimal_symbol
*msym
;
173 /* If the minimal symbol changed, we certainly switched functions. */
174 if (mfun
!= NULL
&& msym
!= NULL
175 && strcmp (MSYMBOL_LINKAGE_NAME (mfun
), MSYMBOL_LINKAGE_NAME (msym
)) != 0)
178 /* If the symbol changed, we certainly switched functions. */
179 if (fun
!= NULL
&& sym
!= NULL
)
181 const char *bfname
, *fname
;
183 /* Check the function name. */
184 if (strcmp (SYMBOL_LINKAGE_NAME (fun
), SYMBOL_LINKAGE_NAME (sym
)) != 0)
187 /* Check the location of those functions, as well. */
188 bfname
= symtab_to_fullname (symbol_symtab (sym
));
189 fname
= symtab_to_fullname (symbol_symtab (fun
));
190 if (filename_cmp (fname
, bfname
) != 0)
194 /* If we lost symbol information, we switched functions. */
195 if (!(msym
== NULL
&& sym
== NULL
) && mfun
== NULL
&& fun
== NULL
)
198 /* If we gained symbol information, we switched functions. */
199 if (msym
== NULL
&& sym
== NULL
&& !(mfun
== NULL
&& fun
== NULL
))
205 /* Allocate and initialize a new branch trace function segment.
206 PREV is the chronologically preceding function segment.
207 MFUN and FUN are the symbol information we have for this function. */
209 static struct btrace_function
*
210 ftrace_new_function (struct btrace_function
*prev
,
211 struct minimal_symbol
*mfun
,
214 struct btrace_function
*bfun
;
216 bfun
= XCNEW (struct btrace_function
);
220 bfun
->flow
.prev
= prev
;
224 /* Start counting at one. */
226 bfun
->insn_offset
= 1;
230 gdb_assert (prev
->flow
.next
== NULL
);
231 prev
->flow
.next
= bfun
;
233 bfun
->number
= prev
->number
+ 1;
234 bfun
->insn_offset
= prev
->insn_offset
+ ftrace_call_num_insn (prev
);
235 bfun
->level
= prev
->level
;
241 /* Update the UP field of a function segment. */
244 ftrace_update_caller (struct btrace_function
*bfun
,
245 struct btrace_function
*caller
,
246 enum btrace_function_flag flags
)
248 if (bfun
->up
!= NULL
)
249 ftrace_debug (bfun
, "updating caller");
254 ftrace_debug (bfun
, "set caller");
255 ftrace_debug (caller
, "..to");
258 /* Fix up the caller for all segments of a function. */
261 ftrace_fixup_caller (struct btrace_function
*bfun
,
262 struct btrace_function
*caller
,
263 enum btrace_function_flag flags
)
265 struct btrace_function
*prev
, *next
;
267 ftrace_update_caller (bfun
, caller
, flags
);
269 /* Update all function segments belonging to the same function. */
270 for (prev
= bfun
->segment
.prev
; prev
!= NULL
; prev
= prev
->segment
.prev
)
271 ftrace_update_caller (prev
, caller
, flags
);
273 for (next
= bfun
->segment
.next
; next
!= NULL
; next
= next
->segment
.next
)
274 ftrace_update_caller (next
, caller
, flags
);
277 /* Add a new function segment for a call.
278 CALLER is the chronologically preceding function segment.
279 MFUN and FUN are the symbol information we have for this function. */
281 static struct btrace_function
*
282 ftrace_new_call (struct btrace_function
*caller
,
283 struct minimal_symbol
*mfun
,
286 struct btrace_function
*bfun
;
288 bfun
= ftrace_new_function (caller
, mfun
, fun
);
292 ftrace_debug (bfun
, "new call");
297 /* Add a new function segment for a tail call.
298 CALLER is the chronologically preceding function segment.
299 MFUN and FUN are the symbol information we have for this function. */
301 static struct btrace_function
*
302 ftrace_new_tailcall (struct btrace_function
*caller
,
303 struct minimal_symbol
*mfun
,
306 struct btrace_function
*bfun
;
308 bfun
= ftrace_new_function (caller
, mfun
, fun
);
311 bfun
->flags
|= BFUN_UP_LINKS_TO_TAILCALL
;
313 ftrace_debug (bfun
, "new tail call");
318 /* Return the caller of BFUN or NULL if there is none. This function skips
319 tail calls in the call chain. */
320 static struct btrace_function
*
321 ftrace_get_caller (struct btrace_function
*bfun
)
323 for (; bfun
!= NULL
; bfun
= bfun
->up
)
324 if ((bfun
->flags
& BFUN_UP_LINKS_TO_TAILCALL
) == 0)
330 /* Find the innermost caller in the back trace of BFUN with MFUN/FUN
331 symbol information. */
333 static struct btrace_function
*
334 ftrace_find_caller (struct btrace_function
*bfun
,
335 struct minimal_symbol
*mfun
,
338 for (; bfun
!= NULL
; bfun
= bfun
->up
)
340 /* Skip functions with incompatible symbol information. */
341 if (ftrace_function_switched (bfun
, mfun
, fun
))
344 /* This is the function segment we're looking for. */
351 /* Find the innermost caller in the back trace of BFUN, skipping all
352 function segments that do not end with a call instruction (e.g.
353 tail calls ending with a jump). */
355 static struct btrace_function
*
356 ftrace_find_call (struct btrace_function
*bfun
)
358 for (; bfun
!= NULL
; bfun
= bfun
->up
)
360 struct btrace_insn
*last
;
363 if (bfun
->errcode
!= 0)
366 last
= VEC_last (btrace_insn_s
, bfun
->insn
);
368 if (last
->iclass
== BTRACE_INSN_CALL
)
375 /* Add a continuation segment for a function into which we return.
376 PREV is the chronologically preceding function segment.
377 MFUN and FUN are the symbol information we have for this function. */
379 static struct btrace_function
*
380 ftrace_new_return (struct btrace_function
*prev
,
381 struct minimal_symbol
*mfun
,
384 struct btrace_function
*bfun
, *caller
;
386 bfun
= ftrace_new_function (prev
, mfun
, fun
);
388 /* It is important to start at PREV's caller. Otherwise, we might find
389 PREV itself, if PREV is a recursive function. */
390 caller
= ftrace_find_caller (prev
->up
, mfun
, fun
);
393 /* The caller of PREV is the preceding btrace function segment in this
394 function instance. */
395 gdb_assert (caller
->segment
.next
== NULL
);
397 caller
->segment
.next
= bfun
;
398 bfun
->segment
.prev
= caller
;
400 /* Maintain the function level. */
401 bfun
->level
= caller
->level
;
403 /* Maintain the call stack. */
404 bfun
->up
= caller
->up
;
405 bfun
->flags
= caller
->flags
;
407 ftrace_debug (bfun
, "new return");
411 /* We did not find a caller. This could mean that something went
412 wrong or that the call is simply not included in the trace. */
414 /* Let's search for some actual call. */
415 caller
= ftrace_find_call (prev
->up
);
418 /* There is no call in PREV's back trace. We assume that the
419 branch trace did not include it. */
421 /* Let's find the topmost function and add a new caller for it.
422 This should handle a series of initial tail calls. */
423 while (prev
->up
!= NULL
)
426 bfun
->level
= prev
->level
- 1;
428 /* Fix up the call stack for PREV. */
429 ftrace_fixup_caller (prev
, bfun
, BFUN_UP_LINKS_TO_RET
);
431 ftrace_debug (bfun
, "new return - no caller");
435 /* There is a call in PREV's back trace to which we should have
436 returned but didn't. Let's start a new, separate back trace
437 from PREV's level. */
438 bfun
->level
= prev
->level
- 1;
440 /* We fix up the back trace for PREV but leave other function segments
441 on the same level as they are.
442 This should handle things like schedule () correctly where we're
443 switching contexts. */
445 prev
->flags
= BFUN_UP_LINKS_TO_RET
;
447 ftrace_debug (bfun
, "new return - unknown caller");
454 /* Add a new function segment for a function switch.
455 PREV is the chronologically preceding function segment.
456 MFUN and FUN are the symbol information we have for this function. */
458 static struct btrace_function
*
459 ftrace_new_switch (struct btrace_function
*prev
,
460 struct minimal_symbol
*mfun
,
463 struct btrace_function
*bfun
;
465 /* This is an unexplained function switch. We can't really be sure about the
466 call stack, yet the best I can think of right now is to preserve it. */
467 bfun
= ftrace_new_function (prev
, mfun
, fun
);
469 bfun
->flags
= prev
->flags
;
471 ftrace_debug (bfun
, "new switch");
476 /* Add a new function segment for a gap in the trace due to a decode error.
477 PREV is the chronologically preceding function segment.
478 ERRCODE is the format-specific error code. */
480 static struct btrace_function
*
481 ftrace_new_gap (struct btrace_function
*prev
, int errcode
)
483 struct btrace_function
*bfun
;
485 /* We hijack prev if it was empty. */
486 if (prev
!= NULL
&& prev
->errcode
== 0
487 && VEC_empty (btrace_insn_s
, prev
->insn
))
490 bfun
= ftrace_new_function (prev
, NULL
, NULL
);
492 bfun
->errcode
= errcode
;
494 ftrace_debug (bfun
, "new gap");
499 /* Update BFUN with respect to the instruction at PC. This may create new
501 Return the chronologically latest function segment, never NULL. */
503 static struct btrace_function
*
504 ftrace_update_function (struct btrace_function
*bfun
, CORE_ADDR pc
)
506 struct bound_minimal_symbol bmfun
;
507 struct minimal_symbol
*mfun
;
509 struct btrace_insn
*last
;
511 /* Try to determine the function we're in. We use both types of symbols
512 to avoid surprises when we sometimes get a full symbol and sometimes
513 only a minimal symbol. */
514 fun
= find_pc_function (pc
);
515 bmfun
= lookup_minimal_symbol_by_pc (pc
);
518 if (fun
== NULL
&& mfun
== NULL
)
519 DEBUG_FTRACE ("no symbol at %s", core_addr_to_string_nz (pc
));
521 /* If we didn't have a function or if we had a gap before, we create one. */
522 if (bfun
== NULL
|| bfun
->errcode
!= 0)
523 return ftrace_new_function (bfun
, mfun
, fun
);
525 /* Check the last instruction, if we have one.
526 We do this check first, since it allows us to fill in the call stack
527 links in addition to the normal flow links. */
529 if (!VEC_empty (btrace_insn_s
, bfun
->insn
))
530 last
= VEC_last (btrace_insn_s
, bfun
->insn
);
534 switch (last
->iclass
)
536 case BTRACE_INSN_RETURN
:
540 /* On some systems, _dl_runtime_resolve returns to the resolved
541 function instead of jumping to it. From our perspective,
542 however, this is a tailcall.
543 If we treated it as return, we wouldn't be able to find the
544 resolved function in our stack back trace. Hence, we would
545 lose the current stack back trace and start anew with an empty
546 back trace. When the resolved function returns, we would then
547 create a stack back trace with the same function names but
548 different frame id's. This will confuse stepping. */
549 fname
= ftrace_print_function_name (bfun
);
550 if (strcmp (fname
, "_dl_runtime_resolve") == 0)
551 return ftrace_new_tailcall (bfun
, mfun
, fun
);
553 return ftrace_new_return (bfun
, mfun
, fun
);
556 case BTRACE_INSN_CALL
:
557 /* Ignore calls to the next instruction. They are used for PIC. */
558 if (last
->pc
+ last
->size
== pc
)
561 return ftrace_new_call (bfun
, mfun
, fun
);
563 case BTRACE_INSN_JUMP
:
567 start
= get_pc_function_start (pc
);
569 /* A jump to the start of a function is (typically) a tail call. */
571 return ftrace_new_tailcall (bfun
, mfun
, fun
);
573 /* If we can't determine the function for PC, we treat a jump at
574 the end of the block as tail call if we're switching functions
575 and as an intra-function branch if we don't. */
576 if (start
== 0 && ftrace_function_switched (bfun
, mfun
, fun
))
577 return ftrace_new_tailcall (bfun
, mfun
, fun
);
584 /* Check if we're switching functions for some other reason. */
585 if (ftrace_function_switched (bfun
, mfun
, fun
))
587 DEBUG_FTRACE ("switching from %s in %s at %s",
588 ftrace_print_insn_addr (last
),
589 ftrace_print_function_name (bfun
),
590 ftrace_print_filename (bfun
));
592 return ftrace_new_switch (bfun
, mfun
, fun
);
598 /* Add the instruction at PC to BFUN's instructions. */
601 ftrace_update_insns (struct btrace_function
*bfun
,
602 const struct btrace_insn
*insn
)
604 VEC_safe_push (btrace_insn_s
, bfun
->insn
, insn
);
606 if (record_debug
> 1)
607 ftrace_debug (bfun
, "update insn");
610 /* Classify the instruction at PC. */
612 static enum btrace_insn_class
613 ftrace_classify_insn (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
615 enum btrace_insn_class iclass
;
617 iclass
= BTRACE_INSN_OTHER
;
620 if (gdbarch_insn_is_call (gdbarch
, pc
))
621 iclass
= BTRACE_INSN_CALL
;
622 else if (gdbarch_insn_is_ret (gdbarch
, pc
))
623 iclass
= BTRACE_INSN_RETURN
;
624 else if (gdbarch_insn_is_jump (gdbarch
, pc
))
625 iclass
= BTRACE_INSN_JUMP
;
627 CATCH (error
, RETURN_MASK_ERROR
)
635 /* Try to match the back trace at LHS to the back trace at RHS. Returns the
636 number of matching function segments or zero if the back traces do not
640 ftrace_match_backtrace (struct btrace_function
*lhs
,
641 struct btrace_function
*rhs
)
645 for (matches
= 0; lhs
!= NULL
&& rhs
!= NULL
; ++matches
)
647 if (ftrace_function_switched (lhs
, rhs
->msym
, rhs
->sym
))
650 lhs
= ftrace_get_caller (lhs
);
651 rhs
= ftrace_get_caller (rhs
);
657 /* Add ADJUSTMENT to the level of BFUN and succeeding function segments. */
660 ftrace_fixup_level (struct btrace_function
*bfun
, int adjustment
)
665 DEBUG_FTRACE ("fixup level (%+d)", adjustment
);
666 ftrace_debug (bfun
, "..bfun");
668 for (; bfun
!= NULL
; bfun
= bfun
->flow
.next
)
669 bfun
->level
+= adjustment
;
672 /* Recompute the global level offset. Traverse the function trace and compute
673 the global level offset as the negative of the minimal function level. */
676 ftrace_compute_global_level_offset (struct btrace_thread_info
*btinfo
)
678 struct btrace_function
*bfun
, *end
;
684 bfun
= btinfo
->begin
;
688 /* The last function segment contains the current instruction, which is not
689 really part of the trace. If it contains just this one instruction, we
690 stop when we reach it; otherwise, we let the below loop run to the end. */
692 if (VEC_length (btrace_insn_s
, end
->insn
) > 1)
696 for (; bfun
!= end
; bfun
= bfun
->flow
.next
)
697 level
= std::min (level
, bfun
->level
);
699 DEBUG_FTRACE ("setting global level offset: %d", -level
);
700 btinfo
->level
= -level
;
703 /* Connect the function segments PREV and NEXT in a bottom-to-top walk as in
704 ftrace_connect_backtrace. */
707 ftrace_connect_bfun (struct btrace_function
*prev
,
708 struct btrace_function
*next
)
710 DEBUG_FTRACE ("connecting...");
711 ftrace_debug (prev
, "..prev");
712 ftrace_debug (next
, "..next");
714 /* The function segments are not yet connected. */
715 gdb_assert (prev
->segment
.next
== NULL
);
716 gdb_assert (next
->segment
.prev
== NULL
);
718 prev
->segment
.next
= next
;
719 next
->segment
.prev
= prev
;
721 /* We may have moved NEXT to a different function level. */
722 ftrace_fixup_level (next
, prev
->level
- next
->level
);
724 /* If we run out of back trace for one, let's use the other's. */
725 if (prev
->up
== NULL
)
727 if (next
->up
!= NULL
)
729 DEBUG_FTRACE ("using next's callers");
730 ftrace_fixup_caller (prev
, next
->up
, next
->flags
);
733 else if (next
->up
== NULL
)
735 if (prev
->up
!= NULL
)
737 DEBUG_FTRACE ("using prev's callers");
738 ftrace_fixup_caller (next
, prev
->up
, prev
->flags
);
743 /* PREV may have a tailcall caller, NEXT can't. If it does, fixup the up
744 link to add the tail callers to NEXT's back trace.
746 This removes NEXT->UP from NEXT's back trace. It will be added back
747 when connecting NEXT and PREV's callers - provided they exist.
749 If PREV's back trace consists of a series of tail calls without an
750 actual call, there will be no further connection and NEXT's caller will
751 be removed for good. To catch this case, we handle it here and connect
752 the top of PREV's back trace to NEXT's caller. */
753 if ((prev
->flags
& BFUN_UP_LINKS_TO_TAILCALL
) != 0)
755 struct btrace_function
*caller
;
756 btrace_function_flags flags
;
758 /* We checked NEXT->UP above so CALLER can't be NULL. */
762 DEBUG_FTRACE ("adding prev's tail calls to next");
764 ftrace_fixup_caller (next
, prev
->up
, prev
->flags
);
766 for (prev
= prev
->up
; prev
!= NULL
; prev
= prev
->up
)
768 /* At the end of PREV's back trace, continue with CALLER. */
769 if (prev
->up
== NULL
)
771 DEBUG_FTRACE ("fixing up link for tailcall chain");
772 ftrace_debug (prev
, "..top");
773 ftrace_debug (caller
, "..up");
775 ftrace_fixup_caller (prev
, caller
, flags
);
777 /* If we skipped any tail calls, this may move CALLER to a
778 different function level.
780 Note that changing CALLER's level is only OK because we
781 know that this is the last iteration of the bottom-to-top
782 walk in ftrace_connect_backtrace.
784 Otherwise we will fix up CALLER's level when we connect it
785 to PREV's caller in the next iteration. */
786 ftrace_fixup_level (caller
, prev
->level
- caller
->level
- 1);
790 /* There's nothing to do if we find a real call. */
791 if ((prev
->flags
& BFUN_UP_LINKS_TO_TAILCALL
) == 0)
793 DEBUG_FTRACE ("will fix up link in next iteration");
801 /* Connect function segments on the same level in the back trace at LHS and RHS.
802 The back traces at LHS and RHS are expected to match according to
803 ftrace_match_backtrace. */
806 ftrace_connect_backtrace (struct btrace_function
*lhs
,
807 struct btrace_function
*rhs
)
809 while (lhs
!= NULL
&& rhs
!= NULL
)
811 struct btrace_function
*prev
, *next
;
813 gdb_assert (!ftrace_function_switched (lhs
, rhs
->msym
, rhs
->sym
));
815 /* Connecting LHS and RHS may change the up link. */
819 lhs
= ftrace_get_caller (lhs
);
820 rhs
= ftrace_get_caller (rhs
);
822 ftrace_connect_bfun (prev
, next
);
826 /* Bridge the gap between two function segments left and right of a gap if their
827 respective back traces match in at least MIN_MATCHES functions.
829 Returns non-zero if the gap could be bridged, zero otherwise. */
832 ftrace_bridge_gap (struct btrace_function
*lhs
, struct btrace_function
*rhs
,
835 struct btrace_function
*best_l
, *best_r
, *cand_l
, *cand_r
;
838 DEBUG_FTRACE ("checking gap at insn %u (req matches: %d)",
839 rhs
->insn_offset
- 1, min_matches
);
845 /* We search the back traces of LHS and RHS for valid connections and connect
846 the two functon segments that give the longest combined back trace. */
848 for (cand_l
= lhs
; cand_l
!= NULL
; cand_l
= ftrace_get_caller (cand_l
))
849 for (cand_r
= rhs
; cand_r
!= NULL
; cand_r
= ftrace_get_caller (cand_r
))
853 matches
= ftrace_match_backtrace (cand_l
, cand_r
);
854 if (best_matches
< matches
)
856 best_matches
= matches
;
862 /* We need at least MIN_MATCHES matches. */
863 gdb_assert (min_matches
> 0);
864 if (best_matches
< min_matches
)
867 DEBUG_FTRACE ("..matches: %d", best_matches
);
869 /* We will fix up the level of BEST_R and succeeding function segments such
870 that BEST_R's level matches BEST_L's when we connect BEST_L to BEST_R.
872 This will ignore the level of RHS and following if BEST_R != RHS. I.e. if
873 BEST_R is a successor of RHS in the back trace of RHS (phases 1 and 3).
875 To catch this, we already fix up the level here where we can start at RHS
876 instead of at BEST_R. We will ignore the level fixup when connecting
877 BEST_L to BEST_R as they will already be on the same level. */
878 ftrace_fixup_level (rhs
, best_l
->level
- best_r
->level
);
880 ftrace_connect_backtrace (best_l
, best_r
);
885 /* Try to bridge gaps due to overflow or decode errors by connecting the
886 function segments that are separated by the gap. */
889 btrace_bridge_gaps (struct thread_info
*tp
, VEC (bfun_s
) **gaps
)
891 VEC (bfun_s
) *remaining
;
892 struct cleanup
*old_chain
;
895 DEBUG ("bridge gaps");
898 old_chain
= make_cleanup (VEC_cleanup (bfun_s
), &remaining
);
900 /* We require a minimum amount of matches for bridging a gap. The number of
901 required matches will be lowered with each iteration.
903 The more matches the higher our confidence that the bridging is correct.
904 For big gaps or small traces, however, it may not be feasible to require a
905 high number of matches. */
906 for (min_matches
= 5; min_matches
> 0; --min_matches
)
908 /* Let's try to bridge as many gaps as we can. In some cases, we need to
909 skip a gap and revisit it again after we closed later gaps. */
910 while (!VEC_empty (bfun_s
, *gaps
))
912 struct btrace_function
*gap
;
915 for (idx
= 0; VEC_iterate (bfun_s
, *gaps
, idx
, gap
); ++idx
)
917 struct btrace_function
*lhs
, *rhs
;
920 /* We may have a sequence of gaps if we run from one error into
921 the next as we try to re-sync onto the trace stream. Ignore
922 all but the leftmost gap in such a sequence.
924 Also ignore gaps at the beginning of the trace. */
925 lhs
= gap
->flow
.prev
;
926 if (lhs
== NULL
|| lhs
->errcode
!= 0)
929 /* Skip gaps to the right. */
930 for (rhs
= gap
->flow
.next
; rhs
!= NULL
; rhs
= rhs
->flow
.next
)
931 if (rhs
->errcode
== 0)
934 /* Ignore gaps at the end of the trace. */
938 bridged
= ftrace_bridge_gap (lhs
, rhs
, min_matches
);
940 /* Keep track of gaps we were not able to bridge and try again.
941 If we just pushed them to the end of GAPS we would risk an
942 infinite loop in case we simply cannot bridge a gap. */
944 VEC_safe_push (bfun_s
, remaining
, gap
);
947 /* Let's see if we made any progress. */
948 if (VEC_length (bfun_s
, remaining
) == VEC_length (bfun_s
, *gaps
))
951 VEC_free (bfun_s
, *gaps
);
957 /* We get here if either GAPS is empty or if GAPS equals REMAINING. */
958 if (VEC_empty (bfun_s
, *gaps
))
961 VEC_free (bfun_s
, remaining
);
964 do_cleanups (old_chain
);
966 /* We may omit this in some cases. Not sure it is worth the extra
967 complication, though. */
968 ftrace_compute_global_level_offset (&tp
->btrace
);
971 /* Compute the function branch trace from BTS trace. */
974 btrace_compute_ftrace_bts (struct thread_info
*tp
,
975 const struct btrace_data_bts
*btrace
,
978 struct btrace_thread_info
*btinfo
;
979 struct btrace_function
*begin
, *end
;
980 struct gdbarch
*gdbarch
;
984 gdbarch
= target_gdbarch ();
985 btinfo
= &tp
->btrace
;
986 begin
= btinfo
->begin
;
988 level
= begin
!= NULL
? -btinfo
->level
: INT_MAX
;
989 blk
= VEC_length (btrace_block_s
, btrace
->blocks
);
993 btrace_block_s
*block
;
998 block
= VEC_index (btrace_block_s
, btrace
->blocks
, blk
);
1003 struct btrace_insn insn
;
1006 /* We should hit the end of the block. Warn if we went too far. */
1007 if (block
->end
< pc
)
1009 /* Indicate the gap in the trace. */
1010 end
= ftrace_new_gap (end
, BDE_BTS_OVERFLOW
);
1014 VEC_safe_push (bfun_s
, *gaps
, end
);
1016 warning (_("Recorded trace may be corrupted at instruction "
1017 "%u (pc = %s)."), end
->insn_offset
- 1,
1018 core_addr_to_string_nz (pc
));
1023 end
= ftrace_update_function (end
, pc
);
1027 /* Maintain the function level offset.
1028 For all but the last block, we do it here. */
1030 level
= std::min (level
, end
->level
);
1035 size
= gdb_insn_length (gdbarch
, pc
);
1037 CATCH (error
, RETURN_MASK_ERROR
)
1044 insn
.iclass
= ftrace_classify_insn (gdbarch
, pc
);
1047 ftrace_update_insns (end
, &insn
);
1049 /* We're done once we pushed the instruction at the end. */
1050 if (block
->end
== pc
)
1053 /* We can't continue if we fail to compute the size. */
1056 /* Indicate the gap in the trace. We just added INSN so we're
1057 not at the beginning. */
1058 end
= ftrace_new_gap (end
, BDE_BTS_INSN_SIZE
);
1060 VEC_safe_push (bfun_s
, *gaps
, end
);
1062 warning (_("Recorded trace may be incomplete at instruction %u "
1063 "(pc = %s)."), end
->insn_offset
- 1,
1064 core_addr_to_string_nz (pc
));
1071 /* Maintain the function level offset.
1072 For the last block, we do it here to not consider the last
1074 Since the last instruction corresponds to the current instruction
1075 and is not really part of the execution history, it shouldn't
1076 affect the level. */
1078 level
= std::min (level
, end
->level
);
1082 btinfo
->begin
= begin
;
1085 /* LEVEL is the minimal function level of all btrace function segments.
1086 Define the global level offset to -LEVEL so all function levels are
1087 normalized to start at zero. */
1088 btinfo
->level
= -level
;
1091 #if defined (HAVE_LIBIPT)
1093 static enum btrace_insn_class
1094 pt_reclassify_insn (enum pt_insn_class iclass
)
1099 return BTRACE_INSN_CALL
;
1102 return BTRACE_INSN_RETURN
;
1105 return BTRACE_INSN_JUMP
;
1108 return BTRACE_INSN_OTHER
;
1112 /* Return the btrace instruction flags for INSN. */
1114 static btrace_insn_flags
1115 pt_btrace_insn_flags (const struct pt_insn
&insn
)
1117 btrace_insn_flags flags
= 0;
1119 if (insn
.speculative
)
1120 flags
|= BTRACE_INSN_FLAG_SPECULATIVE
;
1125 /* Return the btrace instruction for INSN. */
1128 pt_btrace_insn (const struct pt_insn
&insn
)
1130 return {(CORE_ADDR
) insn
.ip
, (gdb_byte
) insn
.size
,
1131 pt_reclassify_insn (insn
.iclass
),
1132 pt_btrace_insn_flags (insn
)};
1136 /* Add function branch trace using DECODER. */
1139 ftrace_add_pt (struct pt_insn_decoder
*decoder
,
1140 struct btrace_function
**pbegin
,
1141 struct btrace_function
**pend
, int *plevel
,
1142 VEC (bfun_s
) **gaps
)
1144 struct btrace_function
*begin
, *end
, *upd
;
1152 struct pt_insn insn
;
1154 errcode
= pt_insn_sync_forward (decoder
);
1157 if (errcode
!= -pte_eos
)
1158 warning (_("Failed to synchronize onto the Intel Processor "
1159 "Trace stream: %s."), pt_errstr (pt_errcode (errcode
)));
1165 errcode
= pt_insn_next (decoder
, &insn
, sizeof(insn
));
1169 /* Look for gaps in the trace - unless we're at the beginning. */
1172 /* Tracing is disabled and re-enabled each time we enter the
1173 kernel. Most times, we continue from the same instruction we
1174 stopped before. This is indicated via the RESUMED instruction
1175 flag. The ENABLED instruction flag means that we continued
1176 from some other instruction. Indicate this as a trace gap. */
1179 *pend
= end
= ftrace_new_gap (end
, BDE_PT_DISABLED
);
1181 VEC_safe_push (bfun_s
, *gaps
, end
);
1183 pt_insn_get_offset (decoder
, &offset
);
1185 warning (_("Non-contiguous trace at instruction %u (offset "
1186 "= 0x%" PRIx64
", pc = 0x%" PRIx64
")."),
1187 end
->insn_offset
- 1, offset
, insn
.ip
);
1191 /* Indicate trace overflows. */
1194 *pend
= end
= ftrace_new_gap (end
, BDE_PT_OVERFLOW
);
1196 *pbegin
= begin
= end
;
1198 VEC_safe_push (bfun_s
, *gaps
, end
);
1200 pt_insn_get_offset (decoder
, &offset
);
1202 warning (_("Overflow at instruction %u (offset = 0x%" PRIx64
1203 ", pc = 0x%" PRIx64
")."), end
->insn_offset
- 1,
1207 upd
= ftrace_update_function (end
, insn
.ip
);
1213 *pbegin
= begin
= upd
;
1216 /* Maintain the function level offset. */
1217 *plevel
= std::min (*plevel
, end
->level
);
1219 btrace_insn btinsn
= pt_btrace_insn (insn
);
1220 ftrace_update_insns (end
, &btinsn
);
1223 if (errcode
== -pte_eos
)
1226 /* Indicate the gap in the trace. */
1227 *pend
= end
= ftrace_new_gap (end
, errcode
);
1229 *pbegin
= begin
= end
;
1231 VEC_safe_push (bfun_s
, *gaps
, end
);
1233 pt_insn_get_offset (decoder
, &offset
);
1235 warning (_("Decode error (%d) at instruction %u (offset = 0x%" PRIx64
1236 ", pc = 0x%" PRIx64
"): %s."), errcode
, end
->insn_offset
- 1,
1237 offset
, insn
.ip
, pt_errstr (pt_errcode (errcode
)));
1241 /* A callback function to allow the trace decoder to read the inferior's
1245 btrace_pt_readmem_callback (gdb_byte
*buffer
, size_t size
,
1246 const struct pt_asid
*asid
, uint64_t pc
,
1249 int result
, errcode
;
1251 result
= (int) size
;
1254 errcode
= target_read_code ((CORE_ADDR
) pc
, buffer
, size
);
1256 result
= -pte_nomap
;
1258 CATCH (error
, RETURN_MASK_ERROR
)
1260 result
= -pte_nomap
;
1267 /* Translate the vendor from one enum to another. */
1269 static enum pt_cpu_vendor
1270 pt_translate_cpu_vendor (enum btrace_cpu_vendor vendor
)
1282 /* Finalize the function branch trace after decode. */
1284 static void btrace_finalize_ftrace_pt (struct pt_insn_decoder
*decoder
,
1285 struct thread_info
*tp
, int level
)
1287 pt_insn_free_decoder (decoder
);
1289 /* LEVEL is the minimal function level of all btrace function segments.
1290 Define the global level offset to -LEVEL so all function levels are
1291 normalized to start at zero. */
1292 tp
->btrace
.level
= -level
;
1294 /* Add a single last instruction entry for the current PC.
1295 This allows us to compute the backtrace at the current PC using both
1296 standard unwind and btrace unwind.
1297 This extra entry is ignored by all record commands. */
1301 /* Compute the function branch trace from Intel Processor Trace
1305 btrace_compute_ftrace_pt (struct thread_info
*tp
,
1306 const struct btrace_data_pt
*btrace
,
1307 VEC (bfun_s
) **gaps
)
1309 struct btrace_thread_info
*btinfo
;
1310 struct pt_insn_decoder
*decoder
;
1311 struct pt_config config
;
1314 if (btrace
->size
== 0)
1317 btinfo
= &tp
->btrace
;
1318 level
= btinfo
->begin
!= NULL
? -btinfo
->level
: INT_MAX
;
1320 pt_config_init(&config
);
1321 config
.begin
= btrace
->data
;
1322 config
.end
= btrace
->data
+ btrace
->size
;
1324 config
.cpu
.vendor
= pt_translate_cpu_vendor (btrace
->config
.cpu
.vendor
);
1325 config
.cpu
.family
= btrace
->config
.cpu
.family
;
1326 config
.cpu
.model
= btrace
->config
.cpu
.model
;
1327 config
.cpu
.stepping
= btrace
->config
.cpu
.stepping
;
1329 errcode
= pt_cpu_errata (&config
.errata
, &config
.cpu
);
1331 error (_("Failed to configure the Intel Processor Trace decoder: %s."),
1332 pt_errstr (pt_errcode (errcode
)));
1334 decoder
= pt_insn_alloc_decoder (&config
);
1335 if (decoder
== NULL
)
1336 error (_("Failed to allocate the Intel Processor Trace decoder."));
1340 struct pt_image
*image
;
1342 image
= pt_insn_get_image(decoder
);
1344 error (_("Failed to configure the Intel Processor Trace decoder."));
1346 errcode
= pt_image_set_callback(image
, btrace_pt_readmem_callback
, NULL
);
1348 error (_("Failed to configure the Intel Processor Trace decoder: "
1349 "%s."), pt_errstr (pt_errcode (errcode
)));
1351 ftrace_add_pt (decoder
, &btinfo
->begin
, &btinfo
->end
, &level
, gaps
);
1353 CATCH (error
, RETURN_MASK_ALL
)
1355 /* Indicate a gap in the trace if we quit trace processing. */
1356 if (error
.reason
== RETURN_QUIT
&& btinfo
->end
!= NULL
)
1358 btinfo
->end
= ftrace_new_gap (btinfo
->end
, BDE_PT_USER_QUIT
);
1360 VEC_safe_push (bfun_s
, *gaps
, btinfo
->end
);
1363 btrace_finalize_ftrace_pt (decoder
, tp
, level
);
1365 throw_exception (error
);
1369 btrace_finalize_ftrace_pt (decoder
, tp
, level
);
1372 #else /* defined (HAVE_LIBIPT) */
1375 btrace_compute_ftrace_pt (struct thread_info
*tp
,
1376 const struct btrace_data_pt
*btrace
,
1377 VEC (bfun_s
) **gaps
)
1379 internal_error (__FILE__
, __LINE__
, _("Unexpected branch trace format."));
1382 #endif /* defined (HAVE_LIBIPT) */
1384 /* Compute the function branch trace from a block branch trace BTRACE for
1385 a thread given by BTINFO. */
1388 btrace_compute_ftrace_1 (struct thread_info
*tp
, struct btrace_data
*btrace
,
1389 VEC (bfun_s
) **gaps
)
1391 DEBUG ("compute ftrace");
1393 switch (btrace
->format
)
1395 case BTRACE_FORMAT_NONE
:
1398 case BTRACE_FORMAT_BTS
:
1399 btrace_compute_ftrace_bts (tp
, &btrace
->variant
.bts
, gaps
);
1402 case BTRACE_FORMAT_PT
:
1403 btrace_compute_ftrace_pt (tp
, &btrace
->variant
.pt
, gaps
);
1407 internal_error (__FILE__
, __LINE__
, _("Unkown branch trace format."));
1411 btrace_finalize_ftrace (struct thread_info
*tp
, VEC (bfun_s
) **gaps
)
1413 if (!VEC_empty (bfun_s
, *gaps
))
1415 tp
->btrace
.ngaps
+= VEC_length (bfun_s
, *gaps
);
1416 btrace_bridge_gaps (tp
, gaps
);
1421 btrace_compute_ftrace (struct thread_info
*tp
, struct btrace_data
*btrace
)
1424 struct cleanup
*old_chain
;
1427 old_chain
= make_cleanup (VEC_cleanup (bfun_s
), &gaps
);
1431 btrace_compute_ftrace_1 (tp
, btrace
, &gaps
);
1433 CATCH (error
, RETURN_MASK_ALL
)
1435 btrace_finalize_ftrace (tp
, &gaps
);
1437 throw_exception (error
);
1441 btrace_finalize_ftrace (tp
, &gaps
);
1443 do_cleanups (old_chain
);
1446 /* Add an entry for the current PC. */
1449 btrace_add_pc (struct thread_info
*tp
)
1451 struct btrace_data btrace
;
1452 struct btrace_block
*block
;
1453 struct regcache
*regcache
;
1454 struct cleanup
*cleanup
;
1457 regcache
= get_thread_regcache (tp
->ptid
);
1458 pc
= regcache_read_pc (regcache
);
1460 btrace_data_init (&btrace
);
1461 btrace
.format
= BTRACE_FORMAT_BTS
;
1462 btrace
.variant
.bts
.blocks
= NULL
;
1464 cleanup
= make_cleanup_btrace_data (&btrace
);
1466 block
= VEC_safe_push (btrace_block_s
, btrace
.variant
.bts
.blocks
, NULL
);
1470 btrace_compute_ftrace (tp
, &btrace
);
1472 do_cleanups (cleanup
);
1478 btrace_enable (struct thread_info
*tp
, const struct btrace_config
*conf
)
1480 if (tp
->btrace
.target
!= NULL
)
1483 #if !defined (HAVE_LIBIPT)
1484 if (conf
->format
== BTRACE_FORMAT_PT
)
1485 error (_("GDB does not support Intel Processor Trace."));
1486 #endif /* !defined (HAVE_LIBIPT) */
1488 if (!target_supports_btrace (conf
->format
))
1489 error (_("Target does not support branch tracing."));
1491 DEBUG ("enable thread %s (%s)", print_thread_id (tp
),
1492 target_pid_to_str (tp
->ptid
));
1494 tp
->btrace
.target
= target_enable_btrace (tp
->ptid
, conf
);
1496 /* We're done if we failed to enable tracing. */
1497 if (tp
->btrace
.target
== NULL
)
1500 /* We need to undo the enable in case of errors. */
1503 /* Add an entry for the current PC so we start tracing from where we
1506 If we can't access TP's registers, TP is most likely running. In this
1507 case, we can't really say where tracing was enabled so it should be
1508 safe to simply skip this step.
1510 This is not relevant for BTRACE_FORMAT_PT since the trace will already
1511 start at the PC at which tracing was enabled. */
1512 if (conf
->format
!= BTRACE_FORMAT_PT
1513 && can_access_registers_ptid (tp
->ptid
))
1516 CATCH (exception
, RETURN_MASK_ALL
)
1518 btrace_disable (tp
);
1520 throw_exception (exception
);
1527 const struct btrace_config
*
1528 btrace_conf (const struct btrace_thread_info
*btinfo
)
1530 if (btinfo
->target
== NULL
)
1533 return target_btrace_conf (btinfo
->target
);
1539 btrace_disable (struct thread_info
*tp
)
1541 struct btrace_thread_info
*btp
= &tp
->btrace
;
1544 if (btp
->target
== NULL
)
1547 DEBUG ("disable thread %s (%s)", print_thread_id (tp
),
1548 target_pid_to_str (tp
->ptid
));
1550 target_disable_btrace (btp
->target
);
1559 btrace_teardown (struct thread_info
*tp
)
1561 struct btrace_thread_info
*btp
= &tp
->btrace
;
1564 if (btp
->target
== NULL
)
1567 DEBUG ("teardown thread %s (%s)", print_thread_id (tp
),
1568 target_pid_to_str (tp
->ptid
));
1570 target_teardown_btrace (btp
->target
);
1576 /* Stitch branch trace in BTS format. */
1579 btrace_stitch_bts (struct btrace_data_bts
*btrace
, struct thread_info
*tp
)
1581 struct btrace_thread_info
*btinfo
;
1582 struct btrace_function
*last_bfun
;
1583 struct btrace_insn
*last_insn
;
1584 btrace_block_s
*first_new_block
;
1586 btinfo
= &tp
->btrace
;
1587 last_bfun
= btinfo
->end
;
1588 gdb_assert (last_bfun
!= NULL
);
1589 gdb_assert (!VEC_empty (btrace_block_s
, btrace
->blocks
));
1591 /* If the existing trace ends with a gap, we just glue the traces
1592 together. We need to drop the last (i.e. chronologically first) block
1593 of the new trace, though, since we can't fill in the start address.*/
1594 if (VEC_empty (btrace_insn_s
, last_bfun
->insn
))
1596 VEC_pop (btrace_block_s
, btrace
->blocks
);
1600 /* Beware that block trace starts with the most recent block, so the
1601 chronologically first block in the new trace is the last block in
1602 the new trace's block vector. */
1603 first_new_block
= VEC_last (btrace_block_s
, btrace
->blocks
);
1604 last_insn
= VEC_last (btrace_insn_s
, last_bfun
->insn
);
1606 /* If the current PC at the end of the block is the same as in our current
1607 trace, there are two explanations:
1608 1. we executed the instruction and some branch brought us back.
1609 2. we have not made any progress.
1610 In the first case, the delta trace vector should contain at least two
1612 In the second case, the delta trace vector should contain exactly one
1613 entry for the partial block containing the current PC. Remove it. */
1614 if (first_new_block
->end
== last_insn
->pc
1615 && VEC_length (btrace_block_s
, btrace
->blocks
) == 1)
1617 VEC_pop (btrace_block_s
, btrace
->blocks
);
1621 DEBUG ("stitching %s to %s", ftrace_print_insn_addr (last_insn
),
1622 core_addr_to_string_nz (first_new_block
->end
));
1624 /* Do a simple sanity check to make sure we don't accidentally end up
1625 with a bad block. This should not occur in practice. */
1626 if (first_new_block
->end
< last_insn
->pc
)
1628 warning (_("Error while trying to read delta trace. Falling back to "
1633 /* We adjust the last block to start at the end of our current trace. */
1634 gdb_assert (first_new_block
->begin
== 0);
1635 first_new_block
->begin
= last_insn
->pc
;
1637 /* We simply pop the last insn so we can insert it again as part of
1638 the normal branch trace computation.
1639 Since instruction iterators are based on indices in the instructions
1640 vector, we don't leave any pointers dangling. */
1641 DEBUG ("pruning insn at %s for stitching",
1642 ftrace_print_insn_addr (last_insn
));
1644 VEC_pop (btrace_insn_s
, last_bfun
->insn
);
1646 /* The instructions vector may become empty temporarily if this has
1647 been the only instruction in this function segment.
1648 This violates the invariant but will be remedied shortly by
1649 btrace_compute_ftrace when we add the new trace. */
1651 /* The only case where this would hurt is if the entire trace consisted
1652 of just that one instruction. If we remove it, we might turn the now
1653 empty btrace function segment into a gap. But we don't want gaps at
1654 the beginning. To avoid this, we remove the entire old trace. */
1655 if (last_bfun
== btinfo
->begin
&& VEC_empty (btrace_insn_s
, last_bfun
->insn
))
1661 /* Adjust the block trace in order to stitch old and new trace together.
1662 BTRACE is the new delta trace between the last and the current stop.
1663 TP is the traced thread.
1664 May modifx BTRACE as well as the existing trace in TP.
1665 Return 0 on success, -1 otherwise. */
1668 btrace_stitch_trace (struct btrace_data
*btrace
, struct thread_info
*tp
)
1670 /* If we don't have trace, there's nothing to do. */
1671 if (btrace_data_empty (btrace
))
1674 switch (btrace
->format
)
1676 case BTRACE_FORMAT_NONE
:
1679 case BTRACE_FORMAT_BTS
:
1680 return btrace_stitch_bts (&btrace
->variant
.bts
, tp
);
1682 case BTRACE_FORMAT_PT
:
1683 /* Delta reads are not supported. */
1687 internal_error (__FILE__
, __LINE__
, _("Unkown branch trace format."));
1690 /* Clear the branch trace histories in BTINFO. */
1693 btrace_clear_history (struct btrace_thread_info
*btinfo
)
1695 xfree (btinfo
->insn_history
);
1696 xfree (btinfo
->call_history
);
1697 xfree (btinfo
->replay
);
1699 btinfo
->insn_history
= NULL
;
1700 btinfo
->call_history
= NULL
;
1701 btinfo
->replay
= NULL
;
1704 /* Clear the branch trace maintenance histories in BTINFO. */
1707 btrace_maint_clear (struct btrace_thread_info
*btinfo
)
1709 switch (btinfo
->data
.format
)
1714 case BTRACE_FORMAT_BTS
:
1715 btinfo
->maint
.variant
.bts
.packet_history
.begin
= 0;
1716 btinfo
->maint
.variant
.bts
.packet_history
.end
= 0;
1719 #if defined (HAVE_LIBIPT)
1720 case BTRACE_FORMAT_PT
:
1721 xfree (btinfo
->maint
.variant
.pt
.packets
);
1723 btinfo
->maint
.variant
.pt
.packets
= NULL
;
1724 btinfo
->maint
.variant
.pt
.packet_history
.begin
= 0;
1725 btinfo
->maint
.variant
.pt
.packet_history
.end
= 0;
1727 #endif /* defined (HAVE_LIBIPT) */
1734 btrace_decode_error (enum btrace_format format
, int errcode
)
1738 case BTRACE_FORMAT_BTS
:
1741 case BDE_BTS_OVERFLOW
:
1742 return _("instruction overflow");
1744 case BDE_BTS_INSN_SIZE
:
1745 return _("unknown instruction");
1752 #if defined (HAVE_LIBIPT)
1753 case BTRACE_FORMAT_PT
:
1756 case BDE_PT_USER_QUIT
:
1757 return _("trace decode cancelled");
1759 case BDE_PT_DISABLED
:
1760 return _("disabled");
1762 case BDE_PT_OVERFLOW
:
1763 return _("overflow");
1767 return pt_errstr (pt_errcode (errcode
));
1771 #endif /* defined (HAVE_LIBIPT) */
1777 return _("unknown");
1783 btrace_fetch (struct thread_info
*tp
)
1785 struct btrace_thread_info
*btinfo
;
1786 struct btrace_target_info
*tinfo
;
1787 struct btrace_data btrace
;
1788 struct cleanup
*cleanup
;
1791 DEBUG ("fetch thread %s (%s)", print_thread_id (tp
),
1792 target_pid_to_str (tp
->ptid
));
1794 btinfo
= &tp
->btrace
;
1795 tinfo
= btinfo
->target
;
1799 /* There's no way we could get new trace while replaying.
1800 On the other hand, delta trace would return a partial record with the
1801 current PC, which is the replay PC, not the last PC, as expected. */
1802 if (btinfo
->replay
!= NULL
)
1805 /* With CLI usage, TP->PTID always equals INFERIOR_PTID here. Now that we
1806 can store a gdb.Record object in Python referring to a different thread
1807 than the current one, temporarily set INFERIOR_PTID. */
1808 cleanup
= save_inferior_ptid ();
1809 inferior_ptid
= tp
->ptid
;
1811 /* We should not be called on running or exited threads. */
1812 gdb_assert (can_access_registers_ptid (tp
->ptid
));
1814 btrace_data_init (&btrace
);
1815 make_cleanup_btrace_data (&btrace
);
1817 /* Let's first try to extend the trace we already have. */
1818 if (btinfo
->end
!= NULL
)
1820 errcode
= target_read_btrace (&btrace
, tinfo
, BTRACE_READ_DELTA
);
1823 /* Success. Let's try to stitch the traces together. */
1824 errcode
= btrace_stitch_trace (&btrace
, tp
);
1828 /* We failed to read delta trace. Let's try to read new trace. */
1829 errcode
= target_read_btrace (&btrace
, tinfo
, BTRACE_READ_NEW
);
1831 /* If we got any new trace, discard what we have. */
1832 if (errcode
== 0 && !btrace_data_empty (&btrace
))
1836 /* If we were not able to read the trace, we start over. */
1840 errcode
= target_read_btrace (&btrace
, tinfo
, BTRACE_READ_ALL
);
1844 errcode
= target_read_btrace (&btrace
, tinfo
, BTRACE_READ_ALL
);
1846 /* If we were not able to read the branch trace, signal an error. */
1848 error (_("Failed to read branch trace."));
1850 /* Compute the trace, provided we have any. */
1851 if (!btrace_data_empty (&btrace
))
1853 struct btrace_function
*bfun
;
1855 /* Store the raw trace data. The stored data will be cleared in
1856 btrace_clear, so we always append the new trace. */
1857 btrace_data_append (&btinfo
->data
, &btrace
);
1858 btrace_maint_clear (btinfo
);
1860 VEC_truncate (btrace_fun_p
, btinfo
->functions
, 0);
1861 btrace_clear_history (btinfo
);
1862 btrace_compute_ftrace (tp
, &btrace
);
1864 for (bfun
= btinfo
->begin
; bfun
!= NULL
; bfun
= bfun
->flow
.next
)
1865 VEC_safe_push (btrace_fun_p
, btinfo
->functions
, bfun
);
1868 do_cleanups (cleanup
);
1874 btrace_clear (struct thread_info
*tp
)
1876 struct btrace_thread_info
*btinfo
;
1877 struct btrace_function
*it
, *trash
;
1879 DEBUG ("clear thread %s (%s)", print_thread_id (tp
),
1880 target_pid_to_str (tp
->ptid
));
1882 /* Make sure btrace frames that may hold a pointer into the branch
1883 trace data are destroyed. */
1884 reinit_frame_cache ();
1886 btinfo
= &tp
->btrace
;
1888 VEC_free (btrace_fun_p
, btinfo
->functions
);
1896 VEC_free (btrace_insn_s
, trash
->insn
);
1900 btinfo
->begin
= NULL
;
1904 /* Must clear the maint data before - it depends on BTINFO->DATA. */
1905 btrace_maint_clear (btinfo
);
1906 btrace_data_clear (&btinfo
->data
);
1907 btrace_clear_history (btinfo
);
1913 btrace_free_objfile (struct objfile
*objfile
)
1915 struct thread_info
*tp
;
1917 DEBUG ("free objfile");
1919 ALL_NON_EXITED_THREADS (tp
)
1923 #if defined (HAVE_LIBEXPAT)
1925 /* Check the btrace document version. */
1928 check_xml_btrace_version (struct gdb_xml_parser
*parser
,
1929 const struct gdb_xml_element
*element
,
1930 void *user_data
, VEC (gdb_xml_value_s
) *attributes
)
1933 = (const char *) xml_find_attribute (attributes
, "version")->value
;
1935 if (strcmp (version
, "1.0") != 0)
1936 gdb_xml_error (parser
, _("Unsupported btrace version: \"%s\""), version
);
1939 /* Parse a btrace "block" xml record. */
1942 parse_xml_btrace_block (struct gdb_xml_parser
*parser
,
1943 const struct gdb_xml_element
*element
,
1944 void *user_data
, VEC (gdb_xml_value_s
) *attributes
)
1946 struct btrace_data
*btrace
;
1947 struct btrace_block
*block
;
1948 ULONGEST
*begin
, *end
;
1950 btrace
= (struct btrace_data
*) user_data
;
1952 switch (btrace
->format
)
1954 case BTRACE_FORMAT_BTS
:
1957 case BTRACE_FORMAT_NONE
:
1958 btrace
->format
= BTRACE_FORMAT_BTS
;
1959 btrace
->variant
.bts
.blocks
= NULL
;
1963 gdb_xml_error (parser
, _("Btrace format error."));
1966 begin
= (ULONGEST
*) xml_find_attribute (attributes
, "begin")->value
;
1967 end
= (ULONGEST
*) xml_find_attribute (attributes
, "end")->value
;
1969 block
= VEC_safe_push (btrace_block_s
, btrace
->variant
.bts
.blocks
, NULL
);
1970 block
->begin
= *begin
;
1974 /* Parse a "raw" xml record. */
1977 parse_xml_raw (struct gdb_xml_parser
*parser
, const char *body_text
,
1978 gdb_byte
**pdata
, size_t *psize
)
1980 struct cleanup
*cleanup
;
1981 gdb_byte
*data
, *bin
;
1984 len
= strlen (body_text
);
1986 gdb_xml_error (parser
, _("Bad raw data size."));
1990 bin
= data
= (gdb_byte
*) xmalloc (size
);
1991 cleanup
= make_cleanup (xfree
, data
);
1993 /* We use hex encoding - see common/rsp-low.h. */
2001 if (hi
== 0 || lo
== 0)
2002 gdb_xml_error (parser
, _("Bad hex encoding."));
2004 *bin
++ = fromhex (hi
) * 16 + fromhex (lo
);
2008 discard_cleanups (cleanup
);
2014 /* Parse a btrace pt-config "cpu" xml record. */
2017 parse_xml_btrace_pt_config_cpu (struct gdb_xml_parser
*parser
,
2018 const struct gdb_xml_element
*element
,
2020 VEC (gdb_xml_value_s
) *attributes
)
2022 struct btrace_data
*btrace
;
2024 ULONGEST
*family
, *model
, *stepping
;
2026 vendor
= (const char *) xml_find_attribute (attributes
, "vendor")->value
;
2027 family
= (ULONGEST
*) xml_find_attribute (attributes
, "family")->value
;
2028 model
= (ULONGEST
*) xml_find_attribute (attributes
, "model")->value
;
2029 stepping
= (ULONGEST
*) xml_find_attribute (attributes
, "stepping")->value
;
2031 btrace
= (struct btrace_data
*) user_data
;
2033 if (strcmp (vendor
, "GenuineIntel") == 0)
2034 btrace
->variant
.pt
.config
.cpu
.vendor
= CV_INTEL
;
2036 btrace
->variant
.pt
.config
.cpu
.family
= *family
;
2037 btrace
->variant
.pt
.config
.cpu
.model
= *model
;
2038 btrace
->variant
.pt
.config
.cpu
.stepping
= *stepping
;
2041 /* Parse a btrace pt "raw" xml record. */
2044 parse_xml_btrace_pt_raw (struct gdb_xml_parser
*parser
,
2045 const struct gdb_xml_element
*element
,
2046 void *user_data
, const char *body_text
)
2048 struct btrace_data
*btrace
;
2050 btrace
= (struct btrace_data
*) user_data
;
2051 parse_xml_raw (parser
, body_text
, &btrace
->variant
.pt
.data
,
2052 &btrace
->variant
.pt
.size
);
2055 /* Parse a btrace "pt" xml record. */
2058 parse_xml_btrace_pt (struct gdb_xml_parser
*parser
,
2059 const struct gdb_xml_element
*element
,
2060 void *user_data
, VEC (gdb_xml_value_s
) *attributes
)
2062 struct btrace_data
*btrace
;
2064 btrace
= (struct btrace_data
*) user_data
;
2065 btrace
->format
= BTRACE_FORMAT_PT
;
2066 btrace
->variant
.pt
.config
.cpu
.vendor
= CV_UNKNOWN
;
2067 btrace
->variant
.pt
.data
= NULL
;
2068 btrace
->variant
.pt
.size
= 0;
2071 static const struct gdb_xml_attribute block_attributes
[] = {
2072 { "begin", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
2073 { "end", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
2074 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
2077 static const struct gdb_xml_attribute btrace_pt_config_cpu_attributes
[] = {
2078 { "vendor", GDB_XML_AF_NONE
, NULL
, NULL
},
2079 { "family", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
2080 { "model", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
2081 { "stepping", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
2082 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
2085 static const struct gdb_xml_element btrace_pt_config_children
[] = {
2086 { "cpu", btrace_pt_config_cpu_attributes
, NULL
, GDB_XML_EF_OPTIONAL
,
2087 parse_xml_btrace_pt_config_cpu
, NULL
},
2088 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
2091 static const struct gdb_xml_element btrace_pt_children
[] = {
2092 { "pt-config", NULL
, btrace_pt_config_children
, GDB_XML_EF_OPTIONAL
, NULL
,
2094 { "raw", NULL
, NULL
, GDB_XML_EF_OPTIONAL
, NULL
, parse_xml_btrace_pt_raw
},
2095 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
2098 static const struct gdb_xml_attribute btrace_attributes
[] = {
2099 { "version", GDB_XML_AF_NONE
, NULL
, NULL
},
2100 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
2103 static const struct gdb_xml_element btrace_children
[] = {
2104 { "block", block_attributes
, NULL
,
2105 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
, parse_xml_btrace_block
, NULL
},
2106 { "pt", NULL
, btrace_pt_children
, GDB_XML_EF_OPTIONAL
, parse_xml_btrace_pt
,
2108 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
2111 static const struct gdb_xml_element btrace_elements
[] = {
2112 { "btrace", btrace_attributes
, btrace_children
, GDB_XML_EF_NONE
,
2113 check_xml_btrace_version
, NULL
},
2114 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
2117 #endif /* defined (HAVE_LIBEXPAT) */
2122 parse_xml_btrace (struct btrace_data
*btrace
, const char *buffer
)
2124 struct cleanup
*cleanup
;
2127 #if defined (HAVE_LIBEXPAT)
2129 btrace
->format
= BTRACE_FORMAT_NONE
;
2131 cleanup
= make_cleanup_btrace_data (btrace
);
2132 errcode
= gdb_xml_parse_quick (_("btrace"), "btrace.dtd", btrace_elements
,
2135 error (_("Error parsing branch trace."));
2137 /* Keep parse results. */
2138 discard_cleanups (cleanup
);
2140 #else /* !defined (HAVE_LIBEXPAT) */
2142 error (_("Cannot process branch trace. XML parsing is not supported."));
2144 #endif /* !defined (HAVE_LIBEXPAT) */
2147 #if defined (HAVE_LIBEXPAT)
2149 /* Parse a btrace-conf "bts" xml record. */
2152 parse_xml_btrace_conf_bts (struct gdb_xml_parser
*parser
,
2153 const struct gdb_xml_element
*element
,
2154 void *user_data
, VEC (gdb_xml_value_s
) *attributes
)
2156 struct btrace_config
*conf
;
2157 struct gdb_xml_value
*size
;
2159 conf
= (struct btrace_config
*) user_data
;
2160 conf
->format
= BTRACE_FORMAT_BTS
;
2163 size
= xml_find_attribute (attributes
, "size");
2165 conf
->bts
.size
= (unsigned int) *(ULONGEST
*) size
->value
;
2168 /* Parse a btrace-conf "pt" xml record. */
2171 parse_xml_btrace_conf_pt (struct gdb_xml_parser
*parser
,
2172 const struct gdb_xml_element
*element
,
2173 void *user_data
, VEC (gdb_xml_value_s
) *attributes
)
2175 struct btrace_config
*conf
;
2176 struct gdb_xml_value
*size
;
2178 conf
= (struct btrace_config
*) user_data
;
2179 conf
->format
= BTRACE_FORMAT_PT
;
2182 size
= xml_find_attribute (attributes
, "size");
2184 conf
->pt
.size
= (unsigned int) *(ULONGEST
*) size
->value
;
2187 static const struct gdb_xml_attribute btrace_conf_pt_attributes
[] = {
2188 { "size", GDB_XML_AF_OPTIONAL
, gdb_xml_parse_attr_ulongest
, NULL
},
2189 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
2192 static const struct gdb_xml_attribute btrace_conf_bts_attributes
[] = {
2193 { "size", GDB_XML_AF_OPTIONAL
, gdb_xml_parse_attr_ulongest
, NULL
},
2194 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
2197 static const struct gdb_xml_element btrace_conf_children
[] = {
2198 { "bts", btrace_conf_bts_attributes
, NULL
, GDB_XML_EF_OPTIONAL
,
2199 parse_xml_btrace_conf_bts
, NULL
},
2200 { "pt", btrace_conf_pt_attributes
, NULL
, GDB_XML_EF_OPTIONAL
,
2201 parse_xml_btrace_conf_pt
, NULL
},
2202 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
2205 static const struct gdb_xml_attribute btrace_conf_attributes
[] = {
2206 { "version", GDB_XML_AF_NONE
, NULL
, NULL
},
2207 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
2210 static const struct gdb_xml_element btrace_conf_elements
[] = {
2211 { "btrace-conf", btrace_conf_attributes
, btrace_conf_children
,
2212 GDB_XML_EF_NONE
, NULL
, NULL
},
2213 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
2216 #endif /* defined (HAVE_LIBEXPAT) */
2221 parse_xml_btrace_conf (struct btrace_config
*conf
, const char *xml
)
2225 #if defined (HAVE_LIBEXPAT)
2227 errcode
= gdb_xml_parse_quick (_("btrace-conf"), "btrace-conf.dtd",
2228 btrace_conf_elements
, xml
, conf
);
2230 error (_("Error parsing branch trace configuration."));
2232 #else /* !defined (HAVE_LIBEXPAT) */
2234 error (_("XML parsing is not supported."));
2236 #endif /* !defined (HAVE_LIBEXPAT) */
2241 const struct btrace_insn
*
2242 btrace_insn_get (const struct btrace_insn_iterator
*it
)
2244 const struct btrace_function
*bfun
;
2245 unsigned int index
, end
;
2248 bfun
= it
->function
;
2250 /* Check if the iterator points to a gap in the trace. */
2251 if (bfun
->errcode
!= 0)
2254 /* The index is within the bounds of this function's instruction vector. */
2255 end
= VEC_length (btrace_insn_s
, bfun
->insn
);
2256 gdb_assert (0 < end
);
2257 gdb_assert (index
< end
);
2259 return VEC_index (btrace_insn_s
, bfun
->insn
, index
);
2265 btrace_insn_get_error (const struct btrace_insn_iterator
*it
)
2267 return it
->function
->errcode
;
2273 btrace_insn_number (const struct btrace_insn_iterator
*it
)
2275 return it
->function
->insn_offset
+ it
->index
;
2281 btrace_insn_begin (struct btrace_insn_iterator
*it
,
2282 const struct btrace_thread_info
*btinfo
)
2284 const struct btrace_function
*bfun
;
2286 bfun
= btinfo
->begin
;
2288 error (_("No trace."));
2290 it
->function
= bfun
;
2297 btrace_insn_end (struct btrace_insn_iterator
*it
,
2298 const struct btrace_thread_info
*btinfo
)
2300 const struct btrace_function
*bfun
;
2301 unsigned int length
;
2305 error (_("No trace."));
2307 length
= VEC_length (btrace_insn_s
, bfun
->insn
);
2309 /* The last function may either be a gap or it contains the current
2310 instruction, which is one past the end of the execution trace; ignore
2315 it
->function
= bfun
;
2322 btrace_insn_next (struct btrace_insn_iterator
*it
, unsigned int stride
)
2324 const struct btrace_function
*bfun
;
2325 unsigned int index
, steps
;
2327 bfun
= it
->function
;
2333 unsigned int end
, space
, adv
;
2335 end
= VEC_length (btrace_insn_s
, bfun
->insn
);
2337 /* An empty function segment represents a gap in the trace. We count
2338 it as one instruction. */
2341 const struct btrace_function
*next
;
2343 next
= bfun
->flow
.next
;
2356 gdb_assert (0 < end
);
2357 gdb_assert (index
< end
);
2359 /* Compute the number of instructions remaining in this segment. */
2360 space
= end
- index
;
2362 /* Advance the iterator as far as possible within this segment. */
2363 adv
= std::min (space
, stride
);
2368 /* Move to the next function if we're at the end of this one. */
2371 const struct btrace_function
*next
;
2373 next
= bfun
->flow
.next
;
2376 /* We stepped past the last function.
2378 Let's adjust the index to point to the last instruction in
2379 the previous function. */
2385 /* We now point to the first instruction in the new function. */
2390 /* We did make progress. */
2391 gdb_assert (adv
> 0);
2394 /* Update the iterator. */
2395 it
->function
= bfun
;
2404 btrace_insn_prev (struct btrace_insn_iterator
*it
, unsigned int stride
)
2406 const struct btrace_function
*bfun
;
2407 unsigned int index
, steps
;
2409 bfun
= it
->function
;
2417 /* Move to the previous function if we're at the start of this one. */
2420 const struct btrace_function
*prev
;
2422 prev
= bfun
->flow
.prev
;
2426 /* We point to one after the last instruction in the new function. */
2428 index
= VEC_length (btrace_insn_s
, bfun
->insn
);
2430 /* An empty function segment represents a gap in the trace. We count
2431 it as one instruction. */
2441 /* Advance the iterator as far as possible within this segment. */
2442 adv
= std::min (index
, stride
);
2448 /* We did make progress. */
2449 gdb_assert (adv
> 0);
2452 /* Update the iterator. */
2453 it
->function
= bfun
;
2462 btrace_insn_cmp (const struct btrace_insn_iterator
*lhs
,
2463 const struct btrace_insn_iterator
*rhs
)
2465 unsigned int lnum
, rnum
;
2467 lnum
= btrace_insn_number (lhs
);
2468 rnum
= btrace_insn_number (rhs
);
2470 return (int) (lnum
- rnum
);
2476 btrace_find_insn_by_number (struct btrace_insn_iterator
*it
,
2477 const struct btrace_thread_info
*btinfo
,
2478 unsigned int number
)
2480 const struct btrace_function
*bfun
;
2481 unsigned int upper
, lower
;
2483 if (VEC_empty (btrace_fun_p
, btinfo
->functions
))
2487 bfun
= VEC_index (btrace_fun_p
, btinfo
->functions
, lower
);
2488 if (number
< bfun
->insn_offset
)
2491 upper
= VEC_length (btrace_fun_p
, btinfo
->functions
) - 1;
2492 bfun
= VEC_index (btrace_fun_p
, btinfo
->functions
, upper
);
2493 if (number
>= bfun
->insn_offset
+ ftrace_call_num_insn (bfun
))
2496 /* We assume that there are no holes in the numbering. */
2499 const unsigned int average
= lower
+ (upper
- lower
) / 2;
2501 bfun
= VEC_index (btrace_fun_p
, btinfo
->functions
, average
);
2503 if (number
< bfun
->insn_offset
)
2505 upper
= average
- 1;
2509 if (number
>= bfun
->insn_offset
+ ftrace_call_num_insn (bfun
))
2511 lower
= average
+ 1;
2518 it
->function
= bfun
;
2519 it
->index
= number
- bfun
->insn_offset
;
2525 const struct btrace_function
*
2526 btrace_call_get (const struct btrace_call_iterator
*it
)
2528 return it
->function
;
2534 btrace_call_number (const struct btrace_call_iterator
*it
)
2536 const struct btrace_thread_info
*btinfo
;
2537 const struct btrace_function
*bfun
;
2540 btinfo
= it
->btinfo
;
2541 bfun
= it
->function
;
2543 return bfun
->number
;
2545 /* For the end iterator, i.e. bfun == NULL, we return one more than the
2546 number of the last function. */
2548 insns
= VEC_length (btrace_insn_s
, bfun
->insn
);
2550 /* If the function contains only a single instruction (i.e. the current
2551 instruction), it will be skipped and its number is already the number
2554 return bfun
->number
;
2556 /* Otherwise, return one more than the number of the last function. */
2557 return bfun
->number
+ 1;
2563 btrace_call_begin (struct btrace_call_iterator
*it
,
2564 const struct btrace_thread_info
*btinfo
)
2566 const struct btrace_function
*bfun
;
2568 bfun
= btinfo
->begin
;
2570 error (_("No trace."));
2572 it
->btinfo
= btinfo
;
2573 it
->function
= bfun
;
2579 btrace_call_end (struct btrace_call_iterator
*it
,
2580 const struct btrace_thread_info
*btinfo
)
2582 const struct btrace_function
*bfun
;
2586 error (_("No trace."));
2588 it
->btinfo
= btinfo
;
2589 it
->function
= NULL
;
2595 btrace_call_next (struct btrace_call_iterator
*it
, unsigned int stride
)
2597 const struct btrace_function
*bfun
;
2600 bfun
= it
->function
;
2602 while (bfun
!= NULL
)
2604 const struct btrace_function
*next
;
2607 next
= bfun
->flow
.next
;
2610 /* Ignore the last function if it only contains a single
2611 (i.e. the current) instruction. */
2612 insns
= VEC_length (btrace_insn_s
, bfun
->insn
);
2617 if (stride
== steps
)
2624 it
->function
= bfun
;
2631 btrace_call_prev (struct btrace_call_iterator
*it
, unsigned int stride
)
2633 const struct btrace_thread_info
*btinfo
;
2634 const struct btrace_function
*bfun
;
2637 bfun
= it
->function
;
2644 btinfo
= it
->btinfo
;
2649 /* Ignore the last function if it only contains a single
2650 (i.e. the current) instruction. */
2651 insns
= VEC_length (btrace_insn_s
, bfun
->insn
);
2653 bfun
= bfun
->flow
.prev
;
2661 while (steps
< stride
)
2663 const struct btrace_function
*prev
;
2665 prev
= bfun
->flow
.prev
;
2673 it
->function
= bfun
;
2680 btrace_call_cmp (const struct btrace_call_iterator
*lhs
,
2681 const struct btrace_call_iterator
*rhs
)
2683 unsigned int lnum
, rnum
;
2685 lnum
= btrace_call_number (lhs
);
2686 rnum
= btrace_call_number (rhs
);
2688 return (int) (lnum
- rnum
);
2694 btrace_find_call_by_number (struct btrace_call_iterator
*it
,
2695 const struct btrace_thread_info
*btinfo
,
2696 unsigned int number
)
2698 const struct btrace_function
*bfun
;
2700 for (bfun
= btinfo
->end
; bfun
!= NULL
; bfun
= bfun
->flow
.prev
)
2704 bnum
= bfun
->number
;
2707 it
->btinfo
= btinfo
;
2708 it
->function
= bfun
;
2712 /* Functions are ordered and numbered consecutively. We could bail out
2713 earlier. On the other hand, it is very unlikely that we search for
2714 a nonexistent function. */
2723 btrace_set_insn_history (struct btrace_thread_info
*btinfo
,
2724 const struct btrace_insn_iterator
*begin
,
2725 const struct btrace_insn_iterator
*end
)
2727 if (btinfo
->insn_history
== NULL
)
2728 btinfo
->insn_history
= XCNEW (struct btrace_insn_history
);
2730 btinfo
->insn_history
->begin
= *begin
;
2731 btinfo
->insn_history
->end
= *end
;
2737 btrace_set_call_history (struct btrace_thread_info
*btinfo
,
2738 const struct btrace_call_iterator
*begin
,
2739 const struct btrace_call_iterator
*end
)
2741 gdb_assert (begin
->btinfo
== end
->btinfo
);
2743 if (btinfo
->call_history
== NULL
)
2744 btinfo
->call_history
= XCNEW (struct btrace_call_history
);
2746 btinfo
->call_history
->begin
= *begin
;
2747 btinfo
->call_history
->end
= *end
;
2753 btrace_is_replaying (struct thread_info
*tp
)
2755 return tp
->btrace
.replay
!= NULL
;
2761 btrace_is_empty (struct thread_info
*tp
)
2763 struct btrace_insn_iterator begin
, end
;
2764 struct btrace_thread_info
*btinfo
;
2766 btinfo
= &tp
->btrace
;
2768 if (btinfo
->begin
== NULL
)
2771 btrace_insn_begin (&begin
, btinfo
);
2772 btrace_insn_end (&end
, btinfo
);
2774 return btrace_insn_cmp (&begin
, &end
) == 0;
2777 /* Forward the cleanup request. */
2780 do_btrace_data_cleanup (void *arg
)
2782 btrace_data_fini ((struct btrace_data
*) arg
);
2788 make_cleanup_btrace_data (struct btrace_data
*data
)
2790 return make_cleanup (do_btrace_data_cleanup
, data
);
2793 #if defined (HAVE_LIBIPT)
2795 /* Print a single packet. */
2798 pt_print_packet (const struct pt_packet
*packet
)
2800 switch (packet
->type
)
2803 printf_unfiltered (("[??: %x]"), packet
->type
);
2807 printf_unfiltered (("psb"));
2811 printf_unfiltered (("psbend"));
2815 printf_unfiltered (("pad"));
2819 printf_unfiltered (("tip %u: 0x%" PRIx64
""),
2820 packet
->payload
.ip
.ipc
,
2821 packet
->payload
.ip
.ip
);
2825 printf_unfiltered (("tip.pge %u: 0x%" PRIx64
""),
2826 packet
->payload
.ip
.ipc
,
2827 packet
->payload
.ip
.ip
);
2831 printf_unfiltered (("tip.pgd %u: 0x%" PRIx64
""),
2832 packet
->payload
.ip
.ipc
,
2833 packet
->payload
.ip
.ip
);
2837 printf_unfiltered (("fup %u: 0x%" PRIx64
""),
2838 packet
->payload
.ip
.ipc
,
2839 packet
->payload
.ip
.ip
);
2843 printf_unfiltered (("tnt-8 %u: 0x%" PRIx64
""),
2844 packet
->payload
.tnt
.bit_size
,
2845 packet
->payload
.tnt
.payload
);
2849 printf_unfiltered (("tnt-64 %u: 0x%" PRIx64
""),
2850 packet
->payload
.tnt
.bit_size
,
2851 packet
->payload
.tnt
.payload
);
2855 printf_unfiltered (("pip %" PRIx64
"%s"), packet
->payload
.pip
.cr3
,
2856 packet
->payload
.pip
.nr
? (" nr") : (""));
2860 printf_unfiltered (("tsc %" PRIx64
""), packet
->payload
.tsc
.tsc
);
2864 printf_unfiltered (("cbr %u"), packet
->payload
.cbr
.ratio
);
2868 switch (packet
->payload
.mode
.leaf
)
2871 printf_unfiltered (("mode %u"), packet
->payload
.mode
.leaf
);
2875 printf_unfiltered (("mode.exec%s%s"),
2876 packet
->payload
.mode
.bits
.exec
.csl
2878 packet
->payload
.mode
.bits
.exec
.csd
2879 ? (" cs.d") : (""));
2883 printf_unfiltered (("mode.tsx%s%s"),
2884 packet
->payload
.mode
.bits
.tsx
.intx
2886 packet
->payload
.mode
.bits
.tsx
.abrt
2887 ? (" abrt") : (""));
2893 printf_unfiltered (("ovf"));
2897 printf_unfiltered (("stop"));
2901 printf_unfiltered (("vmcs %" PRIx64
""), packet
->payload
.vmcs
.base
);
2905 printf_unfiltered (("tma %x %x"), packet
->payload
.tma
.ctc
,
2906 packet
->payload
.tma
.fc
);
2910 printf_unfiltered (("mtc %x"), packet
->payload
.mtc
.ctc
);
2914 printf_unfiltered (("cyc %" PRIx64
""), packet
->payload
.cyc
.value
);
2918 printf_unfiltered (("mnt %" PRIx64
""), packet
->payload
.mnt
.payload
);
2923 /* Decode packets into MAINT using DECODER. */
2926 btrace_maint_decode_pt (struct btrace_maint_info
*maint
,
2927 struct pt_packet_decoder
*decoder
)
2933 struct btrace_pt_packet packet
;
2935 errcode
= pt_pkt_sync_forward (decoder
);
2941 pt_pkt_get_offset (decoder
, &packet
.offset
);
2943 errcode
= pt_pkt_next (decoder
, &packet
.packet
,
2944 sizeof(packet
.packet
));
2948 if (maint_btrace_pt_skip_pad
== 0 || packet
.packet
.type
!= ppt_pad
)
2950 packet
.errcode
= pt_errcode (errcode
);
2951 VEC_safe_push (btrace_pt_packet_s
, maint
->variant
.pt
.packets
,
2956 if (errcode
== -pte_eos
)
2959 packet
.errcode
= pt_errcode (errcode
);
2960 VEC_safe_push (btrace_pt_packet_s
, maint
->variant
.pt
.packets
,
2963 warning (_("Error at trace offset 0x%" PRIx64
": %s."),
2964 packet
.offset
, pt_errstr (packet
.errcode
));
2967 if (errcode
!= -pte_eos
)
2968 warning (_("Failed to synchronize onto the Intel Processor Trace "
2969 "stream: %s."), pt_errstr (pt_errcode (errcode
)));
2972 /* Update the packet history in BTINFO. */
2975 btrace_maint_update_pt_packets (struct btrace_thread_info
*btinfo
)
2977 volatile struct gdb_exception except
;
2978 struct pt_packet_decoder
*decoder
;
2979 struct btrace_data_pt
*pt
;
2980 struct pt_config config
;
2983 pt
= &btinfo
->data
.variant
.pt
;
2985 /* Nothing to do if there is no trace. */
2989 memset (&config
, 0, sizeof(config
));
2991 config
.size
= sizeof (config
);
2992 config
.begin
= pt
->data
;
2993 config
.end
= pt
->data
+ pt
->size
;
2995 config
.cpu
.vendor
= pt_translate_cpu_vendor (pt
->config
.cpu
.vendor
);
2996 config
.cpu
.family
= pt
->config
.cpu
.family
;
2997 config
.cpu
.model
= pt
->config
.cpu
.model
;
2998 config
.cpu
.stepping
= pt
->config
.cpu
.stepping
;
3000 errcode
= pt_cpu_errata (&config
.errata
, &config
.cpu
);
3002 error (_("Failed to configure the Intel Processor Trace decoder: %s."),
3003 pt_errstr (pt_errcode (errcode
)));
3005 decoder
= pt_pkt_alloc_decoder (&config
);
3006 if (decoder
== NULL
)
3007 error (_("Failed to allocate the Intel Processor Trace decoder."));
3011 btrace_maint_decode_pt (&btinfo
->maint
, decoder
);
3013 CATCH (except
, RETURN_MASK_ALL
)
3015 pt_pkt_free_decoder (decoder
);
3017 if (except
.reason
< 0)
3018 throw_exception (except
);
3022 pt_pkt_free_decoder (decoder
);
3025 #endif /* !defined (HAVE_LIBIPT) */
3027 /* Update the packet maintenance information for BTINFO and store the
3028 low and high bounds into BEGIN and END, respectively.
3029 Store the current iterator state into FROM and TO. */
3032 btrace_maint_update_packets (struct btrace_thread_info
*btinfo
,
3033 unsigned int *begin
, unsigned int *end
,
3034 unsigned int *from
, unsigned int *to
)
3036 switch (btinfo
->data
.format
)
3045 case BTRACE_FORMAT_BTS
:
3046 /* Nothing to do - we operate directly on BTINFO->DATA. */
3048 *end
= VEC_length (btrace_block_s
, btinfo
->data
.variant
.bts
.blocks
);
3049 *from
= btinfo
->maint
.variant
.bts
.packet_history
.begin
;
3050 *to
= btinfo
->maint
.variant
.bts
.packet_history
.end
;
3053 #if defined (HAVE_LIBIPT)
3054 case BTRACE_FORMAT_PT
:
3055 if (VEC_empty (btrace_pt_packet_s
, btinfo
->maint
.variant
.pt
.packets
))
3056 btrace_maint_update_pt_packets (btinfo
);
3059 *end
= VEC_length (btrace_pt_packet_s
, btinfo
->maint
.variant
.pt
.packets
);
3060 *from
= btinfo
->maint
.variant
.pt
.packet_history
.begin
;
3061 *to
= btinfo
->maint
.variant
.pt
.packet_history
.end
;
3063 #endif /* defined (HAVE_LIBIPT) */
3067 /* Print packets in BTINFO from BEGIN (inclusive) until END (exclusive) and
3068 update the current iterator position. */
3071 btrace_maint_print_packets (struct btrace_thread_info
*btinfo
,
3072 unsigned int begin
, unsigned int end
)
3074 switch (btinfo
->data
.format
)
3079 case BTRACE_FORMAT_BTS
:
3081 VEC (btrace_block_s
) *blocks
;
3084 blocks
= btinfo
->data
.variant
.bts
.blocks
;
3085 for (blk
= begin
; blk
< end
; ++blk
)
3087 const btrace_block_s
*block
;
3089 block
= VEC_index (btrace_block_s
, blocks
, blk
);
3091 printf_unfiltered ("%u\tbegin: %s, end: %s\n", blk
,
3092 core_addr_to_string_nz (block
->begin
),
3093 core_addr_to_string_nz (block
->end
));
3096 btinfo
->maint
.variant
.bts
.packet_history
.begin
= begin
;
3097 btinfo
->maint
.variant
.bts
.packet_history
.end
= end
;
3101 #if defined (HAVE_LIBIPT)
3102 case BTRACE_FORMAT_PT
:
3104 VEC (btrace_pt_packet_s
) *packets
;
3107 packets
= btinfo
->maint
.variant
.pt
.packets
;
3108 for (pkt
= begin
; pkt
< end
; ++pkt
)
3110 const struct btrace_pt_packet
*packet
;
3112 packet
= VEC_index (btrace_pt_packet_s
, packets
, pkt
);
3114 printf_unfiltered ("%u\t", pkt
);
3115 printf_unfiltered ("0x%" PRIx64
"\t", packet
->offset
);
3117 if (packet
->errcode
== pte_ok
)
3118 pt_print_packet (&packet
->packet
);
3120 printf_unfiltered ("[error: %s]", pt_errstr (packet
->errcode
));
3122 printf_unfiltered ("\n");
3125 btinfo
->maint
.variant
.pt
.packet_history
.begin
= begin
;
3126 btinfo
->maint
.variant
.pt
.packet_history
.end
= end
;
3129 #endif /* defined (HAVE_LIBIPT) */
3133 /* Read a number from an argument string. */
3136 get_uint (char **arg
)
3138 char *begin
, *end
, *pos
;
3139 unsigned long number
;
3142 pos
= skip_spaces (begin
);
3144 if (!isdigit (*pos
))
3145 error (_("Expected positive number, got: %s."), pos
);
3147 number
= strtoul (pos
, &end
, 10);
3148 if (number
> UINT_MAX
)
3149 error (_("Number too big."));
3151 *arg
+= (end
- begin
);
3153 return (unsigned int) number
;
3156 /* Read a context size from an argument string. */
3159 get_context_size (char **arg
)
3164 pos
= skip_spaces (*arg
);
3166 if (!isdigit (*pos
))
3167 error (_("Expected positive number, got: %s."), pos
);
3169 return strtol (pos
, arg
, 10);
3172 /* Complain about junk at the end of an argument string. */
3175 no_chunk (char *arg
)
3178 error (_("Junk after argument: %s."), arg
);
3181 /* The "maintenance btrace packet-history" command. */
3184 maint_btrace_packet_history_cmd (char *arg
, int from_tty
)
3186 struct btrace_thread_info
*btinfo
;
3187 struct thread_info
*tp
;
3188 unsigned int size
, begin
, end
, from
, to
;
3190 tp
= find_thread_ptid (inferior_ptid
);
3192 error (_("No thread."));
3195 btinfo
= &tp
->btrace
;
3197 btrace_maint_update_packets (btinfo
, &begin
, &end
, &from
, &to
);
3200 printf_unfiltered (_("No trace.\n"));
3204 if (arg
== NULL
|| *arg
== 0 || strcmp (arg
, "+") == 0)
3208 if (end
- from
< size
)
3212 else if (strcmp (arg
, "-") == 0)
3216 if (to
- begin
< size
)
3222 from
= get_uint (&arg
);
3224 error (_("'%u' is out of range."), from
);
3226 arg
= skip_spaces (arg
);
3229 arg
= skip_spaces (++arg
);
3234 size
= get_context_size (&arg
);
3238 if (end
- from
< size
)
3242 else if (*arg
== '-')
3245 size
= get_context_size (&arg
);
3249 /* Include the packet given as first argument. */
3253 if (to
- begin
< size
)
3259 to
= get_uint (&arg
);
3261 /* Include the packet at the second argument and silently
3262 truncate the range. */
3275 if (end
- from
< size
)
3283 btrace_maint_print_packets (btinfo
, from
, to
);
3286 /* The "maintenance btrace clear-packet-history" command. */
3289 maint_btrace_clear_packet_history_cmd (char *args
, int from_tty
)
3291 struct btrace_thread_info
*btinfo
;
3292 struct thread_info
*tp
;
3294 if (args
!= NULL
&& *args
!= 0)
3295 error (_("Invalid argument."));
3297 tp
= find_thread_ptid (inferior_ptid
);
3299 error (_("No thread."));
3301 btinfo
= &tp
->btrace
;
3303 /* Must clear the maint data before - it depends on BTINFO->DATA. */
3304 btrace_maint_clear (btinfo
);
3305 btrace_data_clear (&btinfo
->data
);
3308 /* The "maintenance btrace clear" command. */
3311 maint_btrace_clear_cmd (char *args
, int from_tty
)
3313 struct btrace_thread_info
*btinfo
;
3314 struct thread_info
*tp
;
3316 if (args
!= NULL
&& *args
!= 0)
3317 error (_("Invalid argument."));
3319 tp
= find_thread_ptid (inferior_ptid
);
3321 error (_("No thread."));
3326 /* The "maintenance btrace" command. */
3329 maint_btrace_cmd (char *args
, int from_tty
)
3331 help_list (maint_btrace_cmdlist
, "maintenance btrace ", all_commands
,
3335 /* The "maintenance set btrace" command. */
3338 maint_btrace_set_cmd (char *args
, int from_tty
)
3340 help_list (maint_btrace_set_cmdlist
, "maintenance set btrace ", all_commands
,
3344 /* The "maintenance show btrace" command. */
3347 maint_btrace_show_cmd (char *args
, int from_tty
)
3349 help_list (maint_btrace_show_cmdlist
, "maintenance show btrace ",
3350 all_commands
, gdb_stdout
);
3353 /* The "maintenance set btrace pt" command. */
3356 maint_btrace_pt_set_cmd (char *args
, int from_tty
)
3358 help_list (maint_btrace_pt_set_cmdlist
, "maintenance set btrace pt ",
3359 all_commands
, gdb_stdout
);
3362 /* The "maintenance show btrace pt" command. */
3365 maint_btrace_pt_show_cmd (char *args
, int from_tty
)
3367 help_list (maint_btrace_pt_show_cmdlist
, "maintenance show btrace pt ",
3368 all_commands
, gdb_stdout
);
3371 /* The "maintenance info btrace" command. */
3374 maint_info_btrace_cmd (char *args
, int from_tty
)
3376 struct btrace_thread_info
*btinfo
;
3377 struct thread_info
*tp
;
3378 const struct btrace_config
*conf
;
3380 if (args
!= NULL
&& *args
!= 0)
3381 error (_("Invalid argument."));
3383 tp
= find_thread_ptid (inferior_ptid
);
3385 error (_("No thread."));
3387 btinfo
= &tp
->btrace
;
3389 conf
= btrace_conf (btinfo
);
3391 error (_("No btrace configuration."));
3393 printf_unfiltered (_("Format: %s.\n"),
3394 btrace_format_string (conf
->format
));
3396 switch (conf
->format
)
3401 case BTRACE_FORMAT_BTS
:
3402 printf_unfiltered (_("Number of packets: %u.\n"),
3403 VEC_length (btrace_block_s
,
3404 btinfo
->data
.variant
.bts
.blocks
));
3407 #if defined (HAVE_LIBIPT)
3408 case BTRACE_FORMAT_PT
:
3410 struct pt_version version
;
3412 version
= pt_library_version ();
3413 printf_unfiltered (_("Version: %u.%u.%u%s.\n"), version
.major
,
3414 version
.minor
, version
.build
,
3415 version
.ext
!= NULL
? version
.ext
: "");
3417 btrace_maint_update_pt_packets (btinfo
);
3418 printf_unfiltered (_("Number of packets: %u.\n"),
3419 VEC_length (btrace_pt_packet_s
,
3420 btinfo
->maint
.variant
.pt
.packets
));
3423 #endif /* defined (HAVE_LIBIPT) */
3427 /* The "maint show btrace pt skip-pad" show value function. */
3430 show_maint_btrace_pt_skip_pad (struct ui_file
*file
, int from_tty
,
3431 struct cmd_list_element
*c
,
3434 fprintf_filtered (file
, _("Skip PAD packets is %s.\n"), value
);
3438 /* Initialize btrace maintenance commands. */
3440 void _initialize_btrace (void);
3442 _initialize_btrace (void)
3444 add_cmd ("btrace", class_maintenance
, maint_info_btrace_cmd
,
3445 _("Info about branch tracing data."), &maintenanceinfolist
);
3447 add_prefix_cmd ("btrace", class_maintenance
, maint_btrace_cmd
,
3448 _("Branch tracing maintenance commands."),
3449 &maint_btrace_cmdlist
, "maintenance btrace ",
3450 0, &maintenancelist
);
3452 add_prefix_cmd ("btrace", class_maintenance
, maint_btrace_set_cmd
, _("\
3453 Set branch tracing specific variables."),
3454 &maint_btrace_set_cmdlist
, "maintenance set btrace ",
3455 0, &maintenance_set_cmdlist
);
3457 add_prefix_cmd ("pt", class_maintenance
, maint_btrace_pt_set_cmd
, _("\
3458 Set Intel Processor Trace specific variables."),
3459 &maint_btrace_pt_set_cmdlist
, "maintenance set btrace pt ",
3460 0, &maint_btrace_set_cmdlist
);
3462 add_prefix_cmd ("btrace", class_maintenance
, maint_btrace_show_cmd
, _("\
3463 Show branch tracing specific variables."),
3464 &maint_btrace_show_cmdlist
, "maintenance show btrace ",
3465 0, &maintenance_show_cmdlist
);
3467 add_prefix_cmd ("pt", class_maintenance
, maint_btrace_pt_show_cmd
, _("\
3468 Show Intel Processor Trace specific variables."),
3469 &maint_btrace_pt_show_cmdlist
, "maintenance show btrace pt ",
3470 0, &maint_btrace_show_cmdlist
);
3472 add_setshow_boolean_cmd ("skip-pad", class_maintenance
,
3473 &maint_btrace_pt_skip_pad
, _("\
3474 Set whether PAD packets should be skipped in the btrace packet history."), _("\
3475 Show whether PAD packets should be skipped in the btrace packet history."),_("\
3476 When enabled, PAD packets are ignored in the btrace packet history."),
3477 NULL
, show_maint_btrace_pt_skip_pad
,
3478 &maint_btrace_pt_set_cmdlist
,
3479 &maint_btrace_pt_show_cmdlist
);
3481 add_cmd ("packet-history", class_maintenance
, maint_btrace_packet_history_cmd
,
3482 _("Print the raw branch tracing data.\n\
3483 With no argument, print ten more packets after the previous ten-line print.\n\
3484 With '-' as argument print ten packets before a previous ten-line print.\n\
3485 One argument specifies the starting packet of a ten-line print.\n\
3486 Two arguments with comma between specify starting and ending packets to \
3488 Preceded with '+'/'-' the second argument specifies the distance from the \
3490 &maint_btrace_cmdlist
);
3492 add_cmd ("clear-packet-history", class_maintenance
,
3493 maint_btrace_clear_packet_history_cmd
,
3494 _("Clears the branch tracing packet history.\n\
3495 Discards the raw branch tracing data but not the execution history data.\n\
3497 &maint_btrace_cmdlist
);
3499 add_cmd ("clear", class_maintenance
, maint_btrace_clear_cmd
,
3500 _("Clears the branch tracing data.\n\
3501 Discards the raw branch tracing data and the execution history data.\n\
3502 The next 'record' command will fetch the branch tracing data anew.\n\
3504 &maint_btrace_cmdlist
);