1 /* Branch trace support for GDB, the GNU debugger.
3 Copyright (C) 2013-2018 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 "event-loop.h"
45 static const target_info record_btrace_target_info = {
47 N_("Branch tracing target"),
48 N_("Collect control-flow trace and provide the execution history.")
51 /* The target_ops of record-btrace. */
53 class record_btrace_target final : public target_ops
56 const target_info &info () const override
57 { return record_btrace_target_info; }
59 strata stratum () const override { return record_stratum; }
61 void close () override;
62 void async (int) override;
64 void detach (inferior *inf, int from_tty) override
65 { record_detach (this, inf, from_tty); }
67 void disconnect (const char *, int) override;
69 void mourn_inferior () override
70 { record_mourn_inferior (this); }
73 { record_kill (this); }
75 enum record_method record_method (ptid_t ptid) override;
77 void stop_recording () override;
78 void info_record () override;
80 void insn_history (int size, gdb_disassembly_flags flags) override;
81 void insn_history_from (ULONGEST from, int size,
82 gdb_disassembly_flags flags) override;
83 void insn_history_range (ULONGEST begin, ULONGEST end,
84 gdb_disassembly_flags flags) override;
85 void call_history (int size, record_print_flags flags) override;
86 void call_history_from (ULONGEST begin, int size, record_print_flags flags)
88 void call_history_range (ULONGEST begin, ULONGEST end, record_print_flags flags)
91 bool record_is_replaying (ptid_t ptid) override;
92 bool record_will_replay (ptid_t ptid, int dir) override;
93 void record_stop_replaying () override;
95 enum target_xfer_status xfer_partial (enum target_object object,
98 const gdb_byte *writebuf,
99 ULONGEST offset, ULONGEST len,
100 ULONGEST *xfered_len) override;
102 int insert_breakpoint (struct gdbarch *,
103 struct bp_target_info *) override;
104 int remove_breakpoint (struct gdbarch *, struct bp_target_info *,
105 enum remove_bp_reason) override;
107 void fetch_registers (struct regcache *, int) override;
109 void store_registers (struct regcache *, int) override;
110 void prepare_to_store (struct regcache *) override;
112 const struct frame_unwind *get_unwinder () override;
114 const struct frame_unwind *get_tailcall_unwinder () override;
116 void commit_resume () override;
117 void resume (ptid_t, int, enum gdb_signal) override;
118 ptid_t wait (ptid_t, struct target_waitstatus *, int) override;
120 void stop (ptid_t) override;
121 void update_thread_list () override;
122 bool thread_alive (ptid_t ptid) override;
123 void goto_record_begin () override;
124 void goto_record_end () override;
125 void goto_record (ULONGEST insn) override;
127 bool can_execute_reverse () override;
129 bool stopped_by_sw_breakpoint () override;
130 bool supports_stopped_by_sw_breakpoint () override;
132 bool stopped_by_hw_breakpoint () override;
133 bool supports_stopped_by_hw_breakpoint () override;
135 enum exec_direction_kind execution_direction () override;
136 void prepare_to_generate_core () override;
137 void done_generating_core () override;
140 static record_btrace_target record_btrace_ops;
142 /* Initialize the record-btrace target ops. */
144 /* Token associated with a new-thread observer enabling branch tracing
145 for the new thread. */
146 static const gdb::observers::token record_btrace_thread_observer_token {};
148 /* Memory access types used in set/show record btrace replay-memory-access. */
149 static const char replay_memory_access_read_only[] = "read-only";
150 static const char replay_memory_access_read_write[] = "read-write";
151 static const char *const replay_memory_access_types[] =
153 replay_memory_access_read_only,
154 replay_memory_access_read_write,
158 /* The currently allowed replay memory access type. */
159 static const char *replay_memory_access = replay_memory_access_read_only;
161 /* The cpu state kinds. */
162 enum record_btrace_cpu_state_kind
169 /* The current cpu state. */
170 static enum record_btrace_cpu_state_kind record_btrace_cpu_state = CS_AUTO;
172 /* The current cpu for trace decode. */
173 static struct btrace_cpu record_btrace_cpu;
175 /* Command lists for "set/show record btrace". */
176 static struct cmd_list_element *set_record_btrace_cmdlist;
177 static struct cmd_list_element *show_record_btrace_cmdlist;
179 /* The execution direction of the last resume we got. See record-full.c. */
180 static enum exec_direction_kind record_btrace_resume_exec_dir = EXEC_FORWARD;
182 /* The async event handler for reverse/replay execution. */
183 static struct async_event_handler *record_btrace_async_inferior_event_handler;
185 /* A flag indicating that we are currently generating a core file. */
186 static int record_btrace_generating_corefile;
188 /* The current branch trace configuration. */
189 static struct btrace_config record_btrace_conf;
191 /* Command list for "record btrace". */
192 static struct cmd_list_element *record_btrace_cmdlist;
194 /* Command lists for "set/show record btrace bts". */
195 static struct cmd_list_element *set_record_btrace_bts_cmdlist;
196 static struct cmd_list_element *show_record_btrace_bts_cmdlist;
198 /* Command lists for "set/show record btrace pt". */
199 static struct cmd_list_element *set_record_btrace_pt_cmdlist;
200 static struct cmd_list_element *show_record_btrace_pt_cmdlist;
202 /* Command list for "set record btrace cpu". */
203 static struct cmd_list_element *set_record_btrace_cpu_cmdlist;
205 /* Print a record-btrace debug message. Use do ... while (0) to avoid
206 ambiguities when used in if statements. */
208 #define DEBUG(msg, args...) \
211 if (record_debug != 0) \
212 fprintf_unfiltered (gdb_stdlog, \
213 "[record-btrace] " msg "\n", ##args); \
218 /* Return the cpu configured by the user. Returns NULL if the cpu was
219 configured as auto. */
220 const struct btrace_cpu *
221 record_btrace_get_cpu (void)
223 switch (record_btrace_cpu_state)
229 record_btrace_cpu.vendor = CV_UNKNOWN;
232 return &record_btrace_cpu;
235 error (_("Internal error: bad record btrace cpu state."));
238 /* Update the branch trace for the current thread and return a pointer to its
241 Throws an error if there is no thread or no trace. This function never
244 static struct thread_info *
245 require_btrace_thread (void)
249 if (inferior_ptid == null_ptid)
250 error (_("No thread."));
252 thread_info *tp = inferior_thread ();
254 validate_registers_access ();
256 btrace_fetch (tp, record_btrace_get_cpu ());
258 if (btrace_is_empty (tp))
259 error (_("No trace."));
264 /* Update the branch trace for the current thread and return a pointer to its
265 branch trace information struct.
267 Throws an error if there is no thread or no trace. This function never
270 static struct btrace_thread_info *
271 require_btrace (void)
273 struct thread_info *tp;
275 tp = require_btrace_thread ();
280 /* Enable branch tracing for one thread. Warn on errors. */
283 record_btrace_enable_warn (struct thread_info *tp)
287 btrace_enable (tp, &record_btrace_conf);
289 CATCH (error, RETURN_MASK_ERROR)
291 warning ("%s", error.message);
296 /* Enable automatic tracing of new threads. */
299 record_btrace_auto_enable (void)
301 DEBUG ("attach thread observer");
303 gdb::observers::new_thread.attach (record_btrace_enable_warn,
304 record_btrace_thread_observer_token);
307 /* Disable automatic tracing of new threads. */
310 record_btrace_auto_disable (void)
312 DEBUG ("detach thread observer");
314 gdb::observers::new_thread.detach (record_btrace_thread_observer_token);
317 /* The record-btrace async event handler function. */
320 record_btrace_handle_async_inferior_event (gdb_client_data data)
322 inferior_event_handler (INF_REG_EVENT, NULL);
325 /* See record-btrace.h. */
328 record_btrace_push_target (void)
332 record_btrace_auto_enable ();
334 push_target (&record_btrace_ops);
336 record_btrace_async_inferior_event_handler
337 = create_async_event_handler (record_btrace_handle_async_inferior_event,
339 record_btrace_generating_corefile = 0;
341 format = btrace_format_short_string (record_btrace_conf.format);
342 gdb::observers::record_changed.notify (current_inferior (), 1, "btrace", format);
345 /* Disable btrace on a set of threads on scope exit. */
347 struct scoped_btrace_disable
349 scoped_btrace_disable () = default;
351 DISABLE_COPY_AND_ASSIGN (scoped_btrace_disable);
353 ~scoped_btrace_disable ()
355 for (thread_info *tp : m_threads)
359 void add_thread (thread_info *thread)
361 m_threads.push_front (thread);
370 std::forward_list<thread_info *> m_threads;
373 /* Open target record-btrace. */
376 record_btrace_target_open (const char *args, int from_tty)
378 /* If we fail to enable btrace for one thread, disable it for the threads for
379 which it was successfully enabled. */
380 scoped_btrace_disable btrace_disable;
386 if (!target_has_execution)
387 error (_("The program is not being run."));
389 for (thread_info *tp : all_non_exited_threads ())
390 if (args == NULL || *args == 0 || number_is_in_list (args, tp->global_num))
392 btrace_enable (tp, &record_btrace_conf);
394 btrace_disable.add_thread (tp);
397 record_btrace_push_target ();
399 btrace_disable.discard ();
402 /* The stop_recording method of target record-btrace. */
405 record_btrace_target::stop_recording ()
407 DEBUG ("stop recording");
409 record_btrace_auto_disable ();
411 for (thread_info *tp : all_non_exited_threads ())
412 if (tp->btrace.target != NULL)
416 /* The disconnect method of target record-btrace. */
419 record_btrace_target::disconnect (const char *args,
422 struct target_ops *beneath = this->beneath ();
424 /* Do not stop recording, just clean up GDB side. */
425 unpush_target (this);
427 /* Forward disconnect. */
428 beneath->disconnect (args, from_tty);
431 /* The close method of target record-btrace. */
434 record_btrace_target::close ()
436 if (record_btrace_async_inferior_event_handler != NULL)
437 delete_async_event_handler (&record_btrace_async_inferior_event_handler);
439 /* Make sure automatic recording gets disabled even if we did not stop
440 recording before closing the record-btrace target. */
441 record_btrace_auto_disable ();
443 /* We should have already stopped recording.
444 Tear down btrace in case we have not. */
445 for (thread_info *tp : all_non_exited_threads ())
446 btrace_teardown (tp);
449 /* The async method of target record-btrace. */
452 record_btrace_target::async (int enable)
455 mark_async_event_handler (record_btrace_async_inferior_event_handler);
457 clear_async_event_handler (record_btrace_async_inferior_event_handler);
459 this->beneath ()->async (enable);
462 /* Adjusts the size and returns a human readable size suffix. */
465 record_btrace_adjust_size (unsigned int *size)
471 if ((sz & ((1u << 30) - 1)) == 0)
476 else if ((sz & ((1u << 20) - 1)) == 0)
481 else if ((sz & ((1u << 10) - 1)) == 0)
490 /* Print a BTS configuration. */
493 record_btrace_print_bts_conf (const struct btrace_config_bts *conf)
501 suffix = record_btrace_adjust_size (&size);
502 printf_unfiltered (_("Buffer size: %u%s.\n"), size, suffix);
506 /* Print an Intel Processor Trace configuration. */
509 record_btrace_print_pt_conf (const struct btrace_config_pt *conf)
517 suffix = record_btrace_adjust_size (&size);
518 printf_unfiltered (_("Buffer size: %u%s.\n"), size, suffix);
522 /* Print a branch tracing configuration. */
525 record_btrace_print_conf (const struct btrace_config *conf)
527 printf_unfiltered (_("Recording format: %s.\n"),
528 btrace_format_string (conf->format));
530 switch (conf->format)
532 case BTRACE_FORMAT_NONE:
535 case BTRACE_FORMAT_BTS:
536 record_btrace_print_bts_conf (&conf->bts);
539 case BTRACE_FORMAT_PT:
540 record_btrace_print_pt_conf (&conf->pt);
544 internal_error (__FILE__, __LINE__, _("Unkown branch trace format."));
547 /* The info_record method of target record-btrace. */
550 record_btrace_target::info_record ()
552 struct btrace_thread_info *btinfo;
553 const struct btrace_config *conf;
554 struct thread_info *tp;
555 unsigned int insns, calls, gaps;
559 tp = find_thread_ptid (inferior_ptid);
561 error (_("No thread."));
563 validate_registers_access ();
565 btinfo = &tp->btrace;
567 conf = ::btrace_conf (btinfo);
569 record_btrace_print_conf (conf);
571 btrace_fetch (tp, record_btrace_get_cpu ());
577 if (!btrace_is_empty (tp))
579 struct btrace_call_iterator call;
580 struct btrace_insn_iterator insn;
582 btrace_call_end (&call, btinfo);
583 btrace_call_prev (&call, 1);
584 calls = btrace_call_number (&call);
586 btrace_insn_end (&insn, btinfo);
587 insns = btrace_insn_number (&insn);
589 /* If the last instruction is not a gap, it is the current instruction
590 that is not actually part of the record. */
591 if (btrace_insn_get (&insn) != NULL)
594 gaps = btinfo->ngaps;
597 printf_unfiltered (_("Recorded %u instructions in %u functions (%u gaps) "
598 "for thread %s (%s).\n"), insns, calls, gaps,
599 print_thread_id (tp), target_pid_to_str (tp->ptid));
601 if (btrace_is_replaying (tp))
602 printf_unfiltered (_("Replay in progress. At instruction %u.\n"),
603 btrace_insn_number (btinfo->replay));
606 /* Print a decode error. */
609 btrace_ui_out_decode_error (struct ui_out *uiout, int errcode,
610 enum btrace_format format)
612 const char *errstr = btrace_decode_error (format, errcode);
614 uiout->text (_("["));
615 /* ERRCODE > 0 indicates notifications on BTRACE_FORMAT_PT. */
616 if (!(format == BTRACE_FORMAT_PT && errcode > 0))
618 uiout->text (_("decode error ("));
619 uiout->field_int ("errcode", errcode);
620 uiout->text (_("): "));
622 uiout->text (errstr);
623 uiout->text (_("]\n"));
626 /* Print an unsigned int. */
629 ui_out_field_uint (struct ui_out *uiout, const char *fld, unsigned int val)
631 uiout->field_fmt (fld, "%u", val);
634 /* A range of source lines. */
636 struct btrace_line_range
638 /* The symtab this line is from. */
639 struct symtab *symtab;
641 /* The first line (inclusive). */
644 /* The last line (exclusive). */
648 /* Construct a line range. */
650 static struct btrace_line_range
651 btrace_mk_line_range (struct symtab *symtab, int begin, int end)
653 struct btrace_line_range range;
655 range.symtab = symtab;
662 /* Add a line to a line range. */
664 static struct btrace_line_range
665 btrace_line_range_add (struct btrace_line_range range, int line)
667 if (range.end <= range.begin)
669 /* This is the first entry. */
671 range.end = line + 1;
673 else if (line < range.begin)
675 else if (range.end < line)
681 /* Return non-zero if RANGE is empty, zero otherwise. */
684 btrace_line_range_is_empty (struct btrace_line_range range)
686 return range.end <= range.begin;
689 /* Return non-zero if LHS contains RHS, zero otherwise. */
692 btrace_line_range_contains_range (struct btrace_line_range lhs,
693 struct btrace_line_range rhs)
695 return ((lhs.symtab == rhs.symtab)
696 && (lhs.begin <= rhs.begin)
697 && (rhs.end <= lhs.end));
700 /* Find the line range associated with PC. */
702 static struct btrace_line_range
703 btrace_find_line_range (CORE_ADDR pc)
705 struct btrace_line_range range;
706 struct linetable_entry *lines;
707 struct linetable *ltable;
708 struct symtab *symtab;
711 symtab = find_pc_line_symtab (pc);
713 return btrace_mk_line_range (NULL, 0, 0);
715 ltable = SYMTAB_LINETABLE (symtab);
717 return btrace_mk_line_range (symtab, 0, 0);
719 nlines = ltable->nitems;
720 lines = ltable->item;
722 return btrace_mk_line_range (symtab, 0, 0);
724 range = btrace_mk_line_range (symtab, 0, 0);
725 for (i = 0; i < nlines - 1; i++)
727 if ((lines[i].pc == pc) && (lines[i].line != 0))
728 range = btrace_line_range_add (range, lines[i].line);
734 /* Print source lines in LINES to UIOUT.
736 UI_ITEM_CHAIN is a cleanup chain for the last source line and the
737 instructions corresponding to that source line. When printing a new source
738 line, we do the cleanups for the open chain and open a new cleanup chain for
739 the new source line. If the source line range in LINES is not empty, this
740 function will leave the cleanup chain for the last printed source line open
741 so instructions can be added to it. */
744 btrace_print_lines (struct btrace_line_range lines, struct ui_out *uiout,
745 gdb::optional<ui_out_emit_tuple> *src_and_asm_tuple,
746 gdb::optional<ui_out_emit_list> *asm_list,
747 gdb_disassembly_flags flags)
749 print_source_lines_flags psl_flags;
751 if (flags & DISASSEMBLY_FILENAME)
752 psl_flags |= PRINT_SOURCE_LINES_FILENAME;
754 for (int line = lines.begin; line < lines.end; ++line)
758 src_and_asm_tuple->emplace (uiout, "src_and_asm_line");
760 print_source_lines (lines.symtab, line, line + 1, psl_flags);
762 asm_list->emplace (uiout, "line_asm_insn");
766 /* Disassemble a section of the recorded instruction trace. */
769 btrace_insn_history (struct ui_out *uiout,
770 const struct btrace_thread_info *btinfo,
771 const struct btrace_insn_iterator *begin,
772 const struct btrace_insn_iterator *end,
773 gdb_disassembly_flags flags)
775 DEBUG ("itrace (0x%x): [%u; %u)", (unsigned) flags,
776 btrace_insn_number (begin), btrace_insn_number (end));
778 flags |= DISASSEMBLY_SPECULATIVE;
780 struct gdbarch *gdbarch = target_gdbarch ();
781 btrace_line_range last_lines = btrace_mk_line_range (NULL, 0, 0);
783 ui_out_emit_list list_emitter (uiout, "asm_insns");
785 gdb::optional<ui_out_emit_tuple> src_and_asm_tuple;
786 gdb::optional<ui_out_emit_list> asm_list;
788 gdb_pretty_print_disassembler disasm (gdbarch);
790 for (btrace_insn_iterator it = *begin; btrace_insn_cmp (&it, end) != 0;
791 btrace_insn_next (&it, 1))
793 const struct btrace_insn *insn;
795 insn = btrace_insn_get (&it);
797 /* A NULL instruction indicates a gap in the trace. */
800 const struct btrace_config *conf;
802 conf = btrace_conf (btinfo);
804 /* We have trace so we must have a configuration. */
805 gdb_assert (conf != NULL);
807 uiout->field_fmt ("insn-number", "%u",
808 btrace_insn_number (&it));
811 btrace_ui_out_decode_error (uiout, btrace_insn_get_error (&it),
816 struct disasm_insn dinsn;
818 if ((flags & DISASSEMBLY_SOURCE) != 0)
820 struct btrace_line_range lines;
822 lines = btrace_find_line_range (insn->pc);
823 if (!btrace_line_range_is_empty (lines)
824 && !btrace_line_range_contains_range (last_lines, lines))
826 btrace_print_lines (lines, uiout, &src_and_asm_tuple, &asm_list,
830 else if (!src_and_asm_tuple.has_value ())
832 gdb_assert (!asm_list.has_value ());
834 src_and_asm_tuple.emplace (uiout, "src_and_asm_line");
836 /* No source information. */
837 asm_list.emplace (uiout, "line_asm_insn");
840 gdb_assert (src_and_asm_tuple.has_value ());
841 gdb_assert (asm_list.has_value ());
844 memset (&dinsn, 0, sizeof (dinsn));
845 dinsn.number = btrace_insn_number (&it);
846 dinsn.addr = insn->pc;
848 if ((insn->flags & BTRACE_INSN_FLAG_SPECULATIVE) != 0)
849 dinsn.is_speculative = 1;
851 disasm.pretty_print_insn (uiout, &dinsn, flags);
856 /* The insn_history method of target record-btrace. */
859 record_btrace_target::insn_history (int size, gdb_disassembly_flags flags)
861 struct btrace_thread_info *btinfo;
862 struct btrace_insn_history *history;
863 struct btrace_insn_iterator begin, end;
864 struct ui_out *uiout;
865 unsigned int context, covered;
867 uiout = current_uiout;
868 ui_out_emit_tuple tuple_emitter (uiout, "insn history");
869 context = abs (size);
871 error (_("Bad record instruction-history-size."));
873 btinfo = require_btrace ();
874 history = btinfo->insn_history;
877 struct btrace_insn_iterator *replay;
879 DEBUG ("insn-history (0x%x): %d", (unsigned) flags, size);
881 /* If we're replaying, we start at the replay position. Otherwise, we
882 start at the tail of the trace. */
883 replay = btinfo->replay;
887 btrace_insn_end (&begin, btinfo);
889 /* We start from here and expand in the requested direction. Then we
890 expand in the other direction, as well, to fill up any remaining
895 /* We want the current position covered, as well. */
896 covered = btrace_insn_next (&end, 1);
897 covered += btrace_insn_prev (&begin, context - covered);
898 covered += btrace_insn_next (&end, context - covered);
902 covered = btrace_insn_next (&end, context);
903 covered += btrace_insn_prev (&begin, context - covered);
908 begin = history->begin;
911 DEBUG ("insn-history (0x%x): %d, prev: [%u; %u)", (unsigned) flags, size,
912 btrace_insn_number (&begin), btrace_insn_number (&end));
917 covered = btrace_insn_prev (&begin, context);
922 covered = btrace_insn_next (&end, context);
927 btrace_insn_history (uiout, btinfo, &begin, &end, flags);
931 printf_unfiltered (_("At the start of the branch trace record.\n"));
933 printf_unfiltered (_("At the end of the branch trace record.\n"));
936 btrace_set_insn_history (btinfo, &begin, &end);
939 /* The insn_history_range method of target record-btrace. */
942 record_btrace_target::insn_history_range (ULONGEST from, ULONGEST to,
943 gdb_disassembly_flags flags)
945 struct btrace_thread_info *btinfo;
946 struct btrace_insn_iterator begin, end;
947 struct ui_out *uiout;
948 unsigned int low, high;
951 uiout = current_uiout;
952 ui_out_emit_tuple tuple_emitter (uiout, "insn history");
956 DEBUG ("insn-history (0x%x): [%u; %u)", (unsigned) flags, low, high);
958 /* Check for wrap-arounds. */
959 if (low != from || high != to)
960 error (_("Bad range."));
963 error (_("Bad range."));
965 btinfo = require_btrace ();
967 found = btrace_find_insn_by_number (&begin, btinfo, low);
969 error (_("Range out of bounds."));
971 found = btrace_find_insn_by_number (&end, btinfo, high);
974 /* Silently truncate the range. */
975 btrace_insn_end (&end, btinfo);
979 /* We want both begin and end to be inclusive. */
980 btrace_insn_next (&end, 1);
983 btrace_insn_history (uiout, btinfo, &begin, &end, flags);
984 btrace_set_insn_history (btinfo, &begin, &end);
987 /* The insn_history_from method of target record-btrace. */
990 record_btrace_target::insn_history_from (ULONGEST from, int size,
991 gdb_disassembly_flags flags)
993 ULONGEST begin, end, context;
995 context = abs (size);
997 error (_("Bad record instruction-history-size."));
1006 begin = from - context + 1;
1011 end = from + context - 1;
1013 /* Check for wrap-around. */
1018 insn_history_range (begin, end, flags);
1021 /* Print the instruction number range for a function call history line. */
1024 btrace_call_history_insn_range (struct ui_out *uiout,
1025 const struct btrace_function *bfun)
1027 unsigned int begin, end, size;
1029 size = bfun->insn.size ();
1030 gdb_assert (size > 0);
1032 begin = bfun->insn_offset;
1033 end = begin + size - 1;
1035 ui_out_field_uint (uiout, "insn begin", begin);
1037 ui_out_field_uint (uiout, "insn end", end);
1040 /* Compute the lowest and highest source line for the instructions in BFUN
1041 and return them in PBEGIN and PEND.
1042 Ignore instructions that can't be mapped to BFUN, e.g. instructions that
1043 result from inlining or macro expansion. */
1046 btrace_compute_src_line_range (const struct btrace_function *bfun,
1047 int *pbegin, int *pend)
1049 struct symtab *symtab;
1060 symtab = symbol_symtab (sym);
1062 for (const btrace_insn &insn : bfun->insn)
1064 struct symtab_and_line sal;
1066 sal = find_pc_line (insn.pc, 0);
1067 if (sal.symtab != symtab || sal.line == 0)
1070 begin = std::min (begin, sal.line);
1071 end = std::max (end, sal.line);
1079 /* Print the source line information for a function call history line. */
1082 btrace_call_history_src_line (struct ui_out *uiout,
1083 const struct btrace_function *bfun)
1092 uiout->field_string ("file",
1093 symtab_to_filename_for_display (symbol_symtab (sym)),
1094 ui_out_style_kind::FILE);
1096 btrace_compute_src_line_range (bfun, &begin, &end);
1101 uiout->field_int ("min line", begin);
1107 uiout->field_int ("max line", end);
1110 /* Get the name of a branch trace function. */
1113 btrace_get_bfun_name (const struct btrace_function *bfun)
1115 struct minimal_symbol *msym;
1125 return SYMBOL_PRINT_NAME (sym);
1126 else if (msym != NULL)
1127 return MSYMBOL_PRINT_NAME (msym);
1132 /* Disassemble a section of the recorded function trace. */
1135 btrace_call_history (struct ui_out *uiout,
1136 const struct btrace_thread_info *btinfo,
1137 const struct btrace_call_iterator *begin,
1138 const struct btrace_call_iterator *end,
1141 struct btrace_call_iterator it;
1142 record_print_flags flags = (enum record_print_flag) int_flags;
1144 DEBUG ("ftrace (0x%x): [%u; %u)", int_flags, btrace_call_number (begin),
1145 btrace_call_number (end));
1147 for (it = *begin; btrace_call_cmp (&it, end) < 0; btrace_call_next (&it, 1))
1149 const struct btrace_function *bfun;
1150 struct minimal_symbol *msym;
1153 bfun = btrace_call_get (&it);
1157 /* Print the function index. */
1158 ui_out_field_uint (uiout, "index", bfun->number);
1161 /* Indicate gaps in the trace. */
1162 if (bfun->errcode != 0)
1164 const struct btrace_config *conf;
1166 conf = btrace_conf (btinfo);
1168 /* We have trace so we must have a configuration. */
1169 gdb_assert (conf != NULL);
1171 btrace_ui_out_decode_error (uiout, bfun->errcode, conf->format);
1176 if ((flags & RECORD_PRINT_INDENT_CALLS) != 0)
1178 int level = bfun->level + btinfo->level, i;
1180 for (i = 0; i < level; ++i)
1185 uiout->field_string ("function", SYMBOL_PRINT_NAME (sym),
1186 ui_out_style_kind::FUNCTION);
1187 else if (msym != NULL)
1188 uiout->field_string ("function", MSYMBOL_PRINT_NAME (msym),
1189 ui_out_style_kind::FUNCTION);
1190 else if (!uiout->is_mi_like_p ())
1191 uiout->field_string ("function", "??",
1192 ui_out_style_kind::FUNCTION);
1194 if ((flags & RECORD_PRINT_INSN_RANGE) != 0)
1196 uiout->text (_("\tinst "));
1197 btrace_call_history_insn_range (uiout, bfun);
1200 if ((flags & RECORD_PRINT_SRC_LINE) != 0)
1202 uiout->text (_("\tat "));
1203 btrace_call_history_src_line (uiout, bfun);
1210 /* The call_history method of target record-btrace. */
1213 record_btrace_target::call_history (int size, record_print_flags flags)
1215 struct btrace_thread_info *btinfo;
1216 struct btrace_call_history *history;
1217 struct btrace_call_iterator begin, end;
1218 struct ui_out *uiout;
1219 unsigned int context, covered;
1221 uiout = current_uiout;
1222 ui_out_emit_tuple tuple_emitter (uiout, "insn history");
1223 context = abs (size);
1225 error (_("Bad record function-call-history-size."));
1227 btinfo = require_btrace ();
1228 history = btinfo->call_history;
1229 if (history == NULL)
1231 struct btrace_insn_iterator *replay;
1233 DEBUG ("call-history (0x%x): %d", (int) flags, size);
1235 /* If we're replaying, we start at the replay position. Otherwise, we
1236 start at the tail of the trace. */
1237 replay = btinfo->replay;
1240 begin.btinfo = btinfo;
1241 begin.index = replay->call_index;
1244 btrace_call_end (&begin, btinfo);
1246 /* We start from here and expand in the requested direction. Then we
1247 expand in the other direction, as well, to fill up any remaining
1252 /* We want the current position covered, as well. */
1253 covered = btrace_call_next (&end, 1);
1254 covered += btrace_call_prev (&begin, context - covered);
1255 covered += btrace_call_next (&end, context - covered);
1259 covered = btrace_call_next (&end, context);
1260 covered += btrace_call_prev (&begin, context- covered);
1265 begin = history->begin;
1268 DEBUG ("call-history (0x%x): %d, prev: [%u; %u)", (int) flags, size,
1269 btrace_call_number (&begin), btrace_call_number (&end));
1274 covered = btrace_call_prev (&begin, context);
1279 covered = btrace_call_next (&end, context);
1284 btrace_call_history (uiout, btinfo, &begin, &end, flags);
1288 printf_unfiltered (_("At the start of the branch trace record.\n"));
1290 printf_unfiltered (_("At the end of the branch trace record.\n"));
1293 btrace_set_call_history (btinfo, &begin, &end);
1296 /* The call_history_range method of target record-btrace. */
1299 record_btrace_target::call_history_range (ULONGEST from, ULONGEST to,
1300 record_print_flags flags)
1302 struct btrace_thread_info *btinfo;
1303 struct btrace_call_iterator begin, end;
1304 struct ui_out *uiout;
1305 unsigned int low, high;
1308 uiout = current_uiout;
1309 ui_out_emit_tuple tuple_emitter (uiout, "func history");
1313 DEBUG ("call-history (0x%x): [%u; %u)", (int) flags, low, high);
1315 /* Check for wrap-arounds. */
1316 if (low != from || high != to)
1317 error (_("Bad range."));
1320 error (_("Bad range."));
1322 btinfo = require_btrace ();
1324 found = btrace_find_call_by_number (&begin, btinfo, low);
1326 error (_("Range out of bounds."));
1328 found = btrace_find_call_by_number (&end, btinfo, high);
1331 /* Silently truncate the range. */
1332 btrace_call_end (&end, btinfo);
1336 /* We want both begin and end to be inclusive. */
1337 btrace_call_next (&end, 1);
1340 btrace_call_history (uiout, btinfo, &begin, &end, flags);
1341 btrace_set_call_history (btinfo, &begin, &end);
1344 /* The call_history_from method of target record-btrace. */
1347 record_btrace_target::call_history_from (ULONGEST from, int size,
1348 record_print_flags flags)
1350 ULONGEST begin, end, context;
1352 context = abs (size);
1354 error (_("Bad record function-call-history-size."));
1363 begin = from - context + 1;
1368 end = from + context - 1;
1370 /* Check for wrap-around. */
1375 call_history_range ( begin, end, flags);
1378 /* The record_method method of target record-btrace. */
1381 record_btrace_target::record_method (ptid_t ptid)
1383 struct thread_info * const tp = find_thread_ptid (ptid);
1386 error (_("No thread."));
1388 if (tp->btrace.target == NULL)
1389 return RECORD_METHOD_NONE;
1391 return RECORD_METHOD_BTRACE;
1394 /* The record_is_replaying method of target record-btrace. */
1397 record_btrace_target::record_is_replaying (ptid_t ptid)
1399 for (thread_info *tp : all_non_exited_threads (ptid))
1400 if (btrace_is_replaying (tp))
1406 /* The record_will_replay method of target record-btrace. */
1409 record_btrace_target::record_will_replay (ptid_t ptid, int dir)
1411 return dir == EXEC_REVERSE || record_is_replaying (ptid);
1414 /* The xfer_partial method of target record-btrace. */
1416 enum target_xfer_status
1417 record_btrace_target::xfer_partial (enum target_object object,
1418 const char *annex, gdb_byte *readbuf,
1419 const gdb_byte *writebuf, ULONGEST offset,
1420 ULONGEST len, ULONGEST *xfered_len)
1422 /* Filter out requests that don't make sense during replay. */
1423 if (replay_memory_access == replay_memory_access_read_only
1424 && !record_btrace_generating_corefile
1425 && record_is_replaying (inferior_ptid))
1429 case TARGET_OBJECT_MEMORY:
1431 struct target_section *section;
1433 /* We do not allow writing memory in general. */
1434 if (writebuf != NULL)
1437 return TARGET_XFER_UNAVAILABLE;
1440 /* We allow reading readonly memory. */
1441 section = target_section_by_addr (this, offset);
1442 if (section != NULL)
1444 /* Check if the section we found is readonly. */
1445 if ((bfd_get_section_flags (section->the_bfd_section->owner,
1446 section->the_bfd_section)
1447 & SEC_READONLY) != 0)
1449 /* Truncate the request to fit into this section. */
1450 len = std::min (len, section->endaddr - offset);
1456 return TARGET_XFER_UNAVAILABLE;
1461 /* Forward the request. */
1462 return this->beneath ()->xfer_partial (object, annex, readbuf, writebuf,
1463 offset, len, xfered_len);
1466 /* The insert_breakpoint method of target record-btrace. */
1469 record_btrace_target::insert_breakpoint (struct gdbarch *gdbarch,
1470 struct bp_target_info *bp_tgt)
1475 /* Inserting breakpoints requires accessing memory. Allow it for the
1476 duration of this function. */
1477 old = replay_memory_access;
1478 replay_memory_access = replay_memory_access_read_write;
1483 ret = this->beneath ()->insert_breakpoint (gdbarch, bp_tgt);
1485 CATCH (except, RETURN_MASK_ALL)
1487 replay_memory_access = old;
1488 throw_exception (except);
1491 replay_memory_access = old;
1496 /* The remove_breakpoint method of target record-btrace. */
1499 record_btrace_target::remove_breakpoint (struct gdbarch *gdbarch,
1500 struct bp_target_info *bp_tgt,
1501 enum remove_bp_reason reason)
1506 /* Removing breakpoints requires accessing memory. Allow it for the
1507 duration of this function. */
1508 old = replay_memory_access;
1509 replay_memory_access = replay_memory_access_read_write;
1514 ret = this->beneath ()->remove_breakpoint (gdbarch, bp_tgt, reason);
1516 CATCH (except, RETURN_MASK_ALL)
1518 replay_memory_access = old;
1519 throw_exception (except);
1522 replay_memory_access = old;
1527 /* The fetch_registers method of target record-btrace. */
1530 record_btrace_target::fetch_registers (struct regcache *regcache, int regno)
1532 struct btrace_insn_iterator *replay;
1533 struct thread_info *tp;
1535 tp = find_thread_ptid (regcache->ptid ());
1536 gdb_assert (tp != NULL);
1538 replay = tp->btrace.replay;
1539 if (replay != NULL && !record_btrace_generating_corefile)
1541 const struct btrace_insn *insn;
1542 struct gdbarch *gdbarch;
1545 gdbarch = regcache->arch ();
1546 pcreg = gdbarch_pc_regnum (gdbarch);
1550 /* We can only provide the PC register. */
1551 if (regno >= 0 && regno != pcreg)
1554 insn = btrace_insn_get (replay);
1555 gdb_assert (insn != NULL);
1557 regcache->raw_supply (regno, &insn->pc);
1560 this->beneath ()->fetch_registers (regcache, regno);
1563 /* The store_registers method of target record-btrace. */
1566 record_btrace_target::store_registers (struct regcache *regcache, int regno)
1568 if (!record_btrace_generating_corefile
1569 && record_is_replaying (regcache->ptid ()))
1570 error (_("Cannot write registers while replaying."));
1572 gdb_assert (may_write_registers != 0);
1574 this->beneath ()->store_registers (regcache, regno);
1577 /* The prepare_to_store method of target record-btrace. */
1580 record_btrace_target::prepare_to_store (struct regcache *regcache)
1582 if (!record_btrace_generating_corefile
1583 && record_is_replaying (regcache->ptid ()))
1586 this->beneath ()->prepare_to_store (regcache);
1589 /* The branch trace frame cache. */
1591 struct btrace_frame_cache
1594 struct thread_info *tp;
1596 /* The frame info. */
1597 struct frame_info *frame;
1599 /* The branch trace function segment. */
1600 const struct btrace_function *bfun;
1603 /* A struct btrace_frame_cache hash table indexed by NEXT. */
1605 static htab_t bfcache;
1607 /* hash_f for htab_create_alloc of bfcache. */
1610 bfcache_hash (const void *arg)
1612 const struct btrace_frame_cache *cache
1613 = (const struct btrace_frame_cache *) arg;
1615 return htab_hash_pointer (cache->frame);
1618 /* eq_f for htab_create_alloc of bfcache. */
1621 bfcache_eq (const void *arg1, const void *arg2)
1623 const struct btrace_frame_cache *cache1
1624 = (const struct btrace_frame_cache *) arg1;
1625 const struct btrace_frame_cache *cache2
1626 = (const struct btrace_frame_cache *) arg2;
1628 return cache1->frame == cache2->frame;
1631 /* Create a new btrace frame cache. */
1633 static struct btrace_frame_cache *
1634 bfcache_new (struct frame_info *frame)
1636 struct btrace_frame_cache *cache;
1639 cache = FRAME_OBSTACK_ZALLOC (struct btrace_frame_cache);
1640 cache->frame = frame;
1642 slot = htab_find_slot (bfcache, cache, INSERT);
1643 gdb_assert (*slot == NULL);
1649 /* Extract the branch trace function from a branch trace frame. */
1651 static const struct btrace_function *
1652 btrace_get_frame_function (struct frame_info *frame)
1654 const struct btrace_frame_cache *cache;
1655 struct btrace_frame_cache pattern;
1658 pattern.frame = frame;
1660 slot = htab_find_slot (bfcache, &pattern, NO_INSERT);
1664 cache = (const struct btrace_frame_cache *) *slot;
1668 /* Implement stop_reason method for record_btrace_frame_unwind. */
1670 static enum unwind_stop_reason
1671 record_btrace_frame_unwind_stop_reason (struct frame_info *this_frame,
1674 const struct btrace_frame_cache *cache;
1675 const struct btrace_function *bfun;
1677 cache = (const struct btrace_frame_cache *) *this_cache;
1679 gdb_assert (bfun != NULL);
1682 return UNWIND_UNAVAILABLE;
1684 return UNWIND_NO_REASON;
1687 /* Implement this_id method for record_btrace_frame_unwind. */
1690 record_btrace_frame_this_id (struct frame_info *this_frame, void **this_cache,
1691 struct frame_id *this_id)
1693 const struct btrace_frame_cache *cache;
1694 const struct btrace_function *bfun;
1695 struct btrace_call_iterator it;
1696 CORE_ADDR code, special;
1698 cache = (const struct btrace_frame_cache *) *this_cache;
1701 gdb_assert (bfun != NULL);
1703 while (btrace_find_call_by_number (&it, &cache->tp->btrace, bfun->prev) != 0)
1704 bfun = btrace_call_get (&it);
1706 code = get_frame_func (this_frame);
1707 special = bfun->number;
1709 *this_id = frame_id_build_unavailable_stack_special (code, special);
1711 DEBUG ("[frame] %s id: (!stack, pc=%s, special=%s)",
1712 btrace_get_bfun_name (cache->bfun),
1713 core_addr_to_string_nz (this_id->code_addr),
1714 core_addr_to_string_nz (this_id->special_addr));
1717 /* Implement prev_register method for record_btrace_frame_unwind. */
1719 static struct value *
1720 record_btrace_frame_prev_register (struct frame_info *this_frame,
1724 const struct btrace_frame_cache *cache;
1725 const struct btrace_function *bfun, *caller;
1726 struct btrace_call_iterator it;
1727 struct gdbarch *gdbarch;
1731 gdbarch = get_frame_arch (this_frame);
1732 pcreg = gdbarch_pc_regnum (gdbarch);
1733 if (pcreg < 0 || regnum != pcreg)
1734 throw_error (NOT_AVAILABLE_ERROR,
1735 _("Registers are not available in btrace record history"));
1737 cache = (const struct btrace_frame_cache *) *this_cache;
1739 gdb_assert (bfun != NULL);
1741 if (btrace_find_call_by_number (&it, &cache->tp->btrace, bfun->up) == 0)
1742 throw_error (NOT_AVAILABLE_ERROR,
1743 _("No caller in btrace record history"));
1745 caller = btrace_call_get (&it);
1747 if ((bfun->flags & BFUN_UP_LINKS_TO_RET) != 0)
1748 pc = caller->insn.front ().pc;
1751 pc = caller->insn.back ().pc;
1752 pc += gdb_insn_length (gdbarch, pc);
1755 DEBUG ("[frame] unwound PC in %s on level %d: %s",
1756 btrace_get_bfun_name (bfun), bfun->level,
1757 core_addr_to_string_nz (pc));
1759 return frame_unwind_got_address (this_frame, regnum, pc);
1762 /* Implement sniffer method for record_btrace_frame_unwind. */
1765 record_btrace_frame_sniffer (const struct frame_unwind *self,
1766 struct frame_info *this_frame,
1769 const struct btrace_function *bfun;
1770 struct btrace_frame_cache *cache;
1771 struct thread_info *tp;
1772 struct frame_info *next;
1774 /* THIS_FRAME does not contain a reference to its thread. */
1775 tp = inferior_thread ();
1778 next = get_next_frame (this_frame);
1781 const struct btrace_insn_iterator *replay;
1783 replay = tp->btrace.replay;
1785 bfun = &replay->btinfo->functions[replay->call_index];
1789 const struct btrace_function *callee;
1790 struct btrace_call_iterator it;
1792 callee = btrace_get_frame_function (next);
1793 if (callee == NULL || (callee->flags & BFUN_UP_LINKS_TO_TAILCALL) != 0)
1796 if (btrace_find_call_by_number (&it, &tp->btrace, callee->up) == 0)
1799 bfun = btrace_call_get (&it);
1805 DEBUG ("[frame] sniffed frame for %s on level %d",
1806 btrace_get_bfun_name (bfun), bfun->level);
1808 /* This is our frame. Initialize the frame cache. */
1809 cache = bfcache_new (this_frame);
1813 *this_cache = cache;
1817 /* Implement sniffer method for record_btrace_tailcall_frame_unwind. */
1820 record_btrace_tailcall_frame_sniffer (const struct frame_unwind *self,
1821 struct frame_info *this_frame,
1824 const struct btrace_function *bfun, *callee;
1825 struct btrace_frame_cache *cache;
1826 struct btrace_call_iterator it;
1827 struct frame_info *next;
1828 struct thread_info *tinfo;
1830 next = get_next_frame (this_frame);
1834 callee = btrace_get_frame_function (next);
1838 if ((callee->flags & BFUN_UP_LINKS_TO_TAILCALL) == 0)
1841 tinfo = inferior_thread ();
1842 if (btrace_find_call_by_number (&it, &tinfo->btrace, callee->up) == 0)
1845 bfun = btrace_call_get (&it);
1847 DEBUG ("[frame] sniffed tailcall frame for %s on level %d",
1848 btrace_get_bfun_name (bfun), bfun->level);
1850 /* This is our frame. Initialize the frame cache. */
1851 cache = bfcache_new (this_frame);
1855 *this_cache = cache;
1860 record_btrace_frame_dealloc_cache (struct frame_info *self, void *this_cache)
1862 struct btrace_frame_cache *cache;
1865 cache = (struct btrace_frame_cache *) this_cache;
1867 slot = htab_find_slot (bfcache, cache, NO_INSERT);
1868 gdb_assert (slot != NULL);
1870 htab_remove_elt (bfcache, cache);
1873 /* btrace recording does not store previous memory content, neither the stack
1874 frames content. Any unwinding would return errorneous results as the stack
1875 contents no longer matches the changed PC value restored from history.
1876 Therefore this unwinder reports any possibly unwound registers as
1879 const struct frame_unwind record_btrace_frame_unwind =
1882 record_btrace_frame_unwind_stop_reason,
1883 record_btrace_frame_this_id,
1884 record_btrace_frame_prev_register,
1886 record_btrace_frame_sniffer,
1887 record_btrace_frame_dealloc_cache
1890 const struct frame_unwind record_btrace_tailcall_frame_unwind =
1893 record_btrace_frame_unwind_stop_reason,
1894 record_btrace_frame_this_id,
1895 record_btrace_frame_prev_register,
1897 record_btrace_tailcall_frame_sniffer,
1898 record_btrace_frame_dealloc_cache
1901 /* Implement the get_unwinder method. */
1903 const struct frame_unwind *
1904 record_btrace_target::get_unwinder ()
1906 return &record_btrace_frame_unwind;
1909 /* Implement the get_tailcall_unwinder method. */
1911 const struct frame_unwind *
1912 record_btrace_target::get_tailcall_unwinder ()
1914 return &record_btrace_tailcall_frame_unwind;
1917 /* Return a human-readable string for FLAG. */
1920 btrace_thread_flag_to_str (enum btrace_thread_flag flag)
1928 return "reverse-step";
1934 return "reverse-cont";
1943 /* Indicate that TP should be resumed according to FLAG. */
1946 record_btrace_resume_thread (struct thread_info *tp,
1947 enum btrace_thread_flag flag)
1949 struct btrace_thread_info *btinfo;
1951 DEBUG ("resuming thread %s (%s): %x (%s)", print_thread_id (tp),
1952 target_pid_to_str (tp->ptid), flag, btrace_thread_flag_to_str (flag));
1954 btinfo = &tp->btrace;
1956 /* Fetch the latest branch trace. */
1957 btrace_fetch (tp, record_btrace_get_cpu ());
1959 /* A resume request overwrites a preceding resume or stop request. */
1960 btinfo->flags &= ~(BTHR_MOVE | BTHR_STOP);
1961 btinfo->flags |= flag;
1964 /* Get the current frame for TP. */
1966 static struct frame_id
1967 get_thread_current_frame_id (struct thread_info *tp)
1972 /* Set current thread, which is implicitly used by
1973 get_current_frame. */
1974 scoped_restore_current_thread restore_thread;
1976 switch_to_thread (tp);
1978 /* Clear the executing flag to allow changes to the current frame.
1979 We are not actually running, yet. We just started a reverse execution
1980 command or a record goto command.
1981 For the latter, EXECUTING is false and this has no effect.
1982 For the former, EXECUTING is true and we're in wait, about to
1983 move the thread. Since we need to recompute the stack, we temporarily
1984 set EXECUTING to flase. */
1985 executing = tp->executing;
1986 set_executing (inferior_ptid, false);
1991 id = get_frame_id (get_current_frame ());
1993 CATCH (except, RETURN_MASK_ALL)
1995 /* Restore the previous execution state. */
1996 set_executing (inferior_ptid, executing);
1998 throw_exception (except);
2002 /* Restore the previous execution state. */
2003 set_executing (inferior_ptid, executing);
2008 /* Start replaying a thread. */
2010 static struct btrace_insn_iterator *
2011 record_btrace_start_replaying (struct thread_info *tp)
2013 struct btrace_insn_iterator *replay;
2014 struct btrace_thread_info *btinfo;
2016 btinfo = &tp->btrace;
2019 /* We can't start replaying without trace. */
2020 if (btinfo->functions.empty ())
2023 /* GDB stores the current frame_id when stepping in order to detects steps
2025 Since frames are computed differently when we're replaying, we need to
2026 recompute those stored frames and fix them up so we can still detect
2027 subroutines after we started replaying. */
2030 struct frame_id frame_id;
2031 int upd_step_frame_id, upd_step_stack_frame_id;
2033 /* The current frame without replaying - computed via normal unwind. */
2034 frame_id = get_thread_current_frame_id (tp);
2036 /* Check if we need to update any stepping-related frame id's. */
2037 upd_step_frame_id = frame_id_eq (frame_id,
2038 tp->control.step_frame_id);
2039 upd_step_stack_frame_id = frame_id_eq (frame_id,
2040 tp->control.step_stack_frame_id);
2042 /* We start replaying at the end of the branch trace. This corresponds
2043 to the current instruction. */
2044 replay = XNEW (struct btrace_insn_iterator);
2045 btrace_insn_end (replay, btinfo);
2047 /* Skip gaps at the end of the trace. */
2048 while (btrace_insn_get (replay) == NULL)
2052 steps = btrace_insn_prev (replay, 1);
2054 error (_("No trace."));
2057 /* We're not replaying, yet. */
2058 gdb_assert (btinfo->replay == NULL);
2059 btinfo->replay = replay;
2061 /* Make sure we're not using any stale registers. */
2062 registers_changed_thread (tp);
2064 /* The current frame with replaying - computed via btrace unwind. */
2065 frame_id = get_thread_current_frame_id (tp);
2067 /* Replace stepping related frames where necessary. */
2068 if (upd_step_frame_id)
2069 tp->control.step_frame_id = frame_id;
2070 if (upd_step_stack_frame_id)
2071 tp->control.step_stack_frame_id = frame_id;
2073 CATCH (except, RETURN_MASK_ALL)
2075 xfree (btinfo->replay);
2076 btinfo->replay = NULL;
2078 registers_changed_thread (tp);
2080 throw_exception (except);
2087 /* Stop replaying a thread. */
2090 record_btrace_stop_replaying (struct thread_info *tp)
2092 struct btrace_thread_info *btinfo;
2094 btinfo = &tp->btrace;
2096 xfree (btinfo->replay);
2097 btinfo->replay = NULL;
2099 /* Make sure we're not leaving any stale registers. */
2100 registers_changed_thread (tp);
2103 /* Stop replaying TP if it is at the end of its execution history. */
2106 record_btrace_stop_replaying_at_end (struct thread_info *tp)
2108 struct btrace_insn_iterator *replay, end;
2109 struct btrace_thread_info *btinfo;
2111 btinfo = &tp->btrace;
2112 replay = btinfo->replay;
2117 btrace_insn_end (&end, btinfo);
2119 if (btrace_insn_cmp (replay, &end) == 0)
2120 record_btrace_stop_replaying (tp);
2123 /* The resume method of target record-btrace. */
2126 record_btrace_target::resume (ptid_t ptid, int step, enum gdb_signal signal)
2128 enum btrace_thread_flag flag, cflag;
2130 DEBUG ("resume %s: %s%s", target_pid_to_str (ptid),
2131 ::execution_direction == EXEC_REVERSE ? "reverse-" : "",
2132 step ? "step" : "cont");
2134 /* Store the execution direction of the last resume.
2136 If there is more than one resume call, we have to rely on infrun
2137 to not change the execution direction in-between. */
2138 record_btrace_resume_exec_dir = ::execution_direction;
2140 /* As long as we're not replaying, just forward the request.
2142 For non-stop targets this means that no thread is replaying. In order to
2143 make progress, we may need to explicitly move replaying threads to the end
2144 of their execution history. */
2145 if ((::execution_direction != EXEC_REVERSE)
2146 && !record_is_replaying (minus_one_ptid))
2148 this->beneath ()->resume (ptid, step, signal);
2152 /* Compute the btrace thread flag for the requested move. */
2153 if (::execution_direction == EXEC_REVERSE)
2155 flag = step == 0 ? BTHR_RCONT : BTHR_RSTEP;
2160 flag = step == 0 ? BTHR_CONT : BTHR_STEP;
2164 /* We just indicate the resume intent here. The actual stepping happens in
2165 record_btrace_wait below.
2167 For all-stop targets, we only step INFERIOR_PTID and continue others. */
2168 if (!target_is_non_stop_p ())
2170 gdb_assert (inferior_ptid.matches (ptid));
2172 for (thread_info *tp : all_non_exited_threads (ptid))
2174 if (tp->ptid.matches (inferior_ptid))
2175 record_btrace_resume_thread (tp, flag);
2177 record_btrace_resume_thread (tp, cflag);
2182 for (thread_info *tp : all_non_exited_threads (ptid))
2183 record_btrace_resume_thread (tp, flag);
2186 /* Async support. */
2187 if (target_can_async_p ())
2190 mark_async_event_handler (record_btrace_async_inferior_event_handler);
2194 /* The commit_resume method of target record-btrace. */
2197 record_btrace_target::commit_resume ()
2199 if ((::execution_direction != EXEC_REVERSE)
2200 && !record_is_replaying (minus_one_ptid))
2201 beneath ()->commit_resume ();
2204 /* Cancel resuming TP. */
2207 record_btrace_cancel_resume (struct thread_info *tp)
2209 enum btrace_thread_flag flags;
2211 flags = tp->btrace.flags & (BTHR_MOVE | BTHR_STOP);
2215 DEBUG ("cancel resume thread %s (%s): %x (%s)",
2216 print_thread_id (tp),
2217 target_pid_to_str (tp->ptid), flags,
2218 btrace_thread_flag_to_str (flags));
2220 tp->btrace.flags &= ~(BTHR_MOVE | BTHR_STOP);
2221 record_btrace_stop_replaying_at_end (tp);
2224 /* Return a target_waitstatus indicating that we ran out of history. */
2226 static struct target_waitstatus
2227 btrace_step_no_history (void)
2229 struct target_waitstatus status;
2231 status.kind = TARGET_WAITKIND_NO_HISTORY;
2236 /* Return a target_waitstatus indicating that a step finished. */
2238 static struct target_waitstatus
2239 btrace_step_stopped (void)
2241 struct target_waitstatus status;
2243 status.kind = TARGET_WAITKIND_STOPPED;
2244 status.value.sig = GDB_SIGNAL_TRAP;
2249 /* Return a target_waitstatus indicating that a thread was stopped as
2252 static struct target_waitstatus
2253 btrace_step_stopped_on_request (void)
2255 struct target_waitstatus status;
2257 status.kind = TARGET_WAITKIND_STOPPED;
2258 status.value.sig = GDB_SIGNAL_0;
2263 /* Return a target_waitstatus indicating a spurious stop. */
2265 static struct target_waitstatus
2266 btrace_step_spurious (void)
2268 struct target_waitstatus status;
2270 status.kind = TARGET_WAITKIND_SPURIOUS;
2275 /* Return a target_waitstatus indicating that the thread was not resumed. */
2277 static struct target_waitstatus
2278 btrace_step_no_resumed (void)
2280 struct target_waitstatus status;
2282 status.kind = TARGET_WAITKIND_NO_RESUMED;
2287 /* Return a target_waitstatus indicating that we should wait again. */
2289 static struct target_waitstatus
2290 btrace_step_again (void)
2292 struct target_waitstatus status;
2294 status.kind = TARGET_WAITKIND_IGNORE;
2299 /* Clear the record histories. */
2302 record_btrace_clear_histories (struct btrace_thread_info *btinfo)
2304 xfree (btinfo->insn_history);
2305 xfree (btinfo->call_history);
2307 btinfo->insn_history = NULL;
2308 btinfo->call_history = NULL;
2311 /* Check whether TP's current replay position is at a breakpoint. */
2314 record_btrace_replay_at_breakpoint (struct thread_info *tp)
2316 struct btrace_insn_iterator *replay;
2317 struct btrace_thread_info *btinfo;
2318 const struct btrace_insn *insn;
2320 btinfo = &tp->btrace;
2321 replay = btinfo->replay;
2326 insn = btrace_insn_get (replay);
2330 return record_check_stopped_by_breakpoint (tp->inf->aspace, insn->pc,
2331 &btinfo->stop_reason);
2334 /* Step one instruction in forward direction. */
2336 static struct target_waitstatus
2337 record_btrace_single_step_forward (struct thread_info *tp)
2339 struct btrace_insn_iterator *replay, end, start;
2340 struct btrace_thread_info *btinfo;
2342 btinfo = &tp->btrace;
2343 replay = btinfo->replay;
2345 /* We're done if we're not replaying. */
2347 return btrace_step_no_history ();
2349 /* Check if we're stepping a breakpoint. */
2350 if (record_btrace_replay_at_breakpoint (tp))
2351 return btrace_step_stopped ();
2353 /* Skip gaps during replay. If we end up at a gap (at the end of the trace),
2354 jump back to the instruction at which we started. */
2360 /* We will bail out here if we continue stepping after reaching the end
2361 of the execution history. */
2362 steps = btrace_insn_next (replay, 1);
2366 return btrace_step_no_history ();
2369 while (btrace_insn_get (replay) == NULL);
2371 /* Determine the end of the instruction trace. */
2372 btrace_insn_end (&end, btinfo);
2374 /* The execution trace contains (and ends with) the current instruction.
2375 This instruction has not been executed, yet, so the trace really ends
2376 one instruction earlier. */
2377 if (btrace_insn_cmp (replay, &end) == 0)
2378 return btrace_step_no_history ();
2380 return btrace_step_spurious ();
2383 /* Step one instruction in backward direction. */
2385 static struct target_waitstatus
2386 record_btrace_single_step_backward (struct thread_info *tp)
2388 struct btrace_insn_iterator *replay, start;
2389 struct btrace_thread_info *btinfo;
2391 btinfo = &tp->btrace;
2392 replay = btinfo->replay;
2394 /* Start replaying if we're not already doing so. */
2396 replay = record_btrace_start_replaying (tp);
2398 /* If we can't step any further, we reached the end of the history.
2399 Skip gaps during replay. If we end up at a gap (at the beginning of
2400 the trace), jump back to the instruction at which we started. */
2406 steps = btrace_insn_prev (replay, 1);
2410 return btrace_step_no_history ();
2413 while (btrace_insn_get (replay) == NULL);
2415 /* Check if we're stepping a breakpoint.
2417 For reverse-stepping, this check is after the step. There is logic in
2418 infrun.c that handles reverse-stepping separately. See, for example,
2419 proceed and adjust_pc_after_break.
2421 This code assumes that for reverse-stepping, PC points to the last
2422 de-executed instruction, whereas for forward-stepping PC points to the
2423 next to-be-executed instruction. */
2424 if (record_btrace_replay_at_breakpoint (tp))
2425 return btrace_step_stopped ();
2427 return btrace_step_spurious ();
2430 /* Step a single thread. */
2432 static struct target_waitstatus
2433 record_btrace_step_thread (struct thread_info *tp)
2435 struct btrace_thread_info *btinfo;
2436 struct target_waitstatus status;
2437 enum btrace_thread_flag flags;
2439 btinfo = &tp->btrace;
2441 flags = btinfo->flags & (BTHR_MOVE | BTHR_STOP);
2442 btinfo->flags &= ~(BTHR_MOVE | BTHR_STOP);
2444 DEBUG ("stepping thread %s (%s): %x (%s)", print_thread_id (tp),
2445 target_pid_to_str (tp->ptid), flags,
2446 btrace_thread_flag_to_str (flags));
2448 /* We can't step without an execution history. */
2449 if ((flags & BTHR_MOVE) != 0 && btrace_is_empty (tp))
2450 return btrace_step_no_history ();
2455 internal_error (__FILE__, __LINE__, _("invalid stepping type."));
2458 return btrace_step_stopped_on_request ();
2461 status = record_btrace_single_step_forward (tp);
2462 if (status.kind != TARGET_WAITKIND_SPURIOUS)
2465 return btrace_step_stopped ();
2468 status = record_btrace_single_step_backward (tp);
2469 if (status.kind != TARGET_WAITKIND_SPURIOUS)
2472 return btrace_step_stopped ();
2475 status = record_btrace_single_step_forward (tp);
2476 if (status.kind != TARGET_WAITKIND_SPURIOUS)
2479 btinfo->flags |= flags;
2480 return btrace_step_again ();
2483 status = record_btrace_single_step_backward (tp);
2484 if (status.kind != TARGET_WAITKIND_SPURIOUS)
2487 btinfo->flags |= flags;
2488 return btrace_step_again ();
2491 /* We keep threads moving at the end of their execution history. The wait
2492 method will stop the thread for whom the event is reported. */
2493 if (status.kind == TARGET_WAITKIND_NO_HISTORY)
2494 btinfo->flags |= flags;
2499 /* Announce further events if necessary. */
2502 record_btrace_maybe_mark_async_event
2503 (const std::vector<thread_info *> &moving,
2504 const std::vector<thread_info *> &no_history)
2506 bool more_moving = !moving.empty ();
2507 bool more_no_history = !no_history.empty ();;
2509 if (!more_moving && !more_no_history)
2513 DEBUG ("movers pending");
2515 if (more_no_history)
2516 DEBUG ("no-history pending");
2518 mark_async_event_handler (record_btrace_async_inferior_event_handler);
2521 /* The wait method of target record-btrace. */
2524 record_btrace_target::wait (ptid_t ptid, struct target_waitstatus *status,
2527 std::vector<thread_info *> moving;
2528 std::vector<thread_info *> no_history;
2530 DEBUG ("wait %s (0x%x)", target_pid_to_str (ptid), options);
2532 /* As long as we're not replaying, just forward the request. */
2533 if ((::execution_direction != EXEC_REVERSE)
2534 && !record_is_replaying (minus_one_ptid))
2536 return this->beneath ()->wait (ptid, status, options);
2539 /* Keep a work list of moving threads. */
2540 for (thread_info *tp : all_non_exited_threads (ptid))
2541 if ((tp->btrace.flags & (BTHR_MOVE | BTHR_STOP)) != 0)
2542 moving.push_back (tp);
2544 if (moving.empty ())
2546 *status = btrace_step_no_resumed ();
2548 DEBUG ("wait ended by %s: %s", target_pid_to_str (null_ptid),
2549 target_waitstatus_to_string (status).c_str ());
2554 /* Step moving threads one by one, one step each, until either one thread
2555 reports an event or we run out of threads to step.
2557 When stepping more than one thread, chances are that some threads reach
2558 the end of their execution history earlier than others. If we reported
2559 this immediately, all-stop on top of non-stop would stop all threads and
2560 resume the same threads next time. And we would report the same thread
2561 having reached the end of its execution history again.
2563 In the worst case, this would starve the other threads. But even if other
2564 threads would be allowed to make progress, this would result in far too
2565 many intermediate stops.
2567 We therefore delay the reporting of "no execution history" until we have
2568 nothing else to report. By this time, all threads should have moved to
2569 either the beginning or the end of their execution history. There will
2570 be a single user-visible stop. */
2571 struct thread_info *eventing = NULL;
2572 while ((eventing == NULL) && !moving.empty ())
2574 for (unsigned int ix = 0; eventing == NULL && ix < moving.size ();)
2576 thread_info *tp = moving[ix];
2578 *status = record_btrace_step_thread (tp);
2580 switch (status->kind)
2582 case TARGET_WAITKIND_IGNORE:
2586 case TARGET_WAITKIND_NO_HISTORY:
2587 no_history.push_back (ordered_remove (moving, ix));
2591 eventing = unordered_remove (moving, ix);
2597 if (eventing == NULL)
2599 /* We started with at least one moving thread. This thread must have
2600 either stopped or reached the end of its execution history.
2602 In the former case, EVENTING must not be NULL.
2603 In the latter case, NO_HISTORY must not be empty. */
2604 gdb_assert (!no_history.empty ());
2606 /* We kept threads moving at the end of their execution history. Stop
2607 EVENTING now that we are going to report its stop. */
2608 eventing = unordered_remove (no_history, 0);
2609 eventing->btrace.flags &= ~BTHR_MOVE;
2611 *status = btrace_step_no_history ();
2614 gdb_assert (eventing != NULL);
2616 /* We kept threads replaying at the end of their execution history. Stop
2617 replaying EVENTING now that we are going to report its stop. */
2618 record_btrace_stop_replaying_at_end (eventing);
2620 /* Stop all other threads. */
2621 if (!target_is_non_stop_p ())
2623 for (thread_info *tp : all_non_exited_threads ())
2624 record_btrace_cancel_resume (tp);
2627 /* In async mode, we need to announce further events. */
2628 if (target_is_async_p ())
2629 record_btrace_maybe_mark_async_event (moving, no_history);
2631 /* Start record histories anew from the current position. */
2632 record_btrace_clear_histories (&eventing->btrace);
2634 /* We moved the replay position but did not update registers. */
2635 registers_changed_thread (eventing);
2637 DEBUG ("wait ended by thread %s (%s): %s",
2638 print_thread_id (eventing),
2639 target_pid_to_str (eventing->ptid),
2640 target_waitstatus_to_string (status).c_str ());
2642 return eventing->ptid;
2645 /* The stop method of target record-btrace. */
2648 record_btrace_target::stop (ptid_t ptid)
2650 DEBUG ("stop %s", target_pid_to_str (ptid));
2652 /* As long as we're not replaying, just forward the request. */
2653 if ((::execution_direction != EXEC_REVERSE)
2654 && !record_is_replaying (minus_one_ptid))
2656 this->beneath ()->stop (ptid);
2660 for (thread_info *tp : all_non_exited_threads (ptid))
2662 tp->btrace.flags &= ~BTHR_MOVE;
2663 tp->btrace.flags |= BTHR_STOP;
2668 /* The can_execute_reverse method of target record-btrace. */
2671 record_btrace_target::can_execute_reverse ()
2676 /* The stopped_by_sw_breakpoint method of target record-btrace. */
2679 record_btrace_target::stopped_by_sw_breakpoint ()
2681 if (record_is_replaying (minus_one_ptid))
2683 struct thread_info *tp = inferior_thread ();
2685 return tp->btrace.stop_reason == TARGET_STOPPED_BY_SW_BREAKPOINT;
2688 return this->beneath ()->stopped_by_sw_breakpoint ();
2691 /* The supports_stopped_by_sw_breakpoint method of target
2695 record_btrace_target::supports_stopped_by_sw_breakpoint ()
2697 if (record_is_replaying (minus_one_ptid))
2700 return this->beneath ()->supports_stopped_by_sw_breakpoint ();
2703 /* The stopped_by_sw_breakpoint method of target record-btrace. */
2706 record_btrace_target::stopped_by_hw_breakpoint ()
2708 if (record_is_replaying (minus_one_ptid))
2710 struct thread_info *tp = inferior_thread ();
2712 return tp->btrace.stop_reason == TARGET_STOPPED_BY_HW_BREAKPOINT;
2715 return this->beneath ()->stopped_by_hw_breakpoint ();
2718 /* The supports_stopped_by_hw_breakpoint method of target
2722 record_btrace_target::supports_stopped_by_hw_breakpoint ()
2724 if (record_is_replaying (minus_one_ptid))
2727 return this->beneath ()->supports_stopped_by_hw_breakpoint ();
2730 /* The update_thread_list method of target record-btrace. */
2733 record_btrace_target::update_thread_list ()
2735 /* We don't add or remove threads during replay. */
2736 if (record_is_replaying (minus_one_ptid))
2739 /* Forward the request. */
2740 this->beneath ()->update_thread_list ();
2743 /* The thread_alive method of target record-btrace. */
2746 record_btrace_target::thread_alive (ptid_t ptid)
2748 /* We don't add or remove threads during replay. */
2749 if (record_is_replaying (minus_one_ptid))
2752 /* Forward the request. */
2753 return this->beneath ()->thread_alive (ptid);
2756 /* Set the replay branch trace instruction iterator. If IT is NULL, replay
2760 record_btrace_set_replay (struct thread_info *tp,
2761 const struct btrace_insn_iterator *it)
2763 struct btrace_thread_info *btinfo;
2765 btinfo = &tp->btrace;
2768 record_btrace_stop_replaying (tp);
2771 if (btinfo->replay == NULL)
2772 record_btrace_start_replaying (tp);
2773 else if (btrace_insn_cmp (btinfo->replay, it) == 0)
2776 *btinfo->replay = *it;
2777 registers_changed_thread (tp);
2780 /* Start anew from the new replay position. */
2781 record_btrace_clear_histories (btinfo);
2783 inferior_thread ()->suspend.stop_pc
2784 = regcache_read_pc (get_current_regcache ());
2785 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC, 1);
2788 /* The goto_record_begin method of target record-btrace. */
2791 record_btrace_target::goto_record_begin ()
2793 struct thread_info *tp;
2794 struct btrace_insn_iterator begin;
2796 tp = require_btrace_thread ();
2798 btrace_insn_begin (&begin, &tp->btrace);
2800 /* Skip gaps at the beginning of the trace. */
2801 while (btrace_insn_get (&begin) == NULL)
2805 steps = btrace_insn_next (&begin, 1);
2807 error (_("No trace."));
2810 record_btrace_set_replay (tp, &begin);
2813 /* The goto_record_end method of target record-btrace. */
2816 record_btrace_target::goto_record_end ()
2818 struct thread_info *tp;
2820 tp = require_btrace_thread ();
2822 record_btrace_set_replay (tp, NULL);
2825 /* The goto_record method of target record-btrace. */
2828 record_btrace_target::goto_record (ULONGEST insn)
2830 struct thread_info *tp;
2831 struct btrace_insn_iterator it;
2832 unsigned int number;
2837 /* Check for wrap-arounds. */
2839 error (_("Instruction number out of range."));
2841 tp = require_btrace_thread ();
2843 found = btrace_find_insn_by_number (&it, &tp->btrace, number);
2845 /* Check if the instruction could not be found or is a gap. */
2846 if (found == 0 || btrace_insn_get (&it) == NULL)
2847 error (_("No such instruction."));
2849 record_btrace_set_replay (tp, &it);
2852 /* The record_stop_replaying method of target record-btrace. */
2855 record_btrace_target::record_stop_replaying ()
2857 for (thread_info *tp : all_non_exited_threads ())
2858 record_btrace_stop_replaying (tp);
2861 /* The execution_direction target method. */
2863 enum exec_direction_kind
2864 record_btrace_target::execution_direction ()
2866 return record_btrace_resume_exec_dir;
2869 /* The prepare_to_generate_core target method. */
2872 record_btrace_target::prepare_to_generate_core ()
2874 record_btrace_generating_corefile = 1;
2877 /* The done_generating_core target method. */
2880 record_btrace_target::done_generating_core ()
2882 record_btrace_generating_corefile = 0;
2885 /* Start recording in BTS format. */
2888 cmd_record_btrace_bts_start (const char *args, int from_tty)
2890 if (args != NULL && *args != 0)
2891 error (_("Invalid argument."));
2893 record_btrace_conf.format = BTRACE_FORMAT_BTS;
2897 execute_command ("target record-btrace", from_tty);
2899 CATCH (exception, RETURN_MASK_ALL)
2901 record_btrace_conf.format = BTRACE_FORMAT_NONE;
2902 throw_exception (exception);
2907 /* Start recording in Intel Processor Trace format. */
2910 cmd_record_btrace_pt_start (const char *args, int from_tty)
2912 if (args != NULL && *args != 0)
2913 error (_("Invalid argument."));
2915 record_btrace_conf.format = BTRACE_FORMAT_PT;
2919 execute_command ("target record-btrace", from_tty);
2921 CATCH (exception, RETURN_MASK_ALL)
2923 record_btrace_conf.format = BTRACE_FORMAT_NONE;
2924 throw_exception (exception);
2929 /* Alias for "target record". */
2932 cmd_record_btrace_start (const char *args, int from_tty)
2934 if (args != NULL && *args != 0)
2935 error (_("Invalid argument."));
2937 record_btrace_conf.format = BTRACE_FORMAT_PT;
2941 execute_command ("target record-btrace", from_tty);
2943 CATCH (exception, RETURN_MASK_ALL)
2945 record_btrace_conf.format = BTRACE_FORMAT_BTS;
2949 execute_command ("target record-btrace", from_tty);
2951 CATCH (ex, RETURN_MASK_ALL)
2953 record_btrace_conf.format = BTRACE_FORMAT_NONE;
2954 throw_exception (ex);
2961 /* The "set record btrace" command. */
2964 cmd_set_record_btrace (const char *args, int from_tty)
2966 printf_unfiltered (_("\"set record btrace\" must be followed "
2967 "by an appropriate subcommand.\n"));
2968 help_list (set_record_btrace_cmdlist, "set record btrace ",
2969 all_commands, gdb_stdout);
2972 /* The "show record btrace" command. */
2975 cmd_show_record_btrace (const char *args, int from_tty)
2977 cmd_show_list (show_record_btrace_cmdlist, from_tty, "");
2980 /* The "show record btrace replay-memory-access" command. */
2983 cmd_show_replay_memory_access (struct ui_file *file, int from_tty,
2984 struct cmd_list_element *c, const char *value)
2986 fprintf_filtered (gdb_stdout, _("Replay memory access is %s.\n"),
2987 replay_memory_access);
2990 /* The "set record btrace cpu none" command. */
2993 cmd_set_record_btrace_cpu_none (const char *args, int from_tty)
2995 if (args != nullptr && *args != 0)
2996 error (_("Trailing junk: '%s'."), args);
2998 record_btrace_cpu_state = CS_NONE;
3001 /* The "set record btrace cpu auto" command. */
3004 cmd_set_record_btrace_cpu_auto (const char *args, int from_tty)
3006 if (args != nullptr && *args != 0)
3007 error (_("Trailing junk: '%s'."), args);
3009 record_btrace_cpu_state = CS_AUTO;
3012 /* The "set record btrace cpu" command. */
3015 cmd_set_record_btrace_cpu (const char *args, int from_tty)
3017 if (args == nullptr)
3020 /* We use a hard-coded vendor string for now. */
3021 unsigned int family, model, stepping;
3022 int l1, l2, matches = sscanf (args, "intel: %u/%u%n/%u%n", &family,
3023 &model, &l1, &stepping, &l2);
3026 if (strlen (args) != l2)
3027 error (_("Trailing junk: '%s'."), args + l2);
3029 else if (matches == 2)
3031 if (strlen (args) != l1)
3032 error (_("Trailing junk: '%s'."), args + l1);
3037 error (_("Bad format. See \"help set record btrace cpu\"."));
3039 if (USHRT_MAX < family)
3040 error (_("Cpu family too big."));
3042 if (UCHAR_MAX < model)
3043 error (_("Cpu model too big."));
3045 if (UCHAR_MAX < stepping)
3046 error (_("Cpu stepping too big."));
3048 record_btrace_cpu.vendor = CV_INTEL;
3049 record_btrace_cpu.family = family;
3050 record_btrace_cpu.model = model;
3051 record_btrace_cpu.stepping = stepping;
3053 record_btrace_cpu_state = CS_CPU;
3056 /* The "show record btrace cpu" command. */
3059 cmd_show_record_btrace_cpu (const char *args, int from_tty)
3061 if (args != nullptr && *args != 0)
3062 error (_("Trailing junk: '%s'."), args);
3064 switch (record_btrace_cpu_state)
3067 printf_unfiltered (_("btrace cpu is 'auto'.\n"));
3071 printf_unfiltered (_("btrace cpu is 'none'.\n"));
3075 switch (record_btrace_cpu.vendor)
3078 if (record_btrace_cpu.stepping == 0)
3079 printf_unfiltered (_("btrace cpu is 'intel: %u/%u'.\n"),
3080 record_btrace_cpu.family,
3081 record_btrace_cpu.model);
3083 printf_unfiltered (_("btrace cpu is 'intel: %u/%u/%u'.\n"),
3084 record_btrace_cpu.family,
3085 record_btrace_cpu.model,
3086 record_btrace_cpu.stepping);
3091 error (_("Internal error: bad cpu state."));
3094 /* The "s record btrace bts" command. */
3097 cmd_set_record_btrace_bts (const char *args, int from_tty)
3099 printf_unfiltered (_("\"set record btrace bts\" must be followed "
3100 "by an appropriate subcommand.\n"));
3101 help_list (set_record_btrace_bts_cmdlist, "set record btrace bts ",
3102 all_commands, gdb_stdout);
3105 /* The "show record btrace bts" command. */
3108 cmd_show_record_btrace_bts (const char *args, int from_tty)
3110 cmd_show_list (show_record_btrace_bts_cmdlist, from_tty, "");
3113 /* The "set record btrace pt" command. */
3116 cmd_set_record_btrace_pt (const char *args, int from_tty)
3118 printf_unfiltered (_("\"set record btrace pt\" must be followed "
3119 "by an appropriate subcommand.\n"));
3120 help_list (set_record_btrace_pt_cmdlist, "set record btrace pt ",
3121 all_commands, gdb_stdout);
3124 /* The "show record btrace pt" command. */
3127 cmd_show_record_btrace_pt (const char *args, int from_tty)
3129 cmd_show_list (show_record_btrace_pt_cmdlist, from_tty, "");
3132 /* The "record bts buffer-size" show value function. */
3135 show_record_bts_buffer_size_value (struct ui_file *file, int from_tty,
3136 struct cmd_list_element *c,
3139 fprintf_filtered (file, _("The record/replay bts buffer size is %s.\n"),
3143 /* The "record pt buffer-size" show value function. */
3146 show_record_pt_buffer_size_value (struct ui_file *file, int from_tty,
3147 struct cmd_list_element *c,
3150 fprintf_filtered (file, _("The record/replay pt buffer size is %s.\n"),
3154 /* Initialize btrace commands. */
3157 _initialize_record_btrace (void)
3159 add_prefix_cmd ("btrace", class_obscure, cmd_record_btrace_start,
3160 _("Start branch trace recording."), &record_btrace_cmdlist,
3161 "record btrace ", 0, &record_cmdlist);
3162 add_alias_cmd ("b", "btrace", class_obscure, 1, &record_cmdlist);
3164 add_cmd ("bts", class_obscure, cmd_record_btrace_bts_start,
3166 Start branch trace recording in Branch Trace Store (BTS) format.\n\n\
3167 The processor stores a from/to record for each branch into a cyclic buffer.\n\
3168 This format may not be available on all processors."),
3169 &record_btrace_cmdlist);
3170 add_alias_cmd ("bts", "btrace bts", class_obscure, 1, &record_cmdlist);
3172 add_cmd ("pt", class_obscure, cmd_record_btrace_pt_start,
3174 Start branch trace recording in Intel Processor Trace format.\n\n\
3175 This format may not be available on all processors."),
3176 &record_btrace_cmdlist);
3177 add_alias_cmd ("pt", "btrace pt", class_obscure, 1, &record_cmdlist);
3179 add_prefix_cmd ("btrace", class_support, cmd_set_record_btrace,
3180 _("Set record options"), &set_record_btrace_cmdlist,
3181 "set record btrace ", 0, &set_record_cmdlist);
3183 add_prefix_cmd ("btrace", class_support, cmd_show_record_btrace,
3184 _("Show record options"), &show_record_btrace_cmdlist,
3185 "show record btrace ", 0, &show_record_cmdlist);
3187 add_setshow_enum_cmd ("replay-memory-access", no_class,
3188 replay_memory_access_types, &replay_memory_access, _("\
3189 Set what memory accesses are allowed during replay."), _("\
3190 Show what memory accesses are allowed during replay."),
3191 _("Default is READ-ONLY.\n\n\
3192 The btrace record target does not trace data.\n\
3193 The memory therefore corresponds to the live target and not \
3194 to the current replay position.\n\n\
3195 When READ-ONLY, allow accesses to read-only memory during replay.\n\
3196 When READ-WRITE, allow accesses to read-only and read-write memory during \
3198 NULL, cmd_show_replay_memory_access,
3199 &set_record_btrace_cmdlist,
3200 &show_record_btrace_cmdlist);
3202 add_prefix_cmd ("cpu", class_support, cmd_set_record_btrace_cpu,
3204 Set the cpu to be used for trace decode.\n\n\
3205 The format is \"VENDOR:IDENTIFIER\" or \"none\" or \"auto\" (default).\n\
3206 For vendor \"intel\" the format is \"FAMILY/MODEL[/STEPPING]\".\n\n\
3207 When decoding branch trace, enable errata workarounds for the specified cpu.\n\
3208 The default is \"auto\", which uses the cpu on which the trace was recorded.\n\
3209 When GDB does not support that cpu, this option can be used to enable\n\
3210 workarounds for a similar cpu that GDB supports.\n\n\
3211 When set to \"none\", errata workarounds are disabled."),
3212 &set_record_btrace_cpu_cmdlist,
3213 _("set record btrace cpu "), 1,
3214 &set_record_btrace_cmdlist);
3216 add_cmd ("auto", class_support, cmd_set_record_btrace_cpu_auto, _("\
3217 Automatically determine the cpu to be used for trace decode."),
3218 &set_record_btrace_cpu_cmdlist);
3220 add_cmd ("none", class_support, cmd_set_record_btrace_cpu_none, _("\
3221 Do not enable errata workarounds for trace decode."),
3222 &set_record_btrace_cpu_cmdlist);
3224 add_cmd ("cpu", class_support, cmd_show_record_btrace_cpu, _("\
3225 Show the cpu to be used for trace decode."),
3226 &show_record_btrace_cmdlist);
3228 add_prefix_cmd ("bts", class_support, cmd_set_record_btrace_bts,
3229 _("Set record btrace bts options"),
3230 &set_record_btrace_bts_cmdlist,
3231 "set record btrace bts ", 0, &set_record_btrace_cmdlist);
3233 add_prefix_cmd ("bts", class_support, cmd_show_record_btrace_bts,
3234 _("Show record btrace bts options"),
3235 &show_record_btrace_bts_cmdlist,
3236 "show record btrace bts ", 0, &show_record_btrace_cmdlist);
3238 add_setshow_uinteger_cmd ("buffer-size", no_class,
3239 &record_btrace_conf.bts.size,
3240 _("Set the record/replay bts buffer size."),
3241 _("Show the record/replay bts buffer size."), _("\
3242 When starting recording request a trace buffer of this size. \
3243 The actual buffer size may differ from the requested size. \
3244 Use \"info record\" to see the actual buffer size.\n\n\
3245 Bigger buffers allow longer recording but also take more time to process \
3246 the recorded execution trace.\n\n\
3247 The trace buffer size may not be changed while recording."), NULL,
3248 show_record_bts_buffer_size_value,
3249 &set_record_btrace_bts_cmdlist,
3250 &show_record_btrace_bts_cmdlist);
3252 add_prefix_cmd ("pt", class_support, cmd_set_record_btrace_pt,
3253 _("Set record btrace pt options"),
3254 &set_record_btrace_pt_cmdlist,
3255 "set record btrace pt ", 0, &set_record_btrace_cmdlist);
3257 add_prefix_cmd ("pt", class_support, cmd_show_record_btrace_pt,
3258 _("Show record btrace pt options"),
3259 &show_record_btrace_pt_cmdlist,
3260 "show record btrace pt ", 0, &show_record_btrace_cmdlist);
3262 add_setshow_uinteger_cmd ("buffer-size", no_class,
3263 &record_btrace_conf.pt.size,
3264 _("Set the record/replay pt buffer size."),
3265 _("Show the record/replay pt buffer size."), _("\
3266 Bigger buffers allow longer recording but also take more time to process \
3267 the recorded execution.\n\
3268 The actual buffer size may differ from the requested size. Use \"info record\" \
3269 to see the actual buffer size."), NULL, show_record_pt_buffer_size_value,
3270 &set_record_btrace_pt_cmdlist,
3271 &show_record_btrace_pt_cmdlist);
3273 add_target (record_btrace_target_info, record_btrace_target_open);
3275 bfcache = htab_create_alloc (50, bfcache_hash, bfcache_eq, NULL,
3278 record_btrace_conf.bts.size = 64 * 1024;
3279 record_btrace_conf.pt.size = 16 * 1024;