1 /* Branch trace support for GDB, the GNU debugger.
3 Copyright (C) 2013-2014 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"
29 #include "exceptions.h"
30 #include "cli/cli-utils.h"
34 #include "filenames.h"
36 /* The target_ops of record-btrace. */
37 static struct target_ops record_btrace_ops;
39 /* A new thread observer enabling branch tracing for the new thread. */
40 static struct observer *record_btrace_thread_observer;
42 /* Print a record-btrace debug message. Use do ... while (0) to avoid
43 ambiguities when used in if statements. */
45 #define DEBUG(msg, args...) \
48 if (record_debug != 0) \
49 fprintf_unfiltered (gdb_stdlog, \
50 "[record-btrace] " msg "\n", ##args); \
55 /* Update the branch trace for the current thread and return a pointer to its
56 branch trace information struct.
58 Throws an error if there is no thread or no trace. This function never
61 static struct btrace_thread_info *
64 struct thread_info *tp;
65 struct btrace_thread_info *btinfo;
69 tp = find_thread_ptid (inferior_ptid);
71 error (_("No thread."));
77 if (btinfo->begin == NULL)
78 error (_("No trace."));
83 /* Enable branch tracing for one thread. Warn on errors. */
86 record_btrace_enable_warn (struct thread_info *tp)
88 volatile struct gdb_exception error;
90 TRY_CATCH (error, RETURN_MASK_ERROR)
93 if (error.message != NULL)
94 warning ("%s", error.message);
97 /* Callback function to disable branch tracing for one thread. */
100 record_btrace_disable_callback (void *arg)
102 struct thread_info *tp;
109 /* Enable automatic tracing of new threads. */
112 record_btrace_auto_enable (void)
114 DEBUG ("attach thread observer");
116 record_btrace_thread_observer
117 = observer_attach_new_thread (record_btrace_enable_warn);
120 /* Disable automatic tracing of new threads. */
123 record_btrace_auto_disable (void)
125 /* The observer may have been detached, already. */
126 if (record_btrace_thread_observer == NULL)
129 DEBUG ("detach thread observer");
131 observer_detach_new_thread (record_btrace_thread_observer);
132 record_btrace_thread_observer = NULL;
135 /* The to_open method of target record-btrace. */
138 record_btrace_open (char *args, int from_tty)
140 struct cleanup *disable_chain;
141 struct thread_info *tp;
147 if (!target_has_execution)
148 error (_("The program is not being run."));
150 if (!target_supports_btrace ())
151 error (_("Target does not support branch tracing."));
153 gdb_assert (record_btrace_thread_observer == NULL);
155 disable_chain = make_cleanup (null_cleanup, NULL);
157 if (args == NULL || *args == 0 || number_is_in_list (args, tp->num))
161 make_cleanup (record_btrace_disable_callback, tp);
164 record_btrace_auto_enable ();
166 push_target (&record_btrace_ops);
168 observer_notify_record_changed (current_inferior (), 1);
170 discard_cleanups (disable_chain);
173 /* The to_stop_recording method of target record-btrace. */
176 record_btrace_stop_recording (void)
178 struct thread_info *tp;
180 DEBUG ("stop recording");
182 record_btrace_auto_disable ();
185 if (tp->btrace.target != NULL)
189 /* The to_close method of target record-btrace. */
192 record_btrace_close (void)
194 /* Make sure automatic recording gets disabled even if we did not stop
195 recording before closing the record-btrace target. */
196 record_btrace_auto_disable ();
198 /* We already stopped recording. */
201 /* The to_info_record method of target record-btrace. */
204 record_btrace_info (void)
206 struct btrace_thread_info *btinfo;
207 struct thread_info *tp;
208 unsigned int insns, calls;
212 tp = find_thread_ptid (inferior_ptid);
214 error (_("No thread."));
221 btinfo = &tp->btrace;
222 if (btinfo->begin != NULL)
224 struct btrace_call_iterator call;
225 struct btrace_insn_iterator insn;
227 btrace_call_end (&call, btinfo);
228 btrace_call_prev (&call, 1);
229 calls = btrace_call_number (&call);
231 btrace_insn_end (&insn, btinfo);
232 btrace_insn_prev (&insn, 1);
233 insns = btrace_insn_number (&insn);
236 printf_unfiltered (_("Recorded %u instructions in %u functions for thread "
237 "%d (%s).\n"), insns, calls, tp->num,
238 target_pid_to_str (tp->ptid));
240 if (btrace_is_replaying (tp))
241 printf_unfiltered (_("Replay in progress. At instruction %u.\n"),
242 btrace_insn_number (btinfo->replay));
245 /* Print an unsigned int. */
248 ui_out_field_uint (struct ui_out *uiout, const char *fld, unsigned int val)
250 ui_out_field_fmt (uiout, fld, "%u", val);
253 /* Disassemble a section of the recorded instruction trace. */
256 btrace_insn_history (struct ui_out *uiout,
257 const struct btrace_insn_iterator *begin,
258 const struct btrace_insn_iterator *end, int flags)
260 struct gdbarch *gdbarch;
261 struct btrace_insn_iterator it;
263 DEBUG ("itrace (0x%x): [%u; %u)", flags, btrace_insn_number (begin),
264 btrace_insn_number (end));
266 gdbarch = target_gdbarch ();
268 for (it = *begin; btrace_insn_cmp (&it, end) != 0; btrace_insn_next (&it, 1))
270 const struct btrace_insn *insn;
272 insn = btrace_insn_get (&it);
274 /* Print the instruction index. */
275 ui_out_field_uint (uiout, "index", btrace_insn_number (&it));
276 ui_out_text (uiout, "\t");
278 /* Disassembly with '/m' flag may not produce the expected result.
280 gdb_disassembly (gdbarch, uiout, NULL, flags, 1, insn->pc, insn->pc + 1);
284 /* The to_insn_history method of target record-btrace. */
287 record_btrace_insn_history (int size, int flags)
289 struct btrace_thread_info *btinfo;
290 struct btrace_insn_history *history;
291 struct btrace_insn_iterator begin, end;
292 struct cleanup *uiout_cleanup;
293 struct ui_out *uiout;
294 unsigned int context, covered;
296 uiout = current_uiout;
297 uiout_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout,
299 context = abs (size);
301 error (_("Bad record instruction-history-size."));
303 btinfo = require_btrace ();
304 history = btinfo->insn_history;
307 struct btrace_insn_iterator *replay;
309 DEBUG ("insn-history (0x%x): %d", flags, size);
311 /* If we're replaying, we start at the replay position. Otherwise, we
312 start at the tail of the trace. */
313 replay = btinfo->replay;
317 btrace_insn_end (&begin, btinfo);
319 /* We start from here and expand in the requested direction. Then we
320 expand in the other direction, as well, to fill up any remaining
325 /* We want the current position covered, as well. */
326 covered = btrace_insn_next (&end, 1);
327 covered += btrace_insn_prev (&begin, context - covered);
328 covered += btrace_insn_next (&end, context - covered);
332 covered = btrace_insn_next (&end, context);
333 covered += btrace_insn_prev (&begin, context - covered);
338 begin = history->begin;
341 DEBUG ("insn-history (0x%x): %d, prev: [%u; %u)", flags, size,
342 btrace_insn_number (&begin), btrace_insn_number (&end));
347 covered = btrace_insn_prev (&begin, context);
352 covered = btrace_insn_next (&end, context);
357 btrace_insn_history (uiout, &begin, &end, flags);
361 printf_unfiltered (_("At the start of the branch trace record.\n"));
363 printf_unfiltered (_("At the end of the branch trace record.\n"));
366 btrace_set_insn_history (btinfo, &begin, &end);
367 do_cleanups (uiout_cleanup);
370 /* The to_insn_history_range method of target record-btrace. */
373 record_btrace_insn_history_range (ULONGEST from, ULONGEST to, int flags)
375 struct btrace_thread_info *btinfo;
376 struct btrace_insn_history *history;
377 struct btrace_insn_iterator begin, end;
378 struct cleanup *uiout_cleanup;
379 struct ui_out *uiout;
380 unsigned int low, high;
383 uiout = current_uiout;
384 uiout_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout,
389 DEBUG ("insn-history (0x%x): [%u; %u)", flags, low, high);
391 /* Check for wrap-arounds. */
392 if (low != from || high != to)
393 error (_("Bad range."));
396 error (_("Bad range."));
398 btinfo = require_btrace ();
400 found = btrace_find_insn_by_number (&begin, btinfo, low);
402 error (_("Range out of bounds."));
404 found = btrace_find_insn_by_number (&end, btinfo, high);
407 /* Silently truncate the range. */
408 btrace_insn_end (&end, btinfo);
412 /* We want both begin and end to be inclusive. */
413 btrace_insn_next (&end, 1);
416 btrace_insn_history (uiout, &begin, &end, flags);
417 btrace_set_insn_history (btinfo, &begin, &end);
419 do_cleanups (uiout_cleanup);
422 /* The to_insn_history_from method of target record-btrace. */
425 record_btrace_insn_history_from (ULONGEST from, int size, int flags)
427 ULONGEST begin, end, context;
429 context = abs (size);
431 error (_("Bad record instruction-history-size."));
440 begin = from - context + 1;
445 end = from + context - 1;
447 /* Check for wrap-around. */
452 record_btrace_insn_history_range (begin, end, flags);
455 /* Print the instruction number range for a function call history line. */
458 btrace_call_history_insn_range (struct ui_out *uiout,
459 const struct btrace_function *bfun)
461 unsigned int begin, end, size;
463 size = VEC_length (btrace_insn_s, bfun->insn);
464 gdb_assert (size > 0);
466 begin = bfun->insn_offset;
467 end = begin + size - 1;
469 ui_out_field_uint (uiout, "insn begin", begin);
470 ui_out_text (uiout, ",");
471 ui_out_field_uint (uiout, "insn end", end);
474 /* Print the source line information for a function call history line. */
477 btrace_call_history_src_line (struct ui_out *uiout,
478 const struct btrace_function *bfun)
487 ui_out_field_string (uiout, "file",
488 symtab_to_filename_for_display (sym->symtab));
490 begin = bfun->lbegin;
496 ui_out_text (uiout, ":");
497 ui_out_field_int (uiout, "min line", begin);
502 ui_out_text (uiout, ",");
503 ui_out_field_int (uiout, "max line", end);
506 /* Disassemble a section of the recorded function trace. */
509 btrace_call_history (struct ui_out *uiout,
510 const struct btrace_thread_info *btinfo,
511 const struct btrace_call_iterator *begin,
512 const struct btrace_call_iterator *end,
513 enum record_print_flag flags)
515 struct btrace_call_iterator it;
517 DEBUG ("ftrace (0x%x): [%u; %u)", flags, btrace_call_number (begin),
518 btrace_call_number (end));
520 for (it = *begin; btrace_call_cmp (&it, end) < 0; btrace_call_next (&it, 1))
522 const struct btrace_function *bfun;
523 struct minimal_symbol *msym;
526 bfun = btrace_call_get (&it);
530 /* Print the function index. */
531 ui_out_field_uint (uiout, "index", bfun->number);
532 ui_out_text (uiout, "\t");
534 if ((flags & RECORD_PRINT_INDENT_CALLS) != 0)
536 int level = bfun->level + btinfo->level, i;
538 for (i = 0; i < level; ++i)
539 ui_out_text (uiout, " ");
543 ui_out_field_string (uiout, "function", SYMBOL_PRINT_NAME (sym));
544 else if (msym != NULL)
545 ui_out_field_string (uiout, "function", SYMBOL_PRINT_NAME (msym));
546 else if (!ui_out_is_mi_like_p (uiout))
547 ui_out_field_string (uiout, "function", "??");
549 if ((flags & RECORD_PRINT_INSN_RANGE) != 0)
551 ui_out_text (uiout, _("\tinst "));
552 btrace_call_history_insn_range (uiout, bfun);
555 if ((flags & RECORD_PRINT_SRC_LINE) != 0)
557 ui_out_text (uiout, _("\tat "));
558 btrace_call_history_src_line (uiout, bfun);
561 ui_out_text (uiout, "\n");
565 /* The to_call_history method of target record-btrace. */
568 record_btrace_call_history (int size, int flags)
570 struct btrace_thread_info *btinfo;
571 struct btrace_call_history *history;
572 struct btrace_call_iterator begin, end;
573 struct cleanup *uiout_cleanup;
574 struct ui_out *uiout;
575 unsigned int context, covered;
577 uiout = current_uiout;
578 uiout_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout,
580 context = abs (size);
582 error (_("Bad record function-call-history-size."));
584 btinfo = require_btrace ();
585 history = btinfo->call_history;
588 struct btrace_insn_iterator *replay;
590 DEBUG ("call-history (0x%x): %d", flags, size);
592 /* If we're replaying, we start at the replay position. Otherwise, we
593 start at the tail of the trace. */
594 replay = btinfo->replay;
597 begin.function = replay->function;
598 begin.btinfo = btinfo;
601 btrace_call_end (&begin, btinfo);
603 /* We start from here and expand in the requested direction. Then we
604 expand in the other direction, as well, to fill up any remaining
609 /* We want the current position covered, as well. */
610 covered = btrace_call_next (&end, 1);
611 covered += btrace_call_prev (&begin, context - covered);
612 covered += btrace_call_next (&end, context - covered);
616 covered = btrace_call_next (&end, context);
617 covered += btrace_call_prev (&begin, context- covered);
622 begin = history->begin;
625 DEBUG ("call-history (0x%x): %d, prev: [%u; %u)", flags, size,
626 btrace_call_number (&begin), btrace_call_number (&end));
631 covered = btrace_call_prev (&begin, context);
636 covered = btrace_call_next (&end, context);
641 btrace_call_history (uiout, btinfo, &begin, &end, flags);
645 printf_unfiltered (_("At the start of the branch trace record.\n"));
647 printf_unfiltered (_("At the end of the branch trace record.\n"));
650 btrace_set_call_history (btinfo, &begin, &end);
651 do_cleanups (uiout_cleanup);
654 /* The to_call_history_range method of target record-btrace. */
657 record_btrace_call_history_range (ULONGEST from, ULONGEST to, int flags)
659 struct btrace_thread_info *btinfo;
660 struct btrace_call_history *history;
661 struct btrace_call_iterator begin, end;
662 struct cleanup *uiout_cleanup;
663 struct ui_out *uiout;
664 unsigned int low, high;
667 uiout = current_uiout;
668 uiout_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout,
673 DEBUG ("call-history (0x%x): [%u; %u)", flags, low, high);
675 /* Check for wrap-arounds. */
676 if (low != from || high != to)
677 error (_("Bad range."));
680 error (_("Bad range."));
682 btinfo = require_btrace ();
684 found = btrace_find_call_by_number (&begin, btinfo, low);
686 error (_("Range out of bounds."));
688 found = btrace_find_call_by_number (&end, btinfo, high);
691 /* Silently truncate the range. */
692 btrace_call_end (&end, btinfo);
696 /* We want both begin and end to be inclusive. */
697 btrace_call_next (&end, 1);
700 btrace_call_history (uiout, btinfo, &begin, &end, flags);
701 btrace_set_call_history (btinfo, &begin, &end);
703 do_cleanups (uiout_cleanup);
706 /* The to_call_history_from method of target record-btrace. */
709 record_btrace_call_history_from (ULONGEST from, int size, int flags)
711 ULONGEST begin, end, context;
713 context = abs (size);
715 error (_("Bad record function-call-history-size."));
724 begin = from - context + 1;
729 end = from + context - 1;
731 /* Check for wrap-around. */
736 record_btrace_call_history_range (begin, end, flags);
739 /* The to_record_is_replaying method of target record-btrace. */
742 record_btrace_is_replaying (void)
744 struct thread_info *tp;
747 if (btrace_is_replaying (tp))
753 /* Initialize the record-btrace target ops. */
756 init_record_btrace_ops (void)
758 struct target_ops *ops;
760 ops = &record_btrace_ops;
761 ops->to_shortname = "record-btrace";
762 ops->to_longname = "Branch tracing target";
763 ops->to_doc = "Collect control-flow trace and provide the execution history.";
764 ops->to_open = record_btrace_open;
765 ops->to_close = record_btrace_close;
766 ops->to_detach = record_detach;
767 ops->to_disconnect = record_disconnect;
768 ops->to_mourn_inferior = record_mourn_inferior;
769 ops->to_kill = record_kill;
770 ops->to_create_inferior = find_default_create_inferior;
771 ops->to_stop_recording = record_btrace_stop_recording;
772 ops->to_info_record = record_btrace_info;
773 ops->to_insn_history = record_btrace_insn_history;
774 ops->to_insn_history_from = record_btrace_insn_history_from;
775 ops->to_insn_history_range = record_btrace_insn_history_range;
776 ops->to_call_history = record_btrace_call_history;
777 ops->to_call_history_from = record_btrace_call_history_from;
778 ops->to_call_history_range = record_btrace_call_history_range;
779 ops->to_record_is_replaying = record_btrace_is_replaying;
780 ops->to_stratum = record_stratum;
781 ops->to_magic = OPS_MAGIC;
784 /* Alias for "target record". */
787 cmd_record_btrace_start (char *args, int from_tty)
789 if (args != NULL && *args != 0)
790 error (_("Invalid argument."));
792 execute_command ("target record-btrace", from_tty);
795 void _initialize_record_btrace (void);
797 /* Initialize btrace commands. */
800 _initialize_record_btrace (void)
802 add_cmd ("btrace", class_obscure, cmd_record_btrace_start,
803 _("Start branch trace recording."),
805 add_alias_cmd ("b", "btrace", class_obscure, 1, &record_cmdlist);
807 init_record_btrace_ops ();
808 add_target (&record_btrace_ops);