| /* Branch trace support for GDB, the GNU debugger. |
| |
| Copyright (C) 2013 Free Software Foundation, Inc. |
| |
| Contributed by Intel Corp. <markus.t.metzger@intel.com> |
| |
| This file is part of GDB. |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by |
| the Free Software Foundation; either version 3 of the License, or |
| (at your option) any later version. |
| |
| This program is distributed in the hope that it will be useful, |
| but WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| GNU General Public License for more details. |
| |
| You should have received a copy of the GNU General Public License |
| along with this program. If not, see <http://www.gnu.org/licenses/>. */ |
| |
| #include "defs.h" |
| #include "record.h" |
| #include "gdbthread.h" |
| #include "target.h" |
| #include "gdbcmd.h" |
| #include "disasm.h" |
| #include "observer.h" |
| #include "exceptions.h" |
| #include "cli/cli-utils.h" |
| #include "source.h" |
| #include "ui-out.h" |
| #include "symtab.h" |
| #include "filenames.h" |
| |
| /* The target_ops of record-btrace. */ |
| static struct target_ops record_btrace_ops; |
| |
| /* A new thread observer enabling branch tracing for the new thread. */ |
| static struct observer *record_btrace_thread_observer; |
| |
| /* Print a record-btrace debug message. Use do ... while (0) to avoid |
| ambiguities when used in if statements. */ |
| |
| #define DEBUG(msg, args...) \ |
| do \ |
| { \ |
| if (record_debug != 0) \ |
| fprintf_unfiltered (gdb_stdlog, \ |
| "[record-btrace] " msg "\n", ##args); \ |
| } \ |
| while (0) |
| |
| |
| /* Update the branch trace for the current thread and return a pointer to its |
| branch trace information struct. |
| |
| Throws an error if there is no thread or no trace. This function never |
| returns NULL. */ |
| |
| static struct btrace_thread_info * |
| require_btrace (void) |
| { |
| struct thread_info *tp; |
| struct btrace_thread_info *btinfo; |
| |
| DEBUG ("require"); |
| |
| tp = find_thread_ptid (inferior_ptid); |
| if (tp == NULL) |
| error (_("No thread.")); |
| |
| btrace_fetch (tp); |
| |
| btinfo = &tp->btrace; |
| |
| if (VEC_empty (btrace_inst_s, btinfo->itrace)) |
| error (_("No trace.")); |
| |
| return btinfo; |
| } |
| |
| /* Enable branch tracing for one thread. Warn on errors. */ |
| |
| static void |
| record_btrace_enable_warn (struct thread_info *tp) |
| { |
| volatile struct gdb_exception error; |
| |
| TRY_CATCH (error, RETURN_MASK_ERROR) |
| btrace_enable (tp); |
| |
| if (error.message != NULL) |
| warning ("%s", error.message); |
| } |
| |
| /* Callback function to disable branch tracing for one thread. */ |
| |
| static void |
| record_btrace_disable_callback (void *arg) |
| { |
| struct thread_info *tp; |
| |
| tp = arg; |
| |
| btrace_disable (tp); |
| } |
| |
| /* Enable automatic tracing of new threads. */ |
| |
| static void |
| record_btrace_auto_enable (void) |
| { |
| DEBUG ("attach thread observer"); |
| |
| record_btrace_thread_observer |
| = observer_attach_new_thread (record_btrace_enable_warn); |
| } |
| |
| /* Disable automatic tracing of new threads. */ |
| |
| static void |
| record_btrace_auto_disable (void) |
| { |
| /* The observer may have been detached, already. */ |
| if (record_btrace_thread_observer == NULL) |
| return; |
| |
| DEBUG ("detach thread observer"); |
| |
| observer_detach_new_thread (record_btrace_thread_observer); |
| record_btrace_thread_observer = NULL; |
| } |
| |
| /* The to_open method of target record-btrace. */ |
| |
| static void |
| record_btrace_open (char *args, int from_tty) |
| { |
| struct cleanup *disable_chain; |
| struct thread_info *tp; |
| |
| DEBUG ("open"); |
| |
| if (RECORD_IS_USED) |
| error (_("The process is already being recorded.")); |
| |
| if (!target_has_execution) |
| error (_("The program is not being run.")); |
| |
| if (!target_supports_btrace ()) |
| error (_("Target does not support branch tracing.")); |
| |
| gdb_assert (record_btrace_thread_observer == NULL); |
| |
| disable_chain = make_cleanup (null_cleanup, NULL); |
| ALL_THREADS (tp) |
| if (args == NULL || *args == 0 || number_is_in_list (args, tp->num)) |
| { |
| btrace_enable (tp); |
| |
| make_cleanup (record_btrace_disable_callback, tp); |
| } |
| |
| record_btrace_auto_enable (); |
| |
| push_target (&record_btrace_ops); |
| |
| observer_notify_record_changed (current_inferior (), 1); |
| |
| discard_cleanups (disable_chain); |
| } |
| |
| /* The to_stop_recording method of target record-btrace. */ |
| |
| static void |
| record_btrace_stop_recording (void) |
| { |
| struct thread_info *tp; |
| |
| DEBUG ("stop recording"); |
| |
| record_btrace_auto_disable (); |
| |
| ALL_THREADS (tp) |
| if (tp->btrace.target != NULL) |
| btrace_disable (tp); |
| } |
| |
| /* The to_close method of target record-btrace. */ |
| |
| static void |
| record_btrace_close (void) |
| { |
| /* Make sure automatic recording gets disabled even if we did not stop |
| recording before closing the record-btrace target. */ |
| record_btrace_auto_disable (); |
| |
| /* We already stopped recording. */ |
| } |
| |
| /* The to_info_record method of target record-btrace. */ |
| |
| static void |
| record_btrace_info (void) |
| { |
| struct btrace_thread_info *btinfo; |
| struct thread_info *tp; |
| unsigned int insts, funcs; |
| |
| DEBUG ("info"); |
| |
| tp = find_thread_ptid (inferior_ptid); |
| if (tp == NULL) |
| error (_("No thread.")); |
| |
| btrace_fetch (tp); |
| |
| btinfo = &tp->btrace; |
| insts = VEC_length (btrace_inst_s, btinfo->itrace); |
| funcs = VEC_length (btrace_func_s, btinfo->ftrace); |
| |
| printf_unfiltered (_("Recorded %u instructions in %u functions for thread " |
| "%d (%s).\n"), insts, funcs, tp->num, |
| target_pid_to_str (tp->ptid)); |
| } |
| |
| /* Print an unsigned int. */ |
| |
| static void |
| ui_out_field_uint (struct ui_out *uiout, const char *fld, unsigned int val) |
| { |
| ui_out_field_fmt (uiout, fld, "%u", val); |
| } |
| |
| /* Disassemble a section of the recorded instruction trace. */ |
| |
| static void |
| btrace_insn_history (struct btrace_thread_info *btinfo, struct ui_out *uiout, |
| unsigned int begin, unsigned int end, int flags) |
| { |
| struct gdbarch *gdbarch; |
| struct btrace_inst *inst; |
| unsigned int idx; |
| |
| DEBUG ("itrace (0x%x): [%u; %u[", flags, begin, end); |
| |
| gdbarch = target_gdbarch (); |
| |
| for (idx = begin; VEC_iterate (btrace_inst_s, btinfo->itrace, idx, inst) |
| && idx < end; ++idx) |
| { |
| /* Print the instruction index. */ |
| ui_out_field_uint (uiout, "index", idx); |
| ui_out_text (uiout, "\t"); |
| |
| /* Disassembly with '/m' flag may not produce the expected result. |
| See PR gdb/11833. */ |
| gdb_disassembly (gdbarch, uiout, NULL, flags, 1, inst->pc, inst->pc + 1); |
| } |
| } |
| |
| /* The to_insn_history method of target record-btrace. */ |
| |
| static void |
| record_btrace_insn_history (int size, int flags) |
| { |
| struct btrace_thread_info *btinfo; |
| struct cleanup *uiout_cleanup; |
| struct ui_out *uiout; |
| unsigned int context, last, begin, end; |
| |
| uiout = current_uiout; |
| uiout_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, |
| "insn history"); |
| btinfo = require_btrace (); |
| last = VEC_length (btrace_inst_s, btinfo->itrace); |
| |
| context = abs (size); |
| begin = btinfo->insn_iterator.begin; |
| end = btinfo->insn_iterator.end; |
| |
| DEBUG ("insn-history (0x%x): %d, prev: [%u; %u[", flags, size, begin, end); |
| |
| if (context == 0) |
| error (_("Bad record instruction-history-size.")); |
| |
| /* We start at the end. */ |
| if (end < begin) |
| { |
| /* Truncate the context, if necessary. */ |
| context = min (context, last); |
| |
| end = last; |
| begin = end - context; |
| } |
| else if (size < 0) |
| { |
| if (begin == 0) |
| { |
| printf_unfiltered (_("At the start of the branch trace record.\n")); |
| |
| btinfo->insn_iterator.end = 0; |
| return; |
| } |
| |
| /* Truncate the context, if necessary. */ |
| context = min (context, begin); |
| |
| end = begin; |
| begin -= context; |
| } |
| else |
| { |
| if (end == last) |
| { |
| printf_unfiltered (_("At the end of the branch trace record.\n")); |
| |
| btinfo->insn_iterator.begin = last; |
| return; |
| } |
| |
| /* Truncate the context, if necessary. */ |
| context = min (context, last - end); |
| |
| begin = end; |
| end += context; |
| } |
| |
| btrace_insn_history (btinfo, uiout, begin, end, flags); |
| |
| btinfo->insn_iterator.begin = begin; |
| btinfo->insn_iterator.end = end; |
| |
| do_cleanups (uiout_cleanup); |
| } |
| |
| /* The to_insn_history_range method of target record-btrace. */ |
| |
| static void |
| record_btrace_insn_history_range (ULONGEST from, ULONGEST to, int flags) |
| { |
| struct btrace_thread_info *btinfo; |
| struct cleanup *uiout_cleanup; |
| struct ui_out *uiout; |
| unsigned int last, begin, end; |
| |
| uiout = current_uiout; |
| uiout_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, |
| "insn history"); |
| btinfo = require_btrace (); |
| last = VEC_length (btrace_inst_s, btinfo->itrace); |
| |
| begin = (unsigned int) from; |
| end = (unsigned int) to; |
| |
| DEBUG ("insn-history (0x%x): [%u; %u[", flags, begin, end); |
| |
| /* Check for wrap-arounds. */ |
| if (begin != from || end != to) |
| error (_("Bad range.")); |
| |
| if (end <= begin) |
| error (_("Bad range.")); |
| |
| if (last <= begin) |
| error (_("Range out of bounds.")); |
| |
| /* Truncate the range, if necessary. */ |
| if (last < end) |
| end = last; |
| |
| btrace_insn_history (btinfo, uiout, begin, end, flags); |
| |
| btinfo->insn_iterator.begin = begin; |
| btinfo->insn_iterator.end = end; |
| |
| do_cleanups (uiout_cleanup); |
| } |
| |
| /* The to_insn_history_from method of target record-btrace. */ |
| |
| static void |
| record_btrace_insn_history_from (ULONGEST from, int size, int flags) |
| { |
| ULONGEST begin, end, context; |
| |
| context = abs (size); |
| |
| if (size < 0) |
| { |
| end = from; |
| |
| if (from < context) |
| begin = 0; |
| else |
| begin = from - context; |
| } |
| else |
| { |
| begin = from; |
| end = from + context; |
| |
| /* Check for wrap-around. */ |
| if (end < begin) |
| end = ULONGEST_MAX; |
| } |
| |
| record_btrace_insn_history_range (begin, end, flags); |
| } |
| |
| /* Print the instruction number range for a function call history line. */ |
| |
| static void |
| btrace_func_history_insn_range (struct ui_out *uiout, struct btrace_func *bfun) |
| { |
| ui_out_field_uint (uiout, "insn begin", bfun->ibegin); |
| |
| if (bfun->ibegin == bfun->iend) |
| return; |
| |
| ui_out_text (uiout, "-"); |
| ui_out_field_uint (uiout, "insn end", bfun->iend); |
| } |
| |
| /* Print the source line information for a function call history line. */ |
| |
| static void |
| btrace_func_history_src_line (struct ui_out *uiout, struct btrace_func *bfun) |
| { |
| struct symbol *sym; |
| |
| sym = bfun->sym; |
| if (sym == NULL) |
| return; |
| |
| ui_out_field_string (uiout, "file", |
| symtab_to_filename_for_display (sym->symtab)); |
| |
| if (bfun->lend == 0) |
| return; |
| |
| ui_out_text (uiout, ":"); |
| ui_out_field_int (uiout, "min line", bfun->lbegin); |
| |
| if (bfun->lend == bfun->lbegin) |
| return; |
| |
| ui_out_text (uiout, "-"); |
| ui_out_field_int (uiout, "max line", bfun->lend); |
| } |
| |
| /* Disassemble a section of the recorded function trace. */ |
| |
| static void |
| btrace_func_history (struct btrace_thread_info *btinfo, struct ui_out *uiout, |
| unsigned int begin, unsigned int end, |
| enum record_print_flag flags) |
| { |
| struct btrace_func *bfun; |
| unsigned int idx; |
| |
| DEBUG ("ftrace (0x%x): [%u; %u[", flags, begin, end); |
| |
| for (idx = begin; VEC_iterate (btrace_func_s, btinfo->ftrace, idx, bfun) |
| && idx < end; ++idx) |
| { |
| /* Print the function index. */ |
| ui_out_field_uint (uiout, "index", idx); |
| ui_out_text (uiout, "\t"); |
| |
| if ((flags & record_print_insn_range) != 0) |
| { |
| btrace_func_history_insn_range (uiout, bfun); |
| ui_out_text (uiout, "\t"); |
| } |
| |
| if ((flags & record_print_src_line) != 0) |
| { |
| btrace_func_history_src_line (uiout, bfun); |
| ui_out_text (uiout, "\t"); |
| } |
| |
| if (bfun->sym != NULL) |
| ui_out_field_string (uiout, "function", SYMBOL_PRINT_NAME (bfun->sym)); |
| else if (bfun->msym != NULL) |
| ui_out_field_string (uiout, "function", SYMBOL_PRINT_NAME (bfun->msym)); |
| ui_out_text (uiout, "\n"); |
| } |
| } |
| |
| /* The to_call_history method of target record-btrace. */ |
| |
| static void |
| record_btrace_call_history (int size, int flags) |
| { |
| struct btrace_thread_info *btinfo; |
| struct cleanup *uiout_cleanup; |
| struct ui_out *uiout; |
| unsigned int context, last, begin, end; |
| |
| uiout = current_uiout; |
| uiout_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, |
| "insn history"); |
| btinfo = require_btrace (); |
| last = VEC_length (btrace_func_s, btinfo->ftrace); |
| |
| context = abs (size); |
| begin = btinfo->func_iterator.begin; |
| end = btinfo->func_iterator.end; |
| |
| DEBUG ("func-history (0x%x): %d, prev: [%u; %u[", flags, size, begin, end); |
| |
| if (context == 0) |
| error (_("Bad record function-call-history-size.")); |
| |
| /* We start at the end. */ |
| if (end < begin) |
| { |
| /* Truncate the context, if necessary. */ |
| context = min (context, last); |
| |
| end = last; |
| begin = end - context; |
| } |
| else if (size < 0) |
| { |
| if (begin == 0) |
| { |
| printf_unfiltered (_("At the start of the branch trace record.\n")); |
| |
| btinfo->func_iterator.end = 0; |
| return; |
| } |
| |
| /* Truncate the context, if necessary. */ |
| context = min (context, begin); |
| |
| end = begin; |
| begin -= context; |
| } |
| else |
| { |
| if (end == last) |
| { |
| printf_unfiltered (_("At the end of the branch trace record.\n")); |
| |
| btinfo->func_iterator.begin = last; |
| return; |
| } |
| |
| /* Truncate the context, if necessary. */ |
| context = min (context, last - end); |
| |
| begin = end; |
| end += context; |
| } |
| |
| btrace_func_history (btinfo, uiout, begin, end, flags); |
| |
| btinfo->func_iterator.begin = begin; |
| btinfo->func_iterator.end = end; |
| |
| do_cleanups (uiout_cleanup); |
| } |
| |
| /* The to_call_history_range method of target record-btrace. */ |
| |
| static void |
| record_btrace_call_history_range (ULONGEST from, ULONGEST to, int flags) |
| { |
| struct btrace_thread_info *btinfo; |
| struct cleanup *uiout_cleanup; |
| struct ui_out *uiout; |
| unsigned int last, begin, end; |
| |
| uiout = current_uiout; |
| uiout_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, |
| "func history"); |
| btinfo = require_btrace (); |
| last = VEC_length (btrace_func_s, btinfo->ftrace); |
| |
| begin = (unsigned int) from; |
| end = (unsigned int) to; |
| |
| DEBUG ("func-history (0x%x): [%u; %u[", flags, begin, end); |
| |
| /* Check for wrap-arounds. */ |
| if (begin != from || end != to) |
| error (_("Bad range.")); |
| |
| if (end <= begin) |
| error (_("Bad range.")); |
| |
| if (last <= begin) |
| error (_("Range out of bounds.")); |
| |
| /* Truncate the range, if necessary. */ |
| if (last < end) |
| end = last; |
| |
| btrace_func_history (btinfo, uiout, begin, end, flags); |
| |
| btinfo->func_iterator.begin = begin; |
| btinfo->func_iterator.end = end; |
| |
| do_cleanups (uiout_cleanup); |
| } |
| |
| /* The to_call_history_from method of target record-btrace. */ |
| |
| static void |
| record_btrace_call_history_from (ULONGEST from, int size, int flags) |
| { |
| ULONGEST begin, end, context; |
| |
| context = abs (size); |
| |
| if (size < 0) |
| { |
| end = from; |
| |
| if (from < context) |
| begin = 0; |
| else |
| begin = from - context; |
| } |
| else |
| { |
| begin = from; |
| end = from + context; |
| |
| /* Check for wrap-around. */ |
| if (end < begin) |
| end = ULONGEST_MAX; |
| } |
| |
| record_btrace_call_history_range (begin, end, flags); |
| } |
| |
| /* Initialize the record-btrace target ops. */ |
| |
| static void |
| init_record_btrace_ops (void) |
| { |
| struct target_ops *ops; |
| |
| ops = &record_btrace_ops; |
| ops->to_shortname = "record-btrace"; |
| ops->to_longname = "Branch tracing target"; |
| ops->to_doc = "Collect control-flow trace and provide the execution history."; |
| ops->to_open = record_btrace_open; |
| ops->to_close = record_btrace_close; |
| ops->to_detach = record_detach; |
| ops->to_disconnect = record_disconnect; |
| ops->to_mourn_inferior = record_mourn_inferior; |
| ops->to_kill = record_kill; |
| ops->to_create_inferior = find_default_create_inferior; |
| ops->to_stop_recording = record_btrace_stop_recording; |
| ops->to_info_record = record_btrace_info; |
| ops->to_insn_history = record_btrace_insn_history; |
| ops->to_insn_history_from = record_btrace_insn_history_from; |
| ops->to_insn_history_range = record_btrace_insn_history_range; |
| ops->to_call_history = record_btrace_call_history; |
| ops->to_call_history_from = record_btrace_call_history_from; |
| ops->to_call_history_range = record_btrace_call_history_range; |
| ops->to_stratum = record_stratum; |
| ops->to_magic = OPS_MAGIC; |
| } |
| |
| /* Alias for "target record". */ |
| |
| static void |
| cmd_record_btrace_start (char *args, int from_tty) |
| { |
| if (args != NULL && *args != 0) |
| error (_("Invalid argument.")); |
| |
| execute_command ("target record-btrace", from_tty); |
| } |
| |
| void _initialize_record_btrace (void); |
| |
| /* Initialize btrace commands. */ |
| |
| void |
| _initialize_record_btrace (void) |
| { |
| add_cmd ("btrace", class_obscure, cmd_record_btrace_start, |
| _("Start branch trace recording."), |
| &record_cmdlist); |
| add_alias_cmd ("b", "btrace", class_obscure, 1, &record_cmdlist); |
| |
| init_record_btrace_ops (); |
| add_target (&record_btrace_ops); |
| } |