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 (struct target_ops
*self
)
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 (struct target_ops
*self
)
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 (struct target_ops
*self
)
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 (struct target_ops
*self
, 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 (struct target_ops
*self
,
402 ULONGEST from
, ULONGEST to
, int flags
)
404 struct btrace_thread_info
*btinfo
;
405 struct btrace_insn_history
*history
;
406 struct btrace_insn_iterator begin
, end
;
407 struct cleanup
*uiout_cleanup
;
408 struct ui_out
*uiout
;
409 unsigned int low
, high
;
412 uiout
= current_uiout
;
413 uiout_cleanup
= make_cleanup_ui_out_tuple_begin_end (uiout
,
418 DEBUG ("insn-history (0x%x): [%u; %u)", flags
, low
, high
);
420 /* Check for wrap-arounds. */
421 if (low
!= from
|| high
!= to
)
422 error (_("Bad range."));
425 error (_("Bad range."));
427 btinfo
= require_btrace ();
429 found
= btrace_find_insn_by_number (&begin
, btinfo
, low
);
431 error (_("Range out of bounds."));
433 found
= btrace_find_insn_by_number (&end
, btinfo
, high
);
436 /* Silently truncate the range. */
437 btrace_insn_end (&end
, btinfo
);
441 /* We want both begin and end to be inclusive. */
442 btrace_insn_next (&end
, 1);
445 btrace_insn_history (uiout
, &begin
, &end
, flags
);
446 btrace_set_insn_history (btinfo
, &begin
, &end
);
448 do_cleanups (uiout_cleanup
);
451 /* The to_insn_history_from method of target record-btrace. */
454 record_btrace_insn_history_from (struct target_ops
*self
,
455 ULONGEST from
, int size
, int flags
)
457 ULONGEST begin
, end
, context
;
459 context
= abs (size
);
461 error (_("Bad record instruction-history-size."));
470 begin
= from
- context
+ 1;
475 end
= from
+ context
- 1;
477 /* Check for wrap-around. */
482 record_btrace_insn_history_range (self
, begin
, end
, flags
);
485 /* Print the instruction number range for a function call history line. */
488 btrace_call_history_insn_range (struct ui_out
*uiout
,
489 const struct btrace_function
*bfun
)
491 unsigned int begin
, end
, size
;
493 size
= VEC_length (btrace_insn_s
, bfun
->insn
);
494 gdb_assert (size
> 0);
496 begin
= bfun
->insn_offset
;
497 end
= begin
+ size
- 1;
499 ui_out_field_uint (uiout
, "insn begin", begin
);
500 ui_out_text (uiout
, ",");
501 ui_out_field_uint (uiout
, "insn end", end
);
504 /* Print the source line information for a function call history line. */
507 btrace_call_history_src_line (struct ui_out
*uiout
,
508 const struct btrace_function
*bfun
)
517 ui_out_field_string (uiout
, "file",
518 symtab_to_filename_for_display (sym
->symtab
));
520 begin
= bfun
->lbegin
;
526 ui_out_text (uiout
, ":");
527 ui_out_field_int (uiout
, "min line", begin
);
532 ui_out_text (uiout
, ",");
533 ui_out_field_int (uiout
, "max line", end
);
536 /* Get the name of a branch trace function. */
539 btrace_get_bfun_name (const struct btrace_function
*bfun
)
541 struct minimal_symbol
*msym
;
551 return SYMBOL_PRINT_NAME (sym
);
552 else if (msym
!= NULL
)
553 return SYMBOL_PRINT_NAME (msym
);
558 /* Disassemble a section of the recorded function trace. */
561 btrace_call_history (struct ui_out
*uiout
,
562 const struct btrace_thread_info
*btinfo
,
563 const struct btrace_call_iterator
*begin
,
564 const struct btrace_call_iterator
*end
,
565 enum record_print_flag flags
)
567 struct btrace_call_iterator it
;
569 DEBUG ("ftrace (0x%x): [%u; %u)", flags
, btrace_call_number (begin
),
570 btrace_call_number (end
));
572 for (it
= *begin
; btrace_call_cmp (&it
, end
) < 0; btrace_call_next (&it
, 1))
574 const struct btrace_function
*bfun
;
575 struct minimal_symbol
*msym
;
578 bfun
= btrace_call_get (&it
);
582 /* Print the function index. */
583 ui_out_field_uint (uiout
, "index", bfun
->number
);
584 ui_out_text (uiout
, "\t");
586 if ((flags
& RECORD_PRINT_INDENT_CALLS
) != 0)
588 int level
= bfun
->level
+ btinfo
->level
, i
;
590 for (i
= 0; i
< level
; ++i
)
591 ui_out_text (uiout
, " ");
595 ui_out_field_string (uiout
, "function", SYMBOL_PRINT_NAME (sym
));
596 else if (msym
!= NULL
)
597 ui_out_field_string (uiout
, "function", SYMBOL_PRINT_NAME (msym
));
598 else if (!ui_out_is_mi_like_p (uiout
))
599 ui_out_field_string (uiout
, "function", "??");
601 if ((flags
& RECORD_PRINT_INSN_RANGE
) != 0)
603 ui_out_text (uiout
, _("\tinst "));
604 btrace_call_history_insn_range (uiout
, bfun
);
607 if ((flags
& RECORD_PRINT_SRC_LINE
) != 0)
609 ui_out_text (uiout
, _("\tat "));
610 btrace_call_history_src_line (uiout
, bfun
);
613 ui_out_text (uiout
, "\n");
617 /* The to_call_history method of target record-btrace. */
620 record_btrace_call_history (struct target_ops
*self
, int size
, int flags
)
622 struct btrace_thread_info
*btinfo
;
623 struct btrace_call_history
*history
;
624 struct btrace_call_iterator begin
, end
;
625 struct cleanup
*uiout_cleanup
;
626 struct ui_out
*uiout
;
627 unsigned int context
, covered
;
629 uiout
= current_uiout
;
630 uiout_cleanup
= make_cleanup_ui_out_tuple_begin_end (uiout
,
632 context
= abs (size
);
634 error (_("Bad record function-call-history-size."));
636 btinfo
= require_btrace ();
637 history
= btinfo
->call_history
;
640 struct btrace_insn_iterator
*replay
;
642 DEBUG ("call-history (0x%x): %d", flags
, size
);
644 /* If we're replaying, we start at the replay position. Otherwise, we
645 start at the tail of the trace. */
646 replay
= btinfo
->replay
;
649 begin
.function
= replay
->function
;
650 begin
.btinfo
= btinfo
;
653 btrace_call_end (&begin
, btinfo
);
655 /* We start from here and expand in the requested direction. Then we
656 expand in the other direction, as well, to fill up any remaining
661 /* We want the current position covered, as well. */
662 covered
= btrace_call_next (&end
, 1);
663 covered
+= btrace_call_prev (&begin
, context
- covered
);
664 covered
+= btrace_call_next (&end
, context
- covered
);
668 covered
= btrace_call_next (&end
, context
);
669 covered
+= btrace_call_prev (&begin
, context
- covered
);
674 begin
= history
->begin
;
677 DEBUG ("call-history (0x%x): %d, prev: [%u; %u)", flags
, size
,
678 btrace_call_number (&begin
), btrace_call_number (&end
));
683 covered
= btrace_call_prev (&begin
, context
);
688 covered
= btrace_call_next (&end
, context
);
693 btrace_call_history (uiout
, btinfo
, &begin
, &end
, flags
);
697 printf_unfiltered (_("At the start of the branch trace record.\n"));
699 printf_unfiltered (_("At the end of the branch trace record.\n"));
702 btrace_set_call_history (btinfo
, &begin
, &end
);
703 do_cleanups (uiout_cleanup
);
706 /* The to_call_history_range method of target record-btrace. */
709 record_btrace_call_history_range (ULONGEST from
, ULONGEST to
, int flags
)
711 struct btrace_thread_info
*btinfo
;
712 struct btrace_call_history
*history
;
713 struct btrace_call_iterator begin
, end
;
714 struct cleanup
*uiout_cleanup
;
715 struct ui_out
*uiout
;
716 unsigned int low
, high
;
719 uiout
= current_uiout
;
720 uiout_cleanup
= make_cleanup_ui_out_tuple_begin_end (uiout
,
725 DEBUG ("call-history (0x%x): [%u; %u)", flags
, low
, high
);
727 /* Check for wrap-arounds. */
728 if (low
!= from
|| high
!= to
)
729 error (_("Bad range."));
732 error (_("Bad range."));
734 btinfo
= require_btrace ();
736 found
= btrace_find_call_by_number (&begin
, btinfo
, low
);
738 error (_("Range out of bounds."));
740 found
= btrace_find_call_by_number (&end
, btinfo
, high
);
743 /* Silently truncate the range. */
744 btrace_call_end (&end
, btinfo
);
748 /* We want both begin and end to be inclusive. */
749 btrace_call_next (&end
, 1);
752 btrace_call_history (uiout
, btinfo
, &begin
, &end
, flags
);
753 btrace_set_call_history (btinfo
, &begin
, &end
);
755 do_cleanups (uiout_cleanup
);
758 /* The to_call_history_from method of target record-btrace. */
761 record_btrace_call_history_from (struct target_ops
*self
,
762 ULONGEST from
, int size
, int flags
)
764 ULONGEST begin
, end
, context
;
766 context
= abs (size
);
768 error (_("Bad record function-call-history-size."));
777 begin
= from
- context
+ 1;
782 end
= from
+ context
- 1;
784 /* Check for wrap-around. */
789 record_btrace_call_history_range (begin
, end
, flags
);
792 /* The to_record_is_replaying method of target record-btrace. */
795 record_btrace_is_replaying (struct target_ops
*self
)
797 struct thread_info
*tp
;
800 if (btrace_is_replaying (tp
))
806 /* The to_xfer_partial method of target record-btrace. */
808 static enum target_xfer_status
809 record_btrace_xfer_partial (struct target_ops
*ops
, enum target_object object
,
810 const char *annex
, gdb_byte
*readbuf
,
811 const gdb_byte
*writebuf
, ULONGEST offset
,
812 ULONGEST len
, ULONGEST
*xfered_len
)
814 struct target_ops
*t
;
816 /* Filter out requests that don't make sense during replay. */
817 if (!record_btrace_allow_memory_access
&& record_btrace_is_replaying (ops
))
821 case TARGET_OBJECT_MEMORY
:
823 struct target_section
*section
;
825 /* We do not allow writing memory in general. */
826 if (writebuf
!= NULL
)
829 return TARGET_XFER_E_UNAVAILABLE
;
832 /* We allow reading readonly memory. */
833 section
= target_section_by_addr (ops
, offset
);
836 /* Check if the section we found is readonly. */
837 if ((bfd_get_section_flags (section
->the_bfd_section
->owner
,
838 section
->the_bfd_section
)
839 & SEC_READONLY
) != 0)
841 /* Truncate the request to fit into this section. */
842 len
= min (len
, section
->endaddr
- offset
);
848 return TARGET_XFER_E_UNAVAILABLE
;
853 /* Forward the request. */
854 for (ops
= ops
->beneath
; ops
!= NULL
; ops
= ops
->beneath
)
855 if (ops
->to_xfer_partial
!= NULL
)
856 return ops
->to_xfer_partial (ops
, object
, annex
, readbuf
, writebuf
,
857 offset
, len
, xfered_len
);
860 return TARGET_XFER_E_UNAVAILABLE
;
863 /* The to_insert_breakpoint method of target record-btrace. */
866 record_btrace_insert_breakpoint (struct target_ops
*ops
,
867 struct gdbarch
*gdbarch
,
868 struct bp_target_info
*bp_tgt
)
870 volatile struct gdb_exception except
;
873 /* Inserting breakpoints requires accessing memory. Allow it for the
874 duration of this function. */
875 old
= record_btrace_allow_memory_access
;
876 record_btrace_allow_memory_access
= 1;
879 TRY_CATCH (except
, RETURN_MASK_ALL
)
880 ret
= ops
->beneath
->to_insert_breakpoint (ops
->beneath
, gdbarch
, bp_tgt
);
882 record_btrace_allow_memory_access
= old
;
884 if (except
.reason
< 0)
885 throw_exception (except
);
890 /* The to_remove_breakpoint method of target record-btrace. */
893 record_btrace_remove_breakpoint (struct target_ops
*ops
,
894 struct gdbarch
*gdbarch
,
895 struct bp_target_info
*bp_tgt
)
897 volatile struct gdb_exception except
;
900 /* Removing breakpoints requires accessing memory. Allow it for the
901 duration of this function. */
902 old
= record_btrace_allow_memory_access
;
903 record_btrace_allow_memory_access
= 1;
906 TRY_CATCH (except
, RETURN_MASK_ALL
)
907 ret
= ops
->beneath
->to_remove_breakpoint (ops
->beneath
, gdbarch
, bp_tgt
);
909 record_btrace_allow_memory_access
= old
;
911 if (except
.reason
< 0)
912 throw_exception (except
);
917 /* The to_fetch_registers method of target record-btrace. */
920 record_btrace_fetch_registers (struct target_ops
*ops
,
921 struct regcache
*regcache
, int regno
)
923 struct btrace_insn_iterator
*replay
;
924 struct thread_info
*tp
;
926 tp
= find_thread_ptid (inferior_ptid
);
927 gdb_assert (tp
!= NULL
);
929 replay
= tp
->btrace
.replay
;
932 const struct btrace_insn
*insn
;
933 struct gdbarch
*gdbarch
;
936 gdbarch
= get_regcache_arch (regcache
);
937 pcreg
= gdbarch_pc_regnum (gdbarch
);
941 /* We can only provide the PC register. */
942 if (regno
>= 0 && regno
!= pcreg
)
945 insn
= btrace_insn_get (replay
);
946 gdb_assert (insn
!= NULL
);
948 regcache_raw_supply (regcache
, regno
, &insn
->pc
);
952 struct target_ops
*t
;
954 for (t
= ops
->beneath
; t
!= NULL
; t
= t
->beneath
)
955 if (t
->to_fetch_registers
!= NULL
)
957 t
->to_fetch_registers (t
, regcache
, regno
);
963 /* The to_store_registers method of target record-btrace. */
966 record_btrace_store_registers (struct target_ops
*ops
,
967 struct regcache
*regcache
, int regno
)
969 struct target_ops
*t
;
971 if (record_btrace_is_replaying (ops
))
972 error (_("This record target does not allow writing registers."));
974 gdb_assert (may_write_registers
!= 0);
976 for (t
= ops
->beneath
; t
!= NULL
; t
= t
->beneath
)
977 if (t
->to_store_registers
!= NULL
)
979 t
->to_store_registers (t
, regcache
, regno
);
986 /* The to_prepare_to_store method of target record-btrace. */
989 record_btrace_prepare_to_store (struct target_ops
*ops
,
990 struct regcache
*regcache
)
992 struct target_ops
*t
;
994 if (record_btrace_is_replaying (ops
))
997 for (t
= ops
->beneath
; t
!= NULL
; t
= t
->beneath
)
998 if (t
->to_prepare_to_store
!= NULL
)
1000 t
->to_prepare_to_store (t
, regcache
);
1005 /* The branch trace frame cache. */
1007 struct btrace_frame_cache
1010 struct thread_info
*tp
;
1012 /* The frame info. */
1013 struct frame_info
*frame
;
1015 /* The branch trace function segment. */
1016 const struct btrace_function
*bfun
;
1019 /* A struct btrace_frame_cache hash table indexed by NEXT. */
1021 static htab_t bfcache
;
1023 /* hash_f for htab_create_alloc of bfcache. */
1026 bfcache_hash (const void *arg
)
1028 const struct btrace_frame_cache
*cache
= arg
;
1030 return htab_hash_pointer (cache
->frame
);
1033 /* eq_f for htab_create_alloc of bfcache. */
1036 bfcache_eq (const void *arg1
, const void *arg2
)
1038 const struct btrace_frame_cache
*cache1
= arg1
;
1039 const struct btrace_frame_cache
*cache2
= arg2
;
1041 return cache1
->frame
== cache2
->frame
;
1044 /* Create a new btrace frame cache. */
1046 static struct btrace_frame_cache
*
1047 bfcache_new (struct frame_info
*frame
)
1049 struct btrace_frame_cache
*cache
;
1052 cache
= FRAME_OBSTACK_ZALLOC (struct btrace_frame_cache
);
1053 cache
->frame
= frame
;
1055 slot
= htab_find_slot (bfcache
, cache
, INSERT
);
1056 gdb_assert (*slot
== NULL
);
1062 /* Extract the branch trace function from a branch trace frame. */
1064 static const struct btrace_function
*
1065 btrace_get_frame_function (struct frame_info
*frame
)
1067 const struct btrace_frame_cache
*cache
;
1068 const struct btrace_function
*bfun
;
1069 struct btrace_frame_cache pattern
;
1072 pattern
.frame
= frame
;
1074 slot
= htab_find_slot (bfcache
, &pattern
, NO_INSERT
);
1082 /* Implement stop_reason method for record_btrace_frame_unwind. */
1084 static enum unwind_stop_reason
1085 record_btrace_frame_unwind_stop_reason (struct frame_info
*this_frame
,
1088 const struct btrace_frame_cache
*cache
;
1089 const struct btrace_function
*bfun
;
1091 cache
= *this_cache
;
1093 gdb_assert (bfun
!= NULL
);
1095 if (bfun
->up
== NULL
)
1096 return UNWIND_UNAVAILABLE
;
1098 return UNWIND_NO_REASON
;
1101 /* Implement this_id method for record_btrace_frame_unwind. */
1104 record_btrace_frame_this_id (struct frame_info
*this_frame
, void **this_cache
,
1105 struct frame_id
*this_id
)
1107 const struct btrace_frame_cache
*cache
;
1108 const struct btrace_function
*bfun
;
1109 CORE_ADDR code
, special
;
1111 cache
= *this_cache
;
1114 gdb_assert (bfun
!= NULL
);
1116 while (bfun
->segment
.prev
!= NULL
)
1117 bfun
= bfun
->segment
.prev
;
1119 code
= get_frame_func (this_frame
);
1120 special
= bfun
->number
;
1122 *this_id
= frame_id_build_unavailable_stack_special (code
, special
);
1124 DEBUG ("[frame] %s id: (!stack, pc=%s, special=%s)",
1125 btrace_get_bfun_name (cache
->bfun
),
1126 core_addr_to_string_nz (this_id
->code_addr
),
1127 core_addr_to_string_nz (this_id
->special_addr
));
1130 /* Implement prev_register method for record_btrace_frame_unwind. */
1132 static struct value
*
1133 record_btrace_frame_prev_register (struct frame_info
*this_frame
,
1137 const struct btrace_frame_cache
*cache
;
1138 const struct btrace_function
*bfun
, *caller
;
1139 const struct btrace_insn
*insn
;
1140 struct gdbarch
*gdbarch
;
1144 gdbarch
= get_frame_arch (this_frame
);
1145 pcreg
= gdbarch_pc_regnum (gdbarch
);
1146 if (pcreg
< 0 || regnum
!= pcreg
)
1147 throw_error (NOT_AVAILABLE_ERROR
,
1148 _("Registers are not available in btrace record history"));
1150 cache
= *this_cache
;
1152 gdb_assert (bfun
!= NULL
);
1156 throw_error (NOT_AVAILABLE_ERROR
,
1157 _("No caller in btrace record history"));
1159 if ((bfun
->flags
& BFUN_UP_LINKS_TO_RET
) != 0)
1161 insn
= VEC_index (btrace_insn_s
, caller
->insn
, 0);
1166 insn
= VEC_last (btrace_insn_s
, caller
->insn
);
1169 pc
+= gdb_insn_length (gdbarch
, pc
);
1172 DEBUG ("[frame] unwound PC in %s on level %d: %s",
1173 btrace_get_bfun_name (bfun
), bfun
->level
,
1174 core_addr_to_string_nz (pc
));
1176 return frame_unwind_got_address (this_frame
, regnum
, pc
);
1179 /* Implement sniffer method for record_btrace_frame_unwind. */
1182 record_btrace_frame_sniffer (const struct frame_unwind
*self
,
1183 struct frame_info
*this_frame
,
1186 const struct btrace_function
*bfun
;
1187 struct btrace_frame_cache
*cache
;
1188 struct thread_info
*tp
;
1189 struct frame_info
*next
;
1191 /* THIS_FRAME does not contain a reference to its thread. */
1192 tp
= find_thread_ptid (inferior_ptid
);
1193 gdb_assert (tp
!= NULL
);
1196 next
= get_next_frame (this_frame
);
1199 const struct btrace_insn_iterator
*replay
;
1201 replay
= tp
->btrace
.replay
;
1203 bfun
= replay
->function
;
1207 const struct btrace_function
*callee
;
1209 callee
= btrace_get_frame_function (next
);
1210 if (callee
!= NULL
&& (callee
->flags
& BFUN_UP_LINKS_TO_TAILCALL
) == 0)
1217 DEBUG ("[frame] sniffed frame for %s on level %d",
1218 btrace_get_bfun_name (bfun
), bfun
->level
);
1220 /* This is our frame. Initialize the frame cache. */
1221 cache
= bfcache_new (this_frame
);
1225 *this_cache
= cache
;
1229 /* Implement sniffer method for record_btrace_tailcall_frame_unwind. */
1232 record_btrace_tailcall_frame_sniffer (const struct frame_unwind
*self
,
1233 struct frame_info
*this_frame
,
1236 const struct btrace_function
*bfun
, *callee
;
1237 struct btrace_frame_cache
*cache
;
1238 struct frame_info
*next
;
1240 next
= get_next_frame (this_frame
);
1244 callee
= btrace_get_frame_function (next
);
1248 if ((callee
->flags
& BFUN_UP_LINKS_TO_TAILCALL
) == 0)
1255 DEBUG ("[frame] sniffed tailcall frame for %s on level %d",
1256 btrace_get_bfun_name (bfun
), bfun
->level
);
1258 /* This is our frame. Initialize the frame cache. */
1259 cache
= bfcache_new (this_frame
);
1260 cache
->tp
= find_thread_ptid (inferior_ptid
);
1263 *this_cache
= cache
;
1268 record_btrace_frame_dealloc_cache (struct frame_info
*self
, void *this_cache
)
1270 struct btrace_frame_cache
*cache
;
1275 slot
= htab_find_slot (bfcache
, cache
, NO_INSERT
);
1276 gdb_assert (slot
!= NULL
);
1278 htab_remove_elt (bfcache
, cache
);
1281 /* btrace recording does not store previous memory content, neither the stack
1282 frames content. Any unwinding would return errorneous results as the stack
1283 contents no longer matches the changed PC value restored from history.
1284 Therefore this unwinder reports any possibly unwound registers as
1287 const struct frame_unwind record_btrace_frame_unwind
=
1290 record_btrace_frame_unwind_stop_reason
,
1291 record_btrace_frame_this_id
,
1292 record_btrace_frame_prev_register
,
1294 record_btrace_frame_sniffer
,
1295 record_btrace_frame_dealloc_cache
1298 const struct frame_unwind record_btrace_tailcall_frame_unwind
=
1301 record_btrace_frame_unwind_stop_reason
,
1302 record_btrace_frame_this_id
,
1303 record_btrace_frame_prev_register
,
1305 record_btrace_tailcall_frame_sniffer
,
1306 record_btrace_frame_dealloc_cache
1309 /* Indicate that TP should be resumed according to FLAG. */
1312 record_btrace_resume_thread (struct thread_info
*tp
,
1313 enum btrace_thread_flag flag
)
1315 struct btrace_thread_info
*btinfo
;
1317 DEBUG ("resuming %d (%s): %u", tp
->num
, target_pid_to_str (tp
->ptid
), flag
);
1319 btinfo
= &tp
->btrace
;
1321 if ((btinfo
->flags
& BTHR_MOVE
) != 0)
1322 error (_("Thread already moving."));
1324 /* Fetch the latest branch trace. */
1327 btinfo
->flags
|= flag
;
1330 /* Find the thread to resume given a PTID. */
1332 static struct thread_info
*
1333 record_btrace_find_resume_thread (ptid_t ptid
)
1335 struct thread_info
*tp
;
1337 /* When asked to resume everything, we pick the current thread. */
1338 if (ptid_equal (minus_one_ptid
, ptid
) || ptid_is_pid (ptid
))
1339 ptid
= inferior_ptid
;
1341 return find_thread_ptid (ptid
);
1344 /* Start replaying a thread. */
1346 static struct btrace_insn_iterator
*
1347 record_btrace_start_replaying (struct thread_info
*tp
)
1349 volatile struct gdb_exception except
;
1350 struct btrace_insn_iterator
*replay
;
1351 struct btrace_thread_info
*btinfo
;
1354 btinfo
= &tp
->btrace
;
1357 /* We can't start replaying without trace. */
1358 if (btinfo
->begin
== NULL
)
1361 /* Clear the executing flag to allow changes to the current frame.
1362 We are not actually running, yet. We just started a reverse execution
1363 command or a record goto command.
1364 For the latter, EXECUTING is false and this has no effect.
1365 For the former, EXECUTING is true and we're in to_wait, about to
1366 move the thread. Since we need to recompute the stack, we temporarily
1367 set EXECUTING to flase. */
1368 executing
= is_executing (tp
->ptid
);
1369 set_executing (tp
->ptid
, 0);
1371 /* GDB stores the current frame_id when stepping in order to detects steps
1373 Since frames are computed differently when we're replaying, we need to
1374 recompute those stored frames and fix them up so we can still detect
1375 subroutines after we started replaying. */
1376 TRY_CATCH (except
, RETURN_MASK_ALL
)
1378 struct frame_info
*frame
;
1379 struct frame_id frame_id
;
1380 int upd_step_frame_id
, upd_step_stack_frame_id
;
1382 /* The current frame without replaying - computed via normal unwind. */
1383 frame
= get_current_frame ();
1384 frame_id
= get_frame_id (frame
);
1386 /* Check if we need to update any stepping-related frame id's. */
1387 upd_step_frame_id
= frame_id_eq (frame_id
,
1388 tp
->control
.step_frame_id
);
1389 upd_step_stack_frame_id
= frame_id_eq (frame_id
,
1390 tp
->control
.step_stack_frame_id
);
1392 /* We start replaying at the end of the branch trace. This corresponds
1393 to the current instruction. */
1394 replay
= xmalloc (sizeof (*replay
));
1395 btrace_insn_end (replay
, btinfo
);
1397 /* We're not replaying, yet. */
1398 gdb_assert (btinfo
->replay
== NULL
);
1399 btinfo
->replay
= replay
;
1401 /* Make sure we're not using any stale registers. */
1402 registers_changed_ptid (tp
->ptid
);
1404 /* The current frame with replaying - computed via btrace unwind. */
1405 frame
= get_current_frame ();
1406 frame_id
= get_frame_id (frame
);
1408 /* Replace stepping related frames where necessary. */
1409 if (upd_step_frame_id
)
1410 tp
->control
.step_frame_id
= frame_id
;
1411 if (upd_step_stack_frame_id
)
1412 tp
->control
.step_stack_frame_id
= frame_id
;
1415 /* Restore the previous execution state. */
1416 set_executing (tp
->ptid
, executing
);
1418 if (except
.reason
< 0)
1420 xfree (btinfo
->replay
);
1421 btinfo
->replay
= NULL
;
1423 registers_changed_ptid (tp
->ptid
);
1425 throw_exception (except
);
1431 /* Stop replaying a thread. */
1434 record_btrace_stop_replaying (struct thread_info
*tp
)
1436 struct btrace_thread_info
*btinfo
;
1438 btinfo
= &tp
->btrace
;
1440 xfree (btinfo
->replay
);
1441 btinfo
->replay
= NULL
;
1443 /* Make sure we're not leaving any stale registers. */
1444 registers_changed_ptid (tp
->ptid
);
1447 /* The to_resume method of target record-btrace. */
1450 record_btrace_resume (struct target_ops
*ops
, ptid_t ptid
, int step
,
1451 enum gdb_signal signal
)
1453 struct thread_info
*tp
, *other
;
1454 enum btrace_thread_flag flag
;
1456 DEBUG ("resume %s: %s", target_pid_to_str (ptid
), step
? "step" : "cont");
1458 tp
= record_btrace_find_resume_thread (ptid
);
1460 error (_("Cannot find thread to resume."));
1462 /* Stop replaying other threads if the thread to resume is not replaying. */
1463 if (!btrace_is_replaying (tp
) && execution_direction
!= EXEC_REVERSE
)
1465 record_btrace_stop_replaying (other
);
1467 /* As long as we're not replaying, just forward the request. */
1468 if (!record_btrace_is_replaying (ops
) && execution_direction
!= EXEC_REVERSE
)
1470 for (ops
= ops
->beneath
; ops
!= NULL
; ops
= ops
->beneath
)
1471 if (ops
->to_resume
!= NULL
)
1472 return ops
->to_resume (ops
, ptid
, step
, signal
);
1474 error (_("Cannot find target for stepping."));
1477 /* Compute the btrace thread flag for the requested move. */
1479 flag
= execution_direction
== EXEC_REVERSE
? BTHR_RCONT
: BTHR_CONT
;
1481 flag
= execution_direction
== EXEC_REVERSE
? BTHR_RSTEP
: BTHR_STEP
;
1483 /* At the moment, we only move a single thread. We could also move
1484 all threads in parallel by single-stepping each resumed thread
1485 until the first runs into an event.
1486 When we do that, we would want to continue all other threads.
1487 For now, just resume one thread to not confuse to_wait. */
1488 record_btrace_resume_thread (tp
, flag
);
1490 /* We just indicate the resume intent here. The actual stepping happens in
1491 record_btrace_wait below. */
1494 /* Find a thread to move. */
1496 static struct thread_info
*
1497 record_btrace_find_thread_to_move (ptid_t ptid
)
1499 struct thread_info
*tp
;
1501 /* First check the parameter thread. */
1502 tp
= find_thread_ptid (ptid
);
1503 if (tp
!= NULL
&& (tp
->btrace
.flags
& BTHR_MOVE
) != 0)
1506 /* Otherwise, find one other thread that has been resumed. */
1508 if ((tp
->btrace
.flags
& BTHR_MOVE
) != 0)
1514 /* Return a target_waitstatus indicating that we ran out of history. */
1516 static struct target_waitstatus
1517 btrace_step_no_history (void)
1519 struct target_waitstatus status
;
1521 status
.kind
= TARGET_WAITKIND_NO_HISTORY
;
1526 /* Return a target_waitstatus indicating that a step finished. */
1528 static struct target_waitstatus
1529 btrace_step_stopped (void)
1531 struct target_waitstatus status
;
1533 status
.kind
= TARGET_WAITKIND_STOPPED
;
1534 status
.value
.sig
= GDB_SIGNAL_TRAP
;
1539 /* Clear the record histories. */
1542 record_btrace_clear_histories (struct btrace_thread_info
*btinfo
)
1544 xfree (btinfo
->insn_history
);
1545 xfree (btinfo
->call_history
);
1547 btinfo
->insn_history
= NULL
;
1548 btinfo
->call_history
= NULL
;
1551 /* Step a single thread. */
1553 static struct target_waitstatus
1554 record_btrace_step_thread (struct thread_info
*tp
)
1556 struct btrace_insn_iterator
*replay
, end
;
1557 struct btrace_thread_info
*btinfo
;
1558 struct address_space
*aspace
;
1559 struct inferior
*inf
;
1560 enum btrace_thread_flag flags
;
1563 btinfo
= &tp
->btrace
;
1564 replay
= btinfo
->replay
;
1566 flags
= btinfo
->flags
& BTHR_MOVE
;
1567 btinfo
->flags
&= ~BTHR_MOVE
;
1569 DEBUG ("stepping %d (%s): %u", tp
->num
, target_pid_to_str (tp
->ptid
), flags
);
1574 internal_error (__FILE__
, __LINE__
, _("invalid stepping type."));
1577 /* We're done if we're not replaying. */
1579 return btrace_step_no_history ();
1581 /* We are always able to step at least once. */
1582 steps
= btrace_insn_next (replay
, 1);
1583 gdb_assert (steps
== 1);
1585 /* Determine the end of the instruction trace. */
1586 btrace_insn_end (&end
, btinfo
);
1588 /* We stop replaying if we reached the end of the trace. */
1589 if (btrace_insn_cmp (replay
, &end
) == 0)
1590 record_btrace_stop_replaying (tp
);
1592 return btrace_step_stopped ();
1595 /* Start replaying if we're not already doing so. */
1597 replay
= record_btrace_start_replaying (tp
);
1599 /* If we can't step any further, we reached the end of the history. */
1600 steps
= btrace_insn_prev (replay
, 1);
1602 return btrace_step_no_history ();
1604 return btrace_step_stopped ();
1607 /* We're done if we're not replaying. */
1609 return btrace_step_no_history ();
1611 inf
= find_inferior_pid (ptid_get_pid (tp
->ptid
));
1612 aspace
= inf
->aspace
;
1614 /* Determine the end of the instruction trace. */
1615 btrace_insn_end (&end
, btinfo
);
1619 const struct btrace_insn
*insn
;
1621 /* We are always able to step at least once. */
1622 steps
= btrace_insn_next (replay
, 1);
1623 gdb_assert (steps
== 1);
1625 /* We stop replaying if we reached the end of the trace. */
1626 if (btrace_insn_cmp (replay
, &end
) == 0)
1628 record_btrace_stop_replaying (tp
);
1629 return btrace_step_no_history ();
1632 insn
= btrace_insn_get (replay
);
1635 DEBUG ("stepping %d (%s) ... %s", tp
->num
,
1636 target_pid_to_str (tp
->ptid
),
1637 core_addr_to_string_nz (insn
->pc
));
1639 if (breakpoint_here_p (aspace
, insn
->pc
))
1640 return btrace_step_stopped ();
1644 /* Start replaying if we're not already doing so. */
1646 replay
= record_btrace_start_replaying (tp
);
1648 inf
= find_inferior_pid (ptid_get_pid (tp
->ptid
));
1649 aspace
= inf
->aspace
;
1653 const struct btrace_insn
*insn
;
1655 /* If we can't step any further, we're done. */
1656 steps
= btrace_insn_prev (replay
, 1);
1658 return btrace_step_no_history ();
1660 insn
= btrace_insn_get (replay
);
1663 DEBUG ("reverse-stepping %d (%s) ... %s", tp
->num
,
1664 target_pid_to_str (tp
->ptid
),
1665 core_addr_to_string_nz (insn
->pc
));
1667 if (breakpoint_here_p (aspace
, insn
->pc
))
1668 return btrace_step_stopped ();
1673 /* The to_wait method of target record-btrace. */
1676 record_btrace_wait (struct target_ops
*ops
, ptid_t ptid
,
1677 struct target_waitstatus
*status
, int options
)
1679 struct thread_info
*tp
, *other
;
1681 DEBUG ("wait %s (0x%x)", target_pid_to_str (ptid
), options
);
1683 /* As long as we're not replaying, just forward the request. */
1684 if (!record_btrace_is_replaying (ops
) && execution_direction
!= EXEC_REVERSE
)
1686 for (ops
= ops
->beneath
; ops
!= NULL
; ops
= ops
->beneath
)
1687 if (ops
->to_wait
!= NULL
)
1688 return ops
->to_wait (ops
, ptid
, status
, options
);
1690 error (_("Cannot find target for waiting."));
1693 /* Let's find a thread to move. */
1694 tp
= record_btrace_find_thread_to_move (ptid
);
1697 DEBUG ("wait %s: no thread", target_pid_to_str (ptid
));
1699 status
->kind
= TARGET_WAITKIND_IGNORE
;
1700 return minus_one_ptid
;
1703 /* We only move a single thread. We're not able to correlate threads. */
1704 *status
= record_btrace_step_thread (tp
);
1706 /* Stop all other threads. */
1709 other
->btrace
.flags
&= ~BTHR_MOVE
;
1711 /* Start record histories anew from the current position. */
1712 record_btrace_clear_histories (&tp
->btrace
);
1714 /* We moved the replay position but did not update registers. */
1715 registers_changed_ptid (tp
->ptid
);
1720 /* The to_can_execute_reverse method of target record-btrace. */
1723 record_btrace_can_execute_reverse (struct target_ops
*self
)
1728 /* The to_decr_pc_after_break method of target record-btrace. */
1731 record_btrace_decr_pc_after_break (struct target_ops
*ops
,
1732 struct gdbarch
*gdbarch
)
1734 /* When replaying, we do not actually execute the breakpoint instruction
1735 so there is no need to adjust the PC after hitting a breakpoint. */
1736 if (record_btrace_is_replaying (ops
))
1739 return forward_target_decr_pc_after_break (ops
->beneath
, gdbarch
);
1742 /* The to_find_new_threads method of target record-btrace. */
1745 record_btrace_find_new_threads (struct target_ops
*ops
)
1747 /* Don't expect new threads if we're replaying. */
1748 if (record_btrace_is_replaying (ops
))
1751 /* Forward the request. */
1752 for (ops
= ops
->beneath
; ops
!= NULL
; ops
= ops
->beneath
)
1753 if (ops
->to_find_new_threads
!= NULL
)
1755 ops
->to_find_new_threads (ops
);
1760 /* The to_thread_alive method of target record-btrace. */
1763 record_btrace_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
1765 /* We don't add or remove threads during replay. */
1766 if (record_btrace_is_replaying (ops
))
1767 return find_thread_ptid (ptid
) != NULL
;
1769 /* Forward the request. */
1770 for (ops
= ops
->beneath
; ops
!= NULL
; ops
= ops
->beneath
)
1771 if (ops
->to_thread_alive
!= NULL
)
1772 return ops
->to_thread_alive (ops
, ptid
);
1777 /* Set the replay branch trace instruction iterator. If IT is NULL, replay
1781 record_btrace_set_replay (struct thread_info
*tp
,
1782 const struct btrace_insn_iterator
*it
)
1784 struct btrace_thread_info
*btinfo
;
1786 btinfo
= &tp
->btrace
;
1788 if (it
== NULL
|| it
->function
== NULL
)
1789 record_btrace_stop_replaying (tp
);
1792 if (btinfo
->replay
== NULL
)
1793 record_btrace_start_replaying (tp
);
1794 else if (btrace_insn_cmp (btinfo
->replay
, it
) == 0)
1797 *btinfo
->replay
= *it
;
1798 registers_changed_ptid (tp
->ptid
);
1801 /* Start anew from the new replay position. */
1802 record_btrace_clear_histories (btinfo
);
1805 /* The to_goto_record_begin method of target record-btrace. */
1808 record_btrace_goto_begin (struct target_ops
*self
)
1810 struct thread_info
*tp
;
1811 struct btrace_insn_iterator begin
;
1813 tp
= require_btrace_thread ();
1815 btrace_insn_begin (&begin
, &tp
->btrace
);
1816 record_btrace_set_replay (tp
, &begin
);
1818 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
, 1);
1821 /* The to_goto_record_end method of target record-btrace. */
1824 record_btrace_goto_end (struct target_ops
*ops
)
1826 struct thread_info
*tp
;
1828 tp
= require_btrace_thread ();
1830 record_btrace_set_replay (tp
, NULL
);
1832 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
, 1);
1835 /* The to_goto_record method of target record-btrace. */
1838 record_btrace_goto (struct target_ops
*self
, ULONGEST insn
)
1840 struct thread_info
*tp
;
1841 struct btrace_insn_iterator it
;
1842 unsigned int number
;
1847 /* Check for wrap-arounds. */
1849 error (_("Instruction number out of range."));
1851 tp
= require_btrace_thread ();
1853 found
= btrace_find_insn_by_number (&it
, &tp
->btrace
, number
);
1855 error (_("No such instruction."));
1857 record_btrace_set_replay (tp
, &it
);
1859 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
, 1);
1862 /* Initialize the record-btrace target ops. */
1865 init_record_btrace_ops (void)
1867 struct target_ops
*ops
;
1869 ops
= &record_btrace_ops
;
1870 ops
->to_shortname
= "record-btrace";
1871 ops
->to_longname
= "Branch tracing target";
1872 ops
->to_doc
= "Collect control-flow trace and provide the execution history.";
1873 ops
->to_open
= record_btrace_open
;
1874 ops
->to_close
= record_btrace_close
;
1875 ops
->to_detach
= record_detach
;
1876 ops
->to_disconnect
= record_disconnect
;
1877 ops
->to_mourn_inferior
= record_mourn_inferior
;
1878 ops
->to_kill
= record_kill
;
1879 ops
->to_create_inferior
= find_default_create_inferior
;
1880 ops
->to_stop_recording
= record_btrace_stop_recording
;
1881 ops
->to_info_record
= record_btrace_info
;
1882 ops
->to_insn_history
= record_btrace_insn_history
;
1883 ops
->to_insn_history_from
= record_btrace_insn_history_from
;
1884 ops
->to_insn_history_range
= record_btrace_insn_history_range
;
1885 ops
->to_call_history
= record_btrace_call_history
;
1886 ops
->to_call_history_from
= record_btrace_call_history_from
;
1887 ops
->to_call_history_range
= record_btrace_call_history_range
;
1888 ops
->to_record_is_replaying
= record_btrace_is_replaying
;
1889 ops
->to_xfer_partial
= record_btrace_xfer_partial
;
1890 ops
->to_remove_breakpoint
= record_btrace_remove_breakpoint
;
1891 ops
->to_insert_breakpoint
= record_btrace_insert_breakpoint
;
1892 ops
->to_fetch_registers
= record_btrace_fetch_registers
;
1893 ops
->to_store_registers
= record_btrace_store_registers
;
1894 ops
->to_prepare_to_store
= record_btrace_prepare_to_store
;
1895 ops
->to_get_unwinder
= &record_btrace_frame_unwind
;
1896 ops
->to_get_tailcall_unwinder
= &record_btrace_tailcall_frame_unwind
;
1897 ops
->to_resume
= record_btrace_resume
;
1898 ops
->to_wait
= record_btrace_wait
;
1899 ops
->to_find_new_threads
= record_btrace_find_new_threads
;
1900 ops
->to_thread_alive
= record_btrace_thread_alive
;
1901 ops
->to_goto_record_begin
= record_btrace_goto_begin
;
1902 ops
->to_goto_record_end
= record_btrace_goto_end
;
1903 ops
->to_goto_record
= record_btrace_goto
;
1904 ops
->to_can_execute_reverse
= record_btrace_can_execute_reverse
;
1905 ops
->to_decr_pc_after_break
= record_btrace_decr_pc_after_break
;
1906 ops
->to_stratum
= record_stratum
;
1907 ops
->to_magic
= OPS_MAGIC
;
1910 /* Alias for "target record". */
1913 cmd_record_btrace_start (char *args
, int from_tty
)
1915 if (args
!= NULL
&& *args
!= 0)
1916 error (_("Invalid argument."));
1918 execute_command ("target record-btrace", from_tty
);
1921 void _initialize_record_btrace (void);
1923 /* Initialize btrace commands. */
1926 _initialize_record_btrace (void)
1928 add_cmd ("btrace", class_obscure
, cmd_record_btrace_start
,
1929 _("Start branch trace recording."),
1931 add_alias_cmd ("b", "btrace", class_obscure
, 1, &record_cmdlist
);
1933 init_record_btrace_ops ();
1934 add_target (&record_btrace_ops
);
1936 bfcache
= htab_create_alloc (50, bfcache_hash
, bfcache_eq
, NULL
,