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 record_btrace_target ()
57 { to_stratum = record_stratum; }
59 const target_info &info () const override
60 { return record_btrace_target_info; }
62 void close () override;
63 void async (int) override;
65 void detach (inferior *inf, int from_tty) override
66 { record_detach (this, inf, from_tty); }
68 void disconnect (const char *, int) override;
70 void mourn_inferior () override
71 { record_mourn_inferior (this); }
74 { record_kill (this); }
76 enum record_method record_method (ptid_t ptid) override;
78 void stop_recording () override;
79 void info_record () override;
81 void insn_history (int size, gdb_disassembly_flags flags) override;
82 void insn_history_from (ULONGEST from, int size,
83 gdb_disassembly_flags flags) override;
84 void insn_history_range (ULONGEST begin, ULONGEST end,
85 gdb_disassembly_flags flags) override;
86 void call_history (int size, record_print_flags flags) override;
87 void call_history_from (ULONGEST begin, int size, record_print_flags flags)
89 void call_history_range (ULONGEST begin, ULONGEST end, record_print_flags flags)
92 bool record_is_replaying (ptid_t ptid) override;
93 bool record_will_replay (ptid_t ptid, int dir) override;
94 void record_stop_replaying () override;
96 enum target_xfer_status xfer_partial (enum target_object object,
99 const gdb_byte *writebuf,
100 ULONGEST offset, ULONGEST len,
101 ULONGEST *xfered_len) override;
103 int insert_breakpoint (struct gdbarch *,
104 struct bp_target_info *) override;
105 int remove_breakpoint (struct gdbarch *, struct bp_target_info *,
106 enum remove_bp_reason) override;
108 void fetch_registers (struct regcache *, int) override;
110 void store_registers (struct regcache *, int) override;
111 void prepare_to_store (struct regcache *) override;
113 const struct frame_unwind *get_unwinder () override;
115 const struct frame_unwind *get_tailcall_unwinder () override;
117 void commit_resume () override;
118 void resume (ptid_t, int, enum gdb_signal) override;
119 ptid_t wait (ptid_t, struct target_waitstatus *, int) override;
121 void stop (ptid_t) override;
122 void update_thread_list () override;
123 bool thread_alive (ptid_t ptid) override;
124 void goto_record_begin () override;
125 void goto_record_end () override;
126 void goto_record (ULONGEST insn) override;
128 bool can_execute_reverse () override;
130 bool stopped_by_sw_breakpoint () override;
131 bool supports_stopped_by_sw_breakpoint () override;
133 bool stopped_by_hw_breakpoint () override;
134 bool supports_stopped_by_hw_breakpoint () override;
136 enum exec_direction_kind execution_direction () override;
137 void prepare_to_generate_core () override;
138 void done_generating_core () override;
141 static record_btrace_target record_btrace_ops;
143 /* Initialize the record-btrace target ops. */
145 /* Token associated with a new-thread observer enabling branch tracing
146 for the new thread. */
147 static const gdb::observers::token record_btrace_thread_observer_token;
149 /* Memory access types used in set/show record btrace replay-memory-access. */
150 static const char replay_memory_access_read_only[] = "read-only";
151 static const char replay_memory_access_read_write[] = "read-write";
152 static const char *const replay_memory_access_types[] =
154 replay_memory_access_read_only,
155 replay_memory_access_read_write,
159 /* The currently allowed replay memory access type. */
160 static const char *replay_memory_access = replay_memory_access_read_only;
162 /* The cpu state kinds. */
163 enum record_btrace_cpu_state_kind
170 /* The current cpu state. */
171 static enum record_btrace_cpu_state_kind record_btrace_cpu_state = CS_AUTO;
173 /* The current cpu for trace decode. */
174 static struct btrace_cpu record_btrace_cpu;
176 /* Command lists for "set/show record btrace". */
177 static struct cmd_list_element *set_record_btrace_cmdlist;
178 static struct cmd_list_element *show_record_btrace_cmdlist;
180 /* The execution direction of the last resume we got. See record-full.c. */
181 static enum exec_direction_kind record_btrace_resume_exec_dir = EXEC_FORWARD;
183 /* The async event handler for reverse/replay execution. */
184 static struct async_event_handler *record_btrace_async_inferior_event_handler;
186 /* A flag indicating that we are currently generating a core file. */
187 static int record_btrace_generating_corefile;
189 /* The current branch trace configuration. */
190 static struct btrace_config record_btrace_conf;
192 /* Command list for "record btrace". */
193 static struct cmd_list_element *record_btrace_cmdlist;
195 /* Command lists for "set/show record btrace bts". */
196 static struct cmd_list_element *set_record_btrace_bts_cmdlist;
197 static struct cmd_list_element *show_record_btrace_bts_cmdlist;
199 /* Command lists for "set/show record btrace pt". */
200 static struct cmd_list_element *set_record_btrace_pt_cmdlist;
201 static struct cmd_list_element *show_record_btrace_pt_cmdlist;
203 /* Command list for "set record btrace cpu". */
204 static struct cmd_list_element *set_record_btrace_cpu_cmdlist;
206 /* Print a record-btrace debug message. Use do ... while (0) to avoid
207 ambiguities when used in if statements. */
209 #define DEBUG(msg, args...) \
212 if (record_debug != 0) \
213 fprintf_unfiltered (gdb_stdlog, \
214 "[record-btrace] " msg "\n", ##args); \
219 /* Return the cpu configured by the user. Returns NULL if the cpu was
220 configured as auto. */
221 const struct btrace_cpu *
222 record_btrace_get_cpu (void)
224 switch (record_btrace_cpu_state)
230 record_btrace_cpu.vendor = CV_UNKNOWN;
233 return &record_btrace_cpu;
236 error (_("Internal error: bad record btrace cpu state."));
239 /* Update the branch trace for the current thread and return a pointer to its
242 Throws an error if there is no thread or no trace. This function never
245 static struct thread_info *
246 require_btrace_thread (void)
250 if (inferior_ptid == null_ptid)
251 error (_("No thread."));
253 thread_info *tp = inferior_thread ();
255 validate_registers_access ();
257 btrace_fetch (tp, record_btrace_get_cpu ());
259 if (btrace_is_empty (tp))
260 error (_("No trace."));
265 /* Update the branch trace for the current thread and return a pointer to its
266 branch trace information struct.
268 Throws an error if there is no thread or no trace. This function never
271 static struct btrace_thread_info *
272 require_btrace (void)
274 struct thread_info *tp;
276 tp = require_btrace_thread ();
281 /* Enable branch tracing for one thread. Warn on errors. */
284 record_btrace_enable_warn (struct thread_info *tp)
288 btrace_enable (tp, &record_btrace_conf);
290 CATCH (error, RETURN_MASK_ERROR)
292 warning ("%s", error.message);
297 /* Enable automatic tracing of new threads. */
300 record_btrace_auto_enable (void)
302 DEBUG ("attach thread observer");
304 gdb::observers::new_thread.attach (record_btrace_enable_warn,
305 record_btrace_thread_observer_token);
308 /* Disable automatic tracing of new threads. */
311 record_btrace_auto_disable (void)
313 DEBUG ("detach thread observer");
315 gdb::observers::new_thread.detach (record_btrace_thread_observer_token);
318 /* The record-btrace async event handler function. */
321 record_btrace_handle_async_inferior_event (gdb_client_data data)
323 inferior_event_handler (INF_REG_EVENT, NULL);
326 /* See record-btrace.h. */
329 record_btrace_push_target (void)
333 record_btrace_auto_enable ();
335 push_target (&record_btrace_ops);
337 record_btrace_async_inferior_event_handler
338 = create_async_event_handler (record_btrace_handle_async_inferior_event,
340 record_btrace_generating_corefile = 0;
342 format = btrace_format_short_string (record_btrace_conf.format);
343 gdb::observers::record_changed.notify (current_inferior (), 1, "btrace", format);
346 /* Disable btrace on a set of threads on scope exit. */
348 struct scoped_btrace_disable
350 scoped_btrace_disable () = default;
352 DISABLE_COPY_AND_ASSIGN (scoped_btrace_disable);
354 ~scoped_btrace_disable ()
356 for (thread_info *tp : m_threads)
360 void add_thread (thread_info *thread)
362 m_threads.push_front (thread);
371 std::forward_list<thread_info *> m_threads;
374 /* Open target record-btrace. */
377 record_btrace_target_open (const char *args, int from_tty)
379 /* If we fail to enable btrace for one thread, disable it for the threads for
380 which it was successfully enabled. */
381 scoped_btrace_disable btrace_disable;
382 struct thread_info *tp;
388 if (!target_has_execution)
389 error (_("The program is not being run."));
391 ALL_NON_EXITED_THREADS (tp)
392 if (args == NULL || *args == 0 || number_is_in_list (args, tp->global_num))
394 btrace_enable (tp, &record_btrace_conf);
396 btrace_disable.add_thread (tp);
399 record_btrace_push_target ();
401 btrace_disable.discard ();
404 /* The stop_recording method of target record-btrace. */
407 record_btrace_target::stop_recording ()
409 struct thread_info *tp;
411 DEBUG ("stop recording");
413 record_btrace_auto_disable ();
415 ALL_NON_EXITED_THREADS (tp)
416 if (tp->btrace.target != NULL)
420 /* The disconnect method of target record-btrace. */
423 record_btrace_target::disconnect (const char *args,
426 struct target_ops *beneath = this->beneath ();
428 /* Do not stop recording, just clean up GDB side. */
429 unpush_target (this);
431 /* Forward disconnect. */
432 beneath->disconnect (args, from_tty);
435 /* The close method of target record-btrace. */
438 record_btrace_target::close ()
440 struct thread_info *tp;
442 if (record_btrace_async_inferior_event_handler != NULL)
443 delete_async_event_handler (&record_btrace_async_inferior_event_handler);
445 /* Make sure automatic recording gets disabled even if we did not stop
446 recording before closing the record-btrace target. */
447 record_btrace_auto_disable ();
449 /* We should have already stopped recording.
450 Tear down btrace in case we have not. */
451 ALL_NON_EXITED_THREADS (tp)
452 btrace_teardown (tp);
455 /* The async method of target record-btrace. */
458 record_btrace_target::async (int enable)
461 mark_async_event_handler (record_btrace_async_inferior_event_handler);
463 clear_async_event_handler (record_btrace_async_inferior_event_handler);
465 this->beneath ()->async (enable);
468 /* Adjusts the size and returns a human readable size suffix. */
471 record_btrace_adjust_size (unsigned int *size)
477 if ((sz & ((1u << 30) - 1)) == 0)
482 else if ((sz & ((1u << 20) - 1)) == 0)
487 else if ((sz & ((1u << 10) - 1)) == 0)
496 /* Print a BTS configuration. */
499 record_btrace_print_bts_conf (const struct btrace_config_bts *conf)
507 suffix = record_btrace_adjust_size (&size);
508 printf_unfiltered (_("Buffer size: %u%s.\n"), size, suffix);
512 /* Print an Intel Processor Trace configuration. */
515 record_btrace_print_pt_conf (const struct btrace_config_pt *conf)
523 suffix = record_btrace_adjust_size (&size);
524 printf_unfiltered (_("Buffer size: %u%s.\n"), size, suffix);
528 /* Print a branch tracing configuration. */
531 record_btrace_print_conf (const struct btrace_config *conf)
533 printf_unfiltered (_("Recording format: %s.\n"),
534 btrace_format_string (conf->format));
536 switch (conf->format)
538 case BTRACE_FORMAT_NONE:
541 case BTRACE_FORMAT_BTS:
542 record_btrace_print_bts_conf (&conf->bts);
545 case BTRACE_FORMAT_PT:
546 record_btrace_print_pt_conf (&conf->pt);
550 internal_error (__FILE__, __LINE__, _("Unkown branch trace format."));
553 /* The info_record method of target record-btrace. */
556 record_btrace_target::info_record ()
558 struct btrace_thread_info *btinfo;
559 const struct btrace_config *conf;
560 struct thread_info *tp;
561 unsigned int insns, calls, gaps;
565 tp = find_thread_ptid (inferior_ptid);
567 error (_("No thread."));
569 validate_registers_access ();
571 btinfo = &tp->btrace;
573 conf = ::btrace_conf (btinfo);
575 record_btrace_print_conf (conf);
577 btrace_fetch (tp, record_btrace_get_cpu ());
583 if (!btrace_is_empty (tp))
585 struct btrace_call_iterator call;
586 struct btrace_insn_iterator insn;
588 btrace_call_end (&call, btinfo);
589 btrace_call_prev (&call, 1);
590 calls = btrace_call_number (&call);
592 btrace_insn_end (&insn, btinfo);
593 insns = btrace_insn_number (&insn);
595 /* If the last instruction is not a gap, it is the current instruction
596 that is not actually part of the record. */
597 if (btrace_insn_get (&insn) != NULL)
600 gaps = btinfo->ngaps;
603 printf_unfiltered (_("Recorded %u instructions in %u functions (%u gaps) "
604 "for thread %s (%s).\n"), insns, calls, gaps,
605 print_thread_id (tp), target_pid_to_str (tp->ptid));
607 if (btrace_is_replaying (tp))
608 printf_unfiltered (_("Replay in progress. At instruction %u.\n"),
609 btrace_insn_number (btinfo->replay));
612 /* Print a decode error. */
615 btrace_ui_out_decode_error (struct ui_out *uiout, int errcode,
616 enum btrace_format format)
618 const char *errstr = btrace_decode_error (format, errcode);
620 uiout->text (_("["));
621 /* ERRCODE > 0 indicates notifications on BTRACE_FORMAT_PT. */
622 if (!(format == BTRACE_FORMAT_PT && errcode > 0))
624 uiout->text (_("decode error ("));
625 uiout->field_int ("errcode", errcode);
626 uiout->text (_("): "));
628 uiout->text (errstr);
629 uiout->text (_("]\n"));
632 /* Print an unsigned int. */
635 ui_out_field_uint (struct ui_out *uiout, const char *fld, unsigned int val)
637 uiout->field_fmt (fld, "%u", val);
640 /* A range of source lines. */
642 struct btrace_line_range
644 /* The symtab this line is from. */
645 struct symtab *symtab;
647 /* The first line (inclusive). */
650 /* The last line (exclusive). */
654 /* Construct a line range. */
656 static struct btrace_line_range
657 btrace_mk_line_range (struct symtab *symtab, int begin, int end)
659 struct btrace_line_range range;
661 range.symtab = symtab;
668 /* Add a line to a line range. */
670 static struct btrace_line_range
671 btrace_line_range_add (struct btrace_line_range range, int line)
673 if (range.end <= range.begin)
675 /* This is the first entry. */
677 range.end = line + 1;
679 else if (line < range.begin)
681 else if (range.end < line)
687 /* Return non-zero if RANGE is empty, zero otherwise. */
690 btrace_line_range_is_empty (struct btrace_line_range range)
692 return range.end <= range.begin;
695 /* Return non-zero if LHS contains RHS, zero otherwise. */
698 btrace_line_range_contains_range (struct btrace_line_range lhs,
699 struct btrace_line_range rhs)
701 return ((lhs.symtab == rhs.symtab)
702 && (lhs.begin <= rhs.begin)
703 && (rhs.end <= lhs.end));
706 /* Find the line range associated with PC. */
708 static struct btrace_line_range
709 btrace_find_line_range (CORE_ADDR pc)
711 struct btrace_line_range range;
712 struct linetable_entry *lines;
713 struct linetable *ltable;
714 struct symtab *symtab;
717 symtab = find_pc_line_symtab (pc);
719 return btrace_mk_line_range (NULL, 0, 0);
721 ltable = SYMTAB_LINETABLE (symtab);
723 return btrace_mk_line_range (symtab, 0, 0);
725 nlines = ltable->nitems;
726 lines = ltable->item;
728 return btrace_mk_line_range (symtab, 0, 0);
730 range = btrace_mk_line_range (symtab, 0, 0);
731 for (i = 0; i < nlines - 1; i++)
733 if ((lines[i].pc == pc) && (lines[i].line != 0))
734 range = btrace_line_range_add (range, lines[i].line);
740 /* Print source lines in LINES to UIOUT.
742 UI_ITEM_CHAIN is a cleanup chain for the last source line and the
743 instructions corresponding to that source line. When printing a new source
744 line, we do the cleanups for the open chain and open a new cleanup chain for
745 the new source line. If the source line range in LINES is not empty, this
746 function will leave the cleanup chain for the last printed source line open
747 so instructions can be added to it. */
750 btrace_print_lines (struct btrace_line_range lines, struct ui_out *uiout,
751 gdb::optional<ui_out_emit_tuple> *src_and_asm_tuple,
752 gdb::optional<ui_out_emit_list> *asm_list,
753 gdb_disassembly_flags flags)
755 print_source_lines_flags psl_flags;
757 if (flags & DISASSEMBLY_FILENAME)
758 psl_flags |= PRINT_SOURCE_LINES_FILENAME;
760 for (int line = lines.begin; line < lines.end; ++line)
764 src_and_asm_tuple->emplace (uiout, "src_and_asm_line");
766 print_source_lines (lines.symtab, line, line + 1, psl_flags);
768 asm_list->emplace (uiout, "line_asm_insn");
772 /* Disassemble a section of the recorded instruction trace. */
775 btrace_insn_history (struct ui_out *uiout,
776 const struct btrace_thread_info *btinfo,
777 const struct btrace_insn_iterator *begin,
778 const struct btrace_insn_iterator *end,
779 gdb_disassembly_flags flags)
781 DEBUG ("itrace (0x%x): [%u; %u)", (unsigned) flags,
782 btrace_insn_number (begin), btrace_insn_number (end));
784 flags |= DISASSEMBLY_SPECULATIVE;
786 struct gdbarch *gdbarch = target_gdbarch ();
787 btrace_line_range last_lines = btrace_mk_line_range (NULL, 0, 0);
789 ui_out_emit_list list_emitter (uiout, "asm_insns");
791 gdb::optional<ui_out_emit_tuple> src_and_asm_tuple;
792 gdb::optional<ui_out_emit_list> asm_list;
794 gdb_pretty_print_disassembler disasm (gdbarch);
796 for (btrace_insn_iterator it = *begin; btrace_insn_cmp (&it, end) != 0;
797 btrace_insn_next (&it, 1))
799 const struct btrace_insn *insn;
801 insn = btrace_insn_get (&it);
803 /* A NULL instruction indicates a gap in the trace. */
806 const struct btrace_config *conf;
808 conf = btrace_conf (btinfo);
810 /* We have trace so we must have a configuration. */
811 gdb_assert (conf != NULL);
813 uiout->field_fmt ("insn-number", "%u",
814 btrace_insn_number (&it));
817 btrace_ui_out_decode_error (uiout, btrace_insn_get_error (&it),
822 struct disasm_insn dinsn;
824 if ((flags & DISASSEMBLY_SOURCE) != 0)
826 struct btrace_line_range lines;
828 lines = btrace_find_line_range (insn->pc);
829 if (!btrace_line_range_is_empty (lines)
830 && !btrace_line_range_contains_range (last_lines, lines))
832 btrace_print_lines (lines, uiout, &src_and_asm_tuple, &asm_list,
836 else if (!src_and_asm_tuple.has_value ())
838 gdb_assert (!asm_list.has_value ());
840 src_and_asm_tuple.emplace (uiout, "src_and_asm_line");
842 /* No source information. */
843 asm_list.emplace (uiout, "line_asm_insn");
846 gdb_assert (src_and_asm_tuple.has_value ());
847 gdb_assert (asm_list.has_value ());
850 memset (&dinsn, 0, sizeof (dinsn));
851 dinsn.number = btrace_insn_number (&it);
852 dinsn.addr = insn->pc;
854 if ((insn->flags & BTRACE_INSN_FLAG_SPECULATIVE) != 0)
855 dinsn.is_speculative = 1;
857 disasm.pretty_print_insn (uiout, &dinsn, flags);
862 /* The insn_history method of target record-btrace. */
865 record_btrace_target::insn_history (int size, gdb_disassembly_flags flags)
867 struct btrace_thread_info *btinfo;
868 struct btrace_insn_history *history;
869 struct btrace_insn_iterator begin, end;
870 struct ui_out *uiout;
871 unsigned int context, covered;
873 uiout = current_uiout;
874 ui_out_emit_tuple tuple_emitter (uiout, "insn history");
875 context = abs (size);
877 error (_("Bad record instruction-history-size."));
879 btinfo = require_btrace ();
880 history = btinfo->insn_history;
883 struct btrace_insn_iterator *replay;
885 DEBUG ("insn-history (0x%x): %d", (unsigned) flags, size);
887 /* If we're replaying, we start at the replay position. Otherwise, we
888 start at the tail of the trace. */
889 replay = btinfo->replay;
893 btrace_insn_end (&begin, btinfo);
895 /* We start from here and expand in the requested direction. Then we
896 expand in the other direction, as well, to fill up any remaining
901 /* We want the current position covered, as well. */
902 covered = btrace_insn_next (&end, 1);
903 covered += btrace_insn_prev (&begin, context - covered);
904 covered += btrace_insn_next (&end, context - covered);
908 covered = btrace_insn_next (&end, context);
909 covered += btrace_insn_prev (&begin, context - covered);
914 begin = history->begin;
917 DEBUG ("insn-history (0x%x): %d, prev: [%u; %u)", (unsigned) flags, size,
918 btrace_insn_number (&begin), btrace_insn_number (&end));
923 covered = btrace_insn_prev (&begin, context);
928 covered = btrace_insn_next (&end, context);
933 btrace_insn_history (uiout, btinfo, &begin, &end, flags);
937 printf_unfiltered (_("At the start of the branch trace record.\n"));
939 printf_unfiltered (_("At the end of the branch trace record.\n"));
942 btrace_set_insn_history (btinfo, &begin, &end);
945 /* The insn_history_range method of target record-btrace. */
948 record_btrace_target::insn_history_range (ULONGEST from, ULONGEST to,
949 gdb_disassembly_flags flags)
951 struct btrace_thread_info *btinfo;
952 struct btrace_insn_iterator begin, end;
953 struct ui_out *uiout;
954 unsigned int low, high;
957 uiout = current_uiout;
958 ui_out_emit_tuple tuple_emitter (uiout, "insn history");
962 DEBUG ("insn-history (0x%x): [%u; %u)", (unsigned) flags, low, high);
964 /* Check for wrap-arounds. */
965 if (low != from || high != to)
966 error (_("Bad range."));
969 error (_("Bad range."));
971 btinfo = require_btrace ();
973 found = btrace_find_insn_by_number (&begin, btinfo, low);
975 error (_("Range out of bounds."));
977 found = btrace_find_insn_by_number (&end, btinfo, high);
980 /* Silently truncate the range. */
981 btrace_insn_end (&end, btinfo);
985 /* We want both begin and end to be inclusive. */
986 btrace_insn_next (&end, 1);
989 btrace_insn_history (uiout, btinfo, &begin, &end, flags);
990 btrace_set_insn_history (btinfo, &begin, &end);
993 /* The insn_history_from method of target record-btrace. */
996 record_btrace_target::insn_history_from (ULONGEST from, int size,
997 gdb_disassembly_flags flags)
999 ULONGEST begin, end, context;
1001 context = abs (size);
1003 error (_("Bad record instruction-history-size."));
1012 begin = from - context + 1;
1017 end = from + context - 1;
1019 /* Check for wrap-around. */
1024 insn_history_range (begin, end, flags);
1027 /* Print the instruction number range for a function call history line. */
1030 btrace_call_history_insn_range (struct ui_out *uiout,
1031 const struct btrace_function *bfun)
1033 unsigned int begin, end, size;
1035 size = bfun->insn.size ();
1036 gdb_assert (size > 0);
1038 begin = bfun->insn_offset;
1039 end = begin + size - 1;
1041 ui_out_field_uint (uiout, "insn begin", begin);
1043 ui_out_field_uint (uiout, "insn end", end);
1046 /* Compute the lowest and highest source line for the instructions in BFUN
1047 and return them in PBEGIN and PEND.
1048 Ignore instructions that can't be mapped to BFUN, e.g. instructions that
1049 result from inlining or macro expansion. */
1052 btrace_compute_src_line_range (const struct btrace_function *bfun,
1053 int *pbegin, int *pend)
1055 struct symtab *symtab;
1066 symtab = symbol_symtab (sym);
1068 for (const btrace_insn &insn : bfun->insn)
1070 struct symtab_and_line sal;
1072 sal = find_pc_line (insn.pc, 0);
1073 if (sal.symtab != symtab || sal.line == 0)
1076 begin = std::min (begin, sal.line);
1077 end = std::max (end, sal.line);
1085 /* Print the source line information for a function call history line. */
1088 btrace_call_history_src_line (struct ui_out *uiout,
1089 const struct btrace_function *bfun)
1098 uiout->field_string ("file",
1099 symtab_to_filename_for_display (symbol_symtab (sym)));
1101 btrace_compute_src_line_range (bfun, &begin, &end);
1106 uiout->field_int ("min line", begin);
1112 uiout->field_int ("max line", end);
1115 /* Get the name of a branch trace function. */
1118 btrace_get_bfun_name (const struct btrace_function *bfun)
1120 struct minimal_symbol *msym;
1130 return SYMBOL_PRINT_NAME (sym);
1131 else if (msym != NULL)
1132 return MSYMBOL_PRINT_NAME (msym);
1137 /* Disassemble a section of the recorded function trace. */
1140 btrace_call_history (struct ui_out *uiout,
1141 const struct btrace_thread_info *btinfo,
1142 const struct btrace_call_iterator *begin,
1143 const struct btrace_call_iterator *end,
1146 struct btrace_call_iterator it;
1147 record_print_flags flags = (enum record_print_flag) int_flags;
1149 DEBUG ("ftrace (0x%x): [%u; %u)", int_flags, btrace_call_number (begin),
1150 btrace_call_number (end));
1152 for (it = *begin; btrace_call_cmp (&it, end) < 0; btrace_call_next (&it, 1))
1154 const struct btrace_function *bfun;
1155 struct minimal_symbol *msym;
1158 bfun = btrace_call_get (&it);
1162 /* Print the function index. */
1163 ui_out_field_uint (uiout, "index", bfun->number);
1166 /* Indicate gaps in the trace. */
1167 if (bfun->errcode != 0)
1169 const struct btrace_config *conf;
1171 conf = btrace_conf (btinfo);
1173 /* We have trace so we must have a configuration. */
1174 gdb_assert (conf != NULL);
1176 btrace_ui_out_decode_error (uiout, bfun->errcode, conf->format);
1181 if ((flags & RECORD_PRINT_INDENT_CALLS) != 0)
1183 int level = bfun->level + btinfo->level, i;
1185 for (i = 0; i < level; ++i)
1190 uiout->field_string ("function", SYMBOL_PRINT_NAME (sym));
1191 else if (msym != NULL)
1192 uiout->field_string ("function", MSYMBOL_PRINT_NAME (msym));
1193 else if (!uiout->is_mi_like_p ())
1194 uiout->field_string ("function", "??");
1196 if ((flags & RECORD_PRINT_INSN_RANGE) != 0)
1198 uiout->text (_("\tinst "));
1199 btrace_call_history_insn_range (uiout, bfun);
1202 if ((flags & RECORD_PRINT_SRC_LINE) != 0)
1204 uiout->text (_("\tat "));
1205 btrace_call_history_src_line (uiout, bfun);
1212 /* The call_history method of target record-btrace. */
1215 record_btrace_target::call_history (int size, record_print_flags flags)
1217 struct btrace_thread_info *btinfo;
1218 struct btrace_call_history *history;
1219 struct btrace_call_iterator begin, end;
1220 struct ui_out *uiout;
1221 unsigned int context, covered;
1223 uiout = current_uiout;
1224 ui_out_emit_tuple tuple_emitter (uiout, "insn history");
1225 context = abs (size);
1227 error (_("Bad record function-call-history-size."));
1229 btinfo = require_btrace ();
1230 history = btinfo->call_history;
1231 if (history == NULL)
1233 struct btrace_insn_iterator *replay;
1235 DEBUG ("call-history (0x%x): %d", (int) flags, size);
1237 /* If we're replaying, we start at the replay position. Otherwise, we
1238 start at the tail of the trace. */
1239 replay = btinfo->replay;
1242 begin.btinfo = btinfo;
1243 begin.index = replay->call_index;
1246 btrace_call_end (&begin, btinfo);
1248 /* We start from here and expand in the requested direction. Then we
1249 expand in the other direction, as well, to fill up any remaining
1254 /* We want the current position covered, as well. */
1255 covered = btrace_call_next (&end, 1);
1256 covered += btrace_call_prev (&begin, context - covered);
1257 covered += btrace_call_next (&end, context - covered);
1261 covered = btrace_call_next (&end, context);
1262 covered += btrace_call_prev (&begin, context- covered);
1267 begin = history->begin;
1270 DEBUG ("call-history (0x%x): %d, prev: [%u; %u)", (int) flags, size,
1271 btrace_call_number (&begin), btrace_call_number (&end));
1276 covered = btrace_call_prev (&begin, context);
1281 covered = btrace_call_next (&end, context);
1286 btrace_call_history (uiout, btinfo, &begin, &end, flags);
1290 printf_unfiltered (_("At the start of the branch trace record.\n"));
1292 printf_unfiltered (_("At the end of the branch trace record.\n"));
1295 btrace_set_call_history (btinfo, &begin, &end);
1298 /* The call_history_range method of target record-btrace. */
1301 record_btrace_target::call_history_range (ULONGEST from, ULONGEST to,
1302 record_print_flags flags)
1304 struct btrace_thread_info *btinfo;
1305 struct btrace_call_iterator begin, end;
1306 struct ui_out *uiout;
1307 unsigned int low, high;
1310 uiout = current_uiout;
1311 ui_out_emit_tuple tuple_emitter (uiout, "func history");
1315 DEBUG ("call-history (0x%x): [%u; %u)", (int) flags, low, high);
1317 /* Check for wrap-arounds. */
1318 if (low != from || high != to)
1319 error (_("Bad range."));
1322 error (_("Bad range."));
1324 btinfo = require_btrace ();
1326 found = btrace_find_call_by_number (&begin, btinfo, low);
1328 error (_("Range out of bounds."));
1330 found = btrace_find_call_by_number (&end, btinfo, high);
1333 /* Silently truncate the range. */
1334 btrace_call_end (&end, btinfo);
1338 /* We want both begin and end to be inclusive. */
1339 btrace_call_next (&end, 1);
1342 btrace_call_history (uiout, btinfo, &begin, &end, flags);
1343 btrace_set_call_history (btinfo, &begin, &end);
1346 /* The call_history_from method of target record-btrace. */
1349 record_btrace_target::call_history_from (ULONGEST from, int size,
1350 record_print_flags flags)
1352 ULONGEST begin, end, context;
1354 context = abs (size);
1356 error (_("Bad record function-call-history-size."));
1365 begin = from - context + 1;
1370 end = from + context - 1;
1372 /* Check for wrap-around. */
1377 call_history_range ( begin, end, flags);
1380 /* The record_method method of target record-btrace. */
1383 record_btrace_target::record_method (ptid_t ptid)
1385 struct thread_info * const tp = find_thread_ptid (ptid);
1388 error (_("No thread."));
1390 if (tp->btrace.target == NULL)
1391 return RECORD_METHOD_NONE;
1393 return RECORD_METHOD_BTRACE;
1396 /* The record_is_replaying method of target record-btrace. */
1399 record_btrace_target::record_is_replaying (ptid_t ptid)
1401 struct thread_info *tp;
1403 ALL_NON_EXITED_THREADS (tp)
1404 if (tp->ptid.matches (ptid) && btrace_is_replaying (tp))
1410 /* The record_will_replay method of target record-btrace. */
1413 record_btrace_target::record_will_replay (ptid_t ptid, int dir)
1415 return dir == EXEC_REVERSE || record_is_replaying (ptid);
1418 /* The xfer_partial method of target record-btrace. */
1420 enum target_xfer_status
1421 record_btrace_target::xfer_partial (enum target_object object,
1422 const char *annex, gdb_byte *readbuf,
1423 const gdb_byte *writebuf, ULONGEST offset,
1424 ULONGEST len, ULONGEST *xfered_len)
1426 /* Filter out requests that don't make sense during replay. */
1427 if (replay_memory_access == replay_memory_access_read_only
1428 && !record_btrace_generating_corefile
1429 && record_is_replaying (inferior_ptid))
1433 case TARGET_OBJECT_MEMORY:
1435 struct target_section *section;
1437 /* We do not allow writing memory in general. */
1438 if (writebuf != NULL)
1441 return TARGET_XFER_UNAVAILABLE;
1444 /* We allow reading readonly memory. */
1445 section = target_section_by_addr (this, offset);
1446 if (section != NULL)
1448 /* Check if the section we found is readonly. */
1449 if ((bfd_get_section_flags (section->the_bfd_section->owner,
1450 section->the_bfd_section)
1451 & SEC_READONLY) != 0)
1453 /* Truncate the request to fit into this section. */
1454 len = std::min (len, section->endaddr - offset);
1460 return TARGET_XFER_UNAVAILABLE;
1465 /* Forward the request. */
1466 return this->beneath ()->xfer_partial (object, annex, readbuf, writebuf,
1467 offset, len, xfered_len);
1470 /* The insert_breakpoint method of target record-btrace. */
1473 record_btrace_target::insert_breakpoint (struct gdbarch *gdbarch,
1474 struct bp_target_info *bp_tgt)
1479 /* Inserting breakpoints requires accessing memory. Allow it for the
1480 duration of this function. */
1481 old = replay_memory_access;
1482 replay_memory_access = replay_memory_access_read_write;
1487 ret = this->beneath ()->insert_breakpoint (gdbarch, bp_tgt);
1489 CATCH (except, RETURN_MASK_ALL)
1491 replay_memory_access = old;
1492 throw_exception (except);
1495 replay_memory_access = old;
1500 /* The remove_breakpoint method of target record-btrace. */
1503 record_btrace_target::remove_breakpoint (struct gdbarch *gdbarch,
1504 struct bp_target_info *bp_tgt,
1505 enum remove_bp_reason reason)
1510 /* Removing breakpoints requires accessing memory. Allow it for the
1511 duration of this function. */
1512 old = replay_memory_access;
1513 replay_memory_access = replay_memory_access_read_write;
1518 ret = this->beneath ()->remove_breakpoint (gdbarch, bp_tgt, reason);
1520 CATCH (except, RETURN_MASK_ALL)
1522 replay_memory_access = old;
1523 throw_exception (except);
1526 replay_memory_access = old;
1531 /* The fetch_registers method of target record-btrace. */
1534 record_btrace_target::fetch_registers (struct regcache *regcache, int regno)
1536 struct btrace_insn_iterator *replay;
1537 struct thread_info *tp;
1539 tp = find_thread_ptid (regcache->ptid ());
1540 gdb_assert (tp != NULL);
1542 replay = tp->btrace.replay;
1543 if (replay != NULL && !record_btrace_generating_corefile)
1545 const struct btrace_insn *insn;
1546 struct gdbarch *gdbarch;
1549 gdbarch = regcache->arch ();
1550 pcreg = gdbarch_pc_regnum (gdbarch);
1554 /* We can only provide the PC register. */
1555 if (regno >= 0 && regno != pcreg)
1558 insn = btrace_insn_get (replay);
1559 gdb_assert (insn != NULL);
1561 regcache->raw_supply (regno, &insn->pc);
1564 this->beneath ()->fetch_registers (regcache, regno);
1567 /* The store_registers method of target record-btrace. */
1570 record_btrace_target::store_registers (struct regcache *regcache, int regno)
1572 if (!record_btrace_generating_corefile
1573 && record_is_replaying (regcache->ptid ()))
1574 error (_("Cannot write registers while replaying."));
1576 gdb_assert (may_write_registers != 0);
1578 this->beneath ()->store_registers (regcache, regno);
1581 /* The prepare_to_store method of target record-btrace. */
1584 record_btrace_target::prepare_to_store (struct regcache *regcache)
1586 if (!record_btrace_generating_corefile
1587 && record_is_replaying (regcache->ptid ()))
1590 this->beneath ()->prepare_to_store (regcache);
1593 /* The branch trace frame cache. */
1595 struct btrace_frame_cache
1598 struct thread_info *tp;
1600 /* The frame info. */
1601 struct frame_info *frame;
1603 /* The branch trace function segment. */
1604 const struct btrace_function *bfun;
1607 /* A struct btrace_frame_cache hash table indexed by NEXT. */
1609 static htab_t bfcache;
1611 /* hash_f for htab_create_alloc of bfcache. */
1614 bfcache_hash (const void *arg)
1616 const struct btrace_frame_cache *cache
1617 = (const struct btrace_frame_cache *) arg;
1619 return htab_hash_pointer (cache->frame);
1622 /* eq_f for htab_create_alloc of bfcache. */
1625 bfcache_eq (const void *arg1, const void *arg2)
1627 const struct btrace_frame_cache *cache1
1628 = (const struct btrace_frame_cache *) arg1;
1629 const struct btrace_frame_cache *cache2
1630 = (const struct btrace_frame_cache *) arg2;
1632 return cache1->frame == cache2->frame;
1635 /* Create a new btrace frame cache. */
1637 static struct btrace_frame_cache *
1638 bfcache_new (struct frame_info *frame)
1640 struct btrace_frame_cache *cache;
1643 cache = FRAME_OBSTACK_ZALLOC (struct btrace_frame_cache);
1644 cache->frame = frame;
1646 slot = htab_find_slot (bfcache, cache, INSERT);
1647 gdb_assert (*slot == NULL);
1653 /* Extract the branch trace function from a branch trace frame. */
1655 static const struct btrace_function *
1656 btrace_get_frame_function (struct frame_info *frame)
1658 const struct btrace_frame_cache *cache;
1659 struct btrace_frame_cache pattern;
1662 pattern.frame = frame;
1664 slot = htab_find_slot (bfcache, &pattern, NO_INSERT);
1668 cache = (const struct btrace_frame_cache *) *slot;
1672 /* Implement stop_reason method for record_btrace_frame_unwind. */
1674 static enum unwind_stop_reason
1675 record_btrace_frame_unwind_stop_reason (struct frame_info *this_frame,
1678 const struct btrace_frame_cache *cache;
1679 const struct btrace_function *bfun;
1681 cache = (const struct btrace_frame_cache *) *this_cache;
1683 gdb_assert (bfun != NULL);
1686 return UNWIND_UNAVAILABLE;
1688 return UNWIND_NO_REASON;
1691 /* Implement this_id method for record_btrace_frame_unwind. */
1694 record_btrace_frame_this_id (struct frame_info *this_frame, void **this_cache,
1695 struct frame_id *this_id)
1697 const struct btrace_frame_cache *cache;
1698 const struct btrace_function *bfun;
1699 struct btrace_call_iterator it;
1700 CORE_ADDR code, special;
1702 cache = (const struct btrace_frame_cache *) *this_cache;
1705 gdb_assert (bfun != NULL);
1707 while (btrace_find_call_by_number (&it, &cache->tp->btrace, bfun->prev) != 0)
1708 bfun = btrace_call_get (&it);
1710 code = get_frame_func (this_frame);
1711 special = bfun->number;
1713 *this_id = frame_id_build_unavailable_stack_special (code, special);
1715 DEBUG ("[frame] %s id: (!stack, pc=%s, special=%s)",
1716 btrace_get_bfun_name (cache->bfun),
1717 core_addr_to_string_nz (this_id->code_addr),
1718 core_addr_to_string_nz (this_id->special_addr));
1721 /* Implement prev_register method for record_btrace_frame_unwind. */
1723 static struct value *
1724 record_btrace_frame_prev_register (struct frame_info *this_frame,
1728 const struct btrace_frame_cache *cache;
1729 const struct btrace_function *bfun, *caller;
1730 struct btrace_call_iterator it;
1731 struct gdbarch *gdbarch;
1735 gdbarch = get_frame_arch (this_frame);
1736 pcreg = gdbarch_pc_regnum (gdbarch);
1737 if (pcreg < 0 || regnum != pcreg)
1738 throw_error (NOT_AVAILABLE_ERROR,
1739 _("Registers are not available in btrace record history"));
1741 cache = (const struct btrace_frame_cache *) *this_cache;
1743 gdb_assert (bfun != NULL);
1745 if (btrace_find_call_by_number (&it, &cache->tp->btrace, bfun->up) == 0)
1746 throw_error (NOT_AVAILABLE_ERROR,
1747 _("No caller in btrace record history"));
1749 caller = btrace_call_get (&it);
1751 if ((bfun->flags & BFUN_UP_LINKS_TO_RET) != 0)
1752 pc = caller->insn.front ().pc;
1755 pc = caller->insn.back ().pc;
1756 pc += gdb_insn_length (gdbarch, pc);
1759 DEBUG ("[frame] unwound PC in %s on level %d: %s",
1760 btrace_get_bfun_name (bfun), bfun->level,
1761 core_addr_to_string_nz (pc));
1763 return frame_unwind_got_address (this_frame, regnum, pc);
1766 /* Implement sniffer method for record_btrace_frame_unwind. */
1769 record_btrace_frame_sniffer (const struct frame_unwind *self,
1770 struct frame_info *this_frame,
1773 const struct btrace_function *bfun;
1774 struct btrace_frame_cache *cache;
1775 struct thread_info *tp;
1776 struct frame_info *next;
1778 /* THIS_FRAME does not contain a reference to its thread. */
1779 tp = inferior_thread ();
1782 next = get_next_frame (this_frame);
1785 const struct btrace_insn_iterator *replay;
1787 replay = tp->btrace.replay;
1789 bfun = &replay->btinfo->functions[replay->call_index];
1793 const struct btrace_function *callee;
1794 struct btrace_call_iterator it;
1796 callee = btrace_get_frame_function (next);
1797 if (callee == NULL || (callee->flags & BFUN_UP_LINKS_TO_TAILCALL) != 0)
1800 if (btrace_find_call_by_number (&it, &tp->btrace, callee->up) == 0)
1803 bfun = btrace_call_get (&it);
1809 DEBUG ("[frame] sniffed frame for %s on level %d",
1810 btrace_get_bfun_name (bfun), bfun->level);
1812 /* This is our frame. Initialize the frame cache. */
1813 cache = bfcache_new (this_frame);
1817 *this_cache = cache;
1821 /* Implement sniffer method for record_btrace_tailcall_frame_unwind. */
1824 record_btrace_tailcall_frame_sniffer (const struct frame_unwind *self,
1825 struct frame_info *this_frame,
1828 const struct btrace_function *bfun, *callee;
1829 struct btrace_frame_cache *cache;
1830 struct btrace_call_iterator it;
1831 struct frame_info *next;
1832 struct thread_info *tinfo;
1834 next = get_next_frame (this_frame);
1838 callee = btrace_get_frame_function (next);
1842 if ((callee->flags & BFUN_UP_LINKS_TO_TAILCALL) == 0)
1845 tinfo = inferior_thread ();
1846 if (btrace_find_call_by_number (&it, &tinfo->btrace, callee->up) == 0)
1849 bfun = btrace_call_get (&it);
1851 DEBUG ("[frame] sniffed tailcall frame for %s on level %d",
1852 btrace_get_bfun_name (bfun), bfun->level);
1854 /* This is our frame. Initialize the frame cache. */
1855 cache = bfcache_new (this_frame);
1859 *this_cache = cache;
1864 record_btrace_frame_dealloc_cache (struct frame_info *self, void *this_cache)
1866 struct btrace_frame_cache *cache;
1869 cache = (struct btrace_frame_cache *) this_cache;
1871 slot = htab_find_slot (bfcache, cache, NO_INSERT);
1872 gdb_assert (slot != NULL);
1874 htab_remove_elt (bfcache, cache);
1877 /* btrace recording does not store previous memory content, neither the stack
1878 frames content. Any unwinding would return errorneous results as the stack
1879 contents no longer matches the changed PC value restored from history.
1880 Therefore this unwinder reports any possibly unwound registers as
1883 const struct frame_unwind record_btrace_frame_unwind =
1886 record_btrace_frame_unwind_stop_reason,
1887 record_btrace_frame_this_id,
1888 record_btrace_frame_prev_register,
1890 record_btrace_frame_sniffer,
1891 record_btrace_frame_dealloc_cache
1894 const struct frame_unwind record_btrace_tailcall_frame_unwind =
1897 record_btrace_frame_unwind_stop_reason,
1898 record_btrace_frame_this_id,
1899 record_btrace_frame_prev_register,
1901 record_btrace_tailcall_frame_sniffer,
1902 record_btrace_frame_dealloc_cache
1905 /* Implement the get_unwinder method. */
1907 const struct frame_unwind *
1908 record_btrace_target::get_unwinder ()
1910 return &record_btrace_frame_unwind;
1913 /* Implement the get_tailcall_unwinder method. */
1915 const struct frame_unwind *
1916 record_btrace_target::get_tailcall_unwinder ()
1918 return &record_btrace_tailcall_frame_unwind;
1921 /* Return a human-readable string for FLAG. */
1924 btrace_thread_flag_to_str (enum btrace_thread_flag flag)
1932 return "reverse-step";
1938 return "reverse-cont";
1947 /* Indicate that TP should be resumed according to FLAG. */
1950 record_btrace_resume_thread (struct thread_info *tp,
1951 enum btrace_thread_flag flag)
1953 struct btrace_thread_info *btinfo;
1955 DEBUG ("resuming thread %s (%s): %x (%s)", print_thread_id (tp),
1956 target_pid_to_str (tp->ptid), flag, btrace_thread_flag_to_str (flag));
1958 btinfo = &tp->btrace;
1960 /* Fetch the latest branch trace. */
1961 btrace_fetch (tp, record_btrace_get_cpu ());
1963 /* A resume request overwrites a preceding resume or stop request. */
1964 btinfo->flags &= ~(BTHR_MOVE | BTHR_STOP);
1965 btinfo->flags |= flag;
1968 /* Get the current frame for TP. */
1970 static struct frame_info *
1971 get_thread_current_frame (struct thread_info *tp)
1973 struct frame_info *frame;
1974 ptid_t old_inferior_ptid;
1977 /* Set current thread, which is implicitly used by
1978 get_current_frame. */
1979 scoped_restore_current_thread restore_thread;
1981 switch_to_thread (tp);
1983 /* Clear the executing flag to allow changes to the current frame.
1984 We are not actually running, yet. We just started a reverse execution
1985 command or a record goto command.
1986 For the latter, EXECUTING is false and this has no effect.
1987 For the former, EXECUTING is true and we're in wait, about to
1988 move the thread. Since we need to recompute the stack, we temporarily
1989 set EXECUTING to flase. */
1990 executing = tp->executing;
1991 set_executing (inferior_ptid, false);
1996 frame = get_current_frame ();
1998 CATCH (except, RETURN_MASK_ALL)
2000 /* Restore the previous execution state. */
2001 set_executing (inferior_ptid, executing);
2003 throw_exception (except);
2007 /* Restore the previous execution state. */
2008 set_executing (inferior_ptid, executing);
2013 /* Start replaying a thread. */
2015 static struct btrace_insn_iterator *
2016 record_btrace_start_replaying (struct thread_info *tp)
2018 struct btrace_insn_iterator *replay;
2019 struct btrace_thread_info *btinfo;
2021 btinfo = &tp->btrace;
2024 /* We can't start replaying without trace. */
2025 if (btinfo->functions.empty ())
2028 /* GDB stores the current frame_id when stepping in order to detects steps
2030 Since frames are computed differently when we're replaying, we need to
2031 recompute those stored frames and fix them up so we can still detect
2032 subroutines after we started replaying. */
2035 struct frame_info *frame;
2036 struct frame_id frame_id;
2037 int upd_step_frame_id, upd_step_stack_frame_id;
2039 /* The current frame without replaying - computed via normal unwind. */
2040 frame = get_thread_current_frame (tp);
2041 frame_id = get_frame_id (frame);
2043 /* Check if we need to update any stepping-related frame id's. */
2044 upd_step_frame_id = frame_id_eq (frame_id,
2045 tp->control.step_frame_id);
2046 upd_step_stack_frame_id = frame_id_eq (frame_id,
2047 tp->control.step_stack_frame_id);
2049 /* We start replaying at the end of the branch trace. This corresponds
2050 to the current instruction. */
2051 replay = XNEW (struct btrace_insn_iterator);
2052 btrace_insn_end (replay, btinfo);
2054 /* Skip gaps at the end of the trace. */
2055 while (btrace_insn_get (replay) == NULL)
2059 steps = btrace_insn_prev (replay, 1);
2061 error (_("No trace."));
2064 /* We're not replaying, yet. */
2065 gdb_assert (btinfo->replay == NULL);
2066 btinfo->replay = replay;
2068 /* Make sure we're not using any stale registers. */
2069 registers_changed_thread (tp);
2071 /* The current frame with replaying - computed via btrace unwind. */
2072 frame = get_thread_current_frame (tp);
2073 frame_id = get_frame_id (frame);
2075 /* Replace stepping related frames where necessary. */
2076 if (upd_step_frame_id)
2077 tp->control.step_frame_id = frame_id;
2078 if (upd_step_stack_frame_id)
2079 tp->control.step_stack_frame_id = frame_id;
2081 CATCH (except, RETURN_MASK_ALL)
2083 xfree (btinfo->replay);
2084 btinfo->replay = NULL;
2086 registers_changed_thread (tp);
2088 throw_exception (except);
2095 /* Stop replaying a thread. */
2098 record_btrace_stop_replaying (struct thread_info *tp)
2100 struct btrace_thread_info *btinfo;
2102 btinfo = &tp->btrace;
2104 xfree (btinfo->replay);
2105 btinfo->replay = NULL;
2107 /* Make sure we're not leaving any stale registers. */
2108 registers_changed_thread (tp);
2111 /* Stop replaying TP if it is at the end of its execution history. */
2114 record_btrace_stop_replaying_at_end (struct thread_info *tp)
2116 struct btrace_insn_iterator *replay, end;
2117 struct btrace_thread_info *btinfo;
2119 btinfo = &tp->btrace;
2120 replay = btinfo->replay;
2125 btrace_insn_end (&end, btinfo);
2127 if (btrace_insn_cmp (replay, &end) == 0)
2128 record_btrace_stop_replaying (tp);
2131 /* The resume method of target record-btrace. */
2134 record_btrace_target::resume (ptid_t ptid, int step, enum gdb_signal signal)
2136 struct thread_info *tp;
2137 enum btrace_thread_flag flag, cflag;
2139 DEBUG ("resume %s: %s%s", target_pid_to_str (ptid),
2140 ::execution_direction == EXEC_REVERSE ? "reverse-" : "",
2141 step ? "step" : "cont");
2143 /* Store the execution direction of the last resume.
2145 If there is more than one resume call, we have to rely on infrun
2146 to not change the execution direction in-between. */
2147 record_btrace_resume_exec_dir = ::execution_direction;
2149 /* As long as we're not replaying, just forward the request.
2151 For non-stop targets this means that no thread is replaying. In order to
2152 make progress, we may need to explicitly move replaying threads to the end
2153 of their execution history. */
2154 if ((::execution_direction != EXEC_REVERSE)
2155 && !record_is_replaying (minus_one_ptid))
2157 this->beneath ()->resume (ptid, step, signal);
2161 /* Compute the btrace thread flag for the requested move. */
2162 if (::execution_direction == EXEC_REVERSE)
2164 flag = step == 0 ? BTHR_RCONT : BTHR_RSTEP;
2169 flag = step == 0 ? BTHR_CONT : BTHR_STEP;
2173 /* We just indicate the resume intent here. The actual stepping happens in
2174 record_btrace_wait below.
2176 For all-stop targets, we only step INFERIOR_PTID and continue others. */
2177 if (!target_is_non_stop_p ())
2179 gdb_assert (inferior_ptid.matches (ptid));
2181 ALL_NON_EXITED_THREADS (tp)
2182 if (tp->ptid.matches (ptid))
2184 if (tp->ptid.matches (inferior_ptid))
2185 record_btrace_resume_thread (tp, flag);
2187 record_btrace_resume_thread (tp, cflag);
2192 ALL_NON_EXITED_THREADS (tp)
2193 if (tp->ptid.matches (ptid))
2194 record_btrace_resume_thread (tp, flag);
2197 /* Async support. */
2198 if (target_can_async_p ())
2201 mark_async_event_handler (record_btrace_async_inferior_event_handler);
2205 /* The commit_resume method of target record-btrace. */
2208 record_btrace_target::commit_resume ()
2210 if ((::execution_direction != EXEC_REVERSE)
2211 && !record_is_replaying (minus_one_ptid))
2212 beneath ()->commit_resume ();
2215 /* Cancel resuming TP. */
2218 record_btrace_cancel_resume (struct thread_info *tp)
2220 enum btrace_thread_flag flags;
2222 flags = tp->btrace.flags & (BTHR_MOVE | BTHR_STOP);
2226 DEBUG ("cancel resume thread %s (%s): %x (%s)",
2227 print_thread_id (tp),
2228 target_pid_to_str (tp->ptid), flags,
2229 btrace_thread_flag_to_str (flags));
2231 tp->btrace.flags &= ~(BTHR_MOVE | BTHR_STOP);
2232 record_btrace_stop_replaying_at_end (tp);
2235 /* Return a target_waitstatus indicating that we ran out of history. */
2237 static struct target_waitstatus
2238 btrace_step_no_history (void)
2240 struct target_waitstatus status;
2242 status.kind = TARGET_WAITKIND_NO_HISTORY;
2247 /* Return a target_waitstatus indicating that a step finished. */
2249 static struct target_waitstatus
2250 btrace_step_stopped (void)
2252 struct target_waitstatus status;
2254 status.kind = TARGET_WAITKIND_STOPPED;
2255 status.value.sig = GDB_SIGNAL_TRAP;
2260 /* Return a target_waitstatus indicating that a thread was stopped as
2263 static struct target_waitstatus
2264 btrace_step_stopped_on_request (void)
2266 struct target_waitstatus status;
2268 status.kind = TARGET_WAITKIND_STOPPED;
2269 status.value.sig = GDB_SIGNAL_0;
2274 /* Return a target_waitstatus indicating a spurious stop. */
2276 static struct target_waitstatus
2277 btrace_step_spurious (void)
2279 struct target_waitstatus status;
2281 status.kind = TARGET_WAITKIND_SPURIOUS;
2286 /* Return a target_waitstatus indicating that the thread was not resumed. */
2288 static struct target_waitstatus
2289 btrace_step_no_resumed (void)
2291 struct target_waitstatus status;
2293 status.kind = TARGET_WAITKIND_NO_RESUMED;
2298 /* Return a target_waitstatus indicating that we should wait again. */
2300 static struct target_waitstatus
2301 btrace_step_again (void)
2303 struct target_waitstatus status;
2305 status.kind = TARGET_WAITKIND_IGNORE;
2310 /* Clear the record histories. */
2313 record_btrace_clear_histories (struct btrace_thread_info *btinfo)
2315 xfree (btinfo->insn_history);
2316 xfree (btinfo->call_history);
2318 btinfo->insn_history = NULL;
2319 btinfo->call_history = NULL;
2322 /* Check whether TP's current replay position is at a breakpoint. */
2325 record_btrace_replay_at_breakpoint (struct thread_info *tp)
2327 struct btrace_insn_iterator *replay;
2328 struct btrace_thread_info *btinfo;
2329 const struct btrace_insn *insn;
2331 btinfo = &tp->btrace;
2332 replay = btinfo->replay;
2337 insn = btrace_insn_get (replay);
2341 return record_check_stopped_by_breakpoint (tp->inf->aspace, insn->pc,
2342 &btinfo->stop_reason);
2345 /* Step one instruction in forward direction. */
2347 static struct target_waitstatus
2348 record_btrace_single_step_forward (struct thread_info *tp)
2350 struct btrace_insn_iterator *replay, end, start;
2351 struct btrace_thread_info *btinfo;
2353 btinfo = &tp->btrace;
2354 replay = btinfo->replay;
2356 /* We're done if we're not replaying. */
2358 return btrace_step_no_history ();
2360 /* Check if we're stepping a breakpoint. */
2361 if (record_btrace_replay_at_breakpoint (tp))
2362 return btrace_step_stopped ();
2364 /* Skip gaps during replay. If we end up at a gap (at the end of the trace),
2365 jump back to the instruction at which we started. */
2371 /* We will bail out here if we continue stepping after reaching the end
2372 of the execution history. */
2373 steps = btrace_insn_next (replay, 1);
2377 return btrace_step_no_history ();
2380 while (btrace_insn_get (replay) == NULL);
2382 /* Determine the end of the instruction trace. */
2383 btrace_insn_end (&end, btinfo);
2385 /* The execution trace contains (and ends with) the current instruction.
2386 This instruction has not been executed, yet, so the trace really ends
2387 one instruction earlier. */
2388 if (btrace_insn_cmp (replay, &end) == 0)
2389 return btrace_step_no_history ();
2391 return btrace_step_spurious ();
2394 /* Step one instruction in backward direction. */
2396 static struct target_waitstatus
2397 record_btrace_single_step_backward (struct thread_info *tp)
2399 struct btrace_insn_iterator *replay, start;
2400 struct btrace_thread_info *btinfo;
2402 btinfo = &tp->btrace;
2403 replay = btinfo->replay;
2405 /* Start replaying if we're not already doing so. */
2407 replay = record_btrace_start_replaying (tp);
2409 /* If we can't step any further, we reached the end of the history.
2410 Skip gaps during replay. If we end up at a gap (at the beginning of
2411 the trace), jump back to the instruction at which we started. */
2417 steps = btrace_insn_prev (replay, 1);
2421 return btrace_step_no_history ();
2424 while (btrace_insn_get (replay) == NULL);
2426 /* Check if we're stepping a breakpoint.
2428 For reverse-stepping, this check is after the step. There is logic in
2429 infrun.c that handles reverse-stepping separately. See, for example,
2430 proceed and adjust_pc_after_break.
2432 This code assumes that for reverse-stepping, PC points to the last
2433 de-executed instruction, whereas for forward-stepping PC points to the
2434 next to-be-executed instruction. */
2435 if (record_btrace_replay_at_breakpoint (tp))
2436 return btrace_step_stopped ();
2438 return btrace_step_spurious ();
2441 /* Step a single thread. */
2443 static struct target_waitstatus
2444 record_btrace_step_thread (struct thread_info *tp)
2446 struct btrace_thread_info *btinfo;
2447 struct target_waitstatus status;
2448 enum btrace_thread_flag flags;
2450 btinfo = &tp->btrace;
2452 flags = btinfo->flags & (BTHR_MOVE | BTHR_STOP);
2453 btinfo->flags &= ~(BTHR_MOVE | BTHR_STOP);
2455 DEBUG ("stepping thread %s (%s): %x (%s)", print_thread_id (tp),
2456 target_pid_to_str (tp->ptid), flags,
2457 btrace_thread_flag_to_str (flags));
2459 /* We can't step without an execution history. */
2460 if ((flags & BTHR_MOVE) != 0 && btrace_is_empty (tp))
2461 return btrace_step_no_history ();
2466 internal_error (__FILE__, __LINE__, _("invalid stepping type."));
2469 return btrace_step_stopped_on_request ();
2472 status = record_btrace_single_step_forward (tp);
2473 if (status.kind != TARGET_WAITKIND_SPURIOUS)
2476 return btrace_step_stopped ();
2479 status = record_btrace_single_step_backward (tp);
2480 if (status.kind != TARGET_WAITKIND_SPURIOUS)
2483 return btrace_step_stopped ();
2486 status = record_btrace_single_step_forward (tp);
2487 if (status.kind != TARGET_WAITKIND_SPURIOUS)
2490 btinfo->flags |= flags;
2491 return btrace_step_again ();
2494 status = record_btrace_single_step_backward (tp);
2495 if (status.kind != TARGET_WAITKIND_SPURIOUS)
2498 btinfo->flags |= flags;
2499 return btrace_step_again ();
2502 /* We keep threads moving at the end of their execution history. The wait
2503 method will stop the thread for whom the event is reported. */
2504 if (status.kind == TARGET_WAITKIND_NO_HISTORY)
2505 btinfo->flags |= flags;
2510 /* Announce further events if necessary. */
2513 record_btrace_maybe_mark_async_event
2514 (const std::vector<thread_info *> &moving,
2515 const std::vector<thread_info *> &no_history)
2517 bool more_moving = !moving.empty ();
2518 bool more_no_history = !no_history.empty ();;
2520 if (!more_moving && !more_no_history)
2524 DEBUG ("movers pending");
2526 if (more_no_history)
2527 DEBUG ("no-history pending");
2529 mark_async_event_handler (record_btrace_async_inferior_event_handler);
2532 /* The wait method of target record-btrace. */
2535 record_btrace_target::wait (ptid_t ptid, struct target_waitstatus *status,
2538 std::vector<thread_info *> moving;
2539 std::vector<thread_info *> no_history;
2541 DEBUG ("wait %s (0x%x)", target_pid_to_str (ptid), options);
2543 /* As long as we're not replaying, just forward the request. */
2544 if ((::execution_direction != EXEC_REVERSE)
2545 && !record_is_replaying (minus_one_ptid))
2547 return this->beneath ()->wait (ptid, status, options);
2550 /* Keep a work list of moving threads. */
2554 ALL_NON_EXITED_THREADS (tp)
2556 if (tp->ptid.matches (ptid)
2557 && ((tp->btrace.flags & (BTHR_MOVE | BTHR_STOP)) != 0))
2558 moving.push_back (tp);
2562 if (moving.empty ())
2564 *status = btrace_step_no_resumed ();
2566 DEBUG ("wait ended by %s: %s", target_pid_to_str (null_ptid),
2567 target_waitstatus_to_string (status).c_str ());
2572 /* Step moving threads one by one, one step each, until either one thread
2573 reports an event or we run out of threads to step.
2575 When stepping more than one thread, chances are that some threads reach
2576 the end of their execution history earlier than others. If we reported
2577 this immediately, all-stop on top of non-stop would stop all threads and
2578 resume the same threads next time. And we would report the same thread
2579 having reached the end of its execution history again.
2581 In the worst case, this would starve the other threads. But even if other
2582 threads would be allowed to make progress, this would result in far too
2583 many intermediate stops.
2585 We therefore delay the reporting of "no execution history" until we have
2586 nothing else to report. By this time, all threads should have moved to
2587 either the beginning or the end of their execution history. There will
2588 be a single user-visible stop. */
2589 struct thread_info *eventing = NULL;
2590 while ((eventing == NULL) && !moving.empty ())
2592 for (unsigned int ix = 0; eventing == NULL && ix < moving.size ();)
2594 thread_info *tp = moving[ix];
2596 *status = record_btrace_step_thread (tp);
2598 switch (status->kind)
2600 case TARGET_WAITKIND_IGNORE:
2604 case TARGET_WAITKIND_NO_HISTORY:
2605 no_history.push_back (ordered_remove (moving, ix));
2609 eventing = unordered_remove (moving, ix);
2615 if (eventing == NULL)
2617 /* We started with at least one moving thread. This thread must have
2618 either stopped or reached the end of its execution history.
2620 In the former case, EVENTING must not be NULL.
2621 In the latter case, NO_HISTORY must not be empty. */
2622 gdb_assert (!no_history.empty ());
2624 /* We kept threads moving at the end of their execution history. Stop
2625 EVENTING now that we are going to report its stop. */
2626 eventing = unordered_remove (no_history, 0);
2627 eventing->btrace.flags &= ~BTHR_MOVE;
2629 *status = btrace_step_no_history ();
2632 gdb_assert (eventing != NULL);
2634 /* We kept threads replaying at the end of their execution history. Stop
2635 replaying EVENTING now that we are going to report its stop. */
2636 record_btrace_stop_replaying_at_end (eventing);
2638 /* Stop all other threads. */
2639 if (!target_is_non_stop_p ())
2643 ALL_NON_EXITED_THREADS (tp)
2644 record_btrace_cancel_resume (tp);
2647 /* In async mode, we need to announce further events. */
2648 if (target_is_async_p ())
2649 record_btrace_maybe_mark_async_event (moving, no_history);
2651 /* Start record histories anew from the current position. */
2652 record_btrace_clear_histories (&eventing->btrace);
2654 /* We moved the replay position but did not update registers. */
2655 registers_changed_thread (eventing);
2657 DEBUG ("wait ended by thread %s (%s): %s",
2658 print_thread_id (eventing),
2659 target_pid_to_str (eventing->ptid),
2660 target_waitstatus_to_string (status).c_str ());
2662 return eventing->ptid;
2665 /* The stop method of target record-btrace. */
2668 record_btrace_target::stop (ptid_t ptid)
2670 DEBUG ("stop %s", target_pid_to_str (ptid));
2672 /* As long as we're not replaying, just forward the request. */
2673 if ((::execution_direction != EXEC_REVERSE)
2674 && !record_is_replaying (minus_one_ptid))
2676 this->beneath ()->stop (ptid);
2680 struct thread_info *tp;
2682 ALL_NON_EXITED_THREADS (tp)
2683 if (tp->ptid.matches (ptid))
2685 tp->btrace.flags &= ~BTHR_MOVE;
2686 tp->btrace.flags |= BTHR_STOP;
2691 /* The can_execute_reverse method of target record-btrace. */
2694 record_btrace_target::can_execute_reverse ()
2699 /* The stopped_by_sw_breakpoint method of target record-btrace. */
2702 record_btrace_target::stopped_by_sw_breakpoint ()
2704 if (record_is_replaying (minus_one_ptid))
2706 struct thread_info *tp = inferior_thread ();
2708 return tp->btrace.stop_reason == TARGET_STOPPED_BY_SW_BREAKPOINT;
2711 return this->beneath ()->stopped_by_sw_breakpoint ();
2714 /* The supports_stopped_by_sw_breakpoint method of target
2718 record_btrace_target::supports_stopped_by_sw_breakpoint ()
2720 if (record_is_replaying (minus_one_ptid))
2723 return this->beneath ()->supports_stopped_by_sw_breakpoint ();
2726 /* The stopped_by_sw_breakpoint method of target record-btrace. */
2729 record_btrace_target::stopped_by_hw_breakpoint ()
2731 if (record_is_replaying (minus_one_ptid))
2733 struct thread_info *tp = inferior_thread ();
2735 return tp->btrace.stop_reason == TARGET_STOPPED_BY_HW_BREAKPOINT;
2738 return this->beneath ()->stopped_by_hw_breakpoint ();
2741 /* The supports_stopped_by_hw_breakpoint method of target
2745 record_btrace_target::supports_stopped_by_hw_breakpoint ()
2747 if (record_is_replaying (minus_one_ptid))
2750 return this->beneath ()->supports_stopped_by_hw_breakpoint ();
2753 /* The update_thread_list method of target record-btrace. */
2756 record_btrace_target::update_thread_list ()
2758 /* We don't add or remove threads during replay. */
2759 if (record_is_replaying (minus_one_ptid))
2762 /* Forward the request. */
2763 this->beneath ()->update_thread_list ();
2766 /* The thread_alive method of target record-btrace. */
2769 record_btrace_target::thread_alive (ptid_t ptid)
2771 /* We don't add or remove threads during replay. */
2772 if (record_is_replaying (minus_one_ptid))
2775 /* Forward the request. */
2776 return this->beneath ()->thread_alive (ptid);
2779 /* Set the replay branch trace instruction iterator. If IT is NULL, replay
2783 record_btrace_set_replay (struct thread_info *tp,
2784 const struct btrace_insn_iterator *it)
2786 struct btrace_thread_info *btinfo;
2788 btinfo = &tp->btrace;
2791 record_btrace_stop_replaying (tp);
2794 if (btinfo->replay == NULL)
2795 record_btrace_start_replaying (tp);
2796 else if (btrace_insn_cmp (btinfo->replay, it) == 0)
2799 *btinfo->replay = *it;
2800 registers_changed_thread (tp);
2803 /* Start anew from the new replay position. */
2804 record_btrace_clear_histories (btinfo);
2806 inferior_thread ()->suspend.stop_pc
2807 = regcache_read_pc (get_current_regcache ());
2808 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC, 1);
2811 /* The goto_record_begin method of target record-btrace. */
2814 record_btrace_target::goto_record_begin ()
2816 struct thread_info *tp;
2817 struct btrace_insn_iterator begin;
2819 tp = require_btrace_thread ();
2821 btrace_insn_begin (&begin, &tp->btrace);
2823 /* Skip gaps at the beginning of the trace. */
2824 while (btrace_insn_get (&begin) == NULL)
2828 steps = btrace_insn_next (&begin, 1);
2830 error (_("No trace."));
2833 record_btrace_set_replay (tp, &begin);
2836 /* The goto_record_end method of target record-btrace. */
2839 record_btrace_target::goto_record_end ()
2841 struct thread_info *tp;
2843 tp = require_btrace_thread ();
2845 record_btrace_set_replay (tp, NULL);
2848 /* The goto_record method of target record-btrace. */
2851 record_btrace_target::goto_record (ULONGEST insn)
2853 struct thread_info *tp;
2854 struct btrace_insn_iterator it;
2855 unsigned int number;
2860 /* Check for wrap-arounds. */
2862 error (_("Instruction number out of range."));
2864 tp = require_btrace_thread ();
2866 found = btrace_find_insn_by_number (&it, &tp->btrace, number);
2868 /* Check if the instruction could not be found or is a gap. */
2869 if (found == 0 || btrace_insn_get (&it) == NULL)
2870 error (_("No such instruction."));
2872 record_btrace_set_replay (tp, &it);
2875 /* The record_stop_replaying method of target record-btrace. */
2878 record_btrace_target::record_stop_replaying ()
2880 struct thread_info *tp;
2882 ALL_NON_EXITED_THREADS (tp)
2883 record_btrace_stop_replaying (tp);
2886 /* The execution_direction target method. */
2888 enum exec_direction_kind
2889 record_btrace_target::execution_direction ()
2891 return record_btrace_resume_exec_dir;
2894 /* The prepare_to_generate_core target method. */
2897 record_btrace_target::prepare_to_generate_core ()
2899 record_btrace_generating_corefile = 1;
2902 /* The done_generating_core target method. */
2905 record_btrace_target::done_generating_core ()
2907 record_btrace_generating_corefile = 0;
2910 /* Start recording in BTS format. */
2913 cmd_record_btrace_bts_start (const char *args, int from_tty)
2915 if (args != NULL && *args != 0)
2916 error (_("Invalid argument."));
2918 record_btrace_conf.format = BTRACE_FORMAT_BTS;
2922 execute_command ("target record-btrace", from_tty);
2924 CATCH (exception, RETURN_MASK_ALL)
2926 record_btrace_conf.format = BTRACE_FORMAT_NONE;
2927 throw_exception (exception);
2932 /* Start recording in Intel Processor Trace format. */
2935 cmd_record_btrace_pt_start (const char *args, int from_tty)
2937 if (args != NULL && *args != 0)
2938 error (_("Invalid argument."));
2940 record_btrace_conf.format = BTRACE_FORMAT_PT;
2944 execute_command ("target record-btrace", from_tty);
2946 CATCH (exception, RETURN_MASK_ALL)
2948 record_btrace_conf.format = BTRACE_FORMAT_NONE;
2949 throw_exception (exception);
2954 /* Alias for "target record". */
2957 cmd_record_btrace_start (const char *args, int from_tty)
2959 if (args != NULL && *args != 0)
2960 error (_("Invalid argument."));
2962 record_btrace_conf.format = BTRACE_FORMAT_PT;
2966 execute_command ("target record-btrace", from_tty);
2968 CATCH (exception, RETURN_MASK_ALL)
2970 record_btrace_conf.format = BTRACE_FORMAT_BTS;
2974 execute_command ("target record-btrace", from_tty);
2976 CATCH (exception, RETURN_MASK_ALL)
2978 record_btrace_conf.format = BTRACE_FORMAT_NONE;
2979 throw_exception (exception);
2986 /* The "set record btrace" command. */
2989 cmd_set_record_btrace (const char *args, int from_tty)
2991 printf_unfiltered (_("\"set record btrace\" must be followed "
2992 "by an appropriate subcommand.\n"));
2993 help_list (set_record_btrace_cmdlist, "set record btrace ",
2994 all_commands, gdb_stdout);
2997 /* The "show record btrace" command. */
3000 cmd_show_record_btrace (const char *args, int from_tty)
3002 cmd_show_list (show_record_btrace_cmdlist, from_tty, "");
3005 /* The "show record btrace replay-memory-access" command. */
3008 cmd_show_replay_memory_access (struct ui_file *file, int from_tty,
3009 struct cmd_list_element *c, const char *value)
3011 fprintf_filtered (gdb_stdout, _("Replay memory access is %s.\n"),
3012 replay_memory_access);
3015 /* The "set record btrace cpu none" command. */
3018 cmd_set_record_btrace_cpu_none (const char *args, int from_tty)
3020 if (args != nullptr && *args != 0)
3021 error (_("Trailing junk: '%s'."), args);
3023 record_btrace_cpu_state = CS_NONE;
3026 /* The "set record btrace cpu auto" command. */
3029 cmd_set_record_btrace_cpu_auto (const char *args, int from_tty)
3031 if (args != nullptr && *args != 0)
3032 error (_("Trailing junk: '%s'."), args);
3034 record_btrace_cpu_state = CS_AUTO;
3037 /* The "set record btrace cpu" command. */
3040 cmd_set_record_btrace_cpu (const char *args, int from_tty)
3042 if (args == nullptr)
3045 /* We use a hard-coded vendor string for now. */
3046 unsigned int family, model, stepping;
3047 int l1, l2, matches = sscanf (args, "intel: %u/%u%n/%u%n", &family,
3048 &model, &l1, &stepping, &l2);
3051 if (strlen (args) != l2)
3052 error (_("Trailing junk: '%s'."), args + l2);
3054 else if (matches == 2)
3056 if (strlen (args) != l1)
3057 error (_("Trailing junk: '%s'."), args + l1);
3062 error (_("Bad format. See \"help set record btrace cpu\"."));
3064 if (USHRT_MAX < family)
3065 error (_("Cpu family too big."));
3067 if (UCHAR_MAX < model)
3068 error (_("Cpu model too big."));
3070 if (UCHAR_MAX < stepping)
3071 error (_("Cpu stepping too big."));
3073 record_btrace_cpu.vendor = CV_INTEL;
3074 record_btrace_cpu.family = family;
3075 record_btrace_cpu.model = model;
3076 record_btrace_cpu.stepping = stepping;
3078 record_btrace_cpu_state = CS_CPU;
3081 /* The "show record btrace cpu" command. */
3084 cmd_show_record_btrace_cpu (const char *args, int from_tty)
3086 if (args != nullptr && *args != 0)
3087 error (_("Trailing junk: '%s'."), args);
3089 switch (record_btrace_cpu_state)
3092 printf_unfiltered (_("btrace cpu is 'auto'.\n"));
3096 printf_unfiltered (_("btrace cpu is 'none'.\n"));
3100 switch (record_btrace_cpu.vendor)
3103 if (record_btrace_cpu.stepping == 0)
3104 printf_unfiltered (_("btrace cpu is 'intel: %u/%u'.\n"),
3105 record_btrace_cpu.family,
3106 record_btrace_cpu.model);
3108 printf_unfiltered (_("btrace cpu is 'intel: %u/%u/%u'.\n"),
3109 record_btrace_cpu.family,
3110 record_btrace_cpu.model,
3111 record_btrace_cpu.stepping);
3116 error (_("Internal error: bad cpu state."));
3119 /* The "s record btrace bts" command. */
3122 cmd_set_record_btrace_bts (const char *args, int from_tty)
3124 printf_unfiltered (_("\"set record btrace bts\" must be followed "
3125 "by an appropriate subcommand.\n"));
3126 help_list (set_record_btrace_bts_cmdlist, "set record btrace bts ",
3127 all_commands, gdb_stdout);
3130 /* The "show record btrace bts" command. */
3133 cmd_show_record_btrace_bts (const char *args, int from_tty)
3135 cmd_show_list (show_record_btrace_bts_cmdlist, from_tty, "");
3138 /* The "set record btrace pt" command. */
3141 cmd_set_record_btrace_pt (const char *args, int from_tty)
3143 printf_unfiltered (_("\"set record btrace pt\" must be followed "
3144 "by an appropriate subcommand.\n"));
3145 help_list (set_record_btrace_pt_cmdlist, "set record btrace pt ",
3146 all_commands, gdb_stdout);
3149 /* The "show record btrace pt" command. */
3152 cmd_show_record_btrace_pt (const char *args, int from_tty)
3154 cmd_show_list (show_record_btrace_pt_cmdlist, from_tty, "");
3157 /* The "record bts buffer-size" show value function. */
3160 show_record_bts_buffer_size_value (struct ui_file *file, int from_tty,
3161 struct cmd_list_element *c,
3164 fprintf_filtered (file, _("The record/replay bts buffer size is %s.\n"),
3168 /* The "record pt buffer-size" show value function. */
3171 show_record_pt_buffer_size_value (struct ui_file *file, int from_tty,
3172 struct cmd_list_element *c,
3175 fprintf_filtered (file, _("The record/replay pt buffer size is %s.\n"),
3179 /* Initialize btrace commands. */
3182 _initialize_record_btrace (void)
3184 add_prefix_cmd ("btrace", class_obscure, cmd_record_btrace_start,
3185 _("Start branch trace recording."), &record_btrace_cmdlist,
3186 "record btrace ", 0, &record_cmdlist);
3187 add_alias_cmd ("b", "btrace", class_obscure, 1, &record_cmdlist);
3189 add_cmd ("bts", class_obscure, cmd_record_btrace_bts_start,
3191 Start branch trace recording in Branch Trace Store (BTS) format.\n\n\
3192 The processor stores a from/to record for each branch into a cyclic buffer.\n\
3193 This format may not be available on all processors."),
3194 &record_btrace_cmdlist);
3195 add_alias_cmd ("bts", "btrace bts", class_obscure, 1, &record_cmdlist);
3197 add_cmd ("pt", class_obscure, cmd_record_btrace_pt_start,
3199 Start branch trace recording in Intel Processor Trace format.\n\n\
3200 This format may not be available on all processors."),
3201 &record_btrace_cmdlist);
3202 add_alias_cmd ("pt", "btrace pt", class_obscure, 1, &record_cmdlist);
3204 add_prefix_cmd ("btrace", class_support, cmd_set_record_btrace,
3205 _("Set record options"), &set_record_btrace_cmdlist,
3206 "set record btrace ", 0, &set_record_cmdlist);
3208 add_prefix_cmd ("btrace", class_support, cmd_show_record_btrace,
3209 _("Show record options"), &show_record_btrace_cmdlist,
3210 "show record btrace ", 0, &show_record_cmdlist);
3212 add_setshow_enum_cmd ("replay-memory-access", no_class,
3213 replay_memory_access_types, &replay_memory_access, _("\
3214 Set what memory accesses are allowed during replay."), _("\
3215 Show what memory accesses are allowed during replay."),
3216 _("Default is READ-ONLY.\n\n\
3217 The btrace record target does not trace data.\n\
3218 The memory therefore corresponds to the live target and not \
3219 to the current replay position.\n\n\
3220 When READ-ONLY, allow accesses to read-only memory during replay.\n\
3221 When READ-WRITE, allow accesses to read-only and read-write memory during \
3223 NULL, cmd_show_replay_memory_access,
3224 &set_record_btrace_cmdlist,
3225 &show_record_btrace_cmdlist);
3227 add_prefix_cmd ("cpu", class_support, cmd_set_record_btrace_cpu,
3229 Set the cpu to be used for trace decode.\n\n\
3230 The format is \"VENDOR:IDENTIFIER\" or \"none\" or \"auto\" (default).\n\
3231 For vendor \"intel\" the format is \"FAMILY/MODEL[/STEPPING]\".\n\n\
3232 When decoding branch trace, enable errata workarounds for the specified cpu.\n\
3233 The default is \"auto\", which uses the cpu on which the trace was recorded.\n\
3234 When GDB does not support that cpu, this option can be used to enable\n\
3235 workarounds for a similar cpu that GDB supports.\n\n\
3236 When set to \"none\", errata workarounds are disabled."),
3237 &set_record_btrace_cpu_cmdlist,
3238 _("set record btrace cpu "), 1,
3239 &set_record_btrace_cmdlist);
3241 add_cmd ("auto", class_support, cmd_set_record_btrace_cpu_auto, _("\
3242 Automatically determine the cpu to be used for trace decode."),
3243 &set_record_btrace_cpu_cmdlist);
3245 add_cmd ("none", class_support, cmd_set_record_btrace_cpu_none, _("\
3246 Do not enable errata workarounds for trace decode."),
3247 &set_record_btrace_cpu_cmdlist);
3249 add_cmd ("cpu", class_support, cmd_show_record_btrace_cpu, _("\
3250 Show the cpu to be used for trace decode."),
3251 &show_record_btrace_cmdlist);
3253 add_prefix_cmd ("bts", class_support, cmd_set_record_btrace_bts,
3254 _("Set record btrace bts options"),
3255 &set_record_btrace_bts_cmdlist,
3256 "set record btrace bts ", 0, &set_record_btrace_cmdlist);
3258 add_prefix_cmd ("bts", class_support, cmd_show_record_btrace_bts,
3259 _("Show record btrace bts options"),
3260 &show_record_btrace_bts_cmdlist,
3261 "show record btrace bts ", 0, &show_record_btrace_cmdlist);
3263 add_setshow_uinteger_cmd ("buffer-size", no_class,
3264 &record_btrace_conf.bts.size,
3265 _("Set the record/replay bts buffer size."),
3266 _("Show the record/replay bts buffer size."), _("\
3267 When starting recording request a trace buffer of this size. \
3268 The actual buffer size may differ from the requested size. \
3269 Use \"info record\" to see the actual buffer size.\n\n\
3270 Bigger buffers allow longer recording but also take more time to process \
3271 the recorded execution trace.\n\n\
3272 The trace buffer size may not be changed while recording."), NULL,
3273 show_record_bts_buffer_size_value,
3274 &set_record_btrace_bts_cmdlist,
3275 &show_record_btrace_bts_cmdlist);
3277 add_prefix_cmd ("pt", class_support, cmd_set_record_btrace_pt,
3278 _("Set record btrace pt options"),
3279 &set_record_btrace_pt_cmdlist,
3280 "set record btrace pt ", 0, &set_record_btrace_cmdlist);
3282 add_prefix_cmd ("pt", class_support, cmd_show_record_btrace_pt,
3283 _("Show record btrace pt options"),
3284 &show_record_btrace_pt_cmdlist,
3285 "show record btrace pt ", 0, &show_record_btrace_cmdlist);
3287 add_setshow_uinteger_cmd ("buffer-size", no_class,
3288 &record_btrace_conf.pt.size,
3289 _("Set the record/replay pt buffer size."),
3290 _("Show the record/replay pt buffer size."), _("\
3291 Bigger buffers allow longer recording but also take more time to process \
3292 the recorded execution.\n\
3293 The actual buffer size may differ from the requested size. Use \"info record\" \
3294 to see the actual buffer size."), NULL, show_record_pt_buffer_size_value,
3295 &set_record_btrace_pt_cmdlist,
3296 &show_record_btrace_pt_cmdlist);
3298 add_target (record_btrace_target_info, record_btrace_target_open);
3300 bfcache = htab_create_alloc (50, bfcache_hash, bfcache_eq, NULL,
3303 record_btrace_conf.bts.size = 64 * 1024;
3304 record_btrace_conf.pt.size = 16 * 1024;