1 /* Branch trace support for GDB, the GNU debugger.
3 Copyright (C) 2013-2021 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 "record-btrace.h"
25 #include "gdbthread.h"
29 #include "observable.h"
30 #include "cli/cli-utils.h"
34 #include "filenames.h"
36 #include "frame-unwind.h"
39 #include "gdbsupport/event-loop.h"
44 #include "cli/cli-style.h"
45 #include "async-event.h"
46 #include <forward_list>
48 static const target_info record_btrace_target_info
= {
50 N_("Branch tracing target"),
51 N_("Collect control-flow trace and provide the execution history.")
54 /* The target_ops of record-btrace. */
56 class record_btrace_target final
: public target_ops
59 const target_info
&info () const override
60 { return record_btrace_target_info
; }
62 strata
stratum () const override
{ return record_stratum
; }
64 void close () override
;
65 void async (int) override
;
67 void detach (inferior
*inf
, int from_tty
) override
68 { record_detach (this, inf
, from_tty
); }
70 void disconnect (const char *, int) override
;
72 void mourn_inferior () override
73 { record_mourn_inferior (this); }
76 { record_kill (this); }
78 enum record_method
record_method (ptid_t ptid
) override
;
80 void stop_recording () override
;
81 void info_record () override
;
83 void insn_history (int size
, gdb_disassembly_flags flags
) override
;
84 void insn_history_from (ULONGEST from
, int size
,
85 gdb_disassembly_flags flags
) override
;
86 void insn_history_range (ULONGEST begin
, ULONGEST end
,
87 gdb_disassembly_flags flags
) override
;
88 void call_history (int size
, record_print_flags flags
) override
;
89 void call_history_from (ULONGEST begin
, int size
, record_print_flags flags
)
91 void call_history_range (ULONGEST begin
, ULONGEST end
, record_print_flags flags
)
94 bool record_is_replaying (ptid_t ptid
) override
;
95 bool record_will_replay (ptid_t ptid
, int dir
) override
;
96 void record_stop_replaying () override
;
98 enum target_xfer_status
xfer_partial (enum target_object object
,
101 const gdb_byte
*writebuf
,
102 ULONGEST offset
, ULONGEST len
,
103 ULONGEST
*xfered_len
) override
;
105 int insert_breakpoint (struct gdbarch
*,
106 struct bp_target_info
*) override
;
107 int remove_breakpoint (struct gdbarch
*, struct bp_target_info
*,
108 enum remove_bp_reason
) override
;
110 void fetch_registers (struct regcache
*, int) override
;
112 void store_registers (struct regcache
*, int) override
;
113 void prepare_to_store (struct regcache
*) override
;
115 const struct frame_unwind
*get_unwinder () override
;
117 const struct frame_unwind
*get_tailcall_unwinder () override
;
119 void resume (ptid_t
, int, enum gdb_signal
) override
;
120 ptid_t
wait (ptid_t
, struct target_waitstatus
*, target_wait_flags
) override
;
122 void stop (ptid_t
) override
;
123 void update_thread_list () override
;
124 bool thread_alive (ptid_t ptid
) override
;
125 void goto_record_begin () override
;
126 void goto_record_end () override
;
127 void goto_record (ULONGEST insn
) override
;
129 bool can_execute_reverse () override
;
131 bool stopped_by_sw_breakpoint () override
;
132 bool supports_stopped_by_sw_breakpoint () override
;
134 bool stopped_by_hw_breakpoint () override
;
135 bool supports_stopped_by_hw_breakpoint () override
;
137 enum exec_direction_kind
execution_direction () override
;
138 void prepare_to_generate_core () override
;
139 void done_generating_core () override
;
142 static record_btrace_target record_btrace_ops
;
144 /* Initialize the record-btrace target ops. */
146 /* Token associated with a new-thread observer enabling branch tracing
147 for the new thread. */
148 static const gdb::observers::token record_btrace_thread_observer_token
{};
150 /* Memory access types used in set/show record btrace replay-memory-access. */
151 static const char replay_memory_access_read_only
[] = "read-only";
152 static const char replay_memory_access_read_write
[] = "read-write";
153 static const char *const replay_memory_access_types
[] =
155 replay_memory_access_read_only
,
156 replay_memory_access_read_write
,
160 /* The currently allowed replay memory access type. */
161 static const char *replay_memory_access
= replay_memory_access_read_only
;
163 /* The cpu state kinds. */
164 enum record_btrace_cpu_state_kind
171 /* The current cpu state. */
172 static enum record_btrace_cpu_state_kind record_btrace_cpu_state
= CS_AUTO
;
174 /* The current cpu for trace decode. */
175 static struct btrace_cpu record_btrace_cpu
;
177 /* Command lists for "set/show record btrace". */
178 static struct cmd_list_element
*set_record_btrace_cmdlist
;
179 static struct cmd_list_element
*show_record_btrace_cmdlist
;
181 /* The execution direction of the last resume we got. See record-full.c. */
182 static enum exec_direction_kind record_btrace_resume_exec_dir
= EXEC_FORWARD
;
184 /* The async event handler for reverse/replay execution. */
185 static struct async_event_handler
*record_btrace_async_inferior_event_handler
;
187 /* A flag indicating that we are currently generating a core file. */
188 static int record_btrace_generating_corefile
;
190 /* The current branch trace configuration. */
191 static struct btrace_config record_btrace_conf
;
193 /* Command list for "record btrace". */
194 static struct cmd_list_element
*record_btrace_cmdlist
;
196 /* Command lists for "set/show record btrace bts". */
197 static struct cmd_list_element
*set_record_btrace_bts_cmdlist
;
198 static struct cmd_list_element
*show_record_btrace_bts_cmdlist
;
200 /* Command lists for "set/show record btrace pt". */
201 static struct cmd_list_element
*set_record_btrace_pt_cmdlist
;
202 static struct cmd_list_element
*show_record_btrace_pt_cmdlist
;
204 /* Command list for "set record btrace cpu". */
205 static struct cmd_list_element
*set_record_btrace_cpu_cmdlist
;
207 /* Print a record-btrace debug message. Use do ... while (0) to avoid
208 ambiguities when used in if statements. */
210 #define DEBUG(msg, args...) \
213 if (record_debug != 0) \
214 fprintf_unfiltered (gdb_stdlog, \
215 "[record-btrace] " msg "\n", ##args); \
220 /* Return the cpu configured by the user. Returns NULL if the cpu was
221 configured as auto. */
222 const struct btrace_cpu
*
223 record_btrace_get_cpu (void)
225 switch (record_btrace_cpu_state
)
231 record_btrace_cpu
.vendor
= CV_UNKNOWN
;
234 return &record_btrace_cpu
;
237 error (_("Internal error: bad record btrace cpu state."));
240 /* Update the branch trace for the current thread and return a pointer to its
243 Throws an error if there is no thread or no trace. This function never
246 static struct thread_info
*
247 require_btrace_thread (void)
251 if (inferior_ptid
== null_ptid
)
252 error (_("No thread."));
254 thread_info
*tp
= inferior_thread ();
256 validate_registers_access ();
258 btrace_fetch (tp
, record_btrace_get_cpu ());
260 if (btrace_is_empty (tp
))
261 error (_("No trace."));
266 /* Update the branch trace for the current thread and return a pointer to its
267 branch trace information struct.
269 Throws an error if there is no thread or no trace. This function never
272 static struct btrace_thread_info
*
273 require_btrace (void)
275 struct thread_info
*tp
;
277 tp
= require_btrace_thread ();
282 /* Enable branch tracing for one thread. Warn on errors. */
285 record_btrace_enable_warn (struct thread_info
*tp
)
287 /* Ignore this thread if its inferior is not recorded by us. */
288 target_ops
*rec
= tp
->inf
->target_at (record_stratum
);
289 if (rec
!= &record_btrace_ops
)
294 btrace_enable (tp
, &record_btrace_conf
);
296 catch (const gdb_exception_error
&error
)
298 warning ("%s", error
.what ());
302 /* Enable automatic tracing of new threads. */
305 record_btrace_auto_enable (void)
307 DEBUG ("attach thread observer");
309 gdb::observers::new_thread
.attach (record_btrace_enable_warn
,
310 record_btrace_thread_observer_token
,
314 /* Disable automatic tracing of new threads. */
317 record_btrace_auto_disable (void)
319 DEBUG ("detach thread observer");
321 gdb::observers::new_thread
.detach (record_btrace_thread_observer_token
);
324 /* The record-btrace async event handler function. */
327 record_btrace_handle_async_inferior_event (gdb_client_data data
)
329 inferior_event_handler (INF_REG_EVENT
);
332 /* See record-btrace.h. */
335 record_btrace_push_target (void)
339 record_btrace_auto_enable ();
341 current_inferior ()->push_target (&record_btrace_ops
);
343 record_btrace_async_inferior_event_handler
344 = create_async_event_handler (record_btrace_handle_async_inferior_event
,
345 NULL
, "record-btrace");
346 record_btrace_generating_corefile
= 0;
348 format
= btrace_format_short_string (record_btrace_conf
.format
);
349 gdb::observers::record_changed
.notify (current_inferior (), 1, "btrace", format
);
352 /* Disable btrace on a set of threads on scope exit. */
354 struct scoped_btrace_disable
356 scoped_btrace_disable () = default;
358 DISABLE_COPY_AND_ASSIGN (scoped_btrace_disable
);
360 ~scoped_btrace_disable ()
362 for (thread_info
*tp
: m_threads
)
366 void add_thread (thread_info
*thread
)
368 m_threads
.push_front (thread
);
377 std::forward_list
<thread_info
*> m_threads
;
380 /* Open target record-btrace. */
383 record_btrace_target_open (const char *args
, int from_tty
)
385 /* If we fail to enable btrace for one thread, disable it for the threads for
386 which it was successfully enabled. */
387 scoped_btrace_disable btrace_disable
;
393 if (!target_has_execution ())
394 error (_("The program is not being run."));
396 for (thread_info
*tp
: current_inferior ()->non_exited_threads ())
397 if (args
== NULL
|| *args
== 0 || number_is_in_list (args
, tp
->global_num
))
399 btrace_enable (tp
, &record_btrace_conf
);
401 btrace_disable
.add_thread (tp
);
404 record_btrace_push_target ();
406 btrace_disable
.discard ();
409 /* The stop_recording method of target record-btrace. */
412 record_btrace_target::stop_recording ()
414 DEBUG ("stop recording");
416 record_btrace_auto_disable ();
418 for (thread_info
*tp
: current_inferior ()->non_exited_threads ())
419 if (tp
->btrace
.target
!= NULL
)
423 /* The disconnect method of target record-btrace. */
426 record_btrace_target::disconnect (const char *args
,
429 struct target_ops
*beneath
= this->beneath ();
431 /* Do not stop recording, just clean up GDB side. */
432 current_inferior ()->unpush_target (this);
434 /* Forward disconnect. */
435 beneath
->disconnect (args
, from_tty
);
438 /* The close method of target record-btrace. */
441 record_btrace_target::close ()
443 if (record_btrace_async_inferior_event_handler
!= NULL
)
444 delete_async_event_handler (&record_btrace_async_inferior_event_handler
);
446 /* Make sure automatic recording gets disabled even if we did not stop
447 recording before closing the record-btrace target. */
448 record_btrace_auto_disable ();
450 /* We should have already stopped recording.
451 Tear down btrace in case we have not. */
452 for (thread_info
*tp
: current_inferior ()->non_exited_threads ())
453 btrace_teardown (tp
);
456 /* The async method of target record-btrace. */
459 record_btrace_target::async (int enable
)
462 mark_async_event_handler (record_btrace_async_inferior_event_handler
);
464 clear_async_event_handler (record_btrace_async_inferior_event_handler
);
466 this->beneath ()->async (enable
);
469 /* Adjusts the size and returns a human readable size suffix. */
472 record_btrace_adjust_size (unsigned int *size
)
478 if ((sz
& ((1u << 30) - 1)) == 0)
483 else if ((sz
& ((1u << 20) - 1)) == 0)
488 else if ((sz
& ((1u << 10) - 1)) == 0)
497 /* Print a BTS configuration. */
500 record_btrace_print_bts_conf (const struct btrace_config_bts
*conf
)
508 suffix
= record_btrace_adjust_size (&size
);
509 printf_unfiltered (_("Buffer size: %u%s.\n"), size
, suffix
);
513 /* Print an Intel Processor Trace configuration. */
516 record_btrace_print_pt_conf (const struct btrace_config_pt
*conf
)
524 suffix
= record_btrace_adjust_size (&size
);
525 printf_unfiltered (_("Buffer size: %u%s.\n"), size
, suffix
);
529 /* Print a branch tracing configuration. */
532 record_btrace_print_conf (const struct btrace_config
*conf
)
534 printf_unfiltered (_("Recording format: %s.\n"),
535 btrace_format_string (conf
->format
));
537 switch (conf
->format
)
539 case BTRACE_FORMAT_NONE
:
542 case BTRACE_FORMAT_BTS
:
543 record_btrace_print_bts_conf (&conf
->bts
);
546 case BTRACE_FORMAT_PT
:
547 record_btrace_print_pt_conf (&conf
->pt
);
551 internal_error (__FILE__
, __LINE__
, _("Unknown branch trace format."));
554 /* The info_record method of target record-btrace. */
557 record_btrace_target::info_record ()
559 struct btrace_thread_info
*btinfo
;
560 const struct btrace_config
*conf
;
561 struct thread_info
*tp
;
562 unsigned int insns
, calls
, gaps
;
566 if (inferior_ptid
== null_ptid
)
567 error (_("No thread."));
569 tp
= inferior_thread ();
571 validate_registers_access ();
573 btinfo
= &tp
->btrace
;
575 conf
= ::btrace_conf (btinfo
);
577 record_btrace_print_conf (conf
);
579 btrace_fetch (tp
, record_btrace_get_cpu ());
585 if (!btrace_is_empty (tp
))
587 struct btrace_call_iterator call
;
588 struct btrace_insn_iterator insn
;
590 btrace_call_end (&call
, btinfo
);
591 btrace_call_prev (&call
, 1);
592 calls
= btrace_call_number (&call
);
594 btrace_insn_end (&insn
, btinfo
);
595 insns
= btrace_insn_number (&insn
);
597 /* If the last instruction is not a gap, it is the current instruction
598 that is not actually part of the record. */
599 if (btrace_insn_get (&insn
) != NULL
)
602 gaps
= btinfo
->ngaps
;
605 printf_unfiltered (_("Recorded %u instructions in %u functions (%u gaps) "
606 "for thread %s (%s).\n"), insns
, calls
, gaps
,
607 print_thread_id (tp
),
608 target_pid_to_str (tp
->ptid
).c_str ());
610 if (btrace_is_replaying (tp
))
611 printf_unfiltered (_("Replay in progress. At instruction %u.\n"),
612 btrace_insn_number (btinfo
->replay
));
615 /* Print a decode error. */
618 btrace_ui_out_decode_error (struct ui_out
*uiout
, int errcode
,
619 enum btrace_format format
)
621 const char *errstr
= btrace_decode_error (format
, errcode
);
623 uiout
->text (_("["));
624 /* ERRCODE > 0 indicates notifications on BTRACE_FORMAT_PT. */
625 if (!(format
== BTRACE_FORMAT_PT
&& errcode
> 0))
627 uiout
->text (_("decode error ("));
628 uiout
->field_signed ("errcode", errcode
);
629 uiout
->text (_("): "));
631 uiout
->text (errstr
);
632 uiout
->text (_("]\n"));
635 /* A range of source lines. */
637 struct btrace_line_range
639 /* The symtab this line is from. */
640 struct symtab
*symtab
;
642 /* The first line (inclusive). */
645 /* The last line (exclusive). */
649 /* Construct a line range. */
651 static struct btrace_line_range
652 btrace_mk_line_range (struct symtab
*symtab
, int begin
, int end
)
654 struct btrace_line_range range
;
656 range
.symtab
= symtab
;
663 /* Add a line to a line range. */
665 static struct btrace_line_range
666 btrace_line_range_add (struct btrace_line_range range
, int line
)
668 if (range
.end
<= range
.begin
)
670 /* This is the first entry. */
672 range
.end
= line
+ 1;
674 else if (line
< range
.begin
)
676 else if (range
.end
< line
)
682 /* Return non-zero if RANGE is empty, zero otherwise. */
685 btrace_line_range_is_empty (struct btrace_line_range range
)
687 return range
.end
<= range
.begin
;
690 /* Return non-zero if LHS contains RHS, zero otherwise. */
693 btrace_line_range_contains_range (struct btrace_line_range lhs
,
694 struct btrace_line_range rhs
)
696 return ((lhs
.symtab
== rhs
.symtab
)
697 && (lhs
.begin
<= rhs
.begin
)
698 && (rhs
.end
<= lhs
.end
));
701 /* Find the line range associated with PC. */
703 static struct btrace_line_range
704 btrace_find_line_range (CORE_ADDR pc
)
706 struct btrace_line_range range
;
707 struct linetable_entry
*lines
;
708 struct linetable
*ltable
;
709 struct symtab
*symtab
;
712 symtab
= find_pc_line_symtab (pc
);
714 return btrace_mk_line_range (NULL
, 0, 0);
716 ltable
= SYMTAB_LINETABLE (symtab
);
718 return btrace_mk_line_range (symtab
, 0, 0);
720 nlines
= ltable
->nitems
;
721 lines
= ltable
->item
;
723 return btrace_mk_line_range (symtab
, 0, 0);
725 range
= btrace_mk_line_range (symtab
, 0, 0);
726 for (i
= 0; i
< nlines
- 1; i
++)
728 /* The test of is_stmt here was added when the is_stmt field was
729 introduced to the 'struct linetable_entry' structure. This
730 ensured that this loop maintained the same behaviour as before we
731 introduced is_stmt. That said, it might be that we would be
732 better off not checking is_stmt here, this would lead to us
733 possibly adding more line numbers to the range. At the time this
734 change was made I was unsure how to test this so chose to go with
735 maintaining the existing experience. */
736 if ((lines
[i
].pc
== pc
) && (lines
[i
].line
!= 0)
737 && (lines
[i
].is_stmt
== 1))
738 range
= btrace_line_range_add (range
, lines
[i
].line
);
744 /* Print source lines in LINES to UIOUT.
746 UI_ITEM_CHAIN is a cleanup chain for the last source line and the
747 instructions corresponding to that source line. When printing a new source
748 line, we do the cleanups for the open chain and open a new cleanup chain for
749 the new source line. If the source line range in LINES is not empty, this
750 function will leave the cleanup chain for the last printed source line open
751 so instructions can be added to it. */
754 btrace_print_lines (struct btrace_line_range lines
, struct ui_out
*uiout
,
755 gdb::optional
<ui_out_emit_tuple
> *src_and_asm_tuple
,
756 gdb::optional
<ui_out_emit_list
> *asm_list
,
757 gdb_disassembly_flags flags
)
759 print_source_lines_flags psl_flags
;
761 if (flags
& DISASSEMBLY_FILENAME
)
762 psl_flags
|= PRINT_SOURCE_LINES_FILENAME
;
764 for (int line
= lines
.begin
; line
< lines
.end
; ++line
)
768 src_and_asm_tuple
->emplace (uiout
, "src_and_asm_line");
770 print_source_lines (lines
.symtab
, line
, line
+ 1, psl_flags
);
772 asm_list
->emplace (uiout
, "line_asm_insn");
776 /* Disassemble a section of the recorded instruction trace. */
779 btrace_insn_history (struct ui_out
*uiout
,
780 const struct btrace_thread_info
*btinfo
,
781 const struct btrace_insn_iterator
*begin
,
782 const struct btrace_insn_iterator
*end
,
783 gdb_disassembly_flags flags
)
785 DEBUG ("itrace (0x%x): [%u; %u)", (unsigned) flags
,
786 btrace_insn_number (begin
), btrace_insn_number (end
));
788 flags
|= DISASSEMBLY_SPECULATIVE
;
790 struct gdbarch
*gdbarch
= target_gdbarch ();
791 btrace_line_range last_lines
= btrace_mk_line_range (NULL
, 0, 0);
793 ui_out_emit_list
list_emitter (uiout
, "asm_insns");
795 gdb::optional
<ui_out_emit_tuple
> src_and_asm_tuple
;
796 gdb::optional
<ui_out_emit_list
> asm_list
;
798 gdb_pretty_print_disassembler
disasm (gdbarch
, uiout
);
800 for (btrace_insn_iterator it
= *begin
; btrace_insn_cmp (&it
, end
) != 0;
801 btrace_insn_next (&it
, 1))
803 const struct btrace_insn
*insn
;
805 insn
= btrace_insn_get (&it
);
807 /* A NULL instruction indicates a gap in the trace. */
810 const struct btrace_config
*conf
;
812 conf
= btrace_conf (btinfo
);
814 /* We have trace so we must have a configuration. */
815 gdb_assert (conf
!= NULL
);
817 uiout
->field_fmt ("insn-number", "%u",
818 btrace_insn_number (&it
));
821 btrace_ui_out_decode_error (uiout
, btrace_insn_get_error (&it
),
826 struct disasm_insn dinsn
;
828 if ((flags
& DISASSEMBLY_SOURCE
) != 0)
830 struct btrace_line_range lines
;
832 lines
= btrace_find_line_range (insn
->pc
);
833 if (!btrace_line_range_is_empty (lines
)
834 && !btrace_line_range_contains_range (last_lines
, lines
))
836 btrace_print_lines (lines
, uiout
, &src_and_asm_tuple
, &asm_list
,
840 else if (!src_and_asm_tuple
.has_value ())
842 gdb_assert (!asm_list
.has_value ());
844 src_and_asm_tuple
.emplace (uiout
, "src_and_asm_line");
846 /* No source information. */
847 asm_list
.emplace (uiout
, "line_asm_insn");
850 gdb_assert (src_and_asm_tuple
.has_value ());
851 gdb_assert (asm_list
.has_value ());
854 memset (&dinsn
, 0, sizeof (dinsn
));
855 dinsn
.number
= btrace_insn_number (&it
);
856 dinsn
.addr
= insn
->pc
;
858 if ((insn
->flags
& BTRACE_INSN_FLAG_SPECULATIVE
) != 0)
859 dinsn
.is_speculative
= 1;
861 disasm
.pretty_print_insn (&dinsn
, flags
);
866 /* The insn_history method of target record-btrace. */
869 record_btrace_target::insn_history (int size
, gdb_disassembly_flags flags
)
871 struct btrace_thread_info
*btinfo
;
872 struct btrace_insn_history
*history
;
873 struct btrace_insn_iterator begin
, end
;
874 struct ui_out
*uiout
;
875 unsigned int context
, covered
;
877 uiout
= current_uiout
;
878 ui_out_emit_tuple
tuple_emitter (uiout
, "insn history");
879 context
= abs (size
);
881 error (_("Bad record instruction-history-size."));
883 btinfo
= require_btrace ();
884 history
= btinfo
->insn_history
;
887 struct btrace_insn_iterator
*replay
;
889 DEBUG ("insn-history (0x%x): %d", (unsigned) flags
, size
);
891 /* If we're replaying, we start at the replay position. Otherwise, we
892 start at the tail of the trace. */
893 replay
= btinfo
->replay
;
897 btrace_insn_end (&begin
, btinfo
);
899 /* We start from here and expand in the requested direction. Then we
900 expand in the other direction, as well, to fill up any remaining
905 /* We want the current position covered, as well. */
906 covered
= btrace_insn_next (&end
, 1);
907 covered
+= btrace_insn_prev (&begin
, context
- covered
);
908 covered
+= btrace_insn_next (&end
, context
- covered
);
912 covered
= btrace_insn_next (&end
, context
);
913 covered
+= btrace_insn_prev (&begin
, context
- covered
);
918 begin
= history
->begin
;
921 DEBUG ("insn-history (0x%x): %d, prev: [%u; %u)", (unsigned) flags
, size
,
922 btrace_insn_number (&begin
), btrace_insn_number (&end
));
927 covered
= btrace_insn_prev (&begin
, context
);
932 covered
= btrace_insn_next (&end
, context
);
937 btrace_insn_history (uiout
, btinfo
, &begin
, &end
, flags
);
941 printf_unfiltered (_("At the start of the branch trace record.\n"));
943 printf_unfiltered (_("At the end of the branch trace record.\n"));
946 btrace_set_insn_history (btinfo
, &begin
, &end
);
949 /* The insn_history_range method of target record-btrace. */
952 record_btrace_target::insn_history_range (ULONGEST from
, ULONGEST to
,
953 gdb_disassembly_flags flags
)
955 struct btrace_thread_info
*btinfo
;
956 struct btrace_insn_iterator begin
, end
;
957 struct ui_out
*uiout
;
958 unsigned int low
, high
;
961 uiout
= current_uiout
;
962 ui_out_emit_tuple
tuple_emitter (uiout
, "insn history");
966 DEBUG ("insn-history (0x%x): [%u; %u)", (unsigned) flags
, low
, high
);
968 /* Check for wrap-arounds. */
969 if (low
!= from
|| high
!= to
)
970 error (_("Bad range."));
973 error (_("Bad range."));
975 btinfo
= require_btrace ();
977 found
= btrace_find_insn_by_number (&begin
, btinfo
, low
);
979 error (_("Range out of bounds."));
981 found
= btrace_find_insn_by_number (&end
, btinfo
, high
);
984 /* Silently truncate the range. */
985 btrace_insn_end (&end
, btinfo
);
989 /* We want both begin and end to be inclusive. */
990 btrace_insn_next (&end
, 1);
993 btrace_insn_history (uiout
, btinfo
, &begin
, &end
, flags
);
994 btrace_set_insn_history (btinfo
, &begin
, &end
);
997 /* The insn_history_from method of target record-btrace. */
1000 record_btrace_target::insn_history_from (ULONGEST from
, int size
,
1001 gdb_disassembly_flags flags
)
1003 ULONGEST begin
, end
, context
;
1005 context
= abs (size
);
1007 error (_("Bad record instruction-history-size."));
1016 begin
= from
- context
+ 1;
1021 end
= from
+ context
- 1;
1023 /* Check for wrap-around. */
1028 insn_history_range (begin
, end
, flags
);
1031 /* Print the instruction number range for a function call history line. */
1034 btrace_call_history_insn_range (struct ui_out
*uiout
,
1035 const struct btrace_function
*bfun
)
1037 unsigned int begin
, end
, size
;
1039 size
= bfun
->insn
.size ();
1040 gdb_assert (size
> 0);
1042 begin
= bfun
->insn_offset
;
1043 end
= begin
+ size
- 1;
1045 uiout
->field_unsigned ("insn begin", begin
);
1047 uiout
->field_unsigned ("insn end", end
);
1050 /* Compute the lowest and highest source line for the instructions in BFUN
1051 and return them in PBEGIN and PEND.
1052 Ignore instructions that can't be mapped to BFUN, e.g. instructions that
1053 result from inlining or macro expansion. */
1056 btrace_compute_src_line_range (const struct btrace_function
*bfun
,
1057 int *pbegin
, int *pend
)
1059 struct symtab
*symtab
;
1070 symtab
= symbol_symtab (sym
);
1072 for (const btrace_insn
&insn
: bfun
->insn
)
1074 struct symtab_and_line sal
;
1076 sal
= find_pc_line (insn
.pc
, 0);
1077 if (sal
.symtab
!= symtab
|| sal
.line
== 0)
1080 begin
= std::min (begin
, sal
.line
);
1081 end
= std::max (end
, sal
.line
);
1089 /* Print the source line information for a function call history line. */
1092 btrace_call_history_src_line (struct ui_out
*uiout
,
1093 const struct btrace_function
*bfun
)
1102 uiout
->field_string ("file",
1103 symtab_to_filename_for_display (symbol_symtab (sym
)),
1104 file_name_style
.style ());
1106 btrace_compute_src_line_range (bfun
, &begin
, &end
);
1111 uiout
->field_signed ("min line", begin
);
1117 uiout
->field_signed ("max line", end
);
1120 /* Get the name of a branch trace function. */
1123 btrace_get_bfun_name (const struct btrace_function
*bfun
)
1125 struct minimal_symbol
*msym
;
1135 return sym
->print_name ();
1136 else if (msym
!= NULL
)
1137 return msym
->print_name ();
1142 /* Disassemble a section of the recorded function trace. */
1145 btrace_call_history (struct ui_out
*uiout
,
1146 const struct btrace_thread_info
*btinfo
,
1147 const struct btrace_call_iterator
*begin
,
1148 const struct btrace_call_iterator
*end
,
1151 struct btrace_call_iterator it
;
1152 record_print_flags flags
= (enum record_print_flag
) int_flags
;
1154 DEBUG ("ftrace (0x%x): [%u; %u)", int_flags
, btrace_call_number (begin
),
1155 btrace_call_number (end
));
1157 for (it
= *begin
; btrace_call_cmp (&it
, end
) < 0; btrace_call_next (&it
, 1))
1159 const struct btrace_function
*bfun
;
1160 struct minimal_symbol
*msym
;
1163 bfun
= btrace_call_get (&it
);
1167 /* Print the function index. */
1168 uiout
->field_unsigned ("index", bfun
->number
);
1171 /* Indicate gaps in the trace. */
1172 if (bfun
->errcode
!= 0)
1174 const struct btrace_config
*conf
;
1176 conf
= btrace_conf (btinfo
);
1178 /* We have trace so we must have a configuration. */
1179 gdb_assert (conf
!= NULL
);
1181 btrace_ui_out_decode_error (uiout
, bfun
->errcode
, conf
->format
);
1186 if ((flags
& RECORD_PRINT_INDENT_CALLS
) != 0)
1188 int level
= bfun
->level
+ btinfo
->level
, i
;
1190 for (i
= 0; i
< level
; ++i
)
1195 uiout
->field_string ("function", sym
->print_name (),
1196 function_name_style
.style ());
1197 else if (msym
!= NULL
)
1198 uiout
->field_string ("function", msym
->print_name (),
1199 function_name_style
.style ());
1200 else if (!uiout
->is_mi_like_p ())
1201 uiout
->field_string ("function", "??",
1202 function_name_style
.style ());
1204 if ((flags
& RECORD_PRINT_INSN_RANGE
) != 0)
1206 uiout
->text (_("\tinst "));
1207 btrace_call_history_insn_range (uiout
, bfun
);
1210 if ((flags
& RECORD_PRINT_SRC_LINE
) != 0)
1212 uiout
->text (_("\tat "));
1213 btrace_call_history_src_line (uiout
, bfun
);
1220 /* The call_history method of target record-btrace. */
1223 record_btrace_target::call_history (int size
, record_print_flags flags
)
1225 struct btrace_thread_info
*btinfo
;
1226 struct btrace_call_history
*history
;
1227 struct btrace_call_iterator begin
, end
;
1228 struct ui_out
*uiout
;
1229 unsigned int context
, covered
;
1231 uiout
= current_uiout
;
1232 ui_out_emit_tuple
tuple_emitter (uiout
, "insn history");
1233 context
= abs (size
);
1235 error (_("Bad record function-call-history-size."));
1237 btinfo
= require_btrace ();
1238 history
= btinfo
->call_history
;
1239 if (history
== NULL
)
1241 struct btrace_insn_iterator
*replay
;
1243 DEBUG ("call-history (0x%x): %d", (int) flags
, size
);
1245 /* If we're replaying, we start at the replay position. Otherwise, we
1246 start at the tail of the trace. */
1247 replay
= btinfo
->replay
;
1250 begin
.btinfo
= btinfo
;
1251 begin
.index
= replay
->call_index
;
1254 btrace_call_end (&begin
, btinfo
);
1256 /* We start from here and expand in the requested direction. Then we
1257 expand in the other direction, as well, to fill up any remaining
1262 /* We want the current position covered, as well. */
1263 covered
= btrace_call_next (&end
, 1);
1264 covered
+= btrace_call_prev (&begin
, context
- covered
);
1265 covered
+= btrace_call_next (&end
, context
- covered
);
1269 covered
= btrace_call_next (&end
, context
);
1270 covered
+= btrace_call_prev (&begin
, context
- covered
);
1275 begin
= history
->begin
;
1278 DEBUG ("call-history (0x%x): %d, prev: [%u; %u)", (int) flags
, size
,
1279 btrace_call_number (&begin
), btrace_call_number (&end
));
1284 covered
= btrace_call_prev (&begin
, context
);
1289 covered
= btrace_call_next (&end
, context
);
1294 btrace_call_history (uiout
, btinfo
, &begin
, &end
, flags
);
1298 printf_unfiltered (_("At the start of the branch trace record.\n"));
1300 printf_unfiltered (_("At the end of the branch trace record.\n"));
1303 btrace_set_call_history (btinfo
, &begin
, &end
);
1306 /* The call_history_range method of target record-btrace. */
1309 record_btrace_target::call_history_range (ULONGEST from
, ULONGEST to
,
1310 record_print_flags flags
)
1312 struct btrace_thread_info
*btinfo
;
1313 struct btrace_call_iterator begin
, end
;
1314 struct ui_out
*uiout
;
1315 unsigned int low
, high
;
1318 uiout
= current_uiout
;
1319 ui_out_emit_tuple
tuple_emitter (uiout
, "func history");
1323 DEBUG ("call-history (0x%x): [%u; %u)", (int) flags
, low
, high
);
1325 /* Check for wrap-arounds. */
1326 if (low
!= from
|| high
!= to
)
1327 error (_("Bad range."));
1330 error (_("Bad range."));
1332 btinfo
= require_btrace ();
1334 found
= btrace_find_call_by_number (&begin
, btinfo
, low
);
1336 error (_("Range out of bounds."));
1338 found
= btrace_find_call_by_number (&end
, btinfo
, high
);
1341 /* Silently truncate the range. */
1342 btrace_call_end (&end
, btinfo
);
1346 /* We want both begin and end to be inclusive. */
1347 btrace_call_next (&end
, 1);
1350 btrace_call_history (uiout
, btinfo
, &begin
, &end
, flags
);
1351 btrace_set_call_history (btinfo
, &begin
, &end
);
1354 /* The call_history_from method of target record-btrace. */
1357 record_btrace_target::call_history_from (ULONGEST from
, int size
,
1358 record_print_flags flags
)
1360 ULONGEST begin
, end
, context
;
1362 context
= abs (size
);
1364 error (_("Bad record function-call-history-size."));
1373 begin
= from
- context
+ 1;
1378 end
= from
+ context
- 1;
1380 /* Check for wrap-around. */
1385 call_history_range ( begin
, end
, flags
);
1388 /* The record_method method of target record-btrace. */
1391 record_btrace_target::record_method (ptid_t ptid
)
1393 process_stratum_target
*proc_target
= current_inferior ()->process_target ();
1394 thread_info
*const tp
= find_thread_ptid (proc_target
, ptid
);
1397 error (_("No thread."));
1399 if (tp
->btrace
.target
== NULL
)
1400 return RECORD_METHOD_NONE
;
1402 return RECORD_METHOD_BTRACE
;
1405 /* The record_is_replaying method of target record-btrace. */
1408 record_btrace_target::record_is_replaying (ptid_t ptid
)
1410 process_stratum_target
*proc_target
= current_inferior ()->process_target ();
1411 for (thread_info
*tp
: all_non_exited_threads (proc_target
, ptid
))
1412 if (btrace_is_replaying (tp
))
1418 /* The record_will_replay method of target record-btrace. */
1421 record_btrace_target::record_will_replay (ptid_t ptid
, int dir
)
1423 return dir
== EXEC_REVERSE
|| record_is_replaying (ptid
);
1426 /* The xfer_partial method of target record-btrace. */
1428 enum target_xfer_status
1429 record_btrace_target::xfer_partial (enum target_object object
,
1430 const char *annex
, gdb_byte
*readbuf
,
1431 const gdb_byte
*writebuf
, ULONGEST offset
,
1432 ULONGEST len
, ULONGEST
*xfered_len
)
1434 /* Filter out requests that don't make sense during replay. */
1435 if (replay_memory_access
== replay_memory_access_read_only
1436 && !record_btrace_generating_corefile
1437 && record_is_replaying (inferior_ptid
))
1441 case TARGET_OBJECT_MEMORY
:
1443 const struct target_section
*section
;
1445 /* We do not allow writing memory in general. */
1446 if (writebuf
!= NULL
)
1449 return TARGET_XFER_UNAVAILABLE
;
1452 /* We allow reading readonly memory. */
1453 section
= target_section_by_addr (this, offset
);
1454 if (section
!= NULL
)
1456 /* Check if the section we found is readonly. */
1457 if ((bfd_section_flags (section
->the_bfd_section
)
1458 & SEC_READONLY
) != 0)
1460 /* Truncate the request to fit into this section. */
1461 len
= std::min (len
, section
->endaddr
- offset
);
1467 return TARGET_XFER_UNAVAILABLE
;
1472 /* Forward the request. */
1473 return this->beneath ()->xfer_partial (object
, annex
, readbuf
, writebuf
,
1474 offset
, len
, xfered_len
);
1477 /* The insert_breakpoint method of target record-btrace. */
1480 record_btrace_target::insert_breakpoint (struct gdbarch
*gdbarch
,
1481 struct bp_target_info
*bp_tgt
)
1486 /* Inserting breakpoints requires accessing memory. Allow it for the
1487 duration of this function. */
1488 old
= replay_memory_access
;
1489 replay_memory_access
= replay_memory_access_read_write
;
1494 ret
= this->beneath ()->insert_breakpoint (gdbarch
, bp_tgt
);
1496 catch (const gdb_exception
&except
)
1498 replay_memory_access
= old
;
1501 replay_memory_access
= old
;
1506 /* The remove_breakpoint method of target record-btrace. */
1509 record_btrace_target::remove_breakpoint (struct gdbarch
*gdbarch
,
1510 struct bp_target_info
*bp_tgt
,
1511 enum remove_bp_reason reason
)
1516 /* Removing breakpoints requires accessing memory. Allow it for the
1517 duration of this function. */
1518 old
= replay_memory_access
;
1519 replay_memory_access
= replay_memory_access_read_write
;
1524 ret
= this->beneath ()->remove_breakpoint (gdbarch
, bp_tgt
, reason
);
1526 catch (const gdb_exception
&except
)
1528 replay_memory_access
= old
;
1531 replay_memory_access
= old
;
1536 /* The fetch_registers method of target record-btrace. */
1539 record_btrace_target::fetch_registers (struct regcache
*regcache
, int regno
)
1541 btrace_insn_iterator
*replay
= nullptr;
1543 /* Thread-db may ask for a thread's registers before GDB knows about the
1544 thread. We forward the request to the target beneath in this
1546 thread_info
*tp
= find_thread_ptid (regcache
->target (), regcache
->ptid ());
1548 replay
= tp
->btrace
.replay
;
1550 if (replay
!= nullptr && !record_btrace_generating_corefile
)
1552 const struct btrace_insn
*insn
;
1553 struct gdbarch
*gdbarch
;
1556 gdbarch
= regcache
->arch ();
1557 pcreg
= gdbarch_pc_regnum (gdbarch
);
1561 /* We can only provide the PC register. */
1562 if (regno
>= 0 && regno
!= pcreg
)
1565 insn
= btrace_insn_get (replay
);
1566 gdb_assert (insn
!= NULL
);
1568 regcache
->raw_supply (regno
, &insn
->pc
);
1571 this->beneath ()->fetch_registers (regcache
, regno
);
1574 /* The store_registers method of target record-btrace. */
1577 record_btrace_target::store_registers (struct regcache
*regcache
, int regno
)
1579 if (!record_btrace_generating_corefile
1580 && record_is_replaying (regcache
->ptid ()))
1581 error (_("Cannot write registers while replaying."));
1583 gdb_assert (may_write_registers
);
1585 this->beneath ()->store_registers (regcache
, regno
);
1588 /* The prepare_to_store method of target record-btrace. */
1591 record_btrace_target::prepare_to_store (struct regcache
*regcache
)
1593 if (!record_btrace_generating_corefile
1594 && record_is_replaying (regcache
->ptid ()))
1597 this->beneath ()->prepare_to_store (regcache
);
1600 /* The branch trace frame cache. */
1602 struct btrace_frame_cache
1605 struct thread_info
*tp
;
1607 /* The frame info. */
1608 struct frame_info
*frame
;
1610 /* The branch trace function segment. */
1611 const struct btrace_function
*bfun
;
1614 /* A struct btrace_frame_cache hash table indexed by NEXT. */
1616 static htab_t bfcache
;
1618 /* hash_f for htab_create_alloc of bfcache. */
1621 bfcache_hash (const void *arg
)
1623 const struct btrace_frame_cache
*cache
1624 = (const struct btrace_frame_cache
*) arg
;
1626 return htab_hash_pointer (cache
->frame
);
1629 /* eq_f for htab_create_alloc of bfcache. */
1632 bfcache_eq (const void *arg1
, const void *arg2
)
1634 const struct btrace_frame_cache
*cache1
1635 = (const struct btrace_frame_cache
*) arg1
;
1636 const struct btrace_frame_cache
*cache2
1637 = (const struct btrace_frame_cache
*) arg2
;
1639 return cache1
->frame
== cache2
->frame
;
1642 /* Create a new btrace frame cache. */
1644 static struct btrace_frame_cache
*
1645 bfcache_new (struct frame_info
*frame
)
1647 struct btrace_frame_cache
*cache
;
1650 cache
= FRAME_OBSTACK_ZALLOC (struct btrace_frame_cache
);
1651 cache
->frame
= frame
;
1653 slot
= htab_find_slot (bfcache
, cache
, INSERT
);
1654 gdb_assert (*slot
== NULL
);
1660 /* Extract the branch trace function from a branch trace frame. */
1662 static const struct btrace_function
*
1663 btrace_get_frame_function (struct frame_info
*frame
)
1665 const struct btrace_frame_cache
*cache
;
1666 struct btrace_frame_cache pattern
;
1669 pattern
.frame
= frame
;
1671 slot
= htab_find_slot (bfcache
, &pattern
, NO_INSERT
);
1675 cache
= (const struct btrace_frame_cache
*) *slot
;
1679 /* Implement stop_reason method for record_btrace_frame_unwind. */
1681 static enum unwind_stop_reason
1682 record_btrace_frame_unwind_stop_reason (struct frame_info
*this_frame
,
1685 const struct btrace_frame_cache
*cache
;
1686 const struct btrace_function
*bfun
;
1688 cache
= (const struct btrace_frame_cache
*) *this_cache
;
1690 gdb_assert (bfun
!= NULL
);
1693 return UNWIND_UNAVAILABLE
;
1695 return UNWIND_NO_REASON
;
1698 /* Implement this_id method for record_btrace_frame_unwind. */
1701 record_btrace_frame_this_id (struct frame_info
*this_frame
, void **this_cache
,
1702 struct frame_id
*this_id
)
1704 const struct btrace_frame_cache
*cache
;
1705 const struct btrace_function
*bfun
;
1706 struct btrace_call_iterator it
;
1707 CORE_ADDR code
, special
;
1709 cache
= (const struct btrace_frame_cache
*) *this_cache
;
1712 gdb_assert (bfun
!= NULL
);
1714 while (btrace_find_call_by_number (&it
, &cache
->tp
->btrace
, bfun
->prev
) != 0)
1715 bfun
= btrace_call_get (&it
);
1717 code
= get_frame_func (this_frame
);
1718 special
= bfun
->number
;
1720 *this_id
= frame_id_build_unavailable_stack_special (code
, special
);
1722 DEBUG ("[frame] %s id: (!stack, pc=%s, special=%s)",
1723 btrace_get_bfun_name (cache
->bfun
),
1724 core_addr_to_string_nz (this_id
->code_addr
),
1725 core_addr_to_string_nz (this_id
->special_addr
));
1728 /* Implement prev_register method for record_btrace_frame_unwind. */
1730 static struct value
*
1731 record_btrace_frame_prev_register (struct frame_info
*this_frame
,
1735 const struct btrace_frame_cache
*cache
;
1736 const struct btrace_function
*bfun
, *caller
;
1737 struct btrace_call_iterator it
;
1738 struct gdbarch
*gdbarch
;
1742 gdbarch
= get_frame_arch (this_frame
);
1743 pcreg
= gdbarch_pc_regnum (gdbarch
);
1744 if (pcreg
< 0 || regnum
!= pcreg
)
1745 throw_error (NOT_AVAILABLE_ERROR
,
1746 _("Registers are not available in btrace record history"));
1748 cache
= (const struct btrace_frame_cache
*) *this_cache
;
1750 gdb_assert (bfun
!= NULL
);
1752 if (btrace_find_call_by_number (&it
, &cache
->tp
->btrace
, bfun
->up
) == 0)
1753 throw_error (NOT_AVAILABLE_ERROR
,
1754 _("No caller in btrace record history"));
1756 caller
= btrace_call_get (&it
);
1758 if ((bfun
->flags
& BFUN_UP_LINKS_TO_RET
) != 0)
1759 pc
= caller
->insn
.front ().pc
;
1762 pc
= caller
->insn
.back ().pc
;
1763 pc
+= gdb_insn_length (gdbarch
, pc
);
1766 DEBUG ("[frame] unwound PC in %s on level %d: %s",
1767 btrace_get_bfun_name (bfun
), bfun
->level
,
1768 core_addr_to_string_nz (pc
));
1770 return frame_unwind_got_address (this_frame
, regnum
, pc
);
1773 /* Implement sniffer method for record_btrace_frame_unwind. */
1776 record_btrace_frame_sniffer (const struct frame_unwind
*self
,
1777 struct frame_info
*this_frame
,
1780 const struct btrace_function
*bfun
;
1781 struct btrace_frame_cache
*cache
;
1782 struct thread_info
*tp
;
1783 struct frame_info
*next
;
1785 /* THIS_FRAME does not contain a reference to its thread. */
1786 tp
= inferior_thread ();
1789 next
= get_next_frame (this_frame
);
1792 const struct btrace_insn_iterator
*replay
;
1794 replay
= tp
->btrace
.replay
;
1796 bfun
= &replay
->btinfo
->functions
[replay
->call_index
];
1800 const struct btrace_function
*callee
;
1801 struct btrace_call_iterator it
;
1803 callee
= btrace_get_frame_function (next
);
1804 if (callee
== NULL
|| (callee
->flags
& BFUN_UP_LINKS_TO_TAILCALL
) != 0)
1807 if (btrace_find_call_by_number (&it
, &tp
->btrace
, callee
->up
) == 0)
1810 bfun
= btrace_call_get (&it
);
1816 DEBUG ("[frame] sniffed frame for %s on level %d",
1817 btrace_get_bfun_name (bfun
), bfun
->level
);
1819 /* This is our frame. Initialize the frame cache. */
1820 cache
= bfcache_new (this_frame
);
1824 *this_cache
= cache
;
1828 /* Implement sniffer method for record_btrace_tailcall_frame_unwind. */
1831 record_btrace_tailcall_frame_sniffer (const struct frame_unwind
*self
,
1832 struct frame_info
*this_frame
,
1835 const struct btrace_function
*bfun
, *callee
;
1836 struct btrace_frame_cache
*cache
;
1837 struct btrace_call_iterator it
;
1838 struct frame_info
*next
;
1839 struct thread_info
*tinfo
;
1841 next
= get_next_frame (this_frame
);
1845 callee
= btrace_get_frame_function (next
);
1849 if ((callee
->flags
& BFUN_UP_LINKS_TO_TAILCALL
) == 0)
1852 tinfo
= inferior_thread ();
1853 if (btrace_find_call_by_number (&it
, &tinfo
->btrace
, callee
->up
) == 0)
1856 bfun
= btrace_call_get (&it
);
1858 DEBUG ("[frame] sniffed tailcall frame for %s on level %d",
1859 btrace_get_bfun_name (bfun
), bfun
->level
);
1861 /* This is our frame. Initialize the frame cache. */
1862 cache
= bfcache_new (this_frame
);
1866 *this_cache
= cache
;
1871 record_btrace_frame_dealloc_cache (struct frame_info
*self
, void *this_cache
)
1873 struct btrace_frame_cache
*cache
;
1876 cache
= (struct btrace_frame_cache
*) this_cache
;
1878 slot
= htab_find_slot (bfcache
, cache
, NO_INSERT
);
1879 gdb_assert (slot
!= NULL
);
1881 htab_remove_elt (bfcache
, cache
);
1884 /* btrace recording does not store previous memory content, neither the stack
1885 frames content. Any unwinding would return erroneous results as the stack
1886 contents no longer matches the changed PC value restored from history.
1887 Therefore this unwinder reports any possibly unwound registers as
1890 const struct frame_unwind record_btrace_frame_unwind
=
1894 record_btrace_frame_unwind_stop_reason
,
1895 record_btrace_frame_this_id
,
1896 record_btrace_frame_prev_register
,
1898 record_btrace_frame_sniffer
,
1899 record_btrace_frame_dealloc_cache
1902 const struct frame_unwind record_btrace_tailcall_frame_unwind
=
1904 "record-btrace tailcall",
1906 record_btrace_frame_unwind_stop_reason
,
1907 record_btrace_frame_this_id
,
1908 record_btrace_frame_prev_register
,
1910 record_btrace_tailcall_frame_sniffer
,
1911 record_btrace_frame_dealloc_cache
1914 /* Implement the get_unwinder method. */
1916 const struct frame_unwind
*
1917 record_btrace_target::get_unwinder ()
1919 return &record_btrace_frame_unwind
;
1922 /* Implement the get_tailcall_unwinder method. */
1924 const struct frame_unwind
*
1925 record_btrace_target::get_tailcall_unwinder ()
1927 return &record_btrace_tailcall_frame_unwind
;
1930 /* Return a human-readable string for FLAG. */
1933 btrace_thread_flag_to_str (btrace_thread_flags flag
)
1941 return "reverse-step";
1947 return "reverse-cont";
1956 /* Indicate that TP should be resumed according to FLAG. */
1959 record_btrace_resume_thread (struct thread_info
*tp
,
1960 enum btrace_thread_flag flag
)
1962 struct btrace_thread_info
*btinfo
;
1964 DEBUG ("resuming thread %s (%s): %x (%s)", print_thread_id (tp
),
1965 target_pid_to_str (tp
->ptid
).c_str (), flag
,
1966 btrace_thread_flag_to_str (flag
));
1968 btinfo
= &tp
->btrace
;
1970 /* Fetch the latest branch trace. */
1971 btrace_fetch (tp
, record_btrace_get_cpu ());
1973 /* A resume request overwrites a preceding resume or stop request. */
1974 btinfo
->flags
&= ~(BTHR_MOVE
| BTHR_STOP
);
1975 btinfo
->flags
|= flag
;
1978 /* Get the current frame for TP. */
1980 static struct frame_id
1981 get_thread_current_frame_id (struct thread_info
*tp
)
1986 /* Set current thread, which is implicitly used by
1987 get_current_frame. */
1988 scoped_restore_current_thread restore_thread
;
1990 switch_to_thread (tp
);
1992 process_stratum_target
*proc_target
= tp
->inf
->process_target ();
1994 /* Clear the executing flag to allow changes to the current frame.
1995 We are not actually running, yet. We just started a reverse execution
1996 command or a record goto command.
1997 For the latter, EXECUTING is false and this has no effect.
1998 For the former, EXECUTING is true and we're in wait, about to
1999 move the thread. Since we need to recompute the stack, we temporarily
2000 set EXECUTING to false. */
2001 executing
= tp
->executing ();
2002 set_executing (proc_target
, inferior_ptid
, false);
2007 id
= get_frame_id (get_current_frame ());
2009 catch (const gdb_exception
&except
)
2011 /* Restore the previous execution state. */
2012 set_executing (proc_target
, inferior_ptid
, executing
);
2017 /* Restore the previous execution state. */
2018 set_executing (proc_target
, inferior_ptid
, executing
);
2023 /* Start replaying a thread. */
2025 static struct btrace_insn_iterator
*
2026 record_btrace_start_replaying (struct thread_info
*tp
)
2028 struct btrace_insn_iterator
*replay
;
2029 struct btrace_thread_info
*btinfo
;
2031 btinfo
= &tp
->btrace
;
2034 /* We can't start replaying without trace. */
2035 if (btinfo
->functions
.empty ())
2038 /* GDB stores the current frame_id when stepping in order to detects steps
2040 Since frames are computed differently when we're replaying, we need to
2041 recompute those stored frames and fix them up so we can still detect
2042 subroutines after we started replaying. */
2045 struct frame_id frame_id
;
2046 int upd_step_frame_id
, upd_step_stack_frame_id
;
2048 /* The current frame without replaying - computed via normal unwind. */
2049 frame_id
= get_thread_current_frame_id (tp
);
2051 /* Check if we need to update any stepping-related frame id's. */
2052 upd_step_frame_id
= frame_id_eq (frame_id
,
2053 tp
->control
.step_frame_id
);
2054 upd_step_stack_frame_id
= frame_id_eq (frame_id
,
2055 tp
->control
.step_stack_frame_id
);
2057 /* We start replaying at the end of the branch trace. This corresponds
2058 to the current instruction. */
2059 replay
= XNEW (struct btrace_insn_iterator
);
2060 btrace_insn_end (replay
, btinfo
);
2062 /* Skip gaps at the end of the trace. */
2063 while (btrace_insn_get (replay
) == NULL
)
2067 steps
= btrace_insn_prev (replay
, 1);
2069 error (_("No trace."));
2072 /* We're not replaying, yet. */
2073 gdb_assert (btinfo
->replay
== NULL
);
2074 btinfo
->replay
= replay
;
2076 /* Make sure we're not using any stale registers. */
2077 registers_changed_thread (tp
);
2079 /* The current frame with replaying - computed via btrace unwind. */
2080 frame_id
= get_thread_current_frame_id (tp
);
2082 /* Replace stepping related frames where necessary. */
2083 if (upd_step_frame_id
)
2084 tp
->control
.step_frame_id
= frame_id
;
2085 if (upd_step_stack_frame_id
)
2086 tp
->control
.step_stack_frame_id
= frame_id
;
2088 catch (const gdb_exception
&except
)
2090 xfree (btinfo
->replay
);
2091 btinfo
->replay
= NULL
;
2093 registers_changed_thread (tp
);
2101 /* Stop replaying a thread. */
2104 record_btrace_stop_replaying (struct thread_info
*tp
)
2106 struct btrace_thread_info
*btinfo
;
2108 btinfo
= &tp
->btrace
;
2110 xfree (btinfo
->replay
);
2111 btinfo
->replay
= NULL
;
2113 /* Make sure we're not leaving any stale registers. */
2114 registers_changed_thread (tp
);
2117 /* Stop replaying TP if it is at the end of its execution history. */
2120 record_btrace_stop_replaying_at_end (struct thread_info
*tp
)
2122 struct btrace_insn_iterator
*replay
, end
;
2123 struct btrace_thread_info
*btinfo
;
2125 btinfo
= &tp
->btrace
;
2126 replay
= btinfo
->replay
;
2131 btrace_insn_end (&end
, btinfo
);
2133 if (btrace_insn_cmp (replay
, &end
) == 0)
2134 record_btrace_stop_replaying (tp
);
2137 /* The resume method of target record-btrace. */
2140 record_btrace_target::resume (ptid_t ptid
, int step
, enum gdb_signal signal
)
2142 enum btrace_thread_flag flag
, cflag
;
2144 DEBUG ("resume %s: %s%s", target_pid_to_str (ptid
).c_str (),
2145 ::execution_direction
== EXEC_REVERSE
? "reverse-" : "",
2146 step
? "step" : "cont");
2148 /* Store the execution direction of the last resume.
2150 If there is more than one resume call, we have to rely on infrun
2151 to not change the execution direction in-between. */
2152 record_btrace_resume_exec_dir
= ::execution_direction
;
2154 /* As long as we're not replaying, just forward the request.
2156 For non-stop targets this means that no thread is replaying. In order to
2157 make progress, we may need to explicitly move replaying threads to the end
2158 of their execution history. */
2159 if ((::execution_direction
!= EXEC_REVERSE
)
2160 && !record_is_replaying (minus_one_ptid
))
2162 this->beneath ()->resume (ptid
, step
, signal
);
2166 /* Compute the btrace thread flag for the requested move. */
2167 if (::execution_direction
== EXEC_REVERSE
)
2169 flag
= step
== 0 ? BTHR_RCONT
: BTHR_RSTEP
;
2174 flag
= step
== 0 ? BTHR_CONT
: BTHR_STEP
;
2178 /* We just indicate the resume intent here. The actual stepping happens in
2179 record_btrace_wait below.
2181 For all-stop targets, we only step INFERIOR_PTID and continue others. */
2183 process_stratum_target
*proc_target
= current_inferior ()->process_target ();
2185 if (!target_is_non_stop_p ())
2187 gdb_assert (inferior_ptid
.matches (ptid
));
2189 for (thread_info
*tp
: all_non_exited_threads (proc_target
, ptid
))
2191 if (tp
->ptid
.matches (inferior_ptid
))
2192 record_btrace_resume_thread (tp
, flag
);
2194 record_btrace_resume_thread (tp
, cflag
);
2199 for (thread_info
*tp
: all_non_exited_threads (proc_target
, ptid
))
2200 record_btrace_resume_thread (tp
, flag
);
2203 /* Async support. */
2204 if (target_can_async_p ())
2207 mark_async_event_handler (record_btrace_async_inferior_event_handler
);
2211 /* Cancel resuming TP. */
2214 record_btrace_cancel_resume (struct thread_info
*tp
)
2216 btrace_thread_flags flags
;
2218 flags
= tp
->btrace
.flags
& (BTHR_MOVE
| BTHR_STOP
);
2222 DEBUG ("cancel resume thread %s (%s): %x (%s)",
2223 print_thread_id (tp
),
2224 target_pid_to_str (tp
->ptid
).c_str (), flags
.raw (),
2225 btrace_thread_flag_to_str (flags
));
2227 tp
->btrace
.flags
&= ~(BTHR_MOVE
| BTHR_STOP
);
2228 record_btrace_stop_replaying_at_end (tp
);
2231 /* Return a target_waitstatus indicating that we ran out of history. */
2233 static struct target_waitstatus
2234 btrace_step_no_history (void)
2236 struct target_waitstatus status
;
2238 status
.set_no_history ();
2243 /* Return a target_waitstatus indicating that a step finished. */
2245 static struct target_waitstatus
2246 btrace_step_stopped (void)
2248 struct target_waitstatus status
;
2250 status
.set_stopped (GDB_SIGNAL_TRAP
);
2255 /* Return a target_waitstatus indicating that a thread was stopped as
2258 static struct target_waitstatus
2259 btrace_step_stopped_on_request (void)
2261 struct target_waitstatus status
;
2263 status
.set_stopped (GDB_SIGNAL_0
);
2268 /* Return a target_waitstatus indicating a spurious stop. */
2270 static struct target_waitstatus
2271 btrace_step_spurious (void)
2273 struct target_waitstatus status
;
2275 status
.set_spurious ();
2280 /* Return a target_waitstatus indicating that the thread was not resumed. */
2282 static struct target_waitstatus
2283 btrace_step_no_resumed (void)
2285 struct target_waitstatus status
;
2287 status
.set_no_resumed ();
2292 /* Return a target_waitstatus indicating that we should wait again. */
2294 static struct target_waitstatus
2295 btrace_step_again (void)
2297 struct target_waitstatus status
;
2299 status
.set_ignore ();
2304 /* Clear the record histories. */
2307 record_btrace_clear_histories (struct btrace_thread_info
*btinfo
)
2309 xfree (btinfo
->insn_history
);
2310 xfree (btinfo
->call_history
);
2312 btinfo
->insn_history
= NULL
;
2313 btinfo
->call_history
= NULL
;
2316 /* Check whether TP's current replay position is at a breakpoint. */
2319 record_btrace_replay_at_breakpoint (struct thread_info
*tp
)
2321 struct btrace_insn_iterator
*replay
;
2322 struct btrace_thread_info
*btinfo
;
2323 const struct btrace_insn
*insn
;
2325 btinfo
= &tp
->btrace
;
2326 replay
= btinfo
->replay
;
2331 insn
= btrace_insn_get (replay
);
2335 return record_check_stopped_by_breakpoint (tp
->inf
->aspace
, insn
->pc
,
2336 &btinfo
->stop_reason
);
2339 /* Step one instruction in forward direction. */
2341 static struct target_waitstatus
2342 record_btrace_single_step_forward (struct thread_info
*tp
)
2344 struct btrace_insn_iterator
*replay
, end
, start
;
2345 struct btrace_thread_info
*btinfo
;
2347 btinfo
= &tp
->btrace
;
2348 replay
= btinfo
->replay
;
2350 /* We're done if we're not replaying. */
2352 return btrace_step_no_history ();
2354 /* Check if we're stepping a breakpoint. */
2355 if (record_btrace_replay_at_breakpoint (tp
))
2356 return btrace_step_stopped ();
2358 /* Skip gaps during replay. If we end up at a gap (at the end of the trace),
2359 jump back to the instruction at which we started. */
2365 /* We will bail out here if we continue stepping after reaching the end
2366 of the execution history. */
2367 steps
= btrace_insn_next (replay
, 1);
2371 return btrace_step_no_history ();
2374 while (btrace_insn_get (replay
) == NULL
);
2376 /* Determine the end of the instruction trace. */
2377 btrace_insn_end (&end
, btinfo
);
2379 /* The execution trace contains (and ends with) the current instruction.
2380 This instruction has not been executed, yet, so the trace really ends
2381 one instruction earlier. */
2382 if (btrace_insn_cmp (replay
, &end
) == 0)
2383 return btrace_step_no_history ();
2385 return btrace_step_spurious ();
2388 /* Step one instruction in backward direction. */
2390 static struct target_waitstatus
2391 record_btrace_single_step_backward (struct thread_info
*tp
)
2393 struct btrace_insn_iterator
*replay
, start
;
2394 struct btrace_thread_info
*btinfo
;
2396 btinfo
= &tp
->btrace
;
2397 replay
= btinfo
->replay
;
2399 /* Start replaying if we're not already doing so. */
2401 replay
= record_btrace_start_replaying (tp
);
2403 /* If we can't step any further, we reached the end of the history.
2404 Skip gaps during replay. If we end up at a gap (at the beginning of
2405 the trace), jump back to the instruction at which we started. */
2411 steps
= btrace_insn_prev (replay
, 1);
2415 return btrace_step_no_history ();
2418 while (btrace_insn_get (replay
) == NULL
);
2420 /* Check if we're stepping a breakpoint.
2422 For reverse-stepping, this check is after the step. There is logic in
2423 infrun.c that handles reverse-stepping separately. See, for example,
2424 proceed and adjust_pc_after_break.
2426 This code assumes that for reverse-stepping, PC points to the last
2427 de-executed instruction, whereas for forward-stepping PC points to the
2428 next to-be-executed instruction. */
2429 if (record_btrace_replay_at_breakpoint (tp
))
2430 return btrace_step_stopped ();
2432 return btrace_step_spurious ();
2435 /* Step a single thread. */
2437 static struct target_waitstatus
2438 record_btrace_step_thread (struct thread_info
*tp
)
2440 struct btrace_thread_info
*btinfo
;
2441 struct target_waitstatus status
;
2442 btrace_thread_flags flags
;
2444 btinfo
= &tp
->btrace
;
2446 flags
= btinfo
->flags
& (BTHR_MOVE
| BTHR_STOP
);
2447 btinfo
->flags
&= ~(BTHR_MOVE
| BTHR_STOP
);
2449 DEBUG ("stepping thread %s (%s): %x (%s)", print_thread_id (tp
),
2450 target_pid_to_str (tp
->ptid
).c_str (), flags
.raw (),
2451 btrace_thread_flag_to_str (flags
));
2453 /* We can't step without an execution history. */
2454 if ((flags
& BTHR_MOVE
) != 0 && btrace_is_empty (tp
))
2455 return btrace_step_no_history ();
2460 internal_error (__FILE__
, __LINE__
, _("invalid stepping type."));
2463 return btrace_step_stopped_on_request ();
2466 status
= record_btrace_single_step_forward (tp
);
2467 if (status
.kind () != TARGET_WAITKIND_SPURIOUS
)
2470 return btrace_step_stopped ();
2473 status
= record_btrace_single_step_backward (tp
);
2474 if (status
.kind () != TARGET_WAITKIND_SPURIOUS
)
2477 return btrace_step_stopped ();
2480 status
= record_btrace_single_step_forward (tp
);
2481 if (status
.kind () != TARGET_WAITKIND_SPURIOUS
)
2484 btinfo
->flags
|= flags
;
2485 return btrace_step_again ();
2488 status
= record_btrace_single_step_backward (tp
);
2489 if (status
.kind () != TARGET_WAITKIND_SPURIOUS
)
2492 btinfo
->flags
|= flags
;
2493 return btrace_step_again ();
2496 /* We keep threads moving at the end of their execution history. The wait
2497 method will stop the thread for whom the event is reported. */
2498 if (status
.kind () == TARGET_WAITKIND_NO_HISTORY
)
2499 btinfo
->flags
|= flags
;
2504 /* Announce further events if necessary. */
2507 record_btrace_maybe_mark_async_event
2508 (const std::vector
<thread_info
*> &moving
,
2509 const std::vector
<thread_info
*> &no_history
)
2511 bool more_moving
= !moving
.empty ();
2512 bool more_no_history
= !no_history
.empty ();;
2514 if (!more_moving
&& !more_no_history
)
2518 DEBUG ("movers pending");
2520 if (more_no_history
)
2521 DEBUG ("no-history pending");
2523 mark_async_event_handler (record_btrace_async_inferior_event_handler
);
2526 /* The wait method of target record-btrace. */
2529 record_btrace_target::wait (ptid_t ptid
, struct target_waitstatus
*status
,
2530 target_wait_flags options
)
2532 std::vector
<thread_info
*> moving
;
2533 std::vector
<thread_info
*> no_history
;
2535 /* Clear this, if needed we'll re-mark it below. */
2536 clear_async_event_handler (record_btrace_async_inferior_event_handler
);
2538 DEBUG ("wait %s (0x%x)", target_pid_to_str (ptid
).c_str (),
2539 (unsigned) options
);
2541 /* As long as we're not replaying, just forward the request. */
2542 if ((::execution_direction
!= EXEC_REVERSE
)
2543 && !record_is_replaying (minus_one_ptid
))
2545 return this->beneath ()->wait (ptid
, status
, options
);
2548 /* Keep a work list of moving threads. */
2549 process_stratum_target
*proc_target
= current_inferior ()->process_target ();
2550 for (thread_info
*tp
: all_non_exited_threads (proc_target
, ptid
))
2551 if ((tp
->btrace
.flags
& (BTHR_MOVE
| BTHR_STOP
)) != 0)
2552 moving
.push_back (tp
);
2554 if (moving
.empty ())
2556 *status
= btrace_step_no_resumed ();
2558 DEBUG ("wait ended by %s: %s", target_pid_to_str (null_ptid
).c_str (),
2559 target_waitstatus_to_string (status
).c_str ());
2564 /* Step moving threads one by one, one step each, until either one thread
2565 reports an event or we run out of threads to step.
2567 When stepping more than one thread, chances are that some threads reach
2568 the end of their execution history earlier than others. If we reported
2569 this immediately, all-stop on top of non-stop would stop all threads and
2570 resume the same threads next time. And we would report the same thread
2571 having reached the end of its execution history again.
2573 In the worst case, this would starve the other threads. But even if other
2574 threads would be allowed to make progress, this would result in far too
2575 many intermediate stops.
2577 We therefore delay the reporting of "no execution history" until we have
2578 nothing else to report. By this time, all threads should have moved to
2579 either the beginning or the end of their execution history. There will
2580 be a single user-visible stop. */
2581 struct thread_info
*eventing
= NULL
;
2582 while ((eventing
== NULL
) && !moving
.empty ())
2584 for (unsigned int ix
= 0; eventing
== NULL
&& ix
< moving
.size ();)
2586 thread_info
*tp
= moving
[ix
];
2588 *status
= record_btrace_step_thread (tp
);
2590 switch (status
->kind ())
2592 case TARGET_WAITKIND_IGNORE
:
2596 case TARGET_WAITKIND_NO_HISTORY
:
2597 no_history
.push_back (ordered_remove (moving
, ix
));
2601 eventing
= unordered_remove (moving
, ix
);
2607 if (eventing
== NULL
)
2609 /* We started with at least one moving thread. This thread must have
2610 either stopped or reached the end of its execution history.
2612 In the former case, EVENTING must not be NULL.
2613 In the latter case, NO_HISTORY must not be empty. */
2614 gdb_assert (!no_history
.empty ());
2616 /* We kept threads moving at the end of their execution history. Stop
2617 EVENTING now that we are going to report its stop. */
2618 eventing
= unordered_remove (no_history
, 0);
2619 eventing
->btrace
.flags
&= ~BTHR_MOVE
;
2621 *status
= btrace_step_no_history ();
2624 gdb_assert (eventing
!= NULL
);
2626 /* We kept threads replaying at the end of their execution history. Stop
2627 replaying EVENTING now that we are going to report its stop. */
2628 record_btrace_stop_replaying_at_end (eventing
);
2630 /* Stop all other threads. */
2631 if (!target_is_non_stop_p ())
2633 for (thread_info
*tp
: current_inferior ()->non_exited_threads ())
2634 record_btrace_cancel_resume (tp
);
2637 /* In async mode, we need to announce further events. */
2638 if (target_is_async_p ())
2639 record_btrace_maybe_mark_async_event (moving
, no_history
);
2641 /* Start record histories anew from the current position. */
2642 record_btrace_clear_histories (&eventing
->btrace
);
2644 /* We moved the replay position but did not update registers. */
2645 registers_changed_thread (eventing
);
2647 DEBUG ("wait ended by thread %s (%s): %s",
2648 print_thread_id (eventing
),
2649 target_pid_to_str (eventing
->ptid
).c_str (),
2650 target_waitstatus_to_string (status
).c_str ());
2652 return eventing
->ptid
;
2655 /* The stop method of target record-btrace. */
2658 record_btrace_target::stop (ptid_t ptid
)
2660 DEBUG ("stop %s", target_pid_to_str (ptid
).c_str ());
2662 /* As long as we're not replaying, just forward the request. */
2663 if ((::execution_direction
!= EXEC_REVERSE
)
2664 && !record_is_replaying (minus_one_ptid
))
2666 this->beneath ()->stop (ptid
);
2670 process_stratum_target
*proc_target
2671 = current_inferior ()->process_target ();
2673 for (thread_info
*tp
: all_non_exited_threads (proc_target
, ptid
))
2675 tp
->btrace
.flags
&= ~BTHR_MOVE
;
2676 tp
->btrace
.flags
|= BTHR_STOP
;
2681 /* The can_execute_reverse method of target record-btrace. */
2684 record_btrace_target::can_execute_reverse ()
2689 /* The stopped_by_sw_breakpoint method of target record-btrace. */
2692 record_btrace_target::stopped_by_sw_breakpoint ()
2694 if (record_is_replaying (minus_one_ptid
))
2696 struct thread_info
*tp
= inferior_thread ();
2698 return tp
->btrace
.stop_reason
== TARGET_STOPPED_BY_SW_BREAKPOINT
;
2701 return this->beneath ()->stopped_by_sw_breakpoint ();
2704 /* The supports_stopped_by_sw_breakpoint method of target
2708 record_btrace_target::supports_stopped_by_sw_breakpoint ()
2710 if (record_is_replaying (minus_one_ptid
))
2713 return this->beneath ()->supports_stopped_by_sw_breakpoint ();
2716 /* The stopped_by_sw_breakpoint method of target record-btrace. */
2719 record_btrace_target::stopped_by_hw_breakpoint ()
2721 if (record_is_replaying (minus_one_ptid
))
2723 struct thread_info
*tp
= inferior_thread ();
2725 return tp
->btrace
.stop_reason
== TARGET_STOPPED_BY_HW_BREAKPOINT
;
2728 return this->beneath ()->stopped_by_hw_breakpoint ();
2731 /* The supports_stopped_by_hw_breakpoint method of target
2735 record_btrace_target::supports_stopped_by_hw_breakpoint ()
2737 if (record_is_replaying (minus_one_ptid
))
2740 return this->beneath ()->supports_stopped_by_hw_breakpoint ();
2743 /* The update_thread_list method of target record-btrace. */
2746 record_btrace_target::update_thread_list ()
2748 /* We don't add or remove threads during replay. */
2749 if (record_is_replaying (minus_one_ptid
))
2752 /* Forward the request. */
2753 this->beneath ()->update_thread_list ();
2756 /* The thread_alive method of target record-btrace. */
2759 record_btrace_target::thread_alive (ptid_t ptid
)
2761 /* We don't add or remove threads during replay. */
2762 if (record_is_replaying (minus_one_ptid
))
2765 /* Forward the request. */
2766 return this->beneath ()->thread_alive (ptid
);
2769 /* Set the replay branch trace instruction iterator. If IT is NULL, replay
2773 record_btrace_set_replay (struct thread_info
*tp
,
2774 const struct btrace_insn_iterator
*it
)
2776 struct btrace_thread_info
*btinfo
;
2778 btinfo
= &tp
->btrace
;
2781 record_btrace_stop_replaying (tp
);
2784 if (btinfo
->replay
== NULL
)
2785 record_btrace_start_replaying (tp
);
2786 else if (btrace_insn_cmp (btinfo
->replay
, it
) == 0)
2789 *btinfo
->replay
= *it
;
2790 registers_changed_thread (tp
);
2793 /* Start anew from the new replay position. */
2794 record_btrace_clear_histories (btinfo
);
2796 inferior_thread ()->set_stop_pc (regcache_read_pc (get_current_regcache ()));
2797 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
, 1);
2800 /* The goto_record_begin method of target record-btrace. */
2803 record_btrace_target::goto_record_begin ()
2805 struct thread_info
*tp
;
2806 struct btrace_insn_iterator begin
;
2808 tp
= require_btrace_thread ();
2810 btrace_insn_begin (&begin
, &tp
->btrace
);
2812 /* Skip gaps at the beginning of the trace. */
2813 while (btrace_insn_get (&begin
) == NULL
)
2817 steps
= btrace_insn_next (&begin
, 1);
2819 error (_("No trace."));
2822 record_btrace_set_replay (tp
, &begin
);
2825 /* The goto_record_end method of target record-btrace. */
2828 record_btrace_target::goto_record_end ()
2830 struct thread_info
*tp
;
2832 tp
= require_btrace_thread ();
2834 record_btrace_set_replay (tp
, NULL
);
2837 /* The goto_record method of target record-btrace. */
2840 record_btrace_target::goto_record (ULONGEST insn
)
2842 struct thread_info
*tp
;
2843 struct btrace_insn_iterator it
;
2844 unsigned int number
;
2849 /* Check for wrap-arounds. */
2851 error (_("Instruction number out of range."));
2853 tp
= require_btrace_thread ();
2855 found
= btrace_find_insn_by_number (&it
, &tp
->btrace
, number
);
2857 /* Check if the instruction could not be found or is a gap. */
2858 if (found
== 0 || btrace_insn_get (&it
) == NULL
)
2859 error (_("No such instruction."));
2861 record_btrace_set_replay (tp
, &it
);
2864 /* The record_stop_replaying method of target record-btrace. */
2867 record_btrace_target::record_stop_replaying ()
2869 for (thread_info
*tp
: current_inferior ()->non_exited_threads ())
2870 record_btrace_stop_replaying (tp
);
2873 /* The execution_direction target method. */
2875 enum exec_direction_kind
2876 record_btrace_target::execution_direction ()
2878 return record_btrace_resume_exec_dir
;
2881 /* The prepare_to_generate_core target method. */
2884 record_btrace_target::prepare_to_generate_core ()
2886 record_btrace_generating_corefile
= 1;
2889 /* The done_generating_core target method. */
2892 record_btrace_target::done_generating_core ()
2894 record_btrace_generating_corefile
= 0;
2897 /* Start recording in BTS format. */
2900 cmd_record_btrace_bts_start (const char *args
, int from_tty
)
2902 if (args
!= NULL
&& *args
!= 0)
2903 error (_("Invalid argument."));
2905 record_btrace_conf
.format
= BTRACE_FORMAT_BTS
;
2909 execute_command ("target record-btrace", from_tty
);
2911 catch (const gdb_exception
&exception
)
2913 record_btrace_conf
.format
= BTRACE_FORMAT_NONE
;
2918 /* Start recording in Intel Processor Trace format. */
2921 cmd_record_btrace_pt_start (const char *args
, int from_tty
)
2923 if (args
!= NULL
&& *args
!= 0)
2924 error (_("Invalid argument."));
2926 record_btrace_conf
.format
= BTRACE_FORMAT_PT
;
2930 execute_command ("target record-btrace", from_tty
);
2932 catch (const gdb_exception
&exception
)
2934 record_btrace_conf
.format
= BTRACE_FORMAT_NONE
;
2939 /* Alias for "target record". */
2942 cmd_record_btrace_start (const char *args
, int from_tty
)
2944 if (args
!= NULL
&& *args
!= 0)
2945 error (_("Invalid argument."));
2947 record_btrace_conf
.format
= BTRACE_FORMAT_PT
;
2951 execute_command ("target record-btrace", from_tty
);
2953 catch (const gdb_exception
&exception
)
2955 record_btrace_conf
.format
= BTRACE_FORMAT_BTS
;
2959 execute_command ("target record-btrace", from_tty
);
2961 catch (const gdb_exception
&ex
)
2963 record_btrace_conf
.format
= BTRACE_FORMAT_NONE
;
2969 /* The "show record btrace replay-memory-access" command. */
2972 cmd_show_replay_memory_access (struct ui_file
*file
, int from_tty
,
2973 struct cmd_list_element
*c
, const char *value
)
2975 fprintf_filtered (gdb_stdout
, _("Replay memory access is %s.\n"),
2976 replay_memory_access
);
2979 /* The "set record btrace cpu none" command. */
2982 cmd_set_record_btrace_cpu_none (const char *args
, int from_tty
)
2984 if (args
!= nullptr && *args
!= 0)
2985 error (_("Trailing junk: '%s'."), args
);
2987 record_btrace_cpu_state
= CS_NONE
;
2990 /* The "set record btrace cpu auto" command. */
2993 cmd_set_record_btrace_cpu_auto (const char *args
, int from_tty
)
2995 if (args
!= nullptr && *args
!= 0)
2996 error (_("Trailing junk: '%s'."), args
);
2998 record_btrace_cpu_state
= CS_AUTO
;
3001 /* The "set record btrace cpu" command. */
3004 cmd_set_record_btrace_cpu (const char *args
, int from_tty
)
3006 if (args
== nullptr)
3009 /* We use a hard-coded vendor string for now. */
3010 unsigned int family
, model
, stepping
;
3011 int l1
, l2
, matches
= sscanf (args
, "intel: %u/%u%n/%u%n", &family
,
3012 &model
, &l1
, &stepping
, &l2
);
3015 if (strlen (args
) != l2
)
3016 error (_("Trailing junk: '%s'."), args
+ l2
);
3018 else if (matches
== 2)
3020 if (strlen (args
) != l1
)
3021 error (_("Trailing junk: '%s'."), args
+ l1
);
3026 error (_("Bad format. See \"help set record btrace cpu\"."));
3028 if (USHRT_MAX
< family
)
3029 error (_("Cpu family too big."));
3031 if (UCHAR_MAX
< model
)
3032 error (_("Cpu model too big."));
3034 if (UCHAR_MAX
< stepping
)
3035 error (_("Cpu stepping too big."));
3037 record_btrace_cpu
.vendor
= CV_INTEL
;
3038 record_btrace_cpu
.family
= family
;
3039 record_btrace_cpu
.model
= model
;
3040 record_btrace_cpu
.stepping
= stepping
;
3042 record_btrace_cpu_state
= CS_CPU
;
3045 /* The "show record btrace cpu" command. */
3048 cmd_show_record_btrace_cpu (const char *args
, int from_tty
)
3050 if (args
!= nullptr && *args
!= 0)
3051 error (_("Trailing junk: '%s'."), args
);
3053 switch (record_btrace_cpu_state
)
3056 printf_unfiltered (_("btrace cpu is 'auto'.\n"));
3060 printf_unfiltered (_("btrace cpu is 'none'.\n"));
3064 switch (record_btrace_cpu
.vendor
)
3067 if (record_btrace_cpu
.stepping
== 0)
3068 printf_unfiltered (_("btrace cpu is 'intel: %u/%u'.\n"),
3069 record_btrace_cpu
.family
,
3070 record_btrace_cpu
.model
);
3072 printf_unfiltered (_("btrace cpu is 'intel: %u/%u/%u'.\n"),
3073 record_btrace_cpu
.family
,
3074 record_btrace_cpu
.model
,
3075 record_btrace_cpu
.stepping
);
3080 error (_("Internal error: bad cpu state."));
3083 /* The "record bts buffer-size" show value function. */
3086 show_record_bts_buffer_size_value (struct ui_file
*file
, int from_tty
,
3087 struct cmd_list_element
*c
,
3090 fprintf_filtered (file
, _("The record/replay bts buffer size is %s.\n"),
3094 /* The "record pt buffer-size" show value function. */
3097 show_record_pt_buffer_size_value (struct ui_file
*file
, int from_tty
,
3098 struct cmd_list_element
*c
,
3101 fprintf_filtered (file
, _("The record/replay pt buffer size is %s.\n"),
3105 /* Initialize btrace commands. */
3107 void _initialize_record_btrace ();
3109 _initialize_record_btrace ()
3111 cmd_list_element
*record_btrace_cmd
3112 = add_prefix_cmd ("btrace", class_obscure
, cmd_record_btrace_start
,
3113 _("Start branch trace recording."),
3114 &record_btrace_cmdlist
, 0, &record_cmdlist
);
3115 add_alias_cmd ("b", record_btrace_cmd
, class_obscure
, 1, &record_cmdlist
);
3117 cmd_list_element
*record_btrace_bts_cmd
3118 = add_cmd ("bts", class_obscure
, cmd_record_btrace_bts_start
,
3120 Start branch trace recording in Branch Trace Store (BTS) format.\n\n\
3121 The processor stores a from/to record for each branch into a cyclic buffer.\n\
3122 This format may not be available on all processors."),
3123 &record_btrace_cmdlist
);
3124 add_alias_cmd ("bts", record_btrace_bts_cmd
, class_obscure
, 1,
3127 cmd_list_element
*record_btrace_pt_cmd
3128 = add_cmd ("pt", class_obscure
, cmd_record_btrace_pt_start
,
3130 Start branch trace recording in Intel Processor Trace format.\n\n\
3131 This format may not be available on all processors."),
3132 &record_btrace_cmdlist
);
3133 add_alias_cmd ("pt", record_btrace_pt_cmd
, class_obscure
, 1, &record_cmdlist
);
3135 add_basic_prefix_cmd ("btrace", class_support
,
3136 _("Set record options."), &set_record_btrace_cmdlist
,
3137 0, &set_record_cmdlist
);
3139 add_show_prefix_cmd ("btrace", class_support
,
3140 _("Show record options."), &show_record_btrace_cmdlist
,
3141 0, &show_record_cmdlist
);
3143 add_setshow_enum_cmd ("replay-memory-access", no_class
,
3144 replay_memory_access_types
, &replay_memory_access
, _("\
3145 Set what memory accesses are allowed during replay."), _("\
3146 Show what memory accesses are allowed during replay."),
3147 _("Default is READ-ONLY.\n\n\
3148 The btrace record target does not trace data.\n\
3149 The memory therefore corresponds to the live target and not \
3150 to the current replay position.\n\n\
3151 When READ-ONLY, allow accesses to read-only memory during replay.\n\
3152 When READ-WRITE, allow accesses to read-only and read-write memory during \
3154 NULL
, cmd_show_replay_memory_access
,
3155 &set_record_btrace_cmdlist
,
3156 &show_record_btrace_cmdlist
);
3158 add_prefix_cmd ("cpu", class_support
, cmd_set_record_btrace_cpu
,
3160 Set the cpu to be used for trace decode.\n\n\
3161 The format is \"VENDOR:IDENTIFIER\" or \"none\" or \"auto\" (default).\n\
3162 For vendor \"intel\" the format is \"FAMILY/MODEL[/STEPPING]\".\n\n\
3163 When decoding branch trace, enable errata workarounds for the specified cpu.\n\
3164 The default is \"auto\", which uses the cpu on which the trace was recorded.\n\
3165 When GDB does not support that cpu, this option can be used to enable\n\
3166 workarounds for a similar cpu that GDB supports.\n\n\
3167 When set to \"none\", errata workarounds are disabled."),
3168 &set_record_btrace_cpu_cmdlist
,
3170 &set_record_btrace_cmdlist
);
3172 add_cmd ("auto", class_support
, cmd_set_record_btrace_cpu_auto
, _("\
3173 Automatically determine the cpu to be used for trace decode."),
3174 &set_record_btrace_cpu_cmdlist
);
3176 add_cmd ("none", class_support
, cmd_set_record_btrace_cpu_none
, _("\
3177 Do not enable errata workarounds for trace decode."),
3178 &set_record_btrace_cpu_cmdlist
);
3180 add_cmd ("cpu", class_support
, cmd_show_record_btrace_cpu
, _("\
3181 Show the cpu to be used for trace decode."),
3182 &show_record_btrace_cmdlist
);
3184 add_basic_prefix_cmd ("bts", class_support
,
3185 _("Set record btrace bts options."),
3186 &set_record_btrace_bts_cmdlist
,
3188 &set_record_btrace_cmdlist
);
3190 add_show_prefix_cmd ("bts", class_support
,
3191 _("Show record btrace bts options."),
3192 &show_record_btrace_bts_cmdlist
,
3194 &show_record_btrace_cmdlist
);
3196 add_setshow_uinteger_cmd ("buffer-size", no_class
,
3197 &record_btrace_conf
.bts
.size
,
3198 _("Set the record/replay bts buffer size."),
3199 _("Show the record/replay bts buffer size."), _("\
3200 When starting recording request a trace buffer of this size. \
3201 The actual buffer size may differ from the requested size. \
3202 Use \"info record\" to see the actual buffer size.\n\n\
3203 Bigger buffers allow longer recording but also take more time to process \
3204 the recorded execution trace.\n\n\
3205 The trace buffer size may not be changed while recording."), NULL
,
3206 show_record_bts_buffer_size_value
,
3207 &set_record_btrace_bts_cmdlist
,
3208 &show_record_btrace_bts_cmdlist
);
3210 add_basic_prefix_cmd ("pt", class_support
,
3211 _("Set record btrace pt options."),
3212 &set_record_btrace_pt_cmdlist
,
3214 &set_record_btrace_cmdlist
);
3216 add_show_prefix_cmd ("pt", class_support
,
3217 _("Show record btrace pt options."),
3218 &show_record_btrace_pt_cmdlist
,
3220 &show_record_btrace_cmdlist
);
3222 add_setshow_uinteger_cmd ("buffer-size", no_class
,
3223 &record_btrace_conf
.pt
.size
,
3224 _("Set the record/replay pt buffer size."),
3225 _("Show the record/replay pt buffer size."), _("\
3226 Bigger buffers allow longer recording but also take more time to process \
3227 the recorded execution.\n\
3228 The actual buffer size may differ from the requested size. Use \"info record\" \
3229 to see the actual buffer size."), NULL
, show_record_pt_buffer_size_value
,
3230 &set_record_btrace_pt_cmdlist
,
3231 &show_record_btrace_pt_cmdlist
);
3233 add_target (record_btrace_target_info
, record_btrace_target_open
);
3235 bfcache
= htab_create_alloc (50, bfcache_hash
, bfcache_eq
, NULL
,
3238 record_btrace_conf
.bts
.size
= 64 * 1024;
3239 record_btrace_conf
.pt
.size
= 16 * 1024;