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 #include "frame-unwind.h"
39 /* The target_ops of record-btrace. */
40 static struct target_ops record_btrace_ops;
42 /* A new thread observer enabling branch tracing for the new thread. */
43 static struct observer *record_btrace_thread_observer;
45 /* Temporarily allow memory accesses. */
46 static int record_btrace_allow_memory_access;
48 /* Print a record-btrace debug message. Use do ... while (0) to avoid
49 ambiguities when used in if statements. */
51 #define DEBUG(msg, args...) \
54 if (record_debug != 0) \
55 fprintf_unfiltered (gdb_stdlog, \
56 "[record-btrace] " msg "\n", ##args); \
61 /* Update the branch trace for the current thread and return a pointer to its
64 Throws an error if there is no thread or no trace. This function never
67 static struct thread_info *
68 require_btrace_thread (void)
70 struct thread_info *tp;
74 tp = find_thread_ptid (inferior_ptid);
76 error (_("No thread."));
80 if (btrace_is_empty (tp))
81 error (_("No trace."));
86 /* Update the branch trace for the current thread and return a pointer to its
87 branch trace information struct.
89 Throws an error if there is no thread or no trace. This function never
92 static struct btrace_thread_info *
95 struct thread_info *tp;
97 tp = require_btrace_thread ();
102 /* Enable branch tracing for one thread. Warn on errors. */
105 record_btrace_enable_warn (struct thread_info *tp)
107 volatile struct gdb_exception error;
109 TRY_CATCH (error, RETURN_MASK_ERROR)
112 if (error.message != NULL)
113 warning ("%s", error.message);
116 /* Callback function to disable branch tracing for one thread. */
119 record_btrace_disable_callback (void *arg)
121 struct thread_info *tp;
128 /* Enable automatic tracing of new threads. */
131 record_btrace_auto_enable (void)
133 DEBUG ("attach thread observer");
135 record_btrace_thread_observer
136 = observer_attach_new_thread (record_btrace_enable_warn);
139 /* Disable automatic tracing of new threads. */
142 record_btrace_auto_disable (void)
144 /* The observer may have been detached, already. */
145 if (record_btrace_thread_observer == NULL)
148 DEBUG ("detach thread observer");
150 observer_detach_new_thread (record_btrace_thread_observer);
151 record_btrace_thread_observer = NULL;
154 /* The to_open method of target record-btrace. */
157 record_btrace_open (char *args, int from_tty)
159 struct cleanup *disable_chain;
160 struct thread_info *tp;
166 if (!target_has_execution)
167 error (_("The program is not being run."));
169 if (!target_supports_btrace ())
170 error (_("Target does not support branch tracing."));
173 error (_("Record btrace can't debug inferior in non-stop mode."));
175 gdb_assert (record_btrace_thread_observer == NULL);
177 disable_chain = make_cleanup (null_cleanup, NULL);
179 if (args == NULL || *args == 0 || number_is_in_list (args, tp->num))
183 make_cleanup (record_btrace_disable_callback, tp);
186 record_btrace_auto_enable ();
188 push_target (&record_btrace_ops);
190 observer_notify_record_changed (current_inferior (), 1);
192 discard_cleanups (disable_chain);
195 /* The to_stop_recording method of target record-btrace. */
198 record_btrace_stop_recording (void)
200 struct thread_info *tp;
202 DEBUG ("stop recording");
204 record_btrace_auto_disable ();
207 if (tp->btrace.target != NULL)
211 /* The to_close method of target record-btrace. */
214 record_btrace_close (void)
216 struct thread_info *tp;
218 /* Make sure automatic recording gets disabled even if we did not stop
219 recording before closing the record-btrace target. */
220 record_btrace_auto_disable ();
222 /* We should have already stopped recording.
223 Tear down btrace in case we have not. */
225 btrace_teardown (tp);
228 /* The to_info_record method of target record-btrace. */
231 record_btrace_info (void)
233 struct btrace_thread_info *btinfo;
234 struct thread_info *tp;
235 unsigned int insns, calls;
239 tp = find_thread_ptid (inferior_ptid);
241 error (_("No thread."));
248 btinfo = &tp->btrace;
250 if (!btrace_is_empty (tp))
252 struct btrace_call_iterator call;
253 struct btrace_insn_iterator insn;
255 btrace_call_end (&call, btinfo);
256 btrace_call_prev (&call, 1);
257 calls = btrace_call_number (&call);
259 btrace_insn_end (&insn, btinfo);
260 btrace_insn_prev (&insn, 1);
261 insns = btrace_insn_number (&insn);
264 printf_unfiltered (_("Recorded %u instructions in %u functions for thread "
265 "%d (%s).\n"), insns, calls, tp->num,
266 target_pid_to_str (tp->ptid));
268 if (btrace_is_replaying (tp))
269 printf_unfiltered (_("Replay in progress. At instruction %u.\n"),
270 btrace_insn_number (btinfo->replay));
273 /* Print an unsigned int. */
276 ui_out_field_uint (struct ui_out *uiout, const char *fld, unsigned int val)
278 ui_out_field_fmt (uiout, fld, "%u", val);
281 /* Disassemble a section of the recorded instruction trace. */
284 btrace_insn_history (struct ui_out *uiout,
285 const struct btrace_insn_iterator *begin,
286 const struct btrace_insn_iterator *end, int flags)
288 struct gdbarch *gdbarch;
289 struct btrace_insn_iterator it;
291 DEBUG ("itrace (0x%x): [%u; %u)", flags, btrace_insn_number (begin),
292 btrace_insn_number (end));
294 gdbarch = target_gdbarch ();
296 for (it = *begin; btrace_insn_cmp (&it, end) != 0; btrace_insn_next (&it, 1))
298 const struct btrace_insn *insn;
300 insn = btrace_insn_get (&it);
302 /* Print the instruction index. */
303 ui_out_field_uint (uiout, "index", btrace_insn_number (&it));
304 ui_out_text (uiout, "\t");
306 /* Disassembly with '/m' flag may not produce the expected result.
308 gdb_disassembly (gdbarch, uiout, NULL, flags, 1, insn->pc, insn->pc + 1);
312 /* The to_insn_history method of target record-btrace. */
315 record_btrace_insn_history (int size, int flags)
317 struct btrace_thread_info *btinfo;
318 struct btrace_insn_history *history;
319 struct btrace_insn_iterator begin, end;
320 struct cleanup *uiout_cleanup;
321 struct ui_out *uiout;
322 unsigned int context, covered;
324 uiout = current_uiout;
325 uiout_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout,
327 context = abs (size);
329 error (_("Bad record instruction-history-size."));
331 btinfo = require_btrace ();
332 history = btinfo->insn_history;
335 struct btrace_insn_iterator *replay;
337 DEBUG ("insn-history (0x%x): %d", flags, size);
339 /* If we're replaying, we start at the replay position. Otherwise, we
340 start at the tail of the trace. */
341 replay = btinfo->replay;
345 btrace_insn_end (&begin, btinfo);
347 /* We start from here and expand in the requested direction. Then we
348 expand in the other direction, as well, to fill up any remaining
353 /* We want the current position covered, as well. */
354 covered = btrace_insn_next (&end, 1);
355 covered += btrace_insn_prev (&begin, context - covered);
356 covered += btrace_insn_next (&end, context - covered);
360 covered = btrace_insn_next (&end, context);
361 covered += btrace_insn_prev (&begin, context - covered);
366 begin = history->begin;
369 DEBUG ("insn-history (0x%x): %d, prev: [%u; %u)", flags, size,
370 btrace_insn_number (&begin), btrace_insn_number (&end));
375 covered = btrace_insn_prev (&begin, context);
380 covered = btrace_insn_next (&end, context);
385 btrace_insn_history (uiout, &begin, &end, flags);
389 printf_unfiltered (_("At the start of the branch trace record.\n"));
391 printf_unfiltered (_("At the end of the branch trace record.\n"));
394 btrace_set_insn_history (btinfo, &begin, &end);
395 do_cleanups (uiout_cleanup);
398 /* The to_insn_history_range method of target record-btrace. */
401 record_btrace_insn_history_range (ULONGEST from, ULONGEST to, int flags)
403 struct btrace_thread_info *btinfo;
404 struct btrace_insn_history *history;
405 struct btrace_insn_iterator begin, end;
406 struct cleanup *uiout_cleanup;
407 struct ui_out *uiout;
408 unsigned int low, high;
411 uiout = current_uiout;
412 uiout_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout,
417 DEBUG ("insn-history (0x%x): [%u; %u)", flags, low, high);
419 /* Check for wrap-arounds. */
420 if (low != from || high != to)
421 error (_("Bad range."));
424 error (_("Bad range."));
426 btinfo = require_btrace ();
428 found = btrace_find_insn_by_number (&begin, btinfo, low);
430 error (_("Range out of bounds."));
432 found = btrace_find_insn_by_number (&end, btinfo, high);
435 /* Silently truncate the range. */
436 btrace_insn_end (&end, btinfo);
440 /* We want both begin and end to be inclusive. */
441 btrace_insn_next (&end, 1);
444 btrace_insn_history (uiout, &begin, &end, flags);
445 btrace_set_insn_history (btinfo, &begin, &end);
447 do_cleanups (uiout_cleanup);
450 /* The to_insn_history_from method of target record-btrace. */
453 record_btrace_insn_history_from (ULONGEST from, int size, int flags)
455 ULONGEST begin, end, context;
457 context = abs (size);
459 error (_("Bad record instruction-history-size."));
468 begin = from - context + 1;
473 end = from + context - 1;
475 /* Check for wrap-around. */
480 record_btrace_insn_history_range (begin, end, flags);
483 /* Print the instruction number range for a function call history line. */
486 btrace_call_history_insn_range (struct ui_out *uiout,
487 const struct btrace_function *bfun)
489 unsigned int begin, end, size;
491 size = VEC_length (btrace_insn_s, bfun->insn);
492 gdb_assert (size > 0);
494 begin = bfun->insn_offset;
495 end = begin + size - 1;
497 ui_out_field_uint (uiout, "insn begin", begin);
498 ui_out_text (uiout, ",");
499 ui_out_field_uint (uiout, "insn end", end);
502 /* Print the source line information for a function call history line. */
505 btrace_call_history_src_line (struct ui_out *uiout,
506 const struct btrace_function *bfun)
515 ui_out_field_string (uiout, "file",
516 symtab_to_filename_for_display (sym->symtab));
518 begin = bfun->lbegin;
524 ui_out_text (uiout, ":");
525 ui_out_field_int (uiout, "min line", begin);
530 ui_out_text (uiout, ",");
531 ui_out_field_int (uiout, "max line", end);
534 /* Get the name of a branch trace function. */
537 btrace_get_bfun_name (const struct btrace_function *bfun)
539 struct minimal_symbol *msym;
549 return SYMBOL_PRINT_NAME (sym);
550 else if (msym != NULL)
551 return SYMBOL_PRINT_NAME (msym);
556 /* Disassemble a section of the recorded function trace. */
559 btrace_call_history (struct ui_out *uiout,
560 const struct btrace_thread_info *btinfo,
561 const struct btrace_call_iterator *begin,
562 const struct btrace_call_iterator *end,
563 enum record_print_flag flags)
565 struct btrace_call_iterator it;
567 DEBUG ("ftrace (0x%x): [%u; %u)", flags, btrace_call_number (begin),
568 btrace_call_number (end));
570 for (it = *begin; btrace_call_cmp (&it, end) < 0; btrace_call_next (&it, 1))
572 const struct btrace_function *bfun;
573 struct minimal_symbol *msym;
576 bfun = btrace_call_get (&it);
580 /* Print the function index. */
581 ui_out_field_uint (uiout, "index", bfun->number);
582 ui_out_text (uiout, "\t");
584 if ((flags & RECORD_PRINT_INDENT_CALLS) != 0)
586 int level = bfun->level + btinfo->level, i;
588 for (i = 0; i < level; ++i)
589 ui_out_text (uiout, " ");
593 ui_out_field_string (uiout, "function", SYMBOL_PRINT_NAME (sym));
594 else if (msym != NULL)
595 ui_out_field_string (uiout, "function", SYMBOL_PRINT_NAME (msym));
596 else if (!ui_out_is_mi_like_p (uiout))
597 ui_out_field_string (uiout, "function", "??");
599 if ((flags & RECORD_PRINT_INSN_RANGE) != 0)
601 ui_out_text (uiout, _("\tinst "));
602 btrace_call_history_insn_range (uiout, bfun);
605 if ((flags & RECORD_PRINT_SRC_LINE) != 0)
607 ui_out_text (uiout, _("\tat "));
608 btrace_call_history_src_line (uiout, bfun);
611 ui_out_text (uiout, "\n");
615 /* The to_call_history method of target record-btrace. */
618 record_btrace_call_history (int size, int flags)
620 struct btrace_thread_info *btinfo;
621 struct btrace_call_history *history;
622 struct btrace_call_iterator begin, end;
623 struct cleanup *uiout_cleanup;
624 struct ui_out *uiout;
625 unsigned int context, covered;
627 uiout = current_uiout;
628 uiout_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout,
630 context = abs (size);
632 error (_("Bad record function-call-history-size."));
634 btinfo = require_btrace ();
635 history = btinfo->call_history;
638 struct btrace_insn_iterator *replay;
640 DEBUG ("call-history (0x%x): %d", flags, size);
642 /* If we're replaying, we start at the replay position. Otherwise, we
643 start at the tail of the trace. */
644 replay = btinfo->replay;
647 begin.function = replay->function;
648 begin.btinfo = btinfo;
651 btrace_call_end (&begin, btinfo);
653 /* We start from here and expand in the requested direction. Then we
654 expand in the other direction, as well, to fill up any remaining
659 /* We want the current position covered, as well. */
660 covered = btrace_call_next (&end, 1);
661 covered += btrace_call_prev (&begin, context - covered);
662 covered += btrace_call_next (&end, context - covered);
666 covered = btrace_call_next (&end, context);
667 covered += btrace_call_prev (&begin, context- covered);
672 begin = history->begin;
675 DEBUG ("call-history (0x%x): %d, prev: [%u; %u)", flags, size,
676 btrace_call_number (&begin), btrace_call_number (&end));
681 covered = btrace_call_prev (&begin, context);
686 covered = btrace_call_next (&end, context);
691 btrace_call_history (uiout, btinfo, &begin, &end, flags);
695 printf_unfiltered (_("At the start of the branch trace record.\n"));
697 printf_unfiltered (_("At the end of the branch trace record.\n"));
700 btrace_set_call_history (btinfo, &begin, &end);
701 do_cleanups (uiout_cleanup);
704 /* The to_call_history_range method of target record-btrace. */
707 record_btrace_call_history_range (ULONGEST from, ULONGEST to, int flags)
709 struct btrace_thread_info *btinfo;
710 struct btrace_call_history *history;
711 struct btrace_call_iterator begin, end;
712 struct cleanup *uiout_cleanup;
713 struct ui_out *uiout;
714 unsigned int low, high;
717 uiout = current_uiout;
718 uiout_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout,
723 DEBUG ("call-history (0x%x): [%u; %u)", flags, low, high);
725 /* Check for wrap-arounds. */
726 if (low != from || high != to)
727 error (_("Bad range."));
730 error (_("Bad range."));
732 btinfo = require_btrace ();
734 found = btrace_find_call_by_number (&begin, btinfo, low);
736 error (_("Range out of bounds."));
738 found = btrace_find_call_by_number (&end, btinfo, high);
741 /* Silently truncate the range. */
742 btrace_call_end (&end, btinfo);
746 /* We want both begin and end to be inclusive. */
747 btrace_call_next (&end, 1);
750 btrace_call_history (uiout, btinfo, &begin, &end, flags);
751 btrace_set_call_history (btinfo, &begin, &end);
753 do_cleanups (uiout_cleanup);
756 /* The to_call_history_from method of target record-btrace. */
759 record_btrace_call_history_from (ULONGEST from, int size, int flags)
761 ULONGEST begin, end, context;
763 context = abs (size);
765 error (_("Bad record function-call-history-size."));
774 begin = from - context + 1;
779 end = from + context - 1;
781 /* Check for wrap-around. */
786 record_btrace_call_history_range (begin, end, flags);
789 /* The to_record_is_replaying method of target record-btrace. */
792 record_btrace_is_replaying (void)
794 struct thread_info *tp;
797 if (btrace_is_replaying (tp))
803 /* The to_xfer_partial method of target record-btrace. */
806 record_btrace_xfer_partial (struct target_ops *ops, enum target_object object,
807 const char *annex, gdb_byte *readbuf,
808 const gdb_byte *writebuf, ULONGEST offset,
811 struct target_ops *t;
813 /* Filter out requests that don't make sense during replay. */
814 if (!record_btrace_allow_memory_access && record_btrace_is_replaying ())
818 case TARGET_OBJECT_MEMORY:
820 struct target_section *section;
822 /* We do not allow writing memory in general. */
823 if (writebuf != NULL)
824 return TARGET_XFER_E_UNAVAILABLE;
826 /* We allow reading readonly memory. */
827 section = target_section_by_addr (ops, offset);
830 /* Check if the section we found is readonly. */
831 if ((bfd_get_section_flags (section->the_bfd_section->owner,
832 section->the_bfd_section)
833 & SEC_READONLY) != 0)
835 /* Truncate the request to fit into this section. */
836 len = min (len, section->endaddr - offset);
841 return TARGET_XFER_E_UNAVAILABLE;
846 /* Forward the request. */
847 for (ops = ops->beneath; ops != NULL; ops = ops->beneath)
848 if (ops->to_xfer_partial != NULL)
849 return ops->to_xfer_partial (ops, object, annex, readbuf, writebuf,
852 return TARGET_XFER_E_UNAVAILABLE;
855 /* The to_insert_breakpoint method of target record-btrace. */
858 record_btrace_insert_breakpoint (struct target_ops *ops,
859 struct gdbarch *gdbarch,
860 struct bp_target_info *bp_tgt)
862 volatile struct gdb_exception except;
865 /* Inserting breakpoints requires accessing memory. Allow it for the
866 duration of this function. */
867 old = record_btrace_allow_memory_access;
868 record_btrace_allow_memory_access = 1;
871 TRY_CATCH (except, RETURN_MASK_ALL)
872 ret = forward_target_insert_breakpoint (ops->beneath, gdbarch, bp_tgt);
874 record_btrace_allow_memory_access = old;
876 if (except.reason < 0)
877 throw_exception (except);
882 /* The to_remove_breakpoint method of target record-btrace. */
885 record_btrace_remove_breakpoint (struct target_ops *ops,
886 struct gdbarch *gdbarch,
887 struct bp_target_info *bp_tgt)
889 volatile struct gdb_exception except;
892 /* Removing breakpoints requires accessing memory. Allow it for the
893 duration of this function. */
894 old = record_btrace_allow_memory_access;
895 record_btrace_allow_memory_access = 1;
898 TRY_CATCH (except, RETURN_MASK_ALL)
899 ret = forward_target_remove_breakpoint (ops->beneath, gdbarch, bp_tgt);
901 record_btrace_allow_memory_access = old;
903 if (except.reason < 0)
904 throw_exception (except);
909 /* The to_fetch_registers method of target record-btrace. */
912 record_btrace_fetch_registers (struct target_ops *ops,
913 struct regcache *regcache, int regno)
915 struct btrace_insn_iterator *replay;
916 struct thread_info *tp;
918 tp = find_thread_ptid (inferior_ptid);
919 gdb_assert (tp != NULL);
921 replay = tp->btrace.replay;
924 const struct btrace_insn *insn;
925 struct gdbarch *gdbarch;
928 gdbarch = get_regcache_arch (regcache);
929 pcreg = gdbarch_pc_regnum (gdbarch);
933 /* We can only provide the PC register. */
934 if (regno >= 0 && regno != pcreg)
937 insn = btrace_insn_get (replay);
938 gdb_assert (insn != NULL);
940 regcache_raw_supply (regcache, regno, &insn->pc);
944 struct target_ops *t;
946 for (t = ops->beneath; t != NULL; t = t->beneath)
947 if (t->to_fetch_registers != NULL)
949 t->to_fetch_registers (t, regcache, regno);
955 /* The to_store_registers method of target record-btrace. */
958 record_btrace_store_registers (struct target_ops *ops,
959 struct regcache *regcache, int regno)
961 struct target_ops *t;
963 if (record_btrace_is_replaying ())
964 error (_("This record target does not allow writing registers."));
966 gdb_assert (may_write_registers != 0);
968 for (t = ops->beneath; t != NULL; t = t->beneath)
969 if (t->to_store_registers != NULL)
971 t->to_store_registers (t, regcache, regno);
978 /* The to_prepare_to_store method of target record-btrace. */
981 record_btrace_prepare_to_store (struct target_ops *ops,
982 struct regcache *regcache)
984 struct target_ops *t;
986 if (record_btrace_is_replaying ())
989 for (t = ops->beneath; t != NULL; t = t->beneath)
990 if (t->to_prepare_to_store != NULL)
992 t->to_prepare_to_store (t, regcache);
997 /* The branch trace frame cache. */
999 struct btrace_frame_cache
1002 struct thread_info *tp;
1004 /* The frame info. */
1005 struct frame_info *frame;
1007 /* The branch trace function segment. */
1008 const struct btrace_function *bfun;
1011 /* A struct btrace_frame_cache hash table indexed by NEXT. */
1013 static htab_t bfcache;
1015 /* hash_f for htab_create_alloc of bfcache. */
1018 bfcache_hash (const void *arg)
1020 const struct btrace_frame_cache *cache = arg;
1022 return htab_hash_pointer (cache->frame);
1025 /* eq_f for htab_create_alloc of bfcache. */
1028 bfcache_eq (const void *arg1, const void *arg2)
1030 const struct btrace_frame_cache *cache1 = arg1;
1031 const struct btrace_frame_cache *cache2 = arg2;
1033 return cache1->frame == cache2->frame;
1036 /* Create a new btrace frame cache. */
1038 static struct btrace_frame_cache *
1039 bfcache_new (struct frame_info *frame)
1041 struct btrace_frame_cache *cache;
1044 cache = FRAME_OBSTACK_ZALLOC (struct btrace_frame_cache);
1045 cache->frame = frame;
1047 slot = htab_find_slot (bfcache, cache, INSERT);
1048 gdb_assert (*slot == NULL);
1054 /* Extract the branch trace function from a branch trace frame. */
1056 static const struct btrace_function *
1057 btrace_get_frame_function (struct frame_info *frame)
1059 const struct btrace_frame_cache *cache;
1060 const struct btrace_function *bfun;
1061 struct btrace_frame_cache pattern;
1064 pattern.frame = frame;
1066 slot = htab_find_slot (bfcache, &pattern, NO_INSERT);
1074 /* Implement stop_reason method for record_btrace_frame_unwind. */
1076 static enum unwind_stop_reason
1077 record_btrace_frame_unwind_stop_reason (struct frame_info *this_frame,
1080 const struct btrace_frame_cache *cache;
1081 const struct btrace_function *bfun;
1083 cache = *this_cache;
1085 gdb_assert (bfun != NULL);
1087 if (bfun->up == NULL)
1088 return UNWIND_UNAVAILABLE;
1090 return UNWIND_NO_REASON;
1093 /* Implement this_id method for record_btrace_frame_unwind. */
1096 record_btrace_frame_this_id (struct frame_info *this_frame, void **this_cache,
1097 struct frame_id *this_id)
1099 const struct btrace_frame_cache *cache;
1100 const struct btrace_function *bfun;
1101 CORE_ADDR code, special;
1103 cache = *this_cache;
1106 gdb_assert (bfun != NULL);
1108 while (bfun->segment.prev != NULL)
1109 bfun = bfun->segment.prev;
1111 code = get_frame_func (this_frame);
1112 special = bfun->number;
1114 *this_id = frame_id_build_unavailable_stack_special (code, special);
1116 DEBUG ("[frame] %s id: (!stack, pc=%s, special=%s)",
1117 btrace_get_bfun_name (cache->bfun),
1118 core_addr_to_string_nz (this_id->code_addr),
1119 core_addr_to_string_nz (this_id->special_addr));
1122 /* Implement prev_register method for record_btrace_frame_unwind. */
1124 static struct value *
1125 record_btrace_frame_prev_register (struct frame_info *this_frame,
1129 const struct btrace_frame_cache *cache;
1130 const struct btrace_function *bfun, *caller;
1131 const struct btrace_insn *insn;
1132 struct gdbarch *gdbarch;
1136 gdbarch = get_frame_arch (this_frame);
1137 pcreg = gdbarch_pc_regnum (gdbarch);
1138 if (pcreg < 0 || regnum != pcreg)
1139 throw_error (NOT_AVAILABLE_ERROR,
1140 _("Registers are not available in btrace record history"));
1142 cache = *this_cache;
1144 gdb_assert (bfun != NULL);
1148 throw_error (NOT_AVAILABLE_ERROR,
1149 _("No caller in btrace record history"));
1151 if ((bfun->flags & BFUN_UP_LINKS_TO_RET) != 0)
1153 insn = VEC_index (btrace_insn_s, caller->insn, 0);
1158 insn = VEC_last (btrace_insn_s, caller->insn);
1161 pc += gdb_insn_length (gdbarch, pc);
1164 DEBUG ("[frame] unwound PC in %s on level %d: %s",
1165 btrace_get_bfun_name (bfun), bfun->level,
1166 core_addr_to_string_nz (pc));
1168 return frame_unwind_got_address (this_frame, regnum, pc);
1171 /* Implement sniffer method for record_btrace_frame_unwind. */
1174 record_btrace_frame_sniffer (const struct frame_unwind *self,
1175 struct frame_info *this_frame,
1178 const struct btrace_function *bfun;
1179 struct btrace_frame_cache *cache;
1180 struct thread_info *tp;
1181 struct frame_info *next;
1183 /* THIS_FRAME does not contain a reference to its thread. */
1184 tp = find_thread_ptid (inferior_ptid);
1185 gdb_assert (tp != NULL);
1188 next = get_next_frame (this_frame);
1191 const struct btrace_insn_iterator *replay;
1193 replay = tp->btrace.replay;
1195 bfun = replay->function;
1199 const struct btrace_function *callee;
1201 callee = btrace_get_frame_function (next);
1202 if (callee != NULL && (callee->flags & BFUN_UP_LINKS_TO_TAILCALL) == 0)
1209 DEBUG ("[frame] sniffed frame for %s on level %d",
1210 btrace_get_bfun_name (bfun), bfun->level);
1212 /* This is our frame. Initialize the frame cache. */
1213 cache = bfcache_new (this_frame);
1217 *this_cache = cache;
1221 /* Implement sniffer method for record_btrace_tailcall_frame_unwind. */
1224 record_btrace_tailcall_frame_sniffer (const struct frame_unwind *self,
1225 struct frame_info *this_frame,
1228 const struct btrace_function *bfun, *callee;
1229 struct btrace_frame_cache *cache;
1230 struct frame_info *next;
1232 next = get_next_frame (this_frame);
1236 callee = btrace_get_frame_function (next);
1240 if ((callee->flags & BFUN_UP_LINKS_TO_TAILCALL) == 0)
1247 DEBUG ("[frame] sniffed tailcall frame for %s on level %d",
1248 btrace_get_bfun_name (bfun), bfun->level);
1250 /* This is our frame. Initialize the frame cache. */
1251 cache = bfcache_new (this_frame);
1252 cache->tp = find_thread_ptid (inferior_ptid);
1255 *this_cache = cache;
1260 record_btrace_frame_dealloc_cache (struct frame_info *self, void *this_cache)
1262 struct btrace_frame_cache *cache;
1267 slot = htab_find_slot (bfcache, cache, NO_INSERT);
1268 gdb_assert (slot != NULL);
1270 htab_remove_elt (bfcache, cache);
1273 /* btrace recording does not store previous memory content, neither the stack
1274 frames content. Any unwinding would return errorneous results as the stack
1275 contents no longer matches the changed PC value restored from history.
1276 Therefore this unwinder reports any possibly unwound registers as
1279 const struct frame_unwind record_btrace_frame_unwind =
1282 record_btrace_frame_unwind_stop_reason,
1283 record_btrace_frame_this_id,
1284 record_btrace_frame_prev_register,
1286 record_btrace_frame_sniffer,
1287 record_btrace_frame_dealloc_cache
1290 const struct frame_unwind record_btrace_tailcall_frame_unwind =
1293 record_btrace_frame_unwind_stop_reason,
1294 record_btrace_frame_this_id,
1295 record_btrace_frame_prev_register,
1297 record_btrace_tailcall_frame_sniffer,
1298 record_btrace_frame_dealloc_cache
1301 /* Indicate that TP should be resumed according to FLAG. */
1304 record_btrace_resume_thread (struct thread_info *tp,
1305 enum btrace_thread_flag flag)
1307 struct btrace_thread_info *btinfo;
1309 DEBUG ("resuming %d (%s): %u", tp->num, target_pid_to_str (tp->ptid), flag);
1311 btinfo = &tp->btrace;
1313 if ((btinfo->flags & BTHR_MOVE) != 0)
1314 error (_("Thread already moving."));
1316 /* Fetch the latest branch trace. */
1319 btinfo->flags |= flag;
1322 /* Find the thread to resume given a PTID. */
1324 static struct thread_info *
1325 record_btrace_find_resume_thread (ptid_t ptid)
1327 struct thread_info *tp;
1329 /* When asked to resume everything, we pick the current thread. */
1330 if (ptid_equal (minus_one_ptid, ptid) || ptid_is_pid (ptid))
1331 ptid = inferior_ptid;
1333 return find_thread_ptid (ptid);
1336 /* Start replaying a thread. */
1338 static struct btrace_insn_iterator *
1339 record_btrace_start_replaying (struct thread_info *tp)
1341 volatile struct gdb_exception except;
1342 struct btrace_insn_iterator *replay;
1343 struct btrace_thread_info *btinfo;
1346 btinfo = &tp->btrace;
1349 /* We can't start replaying without trace. */
1350 if (btinfo->begin == NULL)
1353 /* Clear the executing flag to allow changes to the current frame.
1354 We are not actually running, yet. We just started a reverse execution
1355 command or a record goto command.
1356 For the latter, EXECUTING is false and this has no effect.
1357 For the former, EXECUTING is true and we're in to_wait, about to
1358 move the thread. Since we need to recompute the stack, we temporarily
1359 set EXECUTING to flase. */
1360 executing = is_executing (tp->ptid);
1361 set_executing (tp->ptid, 0);
1363 /* GDB stores the current frame_id when stepping in order to detects steps
1365 Since frames are computed differently when we're replaying, we need to
1366 recompute those stored frames and fix them up so we can still detect
1367 subroutines after we started replaying. */
1368 TRY_CATCH (except, RETURN_MASK_ALL)
1370 struct frame_info *frame;
1371 struct frame_id frame_id;
1372 int upd_step_frame_id, upd_step_stack_frame_id;
1374 /* The current frame without replaying - computed via normal unwind. */
1375 frame = get_current_frame ();
1376 frame_id = get_frame_id (frame);
1378 /* Check if we need to update any stepping-related frame id's. */
1379 upd_step_frame_id = frame_id_eq (frame_id,
1380 tp->control.step_frame_id);
1381 upd_step_stack_frame_id = frame_id_eq (frame_id,
1382 tp->control.step_stack_frame_id);
1384 /* We start replaying at the end of the branch trace. This corresponds
1385 to the current instruction. */
1386 replay = xmalloc (sizeof (*replay));
1387 btrace_insn_end (replay, btinfo);
1389 /* We're not replaying, yet. */
1390 gdb_assert (btinfo->replay == NULL);
1391 btinfo->replay = replay;
1393 /* Make sure we're not using any stale registers. */
1394 registers_changed_ptid (tp->ptid);
1396 /* The current frame with replaying - computed via btrace unwind. */
1397 frame = get_current_frame ();
1398 frame_id = get_frame_id (frame);
1400 /* Replace stepping related frames where necessary. */
1401 if (upd_step_frame_id)
1402 tp->control.step_frame_id = frame_id;
1403 if (upd_step_stack_frame_id)
1404 tp->control.step_stack_frame_id = frame_id;
1407 /* Restore the previous execution state. */
1408 set_executing (tp->ptid, executing);
1410 if (except.reason < 0)
1412 xfree (btinfo->replay);
1413 btinfo->replay = NULL;
1415 registers_changed_ptid (tp->ptid);
1417 throw_exception (except);
1423 /* Stop replaying a thread. */
1426 record_btrace_stop_replaying (struct thread_info *tp)
1428 struct btrace_thread_info *btinfo;
1430 btinfo = &tp->btrace;
1432 xfree (btinfo->replay);
1433 btinfo->replay = NULL;
1435 /* Make sure we're not leaving any stale registers. */
1436 registers_changed_ptid (tp->ptid);
1439 /* The to_resume method of target record-btrace. */
1442 record_btrace_resume (struct target_ops *ops, ptid_t ptid, int step,
1443 enum gdb_signal signal)
1445 struct thread_info *tp, *other;
1446 enum btrace_thread_flag flag;
1448 DEBUG ("resume %s: %s", target_pid_to_str (ptid), step ? "step" : "cont");
1450 tp = record_btrace_find_resume_thread (ptid);
1452 error (_("Cannot find thread to resume."));
1454 /* Stop replaying other threads if the thread to resume is not replaying. */
1455 if (!btrace_is_replaying (tp) && execution_direction != EXEC_REVERSE)
1457 record_btrace_stop_replaying (other);
1459 /* As long as we're not replaying, just forward the request. */
1460 if (!record_btrace_is_replaying () && execution_direction != EXEC_REVERSE)
1462 for (ops = ops->beneath; ops != NULL; ops = ops->beneath)
1463 if (ops->to_resume != NULL)
1464 return ops->to_resume (ops, ptid, step, signal);
1466 error (_("Cannot find target for stepping."));
1469 /* Compute the btrace thread flag for the requested move. */
1471 flag = execution_direction == EXEC_REVERSE ? BTHR_RCONT : BTHR_CONT;
1473 flag = execution_direction == EXEC_REVERSE ? BTHR_RSTEP : BTHR_STEP;
1475 /* At the moment, we only move a single thread. We could also move
1476 all threads in parallel by single-stepping each resumed thread
1477 until the first runs into an event.
1478 When we do that, we would want to continue all other threads.
1479 For now, just resume one thread to not confuse to_wait. */
1480 record_btrace_resume_thread (tp, flag);
1482 /* We just indicate the resume intent here. The actual stepping happens in
1483 record_btrace_wait below. */
1486 /* Find a thread to move. */
1488 static struct thread_info *
1489 record_btrace_find_thread_to_move (ptid_t ptid)
1491 struct thread_info *tp;
1493 /* First check the parameter thread. */
1494 tp = find_thread_ptid (ptid);
1495 if (tp != NULL && (tp->btrace.flags & BTHR_MOVE) != 0)
1498 /* Otherwise, find one other thread that has been resumed. */
1500 if ((tp->btrace.flags & BTHR_MOVE) != 0)
1506 /* Return a target_waitstatus indicating that we ran out of history. */
1508 static struct target_waitstatus
1509 btrace_step_no_history (void)
1511 struct target_waitstatus status;
1513 status.kind = TARGET_WAITKIND_NO_HISTORY;
1518 /* Return a target_waitstatus indicating that a step finished. */
1520 static struct target_waitstatus
1521 btrace_step_stopped (void)
1523 struct target_waitstatus status;
1525 status.kind = TARGET_WAITKIND_STOPPED;
1526 status.value.sig = GDB_SIGNAL_TRAP;
1531 /* Clear the record histories. */
1534 record_btrace_clear_histories (struct btrace_thread_info *btinfo)
1536 xfree (btinfo->insn_history);
1537 xfree (btinfo->call_history);
1539 btinfo->insn_history = NULL;
1540 btinfo->call_history = NULL;
1543 /* Step a single thread. */
1545 static struct target_waitstatus
1546 record_btrace_step_thread (struct thread_info *tp)
1548 struct btrace_insn_iterator *replay, end;
1549 struct btrace_thread_info *btinfo;
1550 struct address_space *aspace;
1551 struct inferior *inf;
1552 enum btrace_thread_flag flags;
1555 btinfo = &tp->btrace;
1556 replay = btinfo->replay;
1558 flags = btinfo->flags & BTHR_MOVE;
1559 btinfo->flags &= ~BTHR_MOVE;
1561 DEBUG ("stepping %d (%s): %u", tp->num, target_pid_to_str (tp->ptid), flags);
1566 internal_error (__FILE__, __LINE__, _("invalid stepping type."));
1569 /* We're done if we're not replaying. */
1571 return btrace_step_no_history ();
1573 /* We are always able to step at least once. */
1574 steps = btrace_insn_next (replay, 1);
1575 gdb_assert (steps == 1);
1577 /* Determine the end of the instruction trace. */
1578 btrace_insn_end (&end, btinfo);
1580 /* We stop replaying if we reached the end of the trace. */
1581 if (btrace_insn_cmp (replay, &end) == 0)
1582 record_btrace_stop_replaying (tp);
1584 return btrace_step_stopped ();
1587 /* Start replaying if we're not already doing so. */
1589 replay = record_btrace_start_replaying (tp);
1591 /* If we can't step any further, we reached the end of the history. */
1592 steps = btrace_insn_prev (replay, 1);
1594 return btrace_step_no_history ();
1596 return btrace_step_stopped ();
1599 /* We're done if we're not replaying. */
1601 return btrace_step_no_history ();
1603 inf = find_inferior_pid (ptid_get_pid (tp->ptid));
1604 aspace = inf->aspace;
1606 /* Determine the end of the instruction trace. */
1607 btrace_insn_end (&end, btinfo);
1611 const struct btrace_insn *insn;
1613 /* We are always able to step at least once. */
1614 steps = btrace_insn_next (replay, 1);
1615 gdb_assert (steps == 1);
1617 /* We stop replaying if we reached the end of the trace. */
1618 if (btrace_insn_cmp (replay, &end) == 0)
1620 record_btrace_stop_replaying (tp);
1621 return btrace_step_no_history ();
1624 insn = btrace_insn_get (replay);
1627 DEBUG ("stepping %d (%s) ... %s", tp->num,
1628 target_pid_to_str (tp->ptid),
1629 core_addr_to_string_nz (insn->pc));
1631 if (breakpoint_here_p (aspace, insn->pc))
1632 return btrace_step_stopped ();
1636 /* Start replaying if we're not already doing so. */
1638 replay = record_btrace_start_replaying (tp);
1640 inf = find_inferior_pid (ptid_get_pid (tp->ptid));
1641 aspace = inf->aspace;
1645 const struct btrace_insn *insn;
1647 /* If we can't step any further, we're done. */
1648 steps = btrace_insn_prev (replay, 1);
1650 return btrace_step_no_history ();
1652 insn = btrace_insn_get (replay);
1655 DEBUG ("reverse-stepping %d (%s) ... %s", tp->num,
1656 target_pid_to_str (tp->ptid),
1657 core_addr_to_string_nz (insn->pc));
1659 if (breakpoint_here_p (aspace, insn->pc))
1660 return btrace_step_stopped ();
1665 /* The to_wait method of target record-btrace. */
1668 record_btrace_wait (struct target_ops *ops, ptid_t ptid,
1669 struct target_waitstatus *status, int options)
1671 struct thread_info *tp, *other;
1673 DEBUG ("wait %s (0x%x)", target_pid_to_str (ptid), options);
1675 /* As long as we're not replaying, just forward the request. */
1676 if (!record_btrace_is_replaying () && execution_direction != EXEC_REVERSE)
1678 for (ops = ops->beneath; ops != NULL; ops = ops->beneath)
1679 if (ops->to_wait != NULL)
1680 return ops->to_wait (ops, ptid, status, options);
1682 error (_("Cannot find target for waiting."));
1685 /* Let's find a thread to move. */
1686 tp = record_btrace_find_thread_to_move (ptid);
1689 DEBUG ("wait %s: no thread", target_pid_to_str (ptid));
1691 status->kind = TARGET_WAITKIND_IGNORE;
1692 return minus_one_ptid;
1695 /* We only move a single thread. We're not able to correlate threads. */
1696 *status = record_btrace_step_thread (tp);
1698 /* Stop all other threads. */
1701 other->btrace.flags &= ~BTHR_MOVE;
1703 /* Start record histories anew from the current position. */
1704 record_btrace_clear_histories (&tp->btrace);
1706 /* We moved the replay position but did not update registers. */
1707 registers_changed_ptid (tp->ptid);
1712 /* The to_can_execute_reverse method of target record-btrace. */
1715 record_btrace_can_execute_reverse (void)
1720 /* The to_decr_pc_after_break method of target record-btrace. */
1723 record_btrace_decr_pc_after_break (struct target_ops *ops,
1724 struct gdbarch *gdbarch)
1726 /* When replaying, we do not actually execute the breakpoint instruction
1727 so there is no need to adjust the PC after hitting a breakpoint. */
1728 if (record_btrace_is_replaying ())
1731 return forward_target_decr_pc_after_break (ops->beneath, gdbarch);
1734 /* The to_find_new_threads method of target record-btrace. */
1737 record_btrace_find_new_threads (struct target_ops *ops)
1739 /* Don't expect new threads if we're replaying. */
1740 if (record_btrace_is_replaying ())
1743 /* Forward the request. */
1744 for (ops = ops->beneath; ops != NULL; ops = ops->beneath)
1745 if (ops->to_find_new_threads != NULL)
1747 ops->to_find_new_threads (ops);
1752 /* The to_thread_alive method of target record-btrace. */
1755 record_btrace_thread_alive (struct target_ops *ops, ptid_t ptid)
1757 /* We don't add or remove threads during replay. */
1758 if (record_btrace_is_replaying ())
1759 return find_thread_ptid (ptid) != NULL;
1761 /* Forward the request. */
1762 for (ops = ops->beneath; ops != NULL; ops = ops->beneath)
1763 if (ops->to_thread_alive != NULL)
1764 return ops->to_thread_alive (ops, ptid);
1769 /* Set the replay branch trace instruction iterator. If IT is NULL, replay
1773 record_btrace_set_replay (struct thread_info *tp,
1774 const struct btrace_insn_iterator *it)
1776 struct btrace_thread_info *btinfo;
1778 btinfo = &tp->btrace;
1780 if (it == NULL || it->function == NULL)
1781 record_btrace_stop_replaying (tp);
1784 if (btinfo->replay == NULL)
1785 record_btrace_start_replaying (tp);
1786 else if (btrace_insn_cmp (btinfo->replay, it) == 0)
1789 *btinfo->replay = *it;
1790 registers_changed_ptid (tp->ptid);
1793 /* Start anew from the new replay position. */
1794 record_btrace_clear_histories (btinfo);
1797 /* The to_goto_record_begin method of target record-btrace. */
1800 record_btrace_goto_begin (void)
1802 struct thread_info *tp;
1803 struct btrace_insn_iterator begin;
1805 tp = require_btrace_thread ();
1807 btrace_insn_begin (&begin, &tp->btrace);
1808 record_btrace_set_replay (tp, &begin);
1810 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC, 1);
1813 /* The to_goto_record_end method of target record-btrace. */
1816 record_btrace_goto_end (void)
1818 struct thread_info *tp;
1820 tp = require_btrace_thread ();
1822 record_btrace_set_replay (tp, NULL);
1824 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC, 1);
1827 /* The to_goto_record method of target record-btrace. */
1830 record_btrace_goto (ULONGEST insn)
1832 struct thread_info *tp;
1833 struct btrace_insn_iterator it;
1834 unsigned int number;
1839 /* Check for wrap-arounds. */
1841 error (_("Instruction number out of range."));
1843 tp = require_btrace_thread ();
1845 found = btrace_find_insn_by_number (&it, &tp->btrace, number);
1847 error (_("No such instruction."));
1849 record_btrace_set_replay (tp, &it);
1851 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC, 1);
1854 /* Initialize the record-btrace target ops. */
1857 init_record_btrace_ops (void)
1859 struct target_ops *ops;
1861 ops = &record_btrace_ops;
1862 ops->to_shortname = "record-btrace";
1863 ops->to_longname = "Branch tracing target";
1864 ops->to_doc = "Collect control-flow trace and provide the execution history.";
1865 ops->to_open = record_btrace_open;
1866 ops->to_close = record_btrace_close;
1867 ops->to_detach = record_detach;
1868 ops->to_disconnect = record_disconnect;
1869 ops->to_mourn_inferior = record_mourn_inferior;
1870 ops->to_kill = record_kill;
1871 ops->to_create_inferior = find_default_create_inferior;
1872 ops->to_stop_recording = record_btrace_stop_recording;
1873 ops->to_info_record = record_btrace_info;
1874 ops->to_insn_history = record_btrace_insn_history;
1875 ops->to_insn_history_from = record_btrace_insn_history_from;
1876 ops->to_insn_history_range = record_btrace_insn_history_range;
1877 ops->to_call_history = record_btrace_call_history;
1878 ops->to_call_history_from = record_btrace_call_history_from;
1879 ops->to_call_history_range = record_btrace_call_history_range;
1880 ops->to_record_is_replaying = record_btrace_is_replaying;
1881 ops->to_xfer_partial = record_btrace_xfer_partial;
1882 ops->to_remove_breakpoint = record_btrace_remove_breakpoint;
1883 ops->to_insert_breakpoint = record_btrace_insert_breakpoint;
1884 ops->to_fetch_registers = record_btrace_fetch_registers;
1885 ops->to_store_registers = record_btrace_store_registers;
1886 ops->to_prepare_to_store = record_btrace_prepare_to_store;
1887 ops->to_get_unwinder = &record_btrace_frame_unwind;
1888 ops->to_get_tailcall_unwinder = &record_btrace_tailcall_frame_unwind;
1889 ops->to_resume = record_btrace_resume;
1890 ops->to_wait = record_btrace_wait;
1891 ops->to_find_new_threads = record_btrace_find_new_threads;
1892 ops->to_thread_alive = record_btrace_thread_alive;
1893 ops->to_goto_record_begin = record_btrace_goto_begin;
1894 ops->to_goto_record_end = record_btrace_goto_end;
1895 ops->to_goto_record = record_btrace_goto;
1896 ops->to_can_execute_reverse = record_btrace_can_execute_reverse;
1897 ops->to_decr_pc_after_break = record_btrace_decr_pc_after_break;
1898 ops->to_stratum = record_stratum;
1899 ops->to_magic = OPS_MAGIC;
1902 /* Alias for "target record". */
1905 cmd_record_btrace_start (char *args, int from_tty)
1907 if (args != NULL && *args != 0)
1908 error (_("Invalid argument."));
1910 execute_command ("target record-btrace", from_tty);
1913 void _initialize_record_btrace (void);
1915 /* Initialize btrace commands. */
1918 _initialize_record_btrace (void)
1920 add_cmd ("btrace", class_obscure, cmd_record_btrace_start,
1921 _("Start branch trace recording."),
1923 add_alias_cmd ("b", "btrace", class_obscure, 1, &record_cmdlist);
1925 init_record_btrace_ops ();
1926 add_target (&record_btrace_ops);
1928 bfcache = htab_create_alloc (50, bfcache_hash, bfcache_eq, NULL,