1 /* Branch trace support for GDB, the GNU debugger.
3 Copyright (C) 2013-2016 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"
41 /* Command lists for btrace maintenance commands. */
42 static struct cmd_list_element
*maint_btrace_cmdlist
;
43 static struct cmd_list_element
*maint_btrace_set_cmdlist
;
44 static struct cmd_list_element
*maint_btrace_show_cmdlist
;
45 static struct cmd_list_element
*maint_btrace_pt_set_cmdlist
;
46 static struct cmd_list_element
*maint_btrace_pt_show_cmdlist
;
48 /* Control whether to skip PAD packets when computing the packet history. */
49 static int maint_btrace_pt_skip_pad
= 1;
51 static void btrace_add_pc (struct thread_info
*tp
);
53 /* Print a record debug message. Use do ... while (0) to avoid ambiguities
54 when used in if statements. */
56 #define DEBUG(msg, args...) \
59 if (record_debug != 0) \
60 fprintf_unfiltered (gdb_stdlog, \
61 "[btrace] " msg "\n", ##args); \
65 #define DEBUG_FTRACE(msg, args...) DEBUG ("[ftrace] " msg, ##args)
67 /* Return the function name of a recorded function segment for printing.
68 This function never returns NULL. */
71 ftrace_print_function_name (const struct btrace_function
*bfun
)
73 struct minimal_symbol
*msym
;
80 return SYMBOL_PRINT_NAME (sym
);
83 return MSYMBOL_PRINT_NAME (msym
);
88 /* Return the file name of a recorded function segment for printing.
89 This function never returns NULL. */
92 ftrace_print_filename (const struct btrace_function
*bfun
)
100 filename
= symtab_to_filename_for_display (symbol_symtab (sym
));
102 filename
= "<unknown>";
107 /* Return a string representation of the address of an instruction.
108 This function never returns NULL. */
111 ftrace_print_insn_addr (const struct btrace_insn
*insn
)
116 return core_addr_to_string_nz (insn
->pc
);
119 /* Print an ftrace debug status message. */
122 ftrace_debug (const struct btrace_function
*bfun
, const char *prefix
)
124 const char *fun
, *file
;
125 unsigned int ibegin
, iend
;
128 fun
= ftrace_print_function_name (bfun
);
129 file
= ftrace_print_filename (bfun
);
132 ibegin
= bfun
->insn_offset
;
133 iend
= ibegin
+ VEC_length (btrace_insn_s
, bfun
->insn
);
135 DEBUG_FTRACE ("%s: fun = %s, file = %s, level = %d, insn = [%u; %u)",
136 prefix
, fun
, file
, level
, ibegin
, iend
);
139 /* Return non-zero if BFUN does not match MFUN and FUN,
140 return zero otherwise. */
143 ftrace_function_switched (const struct btrace_function
*bfun
,
144 const struct minimal_symbol
*mfun
,
145 const struct symbol
*fun
)
147 struct minimal_symbol
*msym
;
153 /* If the minimal symbol changed, we certainly switched functions. */
154 if (mfun
!= NULL
&& msym
!= NULL
155 && strcmp (MSYMBOL_LINKAGE_NAME (mfun
), MSYMBOL_LINKAGE_NAME (msym
)) != 0)
158 /* If the symbol changed, we certainly switched functions. */
159 if (fun
!= NULL
&& sym
!= NULL
)
161 const char *bfname
, *fname
;
163 /* Check the function name. */
164 if (strcmp (SYMBOL_LINKAGE_NAME (fun
), SYMBOL_LINKAGE_NAME (sym
)) != 0)
167 /* Check the location of those functions, as well. */
168 bfname
= symtab_to_fullname (symbol_symtab (sym
));
169 fname
= symtab_to_fullname (symbol_symtab (fun
));
170 if (filename_cmp (fname
, bfname
) != 0)
174 /* If we lost symbol information, we switched functions. */
175 if (!(msym
== NULL
&& sym
== NULL
) && mfun
== NULL
&& fun
== NULL
)
178 /* If we gained symbol information, we switched functions. */
179 if (msym
== NULL
&& sym
== NULL
&& !(mfun
== NULL
&& fun
== NULL
))
185 /* Allocate and initialize a new branch trace function segment.
186 PREV is the chronologically preceding function segment.
187 MFUN and FUN are the symbol information we have for this function. */
189 static struct btrace_function
*
190 ftrace_new_function (struct btrace_function
*prev
,
191 struct minimal_symbol
*mfun
,
194 struct btrace_function
*bfun
;
196 bfun
= XCNEW (struct btrace_function
);
200 bfun
->flow
.prev
= prev
;
204 /* Start counting at one. */
206 bfun
->insn_offset
= 1;
210 gdb_assert (prev
->flow
.next
== NULL
);
211 prev
->flow
.next
= bfun
;
213 bfun
->number
= prev
->number
+ 1;
214 bfun
->insn_offset
= (prev
->insn_offset
215 + VEC_length (btrace_insn_s
, prev
->insn
));
216 bfun
->level
= prev
->level
;
222 /* Update the UP field of a function segment. */
225 ftrace_update_caller (struct btrace_function
*bfun
,
226 struct btrace_function
*caller
,
227 enum btrace_function_flag flags
)
229 if (bfun
->up
!= NULL
)
230 ftrace_debug (bfun
, "updating caller");
235 ftrace_debug (bfun
, "set caller");
238 /* Fix up the caller for all segments of a function. */
241 ftrace_fixup_caller (struct btrace_function
*bfun
,
242 struct btrace_function
*caller
,
243 enum btrace_function_flag flags
)
245 struct btrace_function
*prev
, *next
;
247 ftrace_update_caller (bfun
, caller
, flags
);
249 /* Update all function segments belonging to the same function. */
250 for (prev
= bfun
->segment
.prev
; prev
!= NULL
; prev
= prev
->segment
.prev
)
251 ftrace_update_caller (prev
, caller
, flags
);
253 for (next
= bfun
->segment
.next
; next
!= NULL
; next
= next
->segment
.next
)
254 ftrace_update_caller (next
, caller
, flags
);
257 /* Add a new function segment for a call.
258 CALLER is the chronologically preceding function segment.
259 MFUN and FUN are the symbol information we have for this function. */
261 static struct btrace_function
*
262 ftrace_new_call (struct btrace_function
*caller
,
263 struct minimal_symbol
*mfun
,
266 struct btrace_function
*bfun
;
268 bfun
= ftrace_new_function (caller
, mfun
, fun
);
272 ftrace_debug (bfun
, "new call");
277 /* Add a new function segment for a tail 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_tailcall (struct btrace_function
*caller
,
283 struct minimal_symbol
*mfun
,
286 struct btrace_function
*bfun
;
288 bfun
= ftrace_new_function (caller
, mfun
, fun
);
291 bfun
->flags
|= BFUN_UP_LINKS_TO_TAILCALL
;
293 ftrace_debug (bfun
, "new tail call");
298 /* Find the innermost caller in the back trace of BFUN with MFUN/FUN
299 symbol information. */
301 static struct btrace_function
*
302 ftrace_find_caller (struct btrace_function
*bfun
,
303 struct minimal_symbol
*mfun
,
306 for (; bfun
!= NULL
; bfun
= bfun
->up
)
308 /* Skip functions with incompatible symbol information. */
309 if (ftrace_function_switched (bfun
, mfun
, fun
))
312 /* This is the function segment we're looking for. */
319 /* Find the innermost caller in the back trace of BFUN, skipping all
320 function segments that do not end with a call instruction (e.g.
321 tail calls ending with a jump). */
323 static struct btrace_function
*
324 ftrace_find_call (struct btrace_function
*bfun
)
326 for (; bfun
!= NULL
; bfun
= bfun
->up
)
328 struct btrace_insn
*last
;
331 if (bfun
->errcode
!= 0)
334 last
= VEC_last (btrace_insn_s
, bfun
->insn
);
336 if (last
->iclass
== BTRACE_INSN_CALL
)
343 /* Add a continuation segment for a function into which we return.
344 PREV is the chronologically preceding function segment.
345 MFUN and FUN are the symbol information we have for this function. */
347 static struct btrace_function
*
348 ftrace_new_return (struct btrace_function
*prev
,
349 struct minimal_symbol
*mfun
,
352 struct btrace_function
*bfun
, *caller
;
354 bfun
= ftrace_new_function (prev
, mfun
, fun
);
356 /* It is important to start at PREV's caller. Otherwise, we might find
357 PREV itself, if PREV is a recursive function. */
358 caller
= ftrace_find_caller (prev
->up
, mfun
, fun
);
361 /* The caller of PREV is the preceding btrace function segment in this
362 function instance. */
363 gdb_assert (caller
->segment
.next
== NULL
);
365 caller
->segment
.next
= bfun
;
366 bfun
->segment
.prev
= caller
;
368 /* Maintain the function level. */
369 bfun
->level
= caller
->level
;
371 /* Maintain the call stack. */
372 bfun
->up
= caller
->up
;
373 bfun
->flags
= caller
->flags
;
375 ftrace_debug (bfun
, "new return");
379 /* We did not find a caller. This could mean that something went
380 wrong or that the call is simply not included in the trace. */
382 /* Let's search for some actual call. */
383 caller
= ftrace_find_call (prev
->up
);
386 /* There is no call in PREV's back trace. We assume that the
387 branch trace did not include it. */
389 /* Let's find the topmost call function - this skips tail calls. */
390 while (prev
->up
!= NULL
)
393 /* We maintain levels for a series of returns for which we have
395 We start at the preceding function's level in case this has
396 already been a return for which we have not seen the call.
397 We start at level 0 otherwise, to handle tail calls correctly. */
398 bfun
->level
= min (0, prev
->level
) - 1;
400 /* Fix up the call stack for PREV. */
401 ftrace_fixup_caller (prev
, bfun
, BFUN_UP_LINKS_TO_RET
);
403 ftrace_debug (bfun
, "new return - no caller");
407 /* There is a call in PREV's back trace to which we should have
408 returned. Let's remain at this level. */
409 bfun
->level
= prev
->level
;
411 ftrace_debug (bfun
, "new return - unknown caller");
418 /* Add a new function segment for a function switch.
419 PREV is the chronologically preceding function segment.
420 MFUN and FUN are the symbol information we have for this function. */
422 static struct btrace_function
*
423 ftrace_new_switch (struct btrace_function
*prev
,
424 struct minimal_symbol
*mfun
,
427 struct btrace_function
*bfun
;
429 /* This is an unexplained function switch. The call stack will likely
430 be wrong at this point. */
431 bfun
= ftrace_new_function (prev
, mfun
, fun
);
433 ftrace_debug (bfun
, "new switch");
438 /* Add a new function segment for a gap in the trace due to a decode error.
439 PREV is the chronologically preceding function segment.
440 ERRCODE is the format-specific error code. */
442 static struct btrace_function
*
443 ftrace_new_gap (struct btrace_function
*prev
, int errcode
)
445 struct btrace_function
*bfun
;
447 /* We hijack prev if it was empty. */
448 if (prev
!= NULL
&& prev
->errcode
== 0
449 && VEC_empty (btrace_insn_s
, prev
->insn
))
452 bfun
= ftrace_new_function (prev
, NULL
, NULL
);
454 bfun
->errcode
= errcode
;
456 ftrace_debug (bfun
, "new gap");
461 /* Update BFUN with respect to the instruction at PC. This may create new
463 Return the chronologically latest function segment, never NULL. */
465 static struct btrace_function
*
466 ftrace_update_function (struct btrace_function
*bfun
, CORE_ADDR pc
)
468 struct bound_minimal_symbol bmfun
;
469 struct minimal_symbol
*mfun
;
471 struct btrace_insn
*last
;
473 /* Try to determine the function we're in. We use both types of symbols
474 to avoid surprises when we sometimes get a full symbol and sometimes
475 only a minimal symbol. */
476 fun
= find_pc_function (pc
);
477 bmfun
= lookup_minimal_symbol_by_pc (pc
);
480 if (fun
== NULL
&& mfun
== NULL
)
481 DEBUG_FTRACE ("no symbol at %s", core_addr_to_string_nz (pc
));
483 /* If we didn't have a function or if we had a gap before, we create one. */
484 if (bfun
== NULL
|| bfun
->errcode
!= 0)
485 return ftrace_new_function (bfun
, mfun
, fun
);
487 /* Check the last instruction, if we have one.
488 We do this check first, since it allows us to fill in the call stack
489 links in addition to the normal flow links. */
491 if (!VEC_empty (btrace_insn_s
, bfun
->insn
))
492 last
= VEC_last (btrace_insn_s
, bfun
->insn
);
496 switch (last
->iclass
)
498 case BTRACE_INSN_RETURN
:
502 /* On some systems, _dl_runtime_resolve returns to the resolved
503 function instead of jumping to it. From our perspective,
504 however, this is a tailcall.
505 If we treated it as return, we wouldn't be able to find the
506 resolved function in our stack back trace. Hence, we would
507 lose the current stack back trace and start anew with an empty
508 back trace. When the resolved function returns, we would then
509 create a stack back trace with the same function names but
510 different frame id's. This will confuse stepping. */
511 fname
= ftrace_print_function_name (bfun
);
512 if (strcmp (fname
, "_dl_runtime_resolve") == 0)
513 return ftrace_new_tailcall (bfun
, mfun
, fun
);
515 return ftrace_new_return (bfun
, mfun
, fun
);
518 case BTRACE_INSN_CALL
:
519 /* Ignore calls to the next instruction. They are used for PIC. */
520 if (last
->pc
+ last
->size
== pc
)
523 return ftrace_new_call (bfun
, mfun
, fun
);
525 case BTRACE_INSN_JUMP
:
529 start
= get_pc_function_start (pc
);
531 /* If we can't determine the function for PC, we treat a jump at
532 the end of the block as tail call. */
533 if (start
== 0 || start
== pc
)
534 return ftrace_new_tailcall (bfun
, mfun
, fun
);
539 /* Check if we're switching functions for some other reason. */
540 if (ftrace_function_switched (bfun
, mfun
, fun
))
542 DEBUG_FTRACE ("switching from %s in %s at %s",
543 ftrace_print_insn_addr (last
),
544 ftrace_print_function_name (bfun
),
545 ftrace_print_filename (bfun
));
547 return ftrace_new_switch (bfun
, mfun
, fun
);
553 /* Add the instruction at PC to BFUN's instructions. */
556 ftrace_update_insns (struct btrace_function
*bfun
,
557 const struct btrace_insn
*insn
)
559 VEC_safe_push (btrace_insn_s
, bfun
->insn
, insn
);
561 if (record_debug
> 1)
562 ftrace_debug (bfun
, "update insn");
565 /* Classify the instruction at PC. */
567 static enum btrace_insn_class
568 ftrace_classify_insn (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
570 enum btrace_insn_class iclass
;
572 iclass
= BTRACE_INSN_OTHER
;
575 if (gdbarch_insn_is_call (gdbarch
, pc
))
576 iclass
= BTRACE_INSN_CALL
;
577 else if (gdbarch_insn_is_ret (gdbarch
, pc
))
578 iclass
= BTRACE_INSN_RETURN
;
579 else if (gdbarch_insn_is_jump (gdbarch
, pc
))
580 iclass
= BTRACE_INSN_JUMP
;
582 CATCH (error
, RETURN_MASK_ERROR
)
590 /* Compute the function branch trace from BTS trace. */
593 btrace_compute_ftrace_bts (struct thread_info
*tp
,
594 const struct btrace_data_bts
*btrace
)
596 struct btrace_thread_info
*btinfo
;
597 struct btrace_function
*begin
, *end
;
598 struct gdbarch
*gdbarch
;
599 unsigned int blk
, ngaps
;
602 gdbarch
= target_gdbarch ();
603 btinfo
= &tp
->btrace
;
604 begin
= btinfo
->begin
;
606 ngaps
= btinfo
->ngaps
;
607 level
= begin
!= NULL
? -btinfo
->level
: INT_MAX
;
608 blk
= VEC_length (btrace_block_s
, btrace
->blocks
);
612 btrace_block_s
*block
;
617 block
= VEC_index (btrace_block_s
, btrace
->blocks
, blk
);
622 struct btrace_insn insn
;
625 /* We should hit the end of the block. Warn if we went too far. */
628 /* Indicate the gap in the trace - unless we're at the
632 warning (_("Recorded trace may be corrupted around %s."),
633 core_addr_to_string_nz (pc
));
635 end
= ftrace_new_gap (end
, BDE_BTS_OVERFLOW
);
641 end
= ftrace_update_function (end
, pc
);
645 /* Maintain the function level offset.
646 For all but the last block, we do it here. */
648 level
= min (level
, end
->level
);
653 size
= gdb_insn_length (gdbarch
, pc
);
655 CATCH (error
, RETURN_MASK_ERROR
)
662 insn
.iclass
= ftrace_classify_insn (gdbarch
, pc
);
665 ftrace_update_insns (end
, &insn
);
667 /* We're done once we pushed the instruction at the end. */
668 if (block
->end
== pc
)
671 /* We can't continue if we fail to compute the size. */
674 warning (_("Recorded trace may be incomplete around %s."),
675 core_addr_to_string_nz (pc
));
677 /* Indicate the gap in the trace. We just added INSN so we're
678 not at the beginning. */
679 end
= ftrace_new_gap (end
, BDE_BTS_INSN_SIZE
);
687 /* Maintain the function level offset.
688 For the last block, we do it here to not consider the last
690 Since the last instruction corresponds to the current instruction
691 and is not really part of the execution history, it shouldn't
694 level
= min (level
, end
->level
);
698 btinfo
->begin
= begin
;
700 btinfo
->ngaps
= ngaps
;
702 /* LEVEL is the minimal function level of all btrace function segments.
703 Define the global level offset to -LEVEL so all function levels are
704 normalized to start at zero. */
705 btinfo
->level
= -level
;
708 #if defined (HAVE_LIBIPT)
710 static enum btrace_insn_class
711 pt_reclassify_insn (enum pt_insn_class iclass
)
716 return BTRACE_INSN_CALL
;
719 return BTRACE_INSN_RETURN
;
722 return BTRACE_INSN_JUMP
;
725 return BTRACE_INSN_OTHER
;
729 /* Return the btrace instruction flags for INSN. */
731 static enum btrace_insn_flag
732 pt_btrace_insn_flags (const struct pt_insn
*insn
)
734 enum btrace_insn_flag flags
= 0;
736 if (insn
->speculative
)
737 flags
|= BTRACE_INSN_FLAG_SPECULATIVE
;
742 /* Add function branch trace using DECODER. */
745 ftrace_add_pt (struct pt_insn_decoder
*decoder
,
746 struct btrace_function
**pbegin
,
747 struct btrace_function
**pend
, int *plevel
,
750 struct btrace_function
*begin
, *end
, *upd
;
752 int errcode
, nerrors
;
759 struct btrace_insn btinsn
;
762 errcode
= pt_insn_sync_forward (decoder
);
765 if (errcode
!= -pte_eos
)
766 warning (_("Failed to synchronize onto the Intel Processor "
767 "Trace stream: %s."), pt_errstr (pt_errcode (errcode
)));
771 memset (&btinsn
, 0, sizeof (btinsn
));
774 errcode
= pt_insn_next (decoder
, &insn
, sizeof(insn
));
778 /* Look for gaps in the trace - unless we're at the beginning. */
781 /* Tracing is disabled and re-enabled each time we enter the
782 kernel. Most times, we continue from the same instruction we
783 stopped before. This is indicated via the RESUMED instruction
784 flag. The ENABLED instruction flag means that we continued
785 from some other instruction. Indicate this as a trace gap. */
787 *pend
= end
= ftrace_new_gap (end
, BDE_PT_DISABLED
);
789 /* Indicate trace overflows. */
791 *pend
= end
= ftrace_new_gap (end
, BDE_PT_OVERFLOW
);
794 upd
= ftrace_update_function (end
, insn
.ip
);
800 *pbegin
= begin
= upd
;
803 /* Maintain the function level offset. */
804 *plevel
= min (*plevel
, end
->level
);
806 btinsn
.pc
= (CORE_ADDR
) insn
.ip
;
807 btinsn
.size
= (gdb_byte
) insn
.size
;
808 btinsn
.iclass
= pt_reclassify_insn (insn
.iclass
);
809 btinsn
.flags
= pt_btrace_insn_flags (&insn
);
811 ftrace_update_insns (end
, &btinsn
);
814 if (errcode
== -pte_eos
)
817 /* If the gap is at the very beginning, we ignore it - we will have
818 less trace, but we won't have any holes in the trace. */
822 pt_insn_get_offset (decoder
, &offset
);
824 warning (_("Failed to decode Intel Processor Trace near trace "
825 "offset 0x%" PRIx64
" near recorded PC 0x%" PRIx64
": %s."),
826 offset
, insn
.ip
, pt_errstr (pt_errcode (errcode
)));
828 /* Indicate the gap in the trace. */
829 *pend
= end
= ftrace_new_gap (end
, errcode
);
834 warning (_("The recorded execution trace may have gaps."));
837 /* A callback function to allow the trace decoder to read the inferior's
841 btrace_pt_readmem_callback (gdb_byte
*buffer
, size_t size
,
842 const struct pt_asid
*asid
, uint64_t pc
,
850 errcode
= target_read_code ((CORE_ADDR
) pc
, buffer
, size
);
854 CATCH (error
, RETURN_MASK_ERROR
)
863 /* Translate the vendor from one enum to another. */
865 static enum pt_cpu_vendor
866 pt_translate_cpu_vendor (enum btrace_cpu_vendor vendor
)
878 /* Finalize the function branch trace after decode. */
880 static void btrace_finalize_ftrace_pt (struct pt_insn_decoder
*decoder
,
881 struct thread_info
*tp
, int level
)
883 pt_insn_free_decoder (decoder
);
885 /* LEVEL is the minimal function level of all btrace function segments.
886 Define the global level offset to -LEVEL so all function levels are
887 normalized to start at zero. */
888 tp
->btrace
.level
= -level
;
890 /* Add a single last instruction entry for the current PC.
891 This allows us to compute the backtrace at the current PC using both
892 standard unwind and btrace unwind.
893 This extra entry is ignored by all record commands. */
897 /* Compute the function branch trace from Intel Processor Trace
901 btrace_compute_ftrace_pt (struct thread_info
*tp
,
902 const struct btrace_data_pt
*btrace
)
904 struct btrace_thread_info
*btinfo
;
905 struct pt_insn_decoder
*decoder
;
906 struct pt_config config
;
909 if (btrace
->size
== 0)
912 btinfo
= &tp
->btrace
;
913 level
= btinfo
->begin
!= NULL
? -btinfo
->level
: INT_MAX
;
915 pt_config_init(&config
);
916 config
.begin
= btrace
->data
;
917 config
.end
= btrace
->data
+ btrace
->size
;
919 config
.cpu
.vendor
= pt_translate_cpu_vendor (btrace
->config
.cpu
.vendor
);
920 config
.cpu
.family
= btrace
->config
.cpu
.family
;
921 config
.cpu
.model
= btrace
->config
.cpu
.model
;
922 config
.cpu
.stepping
= btrace
->config
.cpu
.stepping
;
924 errcode
= pt_cpu_errata (&config
.errata
, &config
.cpu
);
926 error (_("Failed to configure the Intel Processor Trace decoder: %s."),
927 pt_errstr (pt_errcode (errcode
)));
929 decoder
= pt_insn_alloc_decoder (&config
);
931 error (_("Failed to allocate the Intel Processor Trace decoder."));
935 struct pt_image
*image
;
937 image
= pt_insn_get_image(decoder
);
939 error (_("Failed to configure the Intel Processor Trace decoder."));
941 errcode
= pt_image_set_callback(image
, btrace_pt_readmem_callback
, NULL
);
943 error (_("Failed to configure the Intel Processor Trace decoder: "
944 "%s."), pt_errstr (pt_errcode (errcode
)));
946 ftrace_add_pt (decoder
, &btinfo
->begin
, &btinfo
->end
, &level
,
949 CATCH (error
, RETURN_MASK_ALL
)
951 /* Indicate a gap in the trace if we quit trace processing. */
952 if (error
.reason
== RETURN_QUIT
&& btinfo
->end
!= NULL
)
954 btinfo
->end
= ftrace_new_gap (btinfo
->end
, BDE_PT_USER_QUIT
);
958 btrace_finalize_ftrace_pt (decoder
, tp
, level
);
960 throw_exception (error
);
964 btrace_finalize_ftrace_pt (decoder
, tp
, level
);
967 #else /* defined (HAVE_LIBIPT) */
970 btrace_compute_ftrace_pt (struct thread_info
*tp
,
971 const struct btrace_data_pt
*btrace
)
973 internal_error (__FILE__
, __LINE__
, _("Unexpected branch trace format."));
976 #endif /* defined (HAVE_LIBIPT) */
978 /* Compute the function branch trace from a block branch trace BTRACE for
979 a thread given by BTINFO. */
982 btrace_compute_ftrace (struct thread_info
*tp
, struct btrace_data
*btrace
)
984 DEBUG ("compute ftrace");
986 switch (btrace
->format
)
988 case BTRACE_FORMAT_NONE
:
991 case BTRACE_FORMAT_BTS
:
992 btrace_compute_ftrace_bts (tp
, &btrace
->variant
.bts
);
995 case BTRACE_FORMAT_PT
:
996 btrace_compute_ftrace_pt (tp
, &btrace
->variant
.pt
);
1000 internal_error (__FILE__
, __LINE__
, _("Unkown branch trace format."));
1003 /* Add an entry for the current PC. */
1006 btrace_add_pc (struct thread_info
*tp
)
1008 struct btrace_data btrace
;
1009 struct btrace_block
*block
;
1010 struct regcache
*regcache
;
1011 struct cleanup
*cleanup
;
1014 regcache
= get_thread_regcache (tp
->ptid
);
1015 pc
= regcache_read_pc (regcache
);
1017 btrace_data_init (&btrace
);
1018 btrace
.format
= BTRACE_FORMAT_BTS
;
1019 btrace
.variant
.bts
.blocks
= NULL
;
1021 cleanup
= make_cleanup_btrace_data (&btrace
);
1023 block
= VEC_safe_push (btrace_block_s
, btrace
.variant
.bts
.blocks
, NULL
);
1027 btrace_compute_ftrace (tp
, &btrace
);
1029 do_cleanups (cleanup
);
1035 btrace_enable (struct thread_info
*tp
, const struct btrace_config
*conf
)
1037 if (tp
->btrace
.target
!= NULL
)
1040 #if !defined (HAVE_LIBIPT)
1041 if (conf
->format
== BTRACE_FORMAT_PT
)
1042 error (_("GDB does not support Intel Processor Trace."));
1043 #endif /* !defined (HAVE_LIBIPT) */
1045 if (!target_supports_btrace (conf
->format
))
1046 error (_("Target does not support branch tracing."));
1048 DEBUG ("enable thread %d (%s)", tp
->num
, target_pid_to_str (tp
->ptid
));
1050 tp
->btrace
.target
= target_enable_btrace (tp
->ptid
, conf
);
1052 /* Add an entry for the current PC so we start tracing from where we
1054 if (tp
->btrace
.target
!= NULL
)
1060 const struct btrace_config
*
1061 btrace_conf (const struct btrace_thread_info
*btinfo
)
1063 if (btinfo
->target
== NULL
)
1066 return target_btrace_conf (btinfo
->target
);
1072 btrace_disable (struct thread_info
*tp
)
1074 struct btrace_thread_info
*btp
= &tp
->btrace
;
1077 if (btp
->target
== NULL
)
1080 DEBUG ("disable thread %d (%s)", tp
->num
, target_pid_to_str (tp
->ptid
));
1082 target_disable_btrace (btp
->target
);
1091 btrace_teardown (struct thread_info
*tp
)
1093 struct btrace_thread_info
*btp
= &tp
->btrace
;
1096 if (btp
->target
== NULL
)
1099 DEBUG ("teardown thread %d (%s)", tp
->num
, target_pid_to_str (tp
->ptid
));
1101 target_teardown_btrace (btp
->target
);
1107 /* Stitch branch trace in BTS format. */
1110 btrace_stitch_bts (struct btrace_data_bts
*btrace
, struct thread_info
*tp
)
1112 struct btrace_thread_info
*btinfo
;
1113 struct btrace_function
*last_bfun
;
1114 struct btrace_insn
*last_insn
;
1115 btrace_block_s
*first_new_block
;
1117 btinfo
= &tp
->btrace
;
1118 last_bfun
= btinfo
->end
;
1119 gdb_assert (last_bfun
!= NULL
);
1120 gdb_assert (!VEC_empty (btrace_block_s
, btrace
->blocks
));
1122 /* If the existing trace ends with a gap, we just glue the traces
1123 together. We need to drop the last (i.e. chronologically first) block
1124 of the new trace, though, since we can't fill in the start address.*/
1125 if (VEC_empty (btrace_insn_s
, last_bfun
->insn
))
1127 VEC_pop (btrace_block_s
, btrace
->blocks
);
1131 /* Beware that block trace starts with the most recent block, so the
1132 chronologically first block in the new trace is the last block in
1133 the new trace's block vector. */
1134 first_new_block
= VEC_last (btrace_block_s
, btrace
->blocks
);
1135 last_insn
= VEC_last (btrace_insn_s
, last_bfun
->insn
);
1137 /* If the current PC at the end of the block is the same as in our current
1138 trace, there are two explanations:
1139 1. we executed the instruction and some branch brought us back.
1140 2. we have not made any progress.
1141 In the first case, the delta trace vector should contain at least two
1143 In the second case, the delta trace vector should contain exactly one
1144 entry for the partial block containing the current PC. Remove it. */
1145 if (first_new_block
->end
== last_insn
->pc
1146 && VEC_length (btrace_block_s
, btrace
->blocks
) == 1)
1148 VEC_pop (btrace_block_s
, btrace
->blocks
);
1152 DEBUG ("stitching %s to %s", ftrace_print_insn_addr (last_insn
),
1153 core_addr_to_string_nz (first_new_block
->end
));
1155 /* Do a simple sanity check to make sure we don't accidentally end up
1156 with a bad block. This should not occur in practice. */
1157 if (first_new_block
->end
< last_insn
->pc
)
1159 warning (_("Error while trying to read delta trace. Falling back to "
1164 /* We adjust the last block to start at the end of our current trace. */
1165 gdb_assert (first_new_block
->begin
== 0);
1166 first_new_block
->begin
= last_insn
->pc
;
1168 /* We simply pop the last insn so we can insert it again as part of
1169 the normal branch trace computation.
1170 Since instruction iterators are based on indices in the instructions
1171 vector, we don't leave any pointers dangling. */
1172 DEBUG ("pruning insn at %s for stitching",
1173 ftrace_print_insn_addr (last_insn
));
1175 VEC_pop (btrace_insn_s
, last_bfun
->insn
);
1177 /* The instructions vector may become empty temporarily if this has
1178 been the only instruction in this function segment.
1179 This violates the invariant but will be remedied shortly by
1180 btrace_compute_ftrace when we add the new trace. */
1182 /* The only case where this would hurt is if the entire trace consisted
1183 of just that one instruction. If we remove it, we might turn the now
1184 empty btrace function segment into a gap. But we don't want gaps at
1185 the beginning. To avoid this, we remove the entire old trace. */
1186 if (last_bfun
== btinfo
->begin
&& VEC_empty (btrace_insn_s
, last_bfun
->insn
))
1192 /* Adjust the block trace in order to stitch old and new trace together.
1193 BTRACE is the new delta trace between the last and the current stop.
1194 TP is the traced thread.
1195 May modifx BTRACE as well as the existing trace in TP.
1196 Return 0 on success, -1 otherwise. */
1199 btrace_stitch_trace (struct btrace_data
*btrace
, struct thread_info
*tp
)
1201 /* If we don't have trace, there's nothing to do. */
1202 if (btrace_data_empty (btrace
))
1205 switch (btrace
->format
)
1207 case BTRACE_FORMAT_NONE
:
1210 case BTRACE_FORMAT_BTS
:
1211 return btrace_stitch_bts (&btrace
->variant
.bts
, tp
);
1213 case BTRACE_FORMAT_PT
:
1214 /* Delta reads are not supported. */
1218 internal_error (__FILE__
, __LINE__
, _("Unkown branch trace format."));
1221 /* Clear the branch trace histories in BTINFO. */
1224 btrace_clear_history (struct btrace_thread_info
*btinfo
)
1226 xfree (btinfo
->insn_history
);
1227 xfree (btinfo
->call_history
);
1228 xfree (btinfo
->replay
);
1230 btinfo
->insn_history
= NULL
;
1231 btinfo
->call_history
= NULL
;
1232 btinfo
->replay
= NULL
;
1235 /* Clear the branch trace maintenance histories in BTINFO. */
1238 btrace_maint_clear (struct btrace_thread_info
*btinfo
)
1240 switch (btinfo
->data
.format
)
1245 case BTRACE_FORMAT_BTS
:
1246 btinfo
->maint
.variant
.bts
.packet_history
.begin
= 0;
1247 btinfo
->maint
.variant
.bts
.packet_history
.end
= 0;
1250 #if defined (HAVE_LIBIPT)
1251 case BTRACE_FORMAT_PT
:
1252 xfree (btinfo
->maint
.variant
.pt
.packets
);
1254 btinfo
->maint
.variant
.pt
.packets
= NULL
;
1255 btinfo
->maint
.variant
.pt
.packet_history
.begin
= 0;
1256 btinfo
->maint
.variant
.pt
.packet_history
.end
= 0;
1258 #endif /* defined (HAVE_LIBIPT) */
1265 btrace_fetch (struct thread_info
*tp
)
1267 struct btrace_thread_info
*btinfo
;
1268 struct btrace_target_info
*tinfo
;
1269 struct btrace_data btrace
;
1270 struct cleanup
*cleanup
;
1273 DEBUG ("fetch thread %d (%s)", tp
->num
, target_pid_to_str (tp
->ptid
));
1275 btinfo
= &tp
->btrace
;
1276 tinfo
= btinfo
->target
;
1280 /* There's no way we could get new trace while replaying.
1281 On the other hand, delta trace would return a partial record with the
1282 current PC, which is the replay PC, not the last PC, as expected. */
1283 if (btinfo
->replay
!= NULL
)
1286 btrace_data_init (&btrace
);
1287 cleanup
= make_cleanup_btrace_data (&btrace
);
1289 /* Let's first try to extend the trace we already have. */
1290 if (btinfo
->end
!= NULL
)
1292 errcode
= target_read_btrace (&btrace
, tinfo
, BTRACE_READ_DELTA
);
1295 /* Success. Let's try to stitch the traces together. */
1296 errcode
= btrace_stitch_trace (&btrace
, tp
);
1300 /* We failed to read delta trace. Let's try to read new trace. */
1301 errcode
= target_read_btrace (&btrace
, tinfo
, BTRACE_READ_NEW
);
1303 /* If we got any new trace, discard what we have. */
1304 if (errcode
== 0 && !btrace_data_empty (&btrace
))
1308 /* If we were not able to read the trace, we start over. */
1312 errcode
= target_read_btrace (&btrace
, tinfo
, BTRACE_READ_ALL
);
1316 errcode
= target_read_btrace (&btrace
, tinfo
, BTRACE_READ_ALL
);
1318 /* If we were not able to read the branch trace, signal an error. */
1320 error (_("Failed to read branch trace."));
1322 /* Compute the trace, provided we have any. */
1323 if (!btrace_data_empty (&btrace
))
1325 /* Store the raw trace data. The stored data will be cleared in
1326 btrace_clear, so we always append the new trace. */
1327 btrace_data_append (&btinfo
->data
, &btrace
);
1328 btrace_maint_clear (btinfo
);
1330 btrace_clear_history (btinfo
);
1331 btrace_compute_ftrace (tp
, &btrace
);
1334 do_cleanups (cleanup
);
1340 btrace_clear (struct thread_info
*tp
)
1342 struct btrace_thread_info
*btinfo
;
1343 struct btrace_function
*it
, *trash
;
1345 DEBUG ("clear thread %d (%s)", tp
->num
, target_pid_to_str (tp
->ptid
));
1347 /* Make sure btrace frames that may hold a pointer into the branch
1348 trace data are destroyed. */
1349 reinit_frame_cache ();
1351 btinfo
= &tp
->btrace
;
1362 btinfo
->begin
= NULL
;
1366 /* Must clear the maint data before - it depends on BTINFO->DATA. */
1367 btrace_maint_clear (btinfo
);
1368 btrace_data_clear (&btinfo
->data
);
1369 btrace_clear_history (btinfo
);
1375 btrace_free_objfile (struct objfile
*objfile
)
1377 struct thread_info
*tp
;
1379 DEBUG ("free objfile");
1381 ALL_NON_EXITED_THREADS (tp
)
1385 #if defined (HAVE_LIBEXPAT)
1387 /* Check the btrace document version. */
1390 check_xml_btrace_version (struct gdb_xml_parser
*parser
,
1391 const struct gdb_xml_element
*element
,
1392 void *user_data
, VEC (gdb_xml_value_s
) *attributes
)
1395 = (const char *) xml_find_attribute (attributes
, "version")->value
;
1397 if (strcmp (version
, "1.0") != 0)
1398 gdb_xml_error (parser
, _("Unsupported btrace version: \"%s\""), version
);
1401 /* Parse a btrace "block" xml record. */
1404 parse_xml_btrace_block (struct gdb_xml_parser
*parser
,
1405 const struct gdb_xml_element
*element
,
1406 void *user_data
, VEC (gdb_xml_value_s
) *attributes
)
1408 struct btrace_data
*btrace
;
1409 struct btrace_block
*block
;
1410 ULONGEST
*begin
, *end
;
1412 btrace
= (struct btrace_data
*) user_data
;
1414 switch (btrace
->format
)
1416 case BTRACE_FORMAT_BTS
:
1419 case BTRACE_FORMAT_NONE
:
1420 btrace
->format
= BTRACE_FORMAT_BTS
;
1421 btrace
->variant
.bts
.blocks
= NULL
;
1425 gdb_xml_error (parser
, _("Btrace format error."));
1428 begin
= (ULONGEST
*) xml_find_attribute (attributes
, "begin")->value
;
1429 end
= (ULONGEST
*) xml_find_attribute (attributes
, "end")->value
;
1431 block
= VEC_safe_push (btrace_block_s
, btrace
->variant
.bts
.blocks
, NULL
);
1432 block
->begin
= *begin
;
1436 /* Parse a "raw" xml record. */
1439 parse_xml_raw (struct gdb_xml_parser
*parser
, const char *body_text
,
1440 gdb_byte
**pdata
, size_t *psize
)
1442 struct cleanup
*cleanup
;
1443 gdb_byte
*data
, *bin
;
1446 len
= strlen (body_text
);
1448 gdb_xml_error (parser
, _("Bad raw data size."));
1452 bin
= data
= (gdb_byte
*) xmalloc (size
);
1453 cleanup
= make_cleanup (xfree
, data
);
1455 /* We use hex encoding - see common/rsp-low.h. */
1463 if (hi
== 0 || lo
== 0)
1464 gdb_xml_error (parser
, _("Bad hex encoding."));
1466 *bin
++ = fromhex (hi
) * 16 + fromhex (lo
);
1470 discard_cleanups (cleanup
);
1476 /* Parse a btrace pt-config "cpu" xml record. */
1479 parse_xml_btrace_pt_config_cpu (struct gdb_xml_parser
*parser
,
1480 const struct gdb_xml_element
*element
,
1482 VEC (gdb_xml_value_s
) *attributes
)
1484 struct btrace_data
*btrace
;
1486 ULONGEST
*family
, *model
, *stepping
;
1488 vendor
= (const char *) xml_find_attribute (attributes
, "vendor")->value
;
1489 family
= (ULONGEST
*) xml_find_attribute (attributes
, "family")->value
;
1490 model
= (ULONGEST
*) xml_find_attribute (attributes
, "model")->value
;
1491 stepping
= (ULONGEST
*) xml_find_attribute (attributes
, "stepping")->value
;
1493 btrace
= (struct btrace_data
*) user_data
;
1495 if (strcmp (vendor
, "GenuineIntel") == 0)
1496 btrace
->variant
.pt
.config
.cpu
.vendor
= CV_INTEL
;
1498 btrace
->variant
.pt
.config
.cpu
.family
= *family
;
1499 btrace
->variant
.pt
.config
.cpu
.model
= *model
;
1500 btrace
->variant
.pt
.config
.cpu
.stepping
= *stepping
;
1503 /* Parse a btrace pt "raw" xml record. */
1506 parse_xml_btrace_pt_raw (struct gdb_xml_parser
*parser
,
1507 const struct gdb_xml_element
*element
,
1508 void *user_data
, const char *body_text
)
1510 struct btrace_data
*btrace
;
1512 btrace
= (struct btrace_data
*) user_data
;
1513 parse_xml_raw (parser
, body_text
, &btrace
->variant
.pt
.data
,
1514 &btrace
->variant
.pt
.size
);
1517 /* Parse a btrace "pt" xml record. */
1520 parse_xml_btrace_pt (struct gdb_xml_parser
*parser
,
1521 const struct gdb_xml_element
*element
,
1522 void *user_data
, VEC (gdb_xml_value_s
) *attributes
)
1524 struct btrace_data
*btrace
;
1526 btrace
= (struct btrace_data
*) user_data
;
1527 btrace
->format
= BTRACE_FORMAT_PT
;
1528 btrace
->variant
.pt
.config
.cpu
.vendor
= CV_UNKNOWN
;
1529 btrace
->variant
.pt
.data
= NULL
;
1530 btrace
->variant
.pt
.size
= 0;
1533 static const struct gdb_xml_attribute block_attributes
[] = {
1534 { "begin", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
1535 { "end", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
1536 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
1539 static const struct gdb_xml_attribute btrace_pt_config_cpu_attributes
[] = {
1540 { "vendor", GDB_XML_AF_NONE
, NULL
, NULL
},
1541 { "family", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
1542 { "model", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
1543 { "stepping", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
1544 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
1547 static const struct gdb_xml_element btrace_pt_config_children
[] = {
1548 { "cpu", btrace_pt_config_cpu_attributes
, NULL
, GDB_XML_EF_OPTIONAL
,
1549 parse_xml_btrace_pt_config_cpu
, NULL
},
1550 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
1553 static const struct gdb_xml_element btrace_pt_children
[] = {
1554 { "pt-config", NULL
, btrace_pt_config_children
, GDB_XML_EF_OPTIONAL
, NULL
,
1556 { "raw", NULL
, NULL
, GDB_XML_EF_OPTIONAL
, NULL
, parse_xml_btrace_pt_raw
},
1557 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
1560 static const struct gdb_xml_attribute btrace_attributes
[] = {
1561 { "version", GDB_XML_AF_NONE
, NULL
, NULL
},
1562 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
1565 static const struct gdb_xml_element btrace_children
[] = {
1566 { "block", block_attributes
, NULL
,
1567 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
, parse_xml_btrace_block
, NULL
},
1568 { "pt", NULL
, btrace_pt_children
, GDB_XML_EF_OPTIONAL
, parse_xml_btrace_pt
,
1570 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
1573 static const struct gdb_xml_element btrace_elements
[] = {
1574 { "btrace", btrace_attributes
, btrace_children
, GDB_XML_EF_NONE
,
1575 check_xml_btrace_version
, NULL
},
1576 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
1579 #endif /* defined (HAVE_LIBEXPAT) */
1584 parse_xml_btrace (struct btrace_data
*btrace
, const char *buffer
)
1586 struct cleanup
*cleanup
;
1589 #if defined (HAVE_LIBEXPAT)
1591 btrace
->format
= BTRACE_FORMAT_NONE
;
1593 cleanup
= make_cleanup_btrace_data (btrace
);
1594 errcode
= gdb_xml_parse_quick (_("btrace"), "btrace.dtd", btrace_elements
,
1597 error (_("Error parsing branch trace."));
1599 /* Keep parse results. */
1600 discard_cleanups (cleanup
);
1602 #else /* !defined (HAVE_LIBEXPAT) */
1604 error (_("Cannot process branch trace. XML parsing is not supported."));
1606 #endif /* !defined (HAVE_LIBEXPAT) */
1609 #if defined (HAVE_LIBEXPAT)
1611 /* Parse a btrace-conf "bts" xml record. */
1614 parse_xml_btrace_conf_bts (struct gdb_xml_parser
*parser
,
1615 const struct gdb_xml_element
*element
,
1616 void *user_data
, VEC (gdb_xml_value_s
) *attributes
)
1618 struct btrace_config
*conf
;
1619 struct gdb_xml_value
*size
;
1621 conf
= (struct btrace_config
*) user_data
;
1622 conf
->format
= BTRACE_FORMAT_BTS
;
1625 size
= xml_find_attribute (attributes
, "size");
1627 conf
->bts
.size
= (unsigned int) *(ULONGEST
*) size
->value
;
1630 /* Parse a btrace-conf "pt" xml record. */
1633 parse_xml_btrace_conf_pt (struct gdb_xml_parser
*parser
,
1634 const struct gdb_xml_element
*element
,
1635 void *user_data
, VEC (gdb_xml_value_s
) *attributes
)
1637 struct btrace_config
*conf
;
1638 struct gdb_xml_value
*size
;
1640 conf
= (struct btrace_config
*) user_data
;
1641 conf
->format
= BTRACE_FORMAT_PT
;
1644 size
= xml_find_attribute (attributes
, "size");
1646 conf
->pt
.size
= (unsigned int) *(ULONGEST
*) size
->value
;
1649 static const struct gdb_xml_attribute btrace_conf_pt_attributes
[] = {
1650 { "size", GDB_XML_AF_OPTIONAL
, gdb_xml_parse_attr_ulongest
, NULL
},
1651 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
1654 static const struct gdb_xml_attribute btrace_conf_bts_attributes
[] = {
1655 { "size", GDB_XML_AF_OPTIONAL
, gdb_xml_parse_attr_ulongest
, NULL
},
1656 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
1659 static const struct gdb_xml_element btrace_conf_children
[] = {
1660 { "bts", btrace_conf_bts_attributes
, NULL
, GDB_XML_EF_OPTIONAL
,
1661 parse_xml_btrace_conf_bts
, NULL
},
1662 { "pt", btrace_conf_pt_attributes
, NULL
, GDB_XML_EF_OPTIONAL
,
1663 parse_xml_btrace_conf_pt
, NULL
},
1664 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
1667 static const struct gdb_xml_attribute btrace_conf_attributes
[] = {
1668 { "version", GDB_XML_AF_NONE
, NULL
, NULL
},
1669 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
1672 static const struct gdb_xml_element btrace_conf_elements
[] = {
1673 { "btrace-conf", btrace_conf_attributes
, btrace_conf_children
,
1674 GDB_XML_EF_NONE
, NULL
, NULL
},
1675 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
1678 #endif /* defined (HAVE_LIBEXPAT) */
1683 parse_xml_btrace_conf (struct btrace_config
*conf
, const char *xml
)
1687 #if defined (HAVE_LIBEXPAT)
1689 errcode
= gdb_xml_parse_quick (_("btrace-conf"), "btrace-conf.dtd",
1690 btrace_conf_elements
, xml
, conf
);
1692 error (_("Error parsing branch trace configuration."));
1694 #else /* !defined (HAVE_LIBEXPAT) */
1696 error (_("XML parsing is not supported."));
1698 #endif /* !defined (HAVE_LIBEXPAT) */
1703 const struct btrace_insn
*
1704 btrace_insn_get (const struct btrace_insn_iterator
*it
)
1706 const struct btrace_function
*bfun
;
1707 unsigned int index
, end
;
1710 bfun
= it
->function
;
1712 /* Check if the iterator points to a gap in the trace. */
1713 if (bfun
->errcode
!= 0)
1716 /* The index is within the bounds of this function's instruction vector. */
1717 end
= VEC_length (btrace_insn_s
, bfun
->insn
);
1718 gdb_assert (0 < end
);
1719 gdb_assert (index
< end
);
1721 return VEC_index (btrace_insn_s
, bfun
->insn
, index
);
1727 btrace_insn_number (const struct btrace_insn_iterator
*it
)
1729 const struct btrace_function
*bfun
;
1731 bfun
= it
->function
;
1733 /* Return zero if the iterator points to a gap in the trace. */
1734 if (bfun
->errcode
!= 0)
1737 return bfun
->insn_offset
+ it
->index
;
1743 btrace_insn_begin (struct btrace_insn_iterator
*it
,
1744 const struct btrace_thread_info
*btinfo
)
1746 const struct btrace_function
*bfun
;
1748 bfun
= btinfo
->begin
;
1750 error (_("No trace."));
1752 it
->function
= bfun
;
1759 btrace_insn_end (struct btrace_insn_iterator
*it
,
1760 const struct btrace_thread_info
*btinfo
)
1762 const struct btrace_function
*bfun
;
1763 unsigned int length
;
1767 error (_("No trace."));
1769 length
= VEC_length (btrace_insn_s
, bfun
->insn
);
1771 /* The last function may either be a gap or it contains the current
1772 instruction, which is one past the end of the execution trace; ignore
1777 it
->function
= bfun
;
1784 btrace_insn_next (struct btrace_insn_iterator
*it
, unsigned int stride
)
1786 const struct btrace_function
*bfun
;
1787 unsigned int index
, steps
;
1789 bfun
= it
->function
;
1795 unsigned int end
, space
, adv
;
1797 end
= VEC_length (btrace_insn_s
, bfun
->insn
);
1799 /* An empty function segment represents a gap in the trace. We count
1800 it as one instruction. */
1803 const struct btrace_function
*next
;
1805 next
= bfun
->flow
.next
;
1818 gdb_assert (0 < end
);
1819 gdb_assert (index
< end
);
1821 /* Compute the number of instructions remaining in this segment. */
1822 space
= end
- index
;
1824 /* Advance the iterator as far as possible within this segment. */
1825 adv
= min (space
, stride
);
1830 /* Move to the next function if we're at the end of this one. */
1833 const struct btrace_function
*next
;
1835 next
= bfun
->flow
.next
;
1838 /* We stepped past the last function.
1840 Let's adjust the index to point to the last instruction in
1841 the previous function. */
1847 /* We now point to the first instruction in the new function. */
1852 /* We did make progress. */
1853 gdb_assert (adv
> 0);
1856 /* Update the iterator. */
1857 it
->function
= bfun
;
1866 btrace_insn_prev (struct btrace_insn_iterator
*it
, unsigned int stride
)
1868 const struct btrace_function
*bfun
;
1869 unsigned int index
, steps
;
1871 bfun
= it
->function
;
1879 /* Move to the previous function if we're at the start of this one. */
1882 const struct btrace_function
*prev
;
1884 prev
= bfun
->flow
.prev
;
1888 /* We point to one after the last instruction in the new function. */
1890 index
= VEC_length (btrace_insn_s
, bfun
->insn
);
1892 /* An empty function segment represents a gap in the trace. We count
1893 it as one instruction. */
1903 /* Advance the iterator as far as possible within this segment. */
1904 adv
= min (index
, stride
);
1910 /* We did make progress. */
1911 gdb_assert (adv
> 0);
1914 /* Update the iterator. */
1915 it
->function
= bfun
;
1924 btrace_insn_cmp (const struct btrace_insn_iterator
*lhs
,
1925 const struct btrace_insn_iterator
*rhs
)
1927 unsigned int lnum
, rnum
;
1929 lnum
= btrace_insn_number (lhs
);
1930 rnum
= btrace_insn_number (rhs
);
1932 /* A gap has an instruction number of zero. Things are getting more
1933 complicated if gaps are involved.
1935 We take the instruction number offset from the iterator's function.
1936 This is the number of the first instruction after the gap.
1938 This is OK as long as both lhs and rhs point to gaps. If only one of
1939 them does, we need to adjust the number based on the other's regular
1940 instruction number. Otherwise, a gap might compare equal to an
1943 if (lnum
== 0 && rnum
== 0)
1945 lnum
= lhs
->function
->insn_offset
;
1946 rnum
= rhs
->function
->insn_offset
;
1950 lnum
= lhs
->function
->insn_offset
;
1957 rnum
= rhs
->function
->insn_offset
;
1963 return (int) (lnum
- rnum
);
1969 btrace_find_insn_by_number (struct btrace_insn_iterator
*it
,
1970 const struct btrace_thread_info
*btinfo
,
1971 unsigned int number
)
1973 const struct btrace_function
*bfun
;
1974 unsigned int end
, length
;
1976 for (bfun
= btinfo
->end
; bfun
!= NULL
; bfun
= bfun
->flow
.prev
)
1979 if (bfun
->errcode
!= 0)
1982 if (bfun
->insn_offset
<= number
)
1989 length
= VEC_length (btrace_insn_s
, bfun
->insn
);
1990 gdb_assert (length
> 0);
1992 end
= bfun
->insn_offset
+ length
;
1996 it
->function
= bfun
;
1997 it
->index
= number
- bfun
->insn_offset
;
2004 const struct btrace_function
*
2005 btrace_call_get (const struct btrace_call_iterator
*it
)
2007 return it
->function
;
2013 btrace_call_number (const struct btrace_call_iterator
*it
)
2015 const struct btrace_thread_info
*btinfo
;
2016 const struct btrace_function
*bfun
;
2019 btinfo
= it
->btinfo
;
2020 bfun
= it
->function
;
2022 return bfun
->number
;
2024 /* For the end iterator, i.e. bfun == NULL, we return one more than the
2025 number of the last function. */
2027 insns
= VEC_length (btrace_insn_s
, bfun
->insn
);
2029 /* If the function contains only a single instruction (i.e. the current
2030 instruction), it will be skipped and its number is already the number
2033 return bfun
->number
;
2035 /* Otherwise, return one more than the number of the last function. */
2036 return bfun
->number
+ 1;
2042 btrace_call_begin (struct btrace_call_iterator
*it
,
2043 const struct btrace_thread_info
*btinfo
)
2045 const struct btrace_function
*bfun
;
2047 bfun
= btinfo
->begin
;
2049 error (_("No trace."));
2051 it
->btinfo
= btinfo
;
2052 it
->function
= bfun
;
2058 btrace_call_end (struct btrace_call_iterator
*it
,
2059 const struct btrace_thread_info
*btinfo
)
2061 const struct btrace_function
*bfun
;
2065 error (_("No trace."));
2067 it
->btinfo
= btinfo
;
2068 it
->function
= NULL
;
2074 btrace_call_next (struct btrace_call_iterator
*it
, unsigned int stride
)
2076 const struct btrace_function
*bfun
;
2079 bfun
= it
->function
;
2081 while (bfun
!= NULL
)
2083 const struct btrace_function
*next
;
2086 next
= bfun
->flow
.next
;
2089 /* Ignore the last function if it only contains a single
2090 (i.e. the current) instruction. */
2091 insns
= VEC_length (btrace_insn_s
, bfun
->insn
);
2096 if (stride
== steps
)
2103 it
->function
= bfun
;
2110 btrace_call_prev (struct btrace_call_iterator
*it
, unsigned int stride
)
2112 const struct btrace_thread_info
*btinfo
;
2113 const struct btrace_function
*bfun
;
2116 bfun
= it
->function
;
2123 btinfo
= it
->btinfo
;
2128 /* Ignore the last function if it only contains a single
2129 (i.e. the current) instruction. */
2130 insns
= VEC_length (btrace_insn_s
, bfun
->insn
);
2132 bfun
= bfun
->flow
.prev
;
2140 while (steps
< stride
)
2142 const struct btrace_function
*prev
;
2144 prev
= bfun
->flow
.prev
;
2152 it
->function
= bfun
;
2159 btrace_call_cmp (const struct btrace_call_iterator
*lhs
,
2160 const struct btrace_call_iterator
*rhs
)
2162 unsigned int lnum
, rnum
;
2164 lnum
= btrace_call_number (lhs
);
2165 rnum
= btrace_call_number (rhs
);
2167 return (int) (lnum
- rnum
);
2173 btrace_find_call_by_number (struct btrace_call_iterator
*it
,
2174 const struct btrace_thread_info
*btinfo
,
2175 unsigned int number
)
2177 const struct btrace_function
*bfun
;
2179 for (bfun
= btinfo
->end
; bfun
!= NULL
; bfun
= bfun
->flow
.prev
)
2183 bnum
= bfun
->number
;
2186 it
->btinfo
= btinfo
;
2187 it
->function
= bfun
;
2191 /* Functions are ordered and numbered consecutively. We could bail out
2192 earlier. On the other hand, it is very unlikely that we search for
2193 a nonexistent function. */
2202 btrace_set_insn_history (struct btrace_thread_info
*btinfo
,
2203 const struct btrace_insn_iterator
*begin
,
2204 const struct btrace_insn_iterator
*end
)
2206 if (btinfo
->insn_history
== NULL
)
2207 btinfo
->insn_history
= XCNEW (struct btrace_insn_history
);
2209 btinfo
->insn_history
->begin
= *begin
;
2210 btinfo
->insn_history
->end
= *end
;
2216 btrace_set_call_history (struct btrace_thread_info
*btinfo
,
2217 const struct btrace_call_iterator
*begin
,
2218 const struct btrace_call_iterator
*end
)
2220 gdb_assert (begin
->btinfo
== end
->btinfo
);
2222 if (btinfo
->call_history
== NULL
)
2223 btinfo
->call_history
= XCNEW (struct btrace_call_history
);
2225 btinfo
->call_history
->begin
= *begin
;
2226 btinfo
->call_history
->end
= *end
;
2232 btrace_is_replaying (struct thread_info
*tp
)
2234 return tp
->btrace
.replay
!= NULL
;
2240 btrace_is_empty (struct thread_info
*tp
)
2242 struct btrace_insn_iterator begin
, end
;
2243 struct btrace_thread_info
*btinfo
;
2245 btinfo
= &tp
->btrace
;
2247 if (btinfo
->begin
== NULL
)
2250 btrace_insn_begin (&begin
, btinfo
);
2251 btrace_insn_end (&end
, btinfo
);
2253 return btrace_insn_cmp (&begin
, &end
) == 0;
2256 /* Forward the cleanup request. */
2259 do_btrace_data_cleanup (void *arg
)
2261 btrace_data_fini ((struct btrace_data
*) arg
);
2267 make_cleanup_btrace_data (struct btrace_data
*data
)
2269 return make_cleanup (do_btrace_data_cleanup
, data
);
2272 #if defined (HAVE_LIBIPT)
2274 /* Print a single packet. */
2277 pt_print_packet (const struct pt_packet
*packet
)
2279 switch (packet
->type
)
2282 printf_unfiltered (("[??: %x]"), packet
->type
);
2286 printf_unfiltered (("psb"));
2290 printf_unfiltered (("psbend"));
2294 printf_unfiltered (("pad"));
2298 printf_unfiltered (("tip %u: 0x%" PRIx64
""),
2299 packet
->payload
.ip
.ipc
,
2300 packet
->payload
.ip
.ip
);
2304 printf_unfiltered (("tip.pge %u: 0x%" PRIx64
""),
2305 packet
->payload
.ip
.ipc
,
2306 packet
->payload
.ip
.ip
);
2310 printf_unfiltered (("tip.pgd %u: 0x%" PRIx64
""),
2311 packet
->payload
.ip
.ipc
,
2312 packet
->payload
.ip
.ip
);
2316 printf_unfiltered (("fup %u: 0x%" PRIx64
""),
2317 packet
->payload
.ip
.ipc
,
2318 packet
->payload
.ip
.ip
);
2322 printf_unfiltered (("tnt-8 %u: 0x%" PRIx64
""),
2323 packet
->payload
.tnt
.bit_size
,
2324 packet
->payload
.tnt
.payload
);
2328 printf_unfiltered (("tnt-64 %u: 0x%" PRIx64
""),
2329 packet
->payload
.tnt
.bit_size
,
2330 packet
->payload
.tnt
.payload
);
2334 printf_unfiltered (("pip %" PRIx64
"%s"), packet
->payload
.pip
.cr3
,
2335 packet
->payload
.pip
.nr
? (" nr") : (""));
2339 printf_unfiltered (("tsc %" PRIx64
""), packet
->payload
.tsc
.tsc
);
2343 printf_unfiltered (("cbr %u"), packet
->payload
.cbr
.ratio
);
2347 switch (packet
->payload
.mode
.leaf
)
2350 printf_unfiltered (("mode %u"), packet
->payload
.mode
.leaf
);
2354 printf_unfiltered (("mode.exec%s%s"),
2355 packet
->payload
.mode
.bits
.exec
.csl
2357 packet
->payload
.mode
.bits
.exec
.csd
2358 ? (" cs.d") : (""));
2362 printf_unfiltered (("mode.tsx%s%s"),
2363 packet
->payload
.mode
.bits
.tsx
.intx
2365 packet
->payload
.mode
.bits
.tsx
.abrt
2366 ? (" abrt") : (""));
2372 printf_unfiltered (("ovf"));
2376 printf_unfiltered (("stop"));
2380 printf_unfiltered (("vmcs %" PRIx64
""), packet
->payload
.vmcs
.base
);
2384 printf_unfiltered (("tma %x %x"), packet
->payload
.tma
.ctc
,
2385 packet
->payload
.tma
.fc
);
2389 printf_unfiltered (("mtc %x"), packet
->payload
.mtc
.ctc
);
2393 printf_unfiltered (("cyc %" PRIx64
""), packet
->payload
.cyc
.value
);
2397 printf_unfiltered (("mnt %" PRIx64
""), packet
->payload
.mnt
.payload
);
2402 /* Decode packets into MAINT using DECODER. */
2405 btrace_maint_decode_pt (struct btrace_maint_info
*maint
,
2406 struct pt_packet_decoder
*decoder
)
2412 struct btrace_pt_packet packet
;
2414 errcode
= pt_pkt_sync_forward (decoder
);
2420 pt_pkt_get_offset (decoder
, &packet
.offset
);
2422 errcode
= pt_pkt_next (decoder
, &packet
.packet
,
2423 sizeof(packet
.packet
));
2427 if (maint_btrace_pt_skip_pad
== 0 || packet
.packet
.type
!= ppt_pad
)
2429 packet
.errcode
= pt_errcode (errcode
);
2430 VEC_safe_push (btrace_pt_packet_s
, maint
->variant
.pt
.packets
,
2435 if (errcode
== -pte_eos
)
2438 packet
.errcode
= pt_errcode (errcode
);
2439 VEC_safe_push (btrace_pt_packet_s
, maint
->variant
.pt
.packets
,
2442 warning (_("Error at trace offset 0x%" PRIx64
": %s."),
2443 packet
.offset
, pt_errstr (packet
.errcode
));
2446 if (errcode
!= -pte_eos
)
2447 warning (_("Failed to synchronize onto the Intel Processor Trace "
2448 "stream: %s."), pt_errstr (pt_errcode (errcode
)));
2451 /* Update the packet history in BTINFO. */
2454 btrace_maint_update_pt_packets (struct btrace_thread_info
*btinfo
)
2456 volatile struct gdb_exception except
;
2457 struct pt_packet_decoder
*decoder
;
2458 struct btrace_data_pt
*pt
;
2459 struct pt_config config
;
2462 pt
= &btinfo
->data
.variant
.pt
;
2464 /* Nothing to do if there is no trace. */
2468 memset (&config
, 0, sizeof(config
));
2470 config
.size
= sizeof (config
);
2471 config
.begin
= pt
->data
;
2472 config
.end
= pt
->data
+ pt
->size
;
2474 config
.cpu
.vendor
= pt_translate_cpu_vendor (pt
->config
.cpu
.vendor
);
2475 config
.cpu
.family
= pt
->config
.cpu
.family
;
2476 config
.cpu
.model
= pt
->config
.cpu
.model
;
2477 config
.cpu
.stepping
= pt
->config
.cpu
.stepping
;
2479 errcode
= pt_cpu_errata (&config
.errata
, &config
.cpu
);
2481 error (_("Failed to configure the Intel Processor Trace decoder: %s."),
2482 pt_errstr (pt_errcode (errcode
)));
2484 decoder
= pt_pkt_alloc_decoder (&config
);
2485 if (decoder
== NULL
)
2486 error (_("Failed to allocate the Intel Processor Trace decoder."));
2490 btrace_maint_decode_pt (&btinfo
->maint
, decoder
);
2492 CATCH (except
, RETURN_MASK_ALL
)
2494 pt_pkt_free_decoder (decoder
);
2496 if (except
.reason
< 0)
2497 throw_exception (except
);
2501 pt_pkt_free_decoder (decoder
);
2504 #endif /* !defined (HAVE_LIBIPT) */
2506 /* Update the packet maintenance information for BTINFO and store the
2507 low and high bounds into BEGIN and END, respectively.
2508 Store the current iterator state into FROM and TO. */
2511 btrace_maint_update_packets (struct btrace_thread_info
*btinfo
,
2512 unsigned int *begin
, unsigned int *end
,
2513 unsigned int *from
, unsigned int *to
)
2515 switch (btinfo
->data
.format
)
2524 case BTRACE_FORMAT_BTS
:
2525 /* Nothing to do - we operate directly on BTINFO->DATA. */
2527 *end
= VEC_length (btrace_block_s
, btinfo
->data
.variant
.bts
.blocks
);
2528 *from
= btinfo
->maint
.variant
.bts
.packet_history
.begin
;
2529 *to
= btinfo
->maint
.variant
.bts
.packet_history
.end
;
2532 #if defined (HAVE_LIBIPT)
2533 case BTRACE_FORMAT_PT
:
2534 if (VEC_empty (btrace_pt_packet_s
, btinfo
->maint
.variant
.pt
.packets
))
2535 btrace_maint_update_pt_packets (btinfo
);
2538 *end
= VEC_length (btrace_pt_packet_s
, btinfo
->maint
.variant
.pt
.packets
);
2539 *from
= btinfo
->maint
.variant
.pt
.packet_history
.begin
;
2540 *to
= btinfo
->maint
.variant
.pt
.packet_history
.end
;
2542 #endif /* defined (HAVE_LIBIPT) */
2546 /* Print packets in BTINFO from BEGIN (inclusive) until END (exclusive) and
2547 update the current iterator position. */
2550 btrace_maint_print_packets (struct btrace_thread_info
*btinfo
,
2551 unsigned int begin
, unsigned int end
)
2553 switch (btinfo
->data
.format
)
2558 case BTRACE_FORMAT_BTS
:
2560 VEC (btrace_block_s
) *blocks
;
2563 blocks
= btinfo
->data
.variant
.bts
.blocks
;
2564 for (blk
= begin
; blk
< end
; ++blk
)
2566 const btrace_block_s
*block
;
2568 block
= VEC_index (btrace_block_s
, blocks
, blk
);
2570 printf_unfiltered ("%u\tbegin: %s, end: %s\n", blk
,
2571 core_addr_to_string_nz (block
->begin
),
2572 core_addr_to_string_nz (block
->end
));
2575 btinfo
->maint
.variant
.bts
.packet_history
.begin
= begin
;
2576 btinfo
->maint
.variant
.bts
.packet_history
.end
= end
;
2580 #if defined (HAVE_LIBIPT)
2581 case BTRACE_FORMAT_PT
:
2583 VEC (btrace_pt_packet_s
) *packets
;
2586 packets
= btinfo
->maint
.variant
.pt
.packets
;
2587 for (pkt
= begin
; pkt
< end
; ++pkt
)
2589 const struct btrace_pt_packet
*packet
;
2591 packet
= VEC_index (btrace_pt_packet_s
, packets
, pkt
);
2593 printf_unfiltered ("%u\t", pkt
);
2594 printf_unfiltered ("0x%" PRIx64
"\t", packet
->offset
);
2596 if (packet
->errcode
== pte_ok
)
2597 pt_print_packet (&packet
->packet
);
2599 printf_unfiltered ("[error: %s]", pt_errstr (packet
->errcode
));
2601 printf_unfiltered ("\n");
2604 btinfo
->maint
.variant
.pt
.packet_history
.begin
= begin
;
2605 btinfo
->maint
.variant
.pt
.packet_history
.end
= end
;
2608 #endif /* defined (HAVE_LIBIPT) */
2612 /* Read a number from an argument string. */
2615 get_uint (char **arg
)
2617 char *begin
, *end
, *pos
;
2618 unsigned long number
;
2621 pos
= skip_spaces (begin
);
2623 if (!isdigit (*pos
))
2624 error (_("Expected positive number, got: %s."), pos
);
2626 number
= strtoul (pos
, &end
, 10);
2627 if (number
> UINT_MAX
)
2628 error (_("Number too big."));
2630 *arg
+= (end
- begin
);
2632 return (unsigned int) number
;
2635 /* Read a context size from an argument string. */
2638 get_context_size (char **arg
)
2643 pos
= skip_spaces (*arg
);
2645 if (!isdigit (*pos
))
2646 error (_("Expected positive number, got: %s."), pos
);
2648 return strtol (pos
, arg
, 10);
2651 /* Complain about junk at the end of an argument string. */
2654 no_chunk (char *arg
)
2657 error (_("Junk after argument: %s."), arg
);
2660 /* The "maintenance btrace packet-history" command. */
2663 maint_btrace_packet_history_cmd (char *arg
, int from_tty
)
2665 struct btrace_thread_info
*btinfo
;
2666 struct thread_info
*tp
;
2667 unsigned int size
, begin
, end
, from
, to
;
2669 tp
= find_thread_ptid (inferior_ptid
);
2671 error (_("No thread."));
2674 btinfo
= &tp
->btrace
;
2676 btrace_maint_update_packets (btinfo
, &begin
, &end
, &from
, &to
);
2679 printf_unfiltered (_("No trace.\n"));
2683 if (arg
== NULL
|| *arg
== 0 || strcmp (arg
, "+") == 0)
2687 if (end
- from
< size
)
2691 else if (strcmp (arg
, "-") == 0)
2695 if (to
- begin
< size
)
2701 from
= get_uint (&arg
);
2703 error (_("'%u' is out of range."), from
);
2705 arg
= skip_spaces (arg
);
2708 arg
= skip_spaces (++arg
);
2713 size
= get_context_size (&arg
);
2717 if (end
- from
< size
)
2721 else if (*arg
== '-')
2724 size
= get_context_size (&arg
);
2728 /* Include the packet given as first argument. */
2732 if (to
- begin
< size
)
2738 to
= get_uint (&arg
);
2740 /* Include the packet at the second argument and silently
2741 truncate the range. */
2754 if (end
- from
< size
)
2762 btrace_maint_print_packets (btinfo
, from
, to
);
2765 /* The "maintenance btrace clear-packet-history" command. */
2768 maint_btrace_clear_packet_history_cmd (char *args
, int from_tty
)
2770 struct btrace_thread_info
*btinfo
;
2771 struct thread_info
*tp
;
2773 if (args
!= NULL
&& *args
!= 0)
2774 error (_("Invalid argument."));
2776 tp
= find_thread_ptid (inferior_ptid
);
2778 error (_("No thread."));
2780 btinfo
= &tp
->btrace
;
2782 /* Must clear the maint data before - it depends on BTINFO->DATA. */
2783 btrace_maint_clear (btinfo
);
2784 btrace_data_clear (&btinfo
->data
);
2787 /* The "maintenance btrace clear" command. */
2790 maint_btrace_clear_cmd (char *args
, int from_tty
)
2792 struct btrace_thread_info
*btinfo
;
2793 struct thread_info
*tp
;
2795 if (args
!= NULL
&& *args
!= 0)
2796 error (_("Invalid argument."));
2798 tp
= find_thread_ptid (inferior_ptid
);
2800 error (_("No thread."));
2805 /* The "maintenance btrace" command. */
2808 maint_btrace_cmd (char *args
, int from_tty
)
2810 help_list (maint_btrace_cmdlist
, "maintenance btrace ", all_commands
,
2814 /* The "maintenance set btrace" command. */
2817 maint_btrace_set_cmd (char *args
, int from_tty
)
2819 help_list (maint_btrace_set_cmdlist
, "maintenance set btrace ", all_commands
,
2823 /* The "maintenance show btrace" command. */
2826 maint_btrace_show_cmd (char *args
, int from_tty
)
2828 help_list (maint_btrace_show_cmdlist
, "maintenance show btrace ",
2829 all_commands
, gdb_stdout
);
2832 /* The "maintenance set btrace pt" command. */
2835 maint_btrace_pt_set_cmd (char *args
, int from_tty
)
2837 help_list (maint_btrace_pt_set_cmdlist
, "maintenance set btrace pt ",
2838 all_commands
, gdb_stdout
);
2841 /* The "maintenance show btrace pt" command. */
2844 maint_btrace_pt_show_cmd (char *args
, int from_tty
)
2846 help_list (maint_btrace_pt_show_cmdlist
, "maintenance show btrace pt ",
2847 all_commands
, gdb_stdout
);
2850 /* The "maintenance info btrace" command. */
2853 maint_info_btrace_cmd (char *args
, int from_tty
)
2855 struct btrace_thread_info
*btinfo
;
2856 struct thread_info
*tp
;
2857 const struct btrace_config
*conf
;
2859 if (args
!= NULL
&& *args
!= 0)
2860 error (_("Invalid argument."));
2862 tp
= find_thread_ptid (inferior_ptid
);
2864 error (_("No thread."));
2866 btinfo
= &tp
->btrace
;
2868 conf
= btrace_conf (btinfo
);
2870 error (_("No btrace configuration."));
2872 printf_unfiltered (_("Format: %s.\n"),
2873 btrace_format_string (conf
->format
));
2875 switch (conf
->format
)
2880 case BTRACE_FORMAT_BTS
:
2881 printf_unfiltered (_("Number of packets: %u.\n"),
2882 VEC_length (btrace_block_s
,
2883 btinfo
->data
.variant
.bts
.blocks
));
2886 #if defined (HAVE_LIBIPT)
2887 case BTRACE_FORMAT_PT
:
2889 struct pt_version version
;
2891 version
= pt_library_version ();
2892 printf_unfiltered (_("Version: %u.%u.%u%s.\n"), version
.major
,
2893 version
.minor
, version
.build
,
2894 version
.ext
!= NULL
? version
.ext
: "");
2896 btrace_maint_update_pt_packets (btinfo
);
2897 printf_unfiltered (_("Number of packets: %u.\n"),
2898 VEC_length (btrace_pt_packet_s
,
2899 btinfo
->maint
.variant
.pt
.packets
));
2902 #endif /* defined (HAVE_LIBIPT) */
2906 /* The "maint show btrace pt skip-pad" show value function. */
2909 show_maint_btrace_pt_skip_pad (struct ui_file
*file
, int from_tty
,
2910 struct cmd_list_element
*c
,
2913 fprintf_filtered (file
, _("Skip PAD packets is %s.\n"), value
);
2917 /* Initialize btrace maintenance commands. */
2919 void _initialize_btrace (void);
2921 _initialize_btrace (void)
2923 add_cmd ("btrace", class_maintenance
, maint_info_btrace_cmd
,
2924 _("Info about branch tracing data."), &maintenanceinfolist
);
2926 add_prefix_cmd ("btrace", class_maintenance
, maint_btrace_cmd
,
2927 _("Branch tracing maintenance commands."),
2928 &maint_btrace_cmdlist
, "maintenance btrace ",
2929 0, &maintenancelist
);
2931 add_prefix_cmd ("btrace", class_maintenance
, maint_btrace_set_cmd
, _("\
2932 Set branch tracing specific variables."),
2933 &maint_btrace_set_cmdlist
, "maintenance set btrace ",
2934 0, &maintenance_set_cmdlist
);
2936 add_prefix_cmd ("pt", class_maintenance
, maint_btrace_pt_set_cmd
, _("\
2937 Set Intel Processor Trace specific variables."),
2938 &maint_btrace_pt_set_cmdlist
, "maintenance set btrace pt ",
2939 0, &maint_btrace_set_cmdlist
);
2941 add_prefix_cmd ("btrace", class_maintenance
, maint_btrace_show_cmd
, _("\
2942 Show branch tracing specific variables."),
2943 &maint_btrace_show_cmdlist
, "maintenance show btrace ",
2944 0, &maintenance_show_cmdlist
);
2946 add_prefix_cmd ("pt", class_maintenance
, maint_btrace_pt_show_cmd
, _("\
2947 Show Intel Processor Trace specific variables."),
2948 &maint_btrace_pt_show_cmdlist
, "maintenance show btrace pt ",
2949 0, &maint_btrace_show_cmdlist
);
2951 add_setshow_boolean_cmd ("skip-pad", class_maintenance
,
2952 &maint_btrace_pt_skip_pad
, _("\
2953 Set whether PAD packets should be skipped in the btrace packet history."), _("\
2954 Show whether PAD packets should be skipped in the btrace packet history."),_("\
2955 When enabled, PAD packets are ignored in the btrace packet history."),
2956 NULL
, show_maint_btrace_pt_skip_pad
,
2957 &maint_btrace_pt_set_cmdlist
,
2958 &maint_btrace_pt_show_cmdlist
);
2960 add_cmd ("packet-history", class_maintenance
, maint_btrace_packet_history_cmd
,
2961 _("Print the raw branch tracing data.\n\
2962 With no argument, print ten more packets after the previous ten-line print.\n\
2963 With '-' as argument print ten packets before a previous ten-line print.\n\
2964 One argument specifies the starting packet of a ten-line print.\n\
2965 Two arguments with comma between specify starting and ending packets to \
2967 Preceded with '+'/'-' the second argument specifies the distance from the \
2969 &maint_btrace_cmdlist
);
2971 add_cmd ("clear-packet-history", class_maintenance
,
2972 maint_btrace_clear_packet_history_cmd
,
2973 _("Clears the branch tracing packet history.\n\
2974 Discards the raw branch tracing data but not the execution history data.\n\
2976 &maint_btrace_cmdlist
);
2978 add_cmd ("clear", class_maintenance
, maint_btrace_clear_cmd
,
2979 _("Clears the branch tracing data.\n\
2980 Discards the raw branch tracing data and the execution history data.\n\
2981 The next 'record' command will fetch the branch tracing data anew.\n\
2983 &maint_btrace_cmdlist
);