1 /* Branch trace support for GDB, the GNU debugger.
3 Copyright (C) 2013-2017 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"
30 #include "cli/cli-utils.h"
34 #include "filenames.h"
36 #include "frame-unwind.h"
39 #include "event-loop.h"
44 /* The target_ops of record-btrace. */
45 static struct target_ops record_btrace_ops;
47 /* A new thread observer enabling branch tracing for the new thread. */
48 static struct observer *record_btrace_thread_observer;
50 /* Memory access types used in set/show record btrace replay-memory-access. */
51 static const char replay_memory_access_read_only[] = "read-only";
52 static const char replay_memory_access_read_write[] = "read-write";
53 static const char *const replay_memory_access_types[] =
55 replay_memory_access_read_only,
56 replay_memory_access_read_write,
60 /* The currently allowed replay memory access type. */
61 static const char *replay_memory_access = replay_memory_access_read_only;
63 /* Command lists for "set/show record btrace". */
64 static struct cmd_list_element *set_record_btrace_cmdlist;
65 static struct cmd_list_element *show_record_btrace_cmdlist;
67 /* The execution direction of the last resume we got. See record-full.c. */
68 static enum exec_direction_kind record_btrace_resume_exec_dir = EXEC_FORWARD;
70 /* The async event handler for reverse/replay execution. */
71 static struct async_event_handler *record_btrace_async_inferior_event_handler;
73 /* A flag indicating that we are currently generating a core file. */
74 static int record_btrace_generating_corefile;
76 /* The current branch trace configuration. */
77 static struct btrace_config record_btrace_conf;
79 /* Command list for "record btrace". */
80 static struct cmd_list_element *record_btrace_cmdlist;
82 /* Command lists for "set/show record btrace bts". */
83 static struct cmd_list_element *set_record_btrace_bts_cmdlist;
84 static struct cmd_list_element *show_record_btrace_bts_cmdlist;
86 /* Command lists for "set/show record btrace pt". */
87 static struct cmd_list_element *set_record_btrace_pt_cmdlist;
88 static struct cmd_list_element *show_record_btrace_pt_cmdlist;
90 /* Print a record-btrace debug message. Use do ... while (0) to avoid
91 ambiguities when used in if statements. */
93 #define DEBUG(msg, args...) \
96 if (record_debug != 0) \
97 fprintf_unfiltered (gdb_stdlog, \
98 "[record-btrace] " msg "\n", ##args); \
103 /* Update the branch trace for the current thread and return a pointer to its
106 Throws an error if there is no thread or no trace. This function never
109 static struct thread_info *
110 require_btrace_thread (void)
112 struct thread_info *tp;
116 tp = find_thread_ptid (inferior_ptid);
118 error (_("No thread."));
120 validate_registers_access ();
124 if (btrace_is_empty (tp))
125 error (_("No trace."));
130 /* Update the branch trace for the current thread and return a pointer to its
131 branch trace information struct.
133 Throws an error if there is no thread or no trace. This function never
136 static struct btrace_thread_info *
137 require_btrace (void)
139 struct thread_info *tp;
141 tp = require_btrace_thread ();
146 /* Enable branch tracing for one thread. Warn on errors. */
149 record_btrace_enable_warn (struct thread_info *tp)
153 btrace_enable (tp, &record_btrace_conf);
155 CATCH (error, RETURN_MASK_ERROR)
157 warning ("%s", error.message);
162 /* Callback function to disable branch tracing for one thread. */
165 record_btrace_disable_callback (void *arg)
167 struct thread_info *tp = (struct thread_info *) arg;
172 /* Enable automatic tracing of new threads. */
175 record_btrace_auto_enable (void)
177 DEBUG ("attach thread observer");
179 record_btrace_thread_observer
180 = observer_attach_new_thread (record_btrace_enable_warn);
183 /* Disable automatic tracing of new threads. */
186 record_btrace_auto_disable (void)
188 /* The observer may have been detached, already. */
189 if (record_btrace_thread_observer == NULL)
192 DEBUG ("detach thread observer");
194 observer_detach_new_thread (record_btrace_thread_observer);
195 record_btrace_thread_observer = NULL;
198 /* The record-btrace async event handler function. */
201 record_btrace_handle_async_inferior_event (gdb_client_data data)
203 inferior_event_handler (INF_REG_EVENT, NULL);
206 /* See record-btrace.h. */
209 record_btrace_push_target (void)
213 record_btrace_auto_enable ();
215 push_target (&record_btrace_ops);
217 record_btrace_async_inferior_event_handler
218 = create_async_event_handler (record_btrace_handle_async_inferior_event,
220 record_btrace_generating_corefile = 0;
222 format = btrace_format_short_string (record_btrace_conf.format);
223 observer_notify_record_changed (current_inferior (), 1, "btrace", format);
226 /* The to_open method of target record-btrace. */
229 record_btrace_open (const char *args, int from_tty)
231 struct cleanup *disable_chain;
232 struct thread_info *tp;
238 if (!target_has_execution)
239 error (_("The program is not being run."));
241 gdb_assert (record_btrace_thread_observer == NULL);
243 disable_chain = make_cleanup (null_cleanup, NULL);
244 ALL_NON_EXITED_THREADS (tp)
245 if (args == NULL || *args == 0 || number_is_in_list (args, tp->global_num))
247 btrace_enable (tp, &record_btrace_conf);
249 make_cleanup (record_btrace_disable_callback, tp);
252 record_btrace_push_target ();
254 discard_cleanups (disable_chain);
257 /* The to_stop_recording method of target record-btrace. */
260 record_btrace_stop_recording (struct target_ops *self)
262 struct thread_info *tp;
264 DEBUG ("stop recording");
266 record_btrace_auto_disable ();
268 ALL_NON_EXITED_THREADS (tp)
269 if (tp->btrace.target != NULL)
273 /* The to_disconnect method of target record-btrace. */
276 record_btrace_disconnect (struct target_ops *self, const char *args,
279 struct target_ops *beneath = self->beneath;
281 /* Do not stop recording, just clean up GDB side. */
282 unpush_target (self);
284 /* Forward disconnect. */
285 beneath->to_disconnect (beneath, args, from_tty);
288 /* The to_close method of target record-btrace. */
291 record_btrace_close (struct target_ops *self)
293 struct thread_info *tp;
295 if (record_btrace_async_inferior_event_handler != NULL)
296 delete_async_event_handler (&record_btrace_async_inferior_event_handler);
298 /* Make sure automatic recording gets disabled even if we did not stop
299 recording before closing the record-btrace target. */
300 record_btrace_auto_disable ();
302 /* We should have already stopped recording.
303 Tear down btrace in case we have not. */
304 ALL_NON_EXITED_THREADS (tp)
305 btrace_teardown (tp);
308 /* The to_async method of target record-btrace. */
311 record_btrace_async (struct target_ops *ops, int enable)
314 mark_async_event_handler (record_btrace_async_inferior_event_handler);
316 clear_async_event_handler (record_btrace_async_inferior_event_handler);
318 ops->beneath->to_async (ops->beneath, enable);
321 /* Adjusts the size and returns a human readable size suffix. */
324 record_btrace_adjust_size (unsigned int *size)
330 if ((sz & ((1u << 30) - 1)) == 0)
335 else if ((sz & ((1u << 20) - 1)) == 0)
340 else if ((sz & ((1u << 10) - 1)) == 0)
349 /* Print a BTS configuration. */
352 record_btrace_print_bts_conf (const struct btrace_config_bts *conf)
360 suffix = record_btrace_adjust_size (&size);
361 printf_unfiltered (_("Buffer size: %u%s.\n"), size, suffix);
365 /* Print an Intel Processor Trace configuration. */
368 record_btrace_print_pt_conf (const struct btrace_config_pt *conf)
376 suffix = record_btrace_adjust_size (&size);
377 printf_unfiltered (_("Buffer size: %u%s.\n"), size, suffix);
381 /* Print a branch tracing configuration. */
384 record_btrace_print_conf (const struct btrace_config *conf)
386 printf_unfiltered (_("Recording format: %s.\n"),
387 btrace_format_string (conf->format));
389 switch (conf->format)
391 case BTRACE_FORMAT_NONE:
394 case BTRACE_FORMAT_BTS:
395 record_btrace_print_bts_conf (&conf->bts);
398 case BTRACE_FORMAT_PT:
399 record_btrace_print_pt_conf (&conf->pt);
403 internal_error (__FILE__, __LINE__, _("Unkown branch trace format."));
406 /* The to_info_record method of target record-btrace. */
409 record_btrace_info (struct target_ops *self)
411 struct btrace_thread_info *btinfo;
412 const struct btrace_config *conf;
413 struct thread_info *tp;
414 unsigned int insns, calls, gaps;
418 tp = find_thread_ptid (inferior_ptid);
420 error (_("No thread."));
422 validate_registers_access ();
424 btinfo = &tp->btrace;
426 conf = btrace_conf (btinfo);
428 record_btrace_print_conf (conf);
436 if (!btrace_is_empty (tp))
438 struct btrace_call_iterator call;
439 struct btrace_insn_iterator insn;
441 btrace_call_end (&call, btinfo);
442 btrace_call_prev (&call, 1);
443 calls = btrace_call_number (&call);
445 btrace_insn_end (&insn, btinfo);
446 insns = btrace_insn_number (&insn);
448 /* If the last instruction is not a gap, it is the current instruction
449 that is not actually part of the record. */
450 if (btrace_insn_get (&insn) != NULL)
453 gaps = btinfo->ngaps;
456 printf_unfiltered (_("Recorded %u instructions in %u functions (%u gaps) "
457 "for thread %s (%s).\n"), insns, calls, gaps,
458 print_thread_id (tp), target_pid_to_str (tp->ptid));
460 if (btrace_is_replaying (tp))
461 printf_unfiltered (_("Replay in progress. At instruction %u.\n"),
462 btrace_insn_number (btinfo->replay));
465 /* Print a decode error. */
468 btrace_ui_out_decode_error (struct ui_out *uiout, int errcode,
469 enum btrace_format format)
471 const char *errstr = btrace_decode_error (format, errcode);
473 uiout->text (_("["));
474 /* ERRCODE > 0 indicates notifications on BTRACE_FORMAT_PT. */
475 if (!(format == BTRACE_FORMAT_PT && errcode > 0))
477 uiout->text (_("decode error ("));
478 uiout->field_int ("errcode", errcode);
479 uiout->text (_("): "));
481 uiout->text (errstr);
482 uiout->text (_("]\n"));
485 /* Print an unsigned int. */
488 ui_out_field_uint (struct ui_out *uiout, const char *fld, unsigned int val)
490 uiout->field_fmt (fld, "%u", val);
493 /* A range of source lines. */
495 struct btrace_line_range
497 /* The symtab this line is from. */
498 struct symtab *symtab;
500 /* The first line (inclusive). */
503 /* The last line (exclusive). */
507 /* Construct a line range. */
509 static struct btrace_line_range
510 btrace_mk_line_range (struct symtab *symtab, int begin, int end)
512 struct btrace_line_range range;
514 range.symtab = symtab;
521 /* Add a line to a line range. */
523 static struct btrace_line_range
524 btrace_line_range_add (struct btrace_line_range range, int line)
526 if (range.end <= range.begin)
528 /* This is the first entry. */
530 range.end = line + 1;
532 else if (line < range.begin)
534 else if (range.end < line)
540 /* Return non-zero if RANGE is empty, zero otherwise. */
543 btrace_line_range_is_empty (struct btrace_line_range range)
545 return range.end <= range.begin;
548 /* Return non-zero if LHS contains RHS, zero otherwise. */
551 btrace_line_range_contains_range (struct btrace_line_range lhs,
552 struct btrace_line_range rhs)
554 return ((lhs.symtab == rhs.symtab)
555 && (lhs.begin <= rhs.begin)
556 && (rhs.end <= lhs.end));
559 /* Find the line range associated with PC. */
561 static struct btrace_line_range
562 btrace_find_line_range (CORE_ADDR pc)
564 struct btrace_line_range range;
565 struct linetable_entry *lines;
566 struct linetable *ltable;
567 struct symtab *symtab;
570 symtab = find_pc_line_symtab (pc);
572 return btrace_mk_line_range (NULL, 0, 0);
574 ltable = SYMTAB_LINETABLE (symtab);
576 return btrace_mk_line_range (symtab, 0, 0);
578 nlines = ltable->nitems;
579 lines = ltable->item;
581 return btrace_mk_line_range (symtab, 0, 0);
583 range = btrace_mk_line_range (symtab, 0, 0);
584 for (i = 0; i < nlines - 1; i++)
586 if ((lines[i].pc == pc) && (lines[i].line != 0))
587 range = btrace_line_range_add (range, lines[i].line);
593 /* Print source lines in LINES to UIOUT.
595 UI_ITEM_CHAIN is a cleanup chain for the last source line and the
596 instructions corresponding to that source line. When printing a new source
597 line, we do the cleanups for the open chain and open a new cleanup chain for
598 the new source line. If the source line range in LINES is not empty, this
599 function will leave the cleanup chain for the last printed source line open
600 so instructions can be added to it. */
603 btrace_print_lines (struct btrace_line_range lines, struct ui_out *uiout,
604 struct cleanup **ui_item_chain, int flags)
606 print_source_lines_flags psl_flags;
610 if (flags & DISASSEMBLY_FILENAME)
611 psl_flags |= PRINT_SOURCE_LINES_FILENAME;
613 for (line = lines.begin; line < lines.end; ++line)
615 if (*ui_item_chain != NULL)
616 do_cleanups (*ui_item_chain);
619 = make_cleanup_ui_out_tuple_begin_end (uiout, "src_and_asm_line");
621 print_source_lines (lines.symtab, line, line + 1, psl_flags);
623 make_cleanup_ui_out_list_begin_end (uiout, "line_asm_insn");
627 /* Disassemble a section of the recorded instruction trace. */
630 btrace_insn_history (struct ui_out *uiout,
631 const struct btrace_thread_info *btinfo,
632 const struct btrace_insn_iterator *begin,
633 const struct btrace_insn_iterator *end, int flags)
635 struct cleanup *cleanups, *ui_item_chain;
636 struct gdbarch *gdbarch;
637 struct btrace_insn_iterator it;
638 struct btrace_line_range last_lines;
640 DEBUG ("itrace (0x%x): [%u; %u)", flags, btrace_insn_number (begin),
641 btrace_insn_number (end));
643 flags |= DISASSEMBLY_SPECULATIVE;
645 gdbarch = target_gdbarch ();
646 last_lines = btrace_mk_line_range (NULL, 0, 0);
648 cleanups = make_cleanup_ui_out_list_begin_end (uiout, "asm_insns");
650 /* UI_ITEM_CHAIN is a cleanup chain for the last source line and the
651 instructions corresponding to that line. */
652 ui_item_chain = NULL;
654 gdb_pretty_print_disassembler disasm (gdbarch);
656 for (it = *begin; btrace_insn_cmp (&it, end) != 0; btrace_insn_next (&it, 1))
658 const struct btrace_insn *insn;
660 insn = btrace_insn_get (&it);
662 /* A NULL instruction indicates a gap in the trace. */
665 const struct btrace_config *conf;
667 conf = btrace_conf (btinfo);
669 /* We have trace so we must have a configuration. */
670 gdb_assert (conf != NULL);
672 uiout->field_fmt ("insn-number", "%u",
673 btrace_insn_number (&it));
676 btrace_ui_out_decode_error (uiout, btrace_insn_get_error (&it),
681 struct disasm_insn dinsn;
683 if ((flags & DISASSEMBLY_SOURCE) != 0)
685 struct btrace_line_range lines;
687 lines = btrace_find_line_range (insn->pc);
688 if (!btrace_line_range_is_empty (lines)
689 && !btrace_line_range_contains_range (last_lines, lines))
691 btrace_print_lines (lines, uiout, &ui_item_chain, flags);
694 else if (ui_item_chain == NULL)
697 = make_cleanup_ui_out_tuple_begin_end (uiout,
699 /* No source information. */
700 make_cleanup_ui_out_list_begin_end (uiout, "line_asm_insn");
703 gdb_assert (ui_item_chain != NULL);
706 memset (&dinsn, 0, sizeof (dinsn));
707 dinsn.number = btrace_insn_number (&it);
708 dinsn.addr = insn->pc;
710 if ((insn->flags & BTRACE_INSN_FLAG_SPECULATIVE) != 0)
711 dinsn.is_speculative = 1;
713 disasm.pretty_print_insn (uiout, &dinsn, flags);
717 do_cleanups (cleanups);
720 /* The to_insn_history method of target record-btrace. */
723 record_btrace_insn_history (struct target_ops *self, int size, int flags)
725 struct btrace_thread_info *btinfo;
726 struct btrace_insn_history *history;
727 struct btrace_insn_iterator begin, end;
728 struct ui_out *uiout;
729 unsigned int context, covered;
731 uiout = current_uiout;
732 ui_out_emit_tuple tuple_emitter (uiout, "insn history");
733 context = abs (size);
735 error (_("Bad record instruction-history-size."));
737 btinfo = require_btrace ();
738 history = btinfo->insn_history;
741 struct btrace_insn_iterator *replay;
743 DEBUG ("insn-history (0x%x): %d", flags, size);
745 /* If we're replaying, we start at the replay position. Otherwise, we
746 start at the tail of the trace. */
747 replay = btinfo->replay;
751 btrace_insn_end (&begin, btinfo);
753 /* We start from here and expand in the requested direction. Then we
754 expand in the other direction, as well, to fill up any remaining
759 /* We want the current position covered, as well. */
760 covered = btrace_insn_next (&end, 1);
761 covered += btrace_insn_prev (&begin, context - covered);
762 covered += btrace_insn_next (&end, context - covered);
766 covered = btrace_insn_next (&end, context);
767 covered += btrace_insn_prev (&begin, context - covered);
772 begin = history->begin;
775 DEBUG ("insn-history (0x%x): %d, prev: [%u; %u)", flags, size,
776 btrace_insn_number (&begin), btrace_insn_number (&end));
781 covered = btrace_insn_prev (&begin, context);
786 covered = btrace_insn_next (&end, context);
791 btrace_insn_history (uiout, btinfo, &begin, &end, flags);
795 printf_unfiltered (_("At the start of the branch trace record.\n"));
797 printf_unfiltered (_("At the end of the branch trace record.\n"));
800 btrace_set_insn_history (btinfo, &begin, &end);
803 /* The to_insn_history_range method of target record-btrace. */
806 record_btrace_insn_history_range (struct target_ops *self,
807 ULONGEST from, ULONGEST to, int flags)
809 struct btrace_thread_info *btinfo;
810 struct btrace_insn_history *history;
811 struct btrace_insn_iterator begin, end;
812 struct ui_out *uiout;
813 unsigned int low, high;
816 uiout = current_uiout;
817 ui_out_emit_tuple tuple_emitter (uiout, "insn history");
821 DEBUG ("insn-history (0x%x): [%u; %u)", flags, low, high);
823 /* Check for wrap-arounds. */
824 if (low != from || high != to)
825 error (_("Bad range."));
828 error (_("Bad range."));
830 btinfo = require_btrace ();
832 found = btrace_find_insn_by_number (&begin, btinfo, low);
834 error (_("Range out of bounds."));
836 found = btrace_find_insn_by_number (&end, btinfo, high);
839 /* Silently truncate the range. */
840 btrace_insn_end (&end, btinfo);
844 /* We want both begin and end to be inclusive. */
845 btrace_insn_next (&end, 1);
848 btrace_insn_history (uiout, btinfo, &begin, &end, flags);
849 btrace_set_insn_history (btinfo, &begin, &end);
852 /* The to_insn_history_from method of target record-btrace. */
855 record_btrace_insn_history_from (struct target_ops *self,
856 ULONGEST from, int size, int flags)
858 ULONGEST begin, end, context;
860 context = abs (size);
862 error (_("Bad record instruction-history-size."));
871 begin = from - context + 1;
876 end = from + context - 1;
878 /* Check for wrap-around. */
883 record_btrace_insn_history_range (self, begin, end, flags);
886 /* Print the instruction number range for a function call history line. */
889 btrace_call_history_insn_range (struct ui_out *uiout,
890 const struct btrace_function *bfun)
892 unsigned int begin, end, size;
894 size = VEC_length (btrace_insn_s, bfun->insn);
895 gdb_assert (size > 0);
897 begin = bfun->insn_offset;
898 end = begin + size - 1;
900 ui_out_field_uint (uiout, "insn begin", begin);
902 ui_out_field_uint (uiout, "insn end", end);
905 /* Compute the lowest and highest source line for the instructions in BFUN
906 and return them in PBEGIN and PEND.
907 Ignore instructions that can't be mapped to BFUN, e.g. instructions that
908 result from inlining or macro expansion. */
911 btrace_compute_src_line_range (const struct btrace_function *bfun,
912 int *pbegin, int *pend)
914 struct btrace_insn *insn;
915 struct symtab *symtab;
927 symtab = symbol_symtab (sym);
929 for (idx = 0; VEC_iterate (btrace_insn_s, bfun->insn, idx, insn); ++idx)
931 struct symtab_and_line sal;
933 sal = find_pc_line (insn->pc, 0);
934 if (sal.symtab != symtab || sal.line == 0)
937 begin = std::min (begin, sal.line);
938 end = std::max (end, sal.line);
946 /* Print the source line information for a function call history line. */
949 btrace_call_history_src_line (struct ui_out *uiout,
950 const struct btrace_function *bfun)
959 uiout->field_string ("file",
960 symtab_to_filename_for_display (symbol_symtab (sym)));
962 btrace_compute_src_line_range (bfun, &begin, &end);
967 uiout->field_int ("min line", begin);
973 uiout->field_int ("max line", end);
976 /* Get the name of a branch trace function. */
979 btrace_get_bfun_name (const struct btrace_function *bfun)
981 struct minimal_symbol *msym;
991 return SYMBOL_PRINT_NAME (sym);
992 else if (msym != NULL)
993 return MSYMBOL_PRINT_NAME (msym);
998 /* Disassemble a section of the recorded function trace. */
1001 btrace_call_history (struct ui_out *uiout,
1002 const struct btrace_thread_info *btinfo,
1003 const struct btrace_call_iterator *begin,
1004 const struct btrace_call_iterator *end,
1007 struct btrace_call_iterator it;
1008 record_print_flags flags = (enum record_print_flag) int_flags;
1010 DEBUG ("ftrace (0x%x): [%u; %u)", int_flags, btrace_call_number (begin),
1011 btrace_call_number (end));
1013 for (it = *begin; btrace_call_cmp (&it, end) < 0; btrace_call_next (&it, 1))
1015 const struct btrace_function *bfun;
1016 struct minimal_symbol *msym;
1019 bfun = btrace_call_get (&it);
1023 /* Print the function index. */
1024 ui_out_field_uint (uiout, "index", bfun->number);
1027 /* Indicate gaps in the trace. */
1028 if (bfun->errcode != 0)
1030 const struct btrace_config *conf;
1032 conf = btrace_conf (btinfo);
1034 /* We have trace so we must have a configuration. */
1035 gdb_assert (conf != NULL);
1037 btrace_ui_out_decode_error (uiout, bfun->errcode, conf->format);
1042 if ((flags & RECORD_PRINT_INDENT_CALLS) != 0)
1044 int level = bfun->level + btinfo->level, i;
1046 for (i = 0; i < level; ++i)
1051 uiout->field_string ("function", SYMBOL_PRINT_NAME (sym));
1052 else if (msym != NULL)
1053 uiout->field_string ("function", MSYMBOL_PRINT_NAME (msym));
1054 else if (!uiout->is_mi_like_p ())
1055 uiout->field_string ("function", "??");
1057 if ((flags & RECORD_PRINT_INSN_RANGE) != 0)
1059 uiout->text (_("\tinst "));
1060 btrace_call_history_insn_range (uiout, bfun);
1063 if ((flags & RECORD_PRINT_SRC_LINE) != 0)
1065 uiout->text (_("\tat "));
1066 btrace_call_history_src_line (uiout, bfun);
1073 /* The to_call_history method of target record-btrace. */
1076 record_btrace_call_history (struct target_ops *self, int size, int int_flags)
1078 struct btrace_thread_info *btinfo;
1079 struct btrace_call_history *history;
1080 struct btrace_call_iterator begin, end;
1081 struct ui_out *uiout;
1082 unsigned int context, covered;
1083 record_print_flags flags = (enum record_print_flag) int_flags;
1085 uiout = current_uiout;
1086 ui_out_emit_tuple tuple_emitter (uiout, "insn history");
1087 context = abs (size);
1089 error (_("Bad record function-call-history-size."));
1091 btinfo = require_btrace ();
1092 history = btinfo->call_history;
1093 if (history == NULL)
1095 struct btrace_insn_iterator *replay;
1097 DEBUG ("call-history (0x%x): %d", int_flags, size);
1099 /* If we're replaying, we start at the replay position. Otherwise, we
1100 start at the tail of the trace. */
1101 replay = btinfo->replay;
1104 begin.btinfo = btinfo;
1105 begin.index = replay->call_index;
1108 btrace_call_end (&begin, btinfo);
1110 /* We start from here and expand in the requested direction. Then we
1111 expand in the other direction, as well, to fill up any remaining
1116 /* We want the current position covered, as well. */
1117 covered = btrace_call_next (&end, 1);
1118 covered += btrace_call_prev (&begin, context - covered);
1119 covered += btrace_call_next (&end, context - covered);
1123 covered = btrace_call_next (&end, context);
1124 covered += btrace_call_prev (&begin, context- covered);
1129 begin = history->begin;
1132 DEBUG ("call-history (0x%x): %d, prev: [%u; %u)", int_flags, size,
1133 btrace_call_number (&begin), btrace_call_number (&end));
1138 covered = btrace_call_prev (&begin, context);
1143 covered = btrace_call_next (&end, context);
1148 btrace_call_history (uiout, btinfo, &begin, &end, flags);
1152 printf_unfiltered (_("At the start of the branch trace record.\n"));
1154 printf_unfiltered (_("At the end of the branch trace record.\n"));
1157 btrace_set_call_history (btinfo, &begin, &end);
1160 /* The to_call_history_range method of target record-btrace. */
1163 record_btrace_call_history_range (struct target_ops *self,
1164 ULONGEST from, ULONGEST to,
1167 struct btrace_thread_info *btinfo;
1168 struct btrace_call_history *history;
1169 struct btrace_call_iterator begin, end;
1170 struct ui_out *uiout;
1171 unsigned int low, high;
1173 record_print_flags flags = (enum record_print_flag) int_flags;
1175 uiout = current_uiout;
1176 ui_out_emit_tuple tuple_emitter (uiout, "func history");
1180 DEBUG ("call-history (0x%x): [%u; %u)", int_flags, low, high);
1182 /* Check for wrap-arounds. */
1183 if (low != from || high != to)
1184 error (_("Bad range."));
1187 error (_("Bad range."));
1189 btinfo = require_btrace ();
1191 found = btrace_find_call_by_number (&begin, btinfo, low);
1193 error (_("Range out of bounds."));
1195 found = btrace_find_call_by_number (&end, btinfo, high);
1198 /* Silently truncate the range. */
1199 btrace_call_end (&end, btinfo);
1203 /* We want both begin and end to be inclusive. */
1204 btrace_call_next (&end, 1);
1207 btrace_call_history (uiout, btinfo, &begin, &end, flags);
1208 btrace_set_call_history (btinfo, &begin, &end);
1211 /* The to_call_history_from method of target record-btrace. */
1214 record_btrace_call_history_from (struct target_ops *self,
1215 ULONGEST from, int size,
1218 ULONGEST begin, end, context;
1219 record_print_flags flags = (enum record_print_flag) int_flags;
1221 context = abs (size);
1223 error (_("Bad record function-call-history-size."));
1232 begin = from - context + 1;
1237 end = from + context - 1;
1239 /* Check for wrap-around. */
1244 record_btrace_call_history_range (self, begin, end, flags);
1247 /* The to_record_method method of target record-btrace. */
1249 static enum record_method
1250 record_btrace_record_method (struct target_ops *self, ptid_t ptid)
1252 const struct btrace_config *config;
1253 struct thread_info * const tp = find_thread_ptid (ptid);
1256 error (_("No thread."));
1258 if (tp->btrace.target == NULL)
1259 return RECORD_METHOD_NONE;
1261 return RECORD_METHOD_BTRACE;
1264 /* The to_record_is_replaying method of target record-btrace. */
1267 record_btrace_is_replaying (struct target_ops *self, ptid_t ptid)
1269 struct thread_info *tp;
1271 ALL_NON_EXITED_THREADS (tp)
1272 if (ptid_match (tp->ptid, ptid) && btrace_is_replaying (tp))
1278 /* The to_record_will_replay method of target record-btrace. */
1281 record_btrace_will_replay (struct target_ops *self, ptid_t ptid, int dir)
1283 return dir == EXEC_REVERSE || record_btrace_is_replaying (self, ptid);
1286 /* The to_xfer_partial method of target record-btrace. */
1288 static enum target_xfer_status
1289 record_btrace_xfer_partial (struct target_ops *ops, enum target_object object,
1290 const char *annex, gdb_byte *readbuf,
1291 const gdb_byte *writebuf, ULONGEST offset,
1292 ULONGEST len, ULONGEST *xfered_len)
1294 struct target_ops *t;
1296 /* Filter out requests that don't make sense during replay. */
1297 if (replay_memory_access == replay_memory_access_read_only
1298 && !record_btrace_generating_corefile
1299 && record_btrace_is_replaying (ops, inferior_ptid))
1303 case TARGET_OBJECT_MEMORY:
1305 struct target_section *section;
1307 /* We do not allow writing memory in general. */
1308 if (writebuf != NULL)
1311 return TARGET_XFER_UNAVAILABLE;
1314 /* We allow reading readonly memory. */
1315 section = target_section_by_addr (ops, offset);
1316 if (section != NULL)
1318 /* Check if the section we found is readonly. */
1319 if ((bfd_get_section_flags (section->the_bfd_section->owner,
1320 section->the_bfd_section)
1321 & SEC_READONLY) != 0)
1323 /* Truncate the request to fit into this section. */
1324 len = std::min (len, section->endaddr - offset);
1330 return TARGET_XFER_UNAVAILABLE;
1335 /* Forward the request. */
1337 return ops->to_xfer_partial (ops, object, annex, readbuf, writebuf,
1338 offset, len, xfered_len);
1341 /* The to_insert_breakpoint method of target record-btrace. */
1344 record_btrace_insert_breakpoint (struct target_ops *ops,
1345 struct gdbarch *gdbarch,
1346 struct bp_target_info *bp_tgt)
1351 /* Inserting breakpoints requires accessing memory. Allow it for the
1352 duration of this function. */
1353 old = replay_memory_access;
1354 replay_memory_access = replay_memory_access_read_write;
1359 ret = ops->beneath->to_insert_breakpoint (ops->beneath, gdbarch, bp_tgt);
1361 CATCH (except, RETURN_MASK_ALL)
1363 replay_memory_access = old;
1364 throw_exception (except);
1367 replay_memory_access = old;
1372 /* The to_remove_breakpoint method of target record-btrace. */
1375 record_btrace_remove_breakpoint (struct target_ops *ops,
1376 struct gdbarch *gdbarch,
1377 struct bp_target_info *bp_tgt,
1378 enum remove_bp_reason reason)
1383 /* Removing breakpoints requires accessing memory. Allow it for the
1384 duration of this function. */
1385 old = replay_memory_access;
1386 replay_memory_access = replay_memory_access_read_write;
1391 ret = ops->beneath->to_remove_breakpoint (ops->beneath, gdbarch, bp_tgt,
1394 CATCH (except, RETURN_MASK_ALL)
1396 replay_memory_access = old;
1397 throw_exception (except);
1400 replay_memory_access = old;
1405 /* The to_fetch_registers method of target record-btrace. */
1408 record_btrace_fetch_registers (struct target_ops *ops,
1409 struct regcache *regcache, int regno)
1411 struct btrace_insn_iterator *replay;
1412 struct thread_info *tp;
1414 tp = find_thread_ptid (regcache_get_ptid (regcache));
1415 gdb_assert (tp != NULL);
1417 replay = tp->btrace.replay;
1418 if (replay != NULL && !record_btrace_generating_corefile)
1420 const struct btrace_insn *insn;
1421 struct gdbarch *gdbarch;
1424 gdbarch = get_regcache_arch (regcache);
1425 pcreg = gdbarch_pc_regnum (gdbarch);
1429 /* We can only provide the PC register. */
1430 if (regno >= 0 && regno != pcreg)
1433 insn = btrace_insn_get (replay);
1434 gdb_assert (insn != NULL);
1436 regcache_raw_supply (regcache, regno, &insn->pc);
1440 struct target_ops *t = ops->beneath;
1442 t->to_fetch_registers (t, regcache, regno);
1446 /* The to_store_registers method of target record-btrace. */
1449 record_btrace_store_registers (struct target_ops *ops,
1450 struct regcache *regcache, int regno)
1452 struct target_ops *t;
1454 if (!record_btrace_generating_corefile
1455 && record_btrace_is_replaying (ops, regcache_get_ptid (regcache)))
1456 error (_("Cannot write registers while replaying."));
1458 gdb_assert (may_write_registers != 0);
1461 t->to_store_registers (t, regcache, regno);
1464 /* The to_prepare_to_store method of target record-btrace. */
1467 record_btrace_prepare_to_store (struct target_ops *ops,
1468 struct regcache *regcache)
1470 struct target_ops *t;
1472 if (!record_btrace_generating_corefile
1473 && record_btrace_is_replaying (ops, regcache_get_ptid (regcache)))
1477 t->to_prepare_to_store (t, regcache);
1480 /* The branch trace frame cache. */
1482 struct btrace_frame_cache
1485 struct thread_info *tp;
1487 /* The frame info. */
1488 struct frame_info *frame;
1490 /* The branch trace function segment. */
1491 const struct btrace_function *bfun;
1494 /* A struct btrace_frame_cache hash table indexed by NEXT. */
1496 static htab_t bfcache;
1498 /* hash_f for htab_create_alloc of bfcache. */
1501 bfcache_hash (const void *arg)
1503 const struct btrace_frame_cache *cache
1504 = (const struct btrace_frame_cache *) arg;
1506 return htab_hash_pointer (cache->frame);
1509 /* eq_f for htab_create_alloc of bfcache. */
1512 bfcache_eq (const void *arg1, const void *arg2)
1514 const struct btrace_frame_cache *cache1
1515 = (const struct btrace_frame_cache *) arg1;
1516 const struct btrace_frame_cache *cache2
1517 = (const struct btrace_frame_cache *) arg2;
1519 return cache1->frame == cache2->frame;
1522 /* Create a new btrace frame cache. */
1524 static struct btrace_frame_cache *
1525 bfcache_new (struct frame_info *frame)
1527 struct btrace_frame_cache *cache;
1530 cache = FRAME_OBSTACK_ZALLOC (struct btrace_frame_cache);
1531 cache->frame = frame;
1533 slot = htab_find_slot (bfcache, cache, INSERT);
1534 gdb_assert (*slot == NULL);
1540 /* Extract the branch trace function from a branch trace frame. */
1542 static const struct btrace_function *
1543 btrace_get_frame_function (struct frame_info *frame)
1545 const struct btrace_frame_cache *cache;
1546 const struct btrace_function *bfun;
1547 struct btrace_frame_cache pattern;
1550 pattern.frame = frame;
1552 slot = htab_find_slot (bfcache, &pattern, NO_INSERT);
1556 cache = (const struct btrace_frame_cache *) *slot;
1560 /* Implement stop_reason method for record_btrace_frame_unwind. */
1562 static enum unwind_stop_reason
1563 record_btrace_frame_unwind_stop_reason (struct frame_info *this_frame,
1566 const struct btrace_frame_cache *cache;
1567 const struct btrace_function *bfun;
1569 cache = (const struct btrace_frame_cache *) *this_cache;
1571 gdb_assert (bfun != NULL);
1574 return UNWIND_UNAVAILABLE;
1576 return UNWIND_NO_REASON;
1579 /* Implement this_id method for record_btrace_frame_unwind. */
1582 record_btrace_frame_this_id (struct frame_info *this_frame, void **this_cache,
1583 struct frame_id *this_id)
1585 const struct btrace_frame_cache *cache;
1586 const struct btrace_function *bfun;
1587 CORE_ADDR code, special;
1589 cache = (const struct btrace_frame_cache *) *this_cache;
1592 gdb_assert (bfun != NULL);
1594 while (bfun->segment.prev != NULL)
1595 bfun = bfun->segment.prev;
1597 code = get_frame_func (this_frame);
1598 special = bfun->number;
1600 *this_id = frame_id_build_unavailable_stack_special (code, special);
1602 DEBUG ("[frame] %s id: (!stack, pc=%s, special=%s)",
1603 btrace_get_bfun_name (cache->bfun),
1604 core_addr_to_string_nz (this_id->code_addr),
1605 core_addr_to_string_nz (this_id->special_addr));
1608 /* Implement prev_register method for record_btrace_frame_unwind. */
1610 static struct value *
1611 record_btrace_frame_prev_register (struct frame_info *this_frame,
1615 const struct btrace_frame_cache *cache;
1616 const struct btrace_function *bfun, *caller;
1617 const struct btrace_insn *insn;
1618 struct btrace_call_iterator it;
1619 struct gdbarch *gdbarch;
1623 gdbarch = get_frame_arch (this_frame);
1624 pcreg = gdbarch_pc_regnum (gdbarch);
1625 if (pcreg < 0 || regnum != pcreg)
1626 throw_error (NOT_AVAILABLE_ERROR,
1627 _("Registers are not available in btrace record history"));
1629 cache = (const struct btrace_frame_cache *) *this_cache;
1631 gdb_assert (bfun != NULL);
1633 if (btrace_find_call_by_number (&it, &cache->tp->btrace, bfun->up) == 0)
1634 throw_error (NOT_AVAILABLE_ERROR,
1635 _("No caller in btrace record history"));
1637 caller = btrace_call_get (&it);
1639 if ((bfun->flags & BFUN_UP_LINKS_TO_RET) != 0)
1641 insn = VEC_index (btrace_insn_s, caller->insn, 0);
1646 insn = VEC_last (btrace_insn_s, caller->insn);
1649 pc += gdb_insn_length (gdbarch, pc);
1652 DEBUG ("[frame] unwound PC in %s on level %d: %s",
1653 btrace_get_bfun_name (bfun), bfun->level,
1654 core_addr_to_string_nz (pc));
1656 return frame_unwind_got_address (this_frame, regnum, pc);
1659 /* Implement sniffer method for record_btrace_frame_unwind. */
1662 record_btrace_frame_sniffer (const struct frame_unwind *self,
1663 struct frame_info *this_frame,
1666 const struct btrace_function *bfun;
1667 struct btrace_frame_cache *cache;
1668 struct thread_info *tp;
1669 struct frame_info *next;
1671 /* THIS_FRAME does not contain a reference to its thread. */
1672 tp = find_thread_ptid (inferior_ptid);
1673 gdb_assert (tp != NULL);
1676 next = get_next_frame (this_frame);
1679 const struct btrace_insn_iterator *replay;
1681 replay = tp->btrace.replay;
1683 bfun = replay->btinfo->functions[replay->call_index];
1687 const struct btrace_function *callee;
1688 struct btrace_call_iterator it;
1690 callee = btrace_get_frame_function (next);
1691 if (callee == NULL || (callee->flags & BFUN_UP_LINKS_TO_TAILCALL) != 0)
1694 if (btrace_find_call_by_number (&it, &tp->btrace, callee->up) == 0)
1697 bfun = btrace_call_get (&it);
1703 DEBUG ("[frame] sniffed frame for %s on level %d",
1704 btrace_get_bfun_name (bfun), bfun->level);
1706 /* This is our frame. Initialize the frame cache. */
1707 cache = bfcache_new (this_frame);
1711 *this_cache = cache;
1715 /* Implement sniffer method for record_btrace_tailcall_frame_unwind. */
1718 record_btrace_tailcall_frame_sniffer (const struct frame_unwind *self,
1719 struct frame_info *this_frame,
1722 const struct btrace_function *bfun, *callee;
1723 struct btrace_frame_cache *cache;
1724 struct btrace_call_iterator it;
1725 struct frame_info *next;
1726 struct thread_info *tinfo;
1728 next = get_next_frame (this_frame);
1732 callee = btrace_get_frame_function (next);
1736 if ((callee->flags & BFUN_UP_LINKS_TO_TAILCALL) == 0)
1739 tinfo = find_thread_ptid (inferior_ptid);
1740 if (btrace_find_call_by_number (&it, &tinfo->btrace, callee->up) == 0)
1743 bfun = btrace_call_get (&it);
1745 DEBUG ("[frame] sniffed tailcall frame for %s on level %d",
1746 btrace_get_bfun_name (bfun), bfun->level);
1748 /* This is our frame. Initialize the frame cache. */
1749 cache = bfcache_new (this_frame);
1753 *this_cache = cache;
1758 record_btrace_frame_dealloc_cache (struct frame_info *self, void *this_cache)
1760 struct btrace_frame_cache *cache;
1763 cache = (struct btrace_frame_cache *) this_cache;
1765 slot = htab_find_slot (bfcache, cache, NO_INSERT);
1766 gdb_assert (slot != NULL);
1768 htab_remove_elt (bfcache, cache);
1771 /* btrace recording does not store previous memory content, neither the stack
1772 frames content. Any unwinding would return errorneous results as the stack
1773 contents no longer matches the changed PC value restored from history.
1774 Therefore this unwinder reports any possibly unwound registers as
1777 const struct frame_unwind record_btrace_frame_unwind =
1780 record_btrace_frame_unwind_stop_reason,
1781 record_btrace_frame_this_id,
1782 record_btrace_frame_prev_register,
1784 record_btrace_frame_sniffer,
1785 record_btrace_frame_dealloc_cache
1788 const struct frame_unwind record_btrace_tailcall_frame_unwind =
1791 record_btrace_frame_unwind_stop_reason,
1792 record_btrace_frame_this_id,
1793 record_btrace_frame_prev_register,
1795 record_btrace_tailcall_frame_sniffer,
1796 record_btrace_frame_dealloc_cache
1799 /* Implement the to_get_unwinder method. */
1801 static const struct frame_unwind *
1802 record_btrace_to_get_unwinder (struct target_ops *self)
1804 return &record_btrace_frame_unwind;
1807 /* Implement the to_get_tailcall_unwinder method. */
1809 static const struct frame_unwind *
1810 record_btrace_to_get_tailcall_unwinder (struct target_ops *self)
1812 return &record_btrace_tailcall_frame_unwind;
1815 /* Return a human-readable string for FLAG. */
1818 btrace_thread_flag_to_str (enum btrace_thread_flag flag)
1826 return "reverse-step";
1832 return "reverse-cont";
1841 /* Indicate that TP should be resumed according to FLAG. */
1844 record_btrace_resume_thread (struct thread_info *tp,
1845 enum btrace_thread_flag flag)
1847 struct btrace_thread_info *btinfo;
1849 DEBUG ("resuming thread %s (%s): %x (%s)", print_thread_id (tp),
1850 target_pid_to_str (tp->ptid), flag, btrace_thread_flag_to_str (flag));
1852 btinfo = &tp->btrace;
1854 /* Fetch the latest branch trace. */
1857 /* A resume request overwrites a preceding resume or stop request. */
1858 btinfo->flags &= ~(BTHR_MOVE | BTHR_STOP);
1859 btinfo->flags |= flag;
1862 /* Get the current frame for TP. */
1864 static struct frame_info *
1865 get_thread_current_frame (struct thread_info *tp)
1867 struct frame_info *frame;
1868 ptid_t old_inferior_ptid;
1871 /* Set INFERIOR_PTID, which is implicitly used by get_current_frame. */
1872 old_inferior_ptid = inferior_ptid;
1873 inferior_ptid = tp->ptid;
1875 /* Clear the executing flag to allow changes to the current frame.
1876 We are not actually running, yet. We just started a reverse execution
1877 command or a record goto command.
1878 For the latter, EXECUTING is false and this has no effect.
1879 For the former, EXECUTING is true and we're in to_wait, about to
1880 move the thread. Since we need to recompute the stack, we temporarily
1881 set EXECUTING to flase. */
1882 executing = is_executing (inferior_ptid);
1883 set_executing (inferior_ptid, 0);
1888 frame = get_current_frame ();
1890 CATCH (except, RETURN_MASK_ALL)
1892 /* Restore the previous execution state. */
1893 set_executing (inferior_ptid, executing);
1895 /* Restore the previous inferior_ptid. */
1896 inferior_ptid = old_inferior_ptid;
1898 throw_exception (except);
1902 /* Restore the previous execution state. */
1903 set_executing (inferior_ptid, executing);
1905 /* Restore the previous inferior_ptid. */
1906 inferior_ptid = old_inferior_ptid;
1911 /* Start replaying a thread. */
1913 static struct btrace_insn_iterator *
1914 record_btrace_start_replaying (struct thread_info *tp)
1916 struct btrace_insn_iterator *replay;
1917 struct btrace_thread_info *btinfo;
1919 btinfo = &tp->btrace;
1922 /* We can't start replaying without trace. */
1923 if (btinfo->functions.empty ())
1926 /* GDB stores the current frame_id when stepping in order to detects steps
1928 Since frames are computed differently when we're replaying, we need to
1929 recompute those stored frames and fix them up so we can still detect
1930 subroutines after we started replaying. */
1933 struct frame_info *frame;
1934 struct frame_id frame_id;
1935 int upd_step_frame_id, upd_step_stack_frame_id;
1937 /* The current frame without replaying - computed via normal unwind. */
1938 frame = get_thread_current_frame (tp);
1939 frame_id = get_frame_id (frame);
1941 /* Check if we need to update any stepping-related frame id's. */
1942 upd_step_frame_id = frame_id_eq (frame_id,
1943 tp->control.step_frame_id);
1944 upd_step_stack_frame_id = frame_id_eq (frame_id,
1945 tp->control.step_stack_frame_id);
1947 /* We start replaying at the end of the branch trace. This corresponds
1948 to the current instruction. */
1949 replay = XNEW (struct btrace_insn_iterator);
1950 btrace_insn_end (replay, btinfo);
1952 /* Skip gaps at the end of the trace. */
1953 while (btrace_insn_get (replay) == NULL)
1957 steps = btrace_insn_prev (replay, 1);
1959 error (_("No trace."));
1962 /* We're not replaying, yet. */
1963 gdb_assert (btinfo->replay == NULL);
1964 btinfo->replay = replay;
1966 /* Make sure we're not using any stale registers. */
1967 registers_changed_ptid (tp->ptid);
1969 /* The current frame with replaying - computed via btrace unwind. */
1970 frame = get_thread_current_frame (tp);
1971 frame_id = get_frame_id (frame);
1973 /* Replace stepping related frames where necessary. */
1974 if (upd_step_frame_id)
1975 tp->control.step_frame_id = frame_id;
1976 if (upd_step_stack_frame_id)
1977 tp->control.step_stack_frame_id = frame_id;
1979 CATCH (except, RETURN_MASK_ALL)
1981 xfree (btinfo->replay);
1982 btinfo->replay = NULL;
1984 registers_changed_ptid (tp->ptid);
1986 throw_exception (except);
1993 /* Stop replaying a thread. */
1996 record_btrace_stop_replaying (struct thread_info *tp)
1998 struct btrace_thread_info *btinfo;
2000 btinfo = &tp->btrace;
2002 xfree (btinfo->replay);
2003 btinfo->replay = NULL;
2005 /* Make sure we're not leaving any stale registers. */
2006 registers_changed_ptid (tp->ptid);
2009 /* Stop replaying TP if it is at the end of its execution history. */
2012 record_btrace_stop_replaying_at_end (struct thread_info *tp)
2014 struct btrace_insn_iterator *replay, end;
2015 struct btrace_thread_info *btinfo;
2017 btinfo = &tp->btrace;
2018 replay = btinfo->replay;
2023 btrace_insn_end (&end, btinfo);
2025 if (btrace_insn_cmp (replay, &end) == 0)
2026 record_btrace_stop_replaying (tp);
2029 /* The to_resume method of target record-btrace. */
2032 record_btrace_resume (struct target_ops *ops, ptid_t ptid, int step,
2033 enum gdb_signal signal)
2035 struct thread_info *tp;
2036 enum btrace_thread_flag flag, cflag;
2038 DEBUG ("resume %s: %s%s", target_pid_to_str (ptid),
2039 execution_direction == EXEC_REVERSE ? "reverse-" : "",
2040 step ? "step" : "cont");
2042 /* Store the execution direction of the last resume.
2044 If there is more than one to_resume call, we have to rely on infrun
2045 to not change the execution direction in-between. */
2046 record_btrace_resume_exec_dir = execution_direction;
2048 /* As long as we're not replaying, just forward the request.
2050 For non-stop targets this means that no thread is replaying. In order to
2051 make progress, we may need to explicitly move replaying threads to the end
2052 of their execution history. */
2053 if ((execution_direction != EXEC_REVERSE)
2054 && !record_btrace_is_replaying (ops, minus_one_ptid))
2057 ops->to_resume (ops, ptid, step, signal);
2061 /* Compute the btrace thread flag for the requested move. */
2062 if (execution_direction == EXEC_REVERSE)
2064 flag = step == 0 ? BTHR_RCONT : BTHR_RSTEP;
2069 flag = step == 0 ? BTHR_CONT : BTHR_STEP;
2073 /* We just indicate the resume intent here. The actual stepping happens in
2074 record_btrace_wait below.
2076 For all-stop targets, we only step INFERIOR_PTID and continue others. */
2077 if (!target_is_non_stop_p ())
2079 gdb_assert (ptid_match (inferior_ptid, ptid));
2081 ALL_NON_EXITED_THREADS (tp)
2082 if (ptid_match (tp->ptid, ptid))
2084 if (ptid_match (tp->ptid, inferior_ptid))
2085 record_btrace_resume_thread (tp, flag);
2087 record_btrace_resume_thread (tp, cflag);
2092 ALL_NON_EXITED_THREADS (tp)
2093 if (ptid_match (tp->ptid, ptid))
2094 record_btrace_resume_thread (tp, flag);
2097 /* Async support. */
2098 if (target_can_async_p ())
2101 mark_async_event_handler (record_btrace_async_inferior_event_handler);
2105 /* The to_commit_resume method of target record-btrace. */
2108 record_btrace_commit_resume (struct target_ops *ops)
2110 if ((execution_direction != EXEC_REVERSE)
2111 && !record_btrace_is_replaying (ops, minus_one_ptid))
2112 ops->beneath->to_commit_resume (ops->beneath);
2115 /* Cancel resuming TP. */
2118 record_btrace_cancel_resume (struct thread_info *tp)
2120 enum btrace_thread_flag flags;
2122 flags = tp->btrace.flags & (BTHR_MOVE | BTHR_STOP);
2126 DEBUG ("cancel resume thread %s (%s): %x (%s)",
2127 print_thread_id (tp),
2128 target_pid_to_str (tp->ptid), flags,
2129 btrace_thread_flag_to_str (flags));
2131 tp->btrace.flags &= ~(BTHR_MOVE | BTHR_STOP);
2132 record_btrace_stop_replaying_at_end (tp);
2135 /* Return a target_waitstatus indicating that we ran out of history. */
2137 static struct target_waitstatus
2138 btrace_step_no_history (void)
2140 struct target_waitstatus status;
2142 status.kind = TARGET_WAITKIND_NO_HISTORY;
2147 /* Return a target_waitstatus indicating that a step finished. */
2149 static struct target_waitstatus
2150 btrace_step_stopped (void)
2152 struct target_waitstatus status;
2154 status.kind = TARGET_WAITKIND_STOPPED;
2155 status.value.sig = GDB_SIGNAL_TRAP;
2160 /* Return a target_waitstatus indicating that a thread was stopped as
2163 static struct target_waitstatus
2164 btrace_step_stopped_on_request (void)
2166 struct target_waitstatus status;
2168 status.kind = TARGET_WAITKIND_STOPPED;
2169 status.value.sig = GDB_SIGNAL_0;
2174 /* Return a target_waitstatus indicating a spurious stop. */
2176 static struct target_waitstatus
2177 btrace_step_spurious (void)
2179 struct target_waitstatus status;
2181 status.kind = TARGET_WAITKIND_SPURIOUS;
2186 /* Return a target_waitstatus indicating that the thread was not resumed. */
2188 static struct target_waitstatus
2189 btrace_step_no_resumed (void)
2191 struct target_waitstatus status;
2193 status.kind = TARGET_WAITKIND_NO_RESUMED;
2198 /* Return a target_waitstatus indicating that we should wait again. */
2200 static struct target_waitstatus
2201 btrace_step_again (void)
2203 struct target_waitstatus status;
2205 status.kind = TARGET_WAITKIND_IGNORE;
2210 /* Clear the record histories. */
2213 record_btrace_clear_histories (struct btrace_thread_info *btinfo)
2215 xfree (btinfo->insn_history);
2216 xfree (btinfo->call_history);
2218 btinfo->insn_history = NULL;
2219 btinfo->call_history = NULL;
2222 /* Check whether TP's current replay position is at a breakpoint. */
2225 record_btrace_replay_at_breakpoint (struct thread_info *tp)
2227 struct btrace_insn_iterator *replay;
2228 struct btrace_thread_info *btinfo;
2229 const struct btrace_insn *insn;
2230 struct inferior *inf;
2232 btinfo = &tp->btrace;
2233 replay = btinfo->replay;
2238 insn = btrace_insn_get (replay);
2242 inf = find_inferior_ptid (tp->ptid);
2246 return record_check_stopped_by_breakpoint (inf->aspace, insn->pc,
2247 &btinfo->stop_reason);
2250 /* Step one instruction in forward direction. */
2252 static struct target_waitstatus
2253 record_btrace_single_step_forward (struct thread_info *tp)
2255 struct btrace_insn_iterator *replay, end, start;
2256 struct btrace_thread_info *btinfo;
2258 btinfo = &tp->btrace;
2259 replay = btinfo->replay;
2261 /* We're done if we're not replaying. */
2263 return btrace_step_no_history ();
2265 /* Check if we're stepping a breakpoint. */
2266 if (record_btrace_replay_at_breakpoint (tp))
2267 return btrace_step_stopped ();
2269 /* Skip gaps during replay. If we end up at a gap (at the end of the trace),
2270 jump back to the instruction at which we started. */
2276 /* We will bail out here if we continue stepping after reaching the end
2277 of the execution history. */
2278 steps = btrace_insn_next (replay, 1);
2282 return btrace_step_no_history ();
2285 while (btrace_insn_get (replay) == NULL);
2287 /* Determine the end of the instruction trace. */
2288 btrace_insn_end (&end, btinfo);
2290 /* The execution trace contains (and ends with) the current instruction.
2291 This instruction has not been executed, yet, so the trace really ends
2292 one instruction earlier. */
2293 if (btrace_insn_cmp (replay, &end) == 0)
2294 return btrace_step_no_history ();
2296 return btrace_step_spurious ();
2299 /* Step one instruction in backward direction. */
2301 static struct target_waitstatus
2302 record_btrace_single_step_backward (struct thread_info *tp)
2304 struct btrace_insn_iterator *replay, start;
2305 struct btrace_thread_info *btinfo;
2307 btinfo = &tp->btrace;
2308 replay = btinfo->replay;
2310 /* Start replaying if we're not already doing so. */
2312 replay = record_btrace_start_replaying (tp);
2314 /* If we can't step any further, we reached the end of the history.
2315 Skip gaps during replay. If we end up at a gap (at the beginning of
2316 the trace), jump back to the instruction at which we started. */
2322 steps = btrace_insn_prev (replay, 1);
2326 return btrace_step_no_history ();
2329 while (btrace_insn_get (replay) == NULL);
2331 /* Check if we're stepping a breakpoint.
2333 For reverse-stepping, this check is after the step. There is logic in
2334 infrun.c that handles reverse-stepping separately. See, for example,
2335 proceed and adjust_pc_after_break.
2337 This code assumes that for reverse-stepping, PC points to the last
2338 de-executed instruction, whereas for forward-stepping PC points to the
2339 next to-be-executed instruction. */
2340 if (record_btrace_replay_at_breakpoint (tp))
2341 return btrace_step_stopped ();
2343 return btrace_step_spurious ();
2346 /* Step a single thread. */
2348 static struct target_waitstatus
2349 record_btrace_step_thread (struct thread_info *tp)
2351 struct btrace_thread_info *btinfo;
2352 struct target_waitstatus status;
2353 enum btrace_thread_flag flags;
2355 btinfo = &tp->btrace;
2357 flags = btinfo->flags & (BTHR_MOVE | BTHR_STOP);
2358 btinfo->flags &= ~(BTHR_MOVE | BTHR_STOP);
2360 DEBUG ("stepping thread %s (%s): %x (%s)", print_thread_id (tp),
2361 target_pid_to_str (tp->ptid), flags,
2362 btrace_thread_flag_to_str (flags));
2364 /* We can't step without an execution history. */
2365 if ((flags & BTHR_MOVE) != 0 && btrace_is_empty (tp))
2366 return btrace_step_no_history ();
2371 internal_error (__FILE__, __LINE__, _("invalid stepping type."));
2374 return btrace_step_stopped_on_request ();
2377 status = record_btrace_single_step_forward (tp);
2378 if (status.kind != TARGET_WAITKIND_SPURIOUS)
2381 return btrace_step_stopped ();
2384 status = record_btrace_single_step_backward (tp);
2385 if (status.kind != TARGET_WAITKIND_SPURIOUS)
2388 return btrace_step_stopped ();
2391 status = record_btrace_single_step_forward (tp);
2392 if (status.kind != TARGET_WAITKIND_SPURIOUS)
2395 btinfo->flags |= flags;
2396 return btrace_step_again ();
2399 status = record_btrace_single_step_backward (tp);
2400 if (status.kind != TARGET_WAITKIND_SPURIOUS)
2403 btinfo->flags |= flags;
2404 return btrace_step_again ();
2407 /* We keep threads moving at the end of their execution history. The to_wait
2408 method will stop the thread for whom the event is reported. */
2409 if (status.kind == TARGET_WAITKIND_NO_HISTORY)
2410 btinfo->flags |= flags;
2415 /* A vector of threads. */
2417 typedef struct thread_info * tp_t;
2420 /* Announce further events if necessary. */
2423 record_btrace_maybe_mark_async_event (const VEC (tp_t) *moving,
2424 const VEC (tp_t) *no_history)
2426 int more_moving, more_no_history;
2428 more_moving = !VEC_empty (tp_t, moving);
2429 more_no_history = !VEC_empty (tp_t, no_history);
2431 if (!more_moving && !more_no_history)
2435 DEBUG ("movers pending");
2437 if (more_no_history)
2438 DEBUG ("no-history pending");
2440 mark_async_event_handler (record_btrace_async_inferior_event_handler);
2443 /* The to_wait method of target record-btrace. */
2446 record_btrace_wait (struct target_ops *ops, ptid_t ptid,
2447 struct target_waitstatus *status, int options)
2449 VEC (tp_t) *moving, *no_history;
2450 struct thread_info *tp, *eventing;
2451 struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
2453 DEBUG ("wait %s (0x%x)", target_pid_to_str (ptid), options);
2455 /* As long as we're not replaying, just forward the request. */
2456 if ((execution_direction != EXEC_REVERSE)
2457 && !record_btrace_is_replaying (ops, minus_one_ptid))
2460 return ops->to_wait (ops, ptid, status, options);
2466 make_cleanup (VEC_cleanup (tp_t), &moving);
2467 make_cleanup (VEC_cleanup (tp_t), &no_history);
2469 /* Keep a work list of moving threads. */
2470 ALL_NON_EXITED_THREADS (tp)
2471 if (ptid_match (tp->ptid, ptid)
2472 && ((tp->btrace.flags & (BTHR_MOVE | BTHR_STOP)) != 0))
2473 VEC_safe_push (tp_t, moving, tp);
2475 if (VEC_empty (tp_t, moving))
2477 *status = btrace_step_no_resumed ();
2479 DEBUG ("wait ended by %s: %s", target_pid_to_str (null_ptid),
2480 target_waitstatus_to_string (status));
2482 do_cleanups (cleanups);
2486 /* Step moving threads one by one, one step each, until either one thread
2487 reports an event or we run out of threads to step.
2489 When stepping more than one thread, chances are that some threads reach
2490 the end of their execution history earlier than others. If we reported
2491 this immediately, all-stop on top of non-stop would stop all threads and
2492 resume the same threads next time. And we would report the same thread
2493 having reached the end of its execution history again.
2495 In the worst case, this would starve the other threads. But even if other
2496 threads would be allowed to make progress, this would result in far too
2497 many intermediate stops.
2499 We therefore delay the reporting of "no execution history" until we have
2500 nothing else to report. By this time, all threads should have moved to
2501 either the beginning or the end of their execution history. There will
2502 be a single user-visible stop. */
2504 while ((eventing == NULL) && !VEC_empty (tp_t, moving))
2509 while ((eventing == NULL) && VEC_iterate (tp_t, moving, ix, tp))
2511 *status = record_btrace_step_thread (tp);
2513 switch (status->kind)
2515 case TARGET_WAITKIND_IGNORE:
2519 case TARGET_WAITKIND_NO_HISTORY:
2520 VEC_safe_push (tp_t, no_history,
2521 VEC_ordered_remove (tp_t, moving, ix));
2525 eventing = VEC_unordered_remove (tp_t, moving, ix);
2531 if (eventing == NULL)
2533 /* We started with at least one moving thread. This thread must have
2534 either stopped or reached the end of its execution history.
2536 In the former case, EVENTING must not be NULL.
2537 In the latter case, NO_HISTORY must not be empty. */
2538 gdb_assert (!VEC_empty (tp_t, no_history));
2540 /* We kept threads moving at the end of their execution history. Stop
2541 EVENTING now that we are going to report its stop. */
2542 eventing = VEC_unordered_remove (tp_t, no_history, 0);
2543 eventing->btrace.flags &= ~BTHR_MOVE;
2545 *status = btrace_step_no_history ();
2548 gdb_assert (eventing != NULL);
2550 /* We kept threads replaying at the end of their execution history. Stop
2551 replaying EVENTING now that we are going to report its stop. */
2552 record_btrace_stop_replaying_at_end (eventing);
2554 /* Stop all other threads. */
2555 if (!target_is_non_stop_p ())
2556 ALL_NON_EXITED_THREADS (tp)
2557 record_btrace_cancel_resume (tp);
2559 /* In async mode, we need to announce further events. */
2560 if (target_is_async_p ())
2561 record_btrace_maybe_mark_async_event (moving, no_history);
2563 /* Start record histories anew from the current position. */
2564 record_btrace_clear_histories (&eventing->btrace);
2566 /* We moved the replay position but did not update registers. */
2567 registers_changed_ptid (eventing->ptid);
2569 DEBUG ("wait ended by thread %s (%s): %s",
2570 print_thread_id (eventing),
2571 target_pid_to_str (eventing->ptid),
2572 target_waitstatus_to_string (status));
2574 do_cleanups (cleanups);
2575 return eventing->ptid;
2578 /* The to_stop method of target record-btrace. */
2581 record_btrace_stop (struct target_ops *ops, ptid_t ptid)
2583 DEBUG ("stop %s", target_pid_to_str (ptid));
2585 /* As long as we're not replaying, just forward the request. */
2586 if ((execution_direction != EXEC_REVERSE)
2587 && !record_btrace_is_replaying (ops, minus_one_ptid))
2590 ops->to_stop (ops, ptid);
2594 struct thread_info *tp;
2596 ALL_NON_EXITED_THREADS (tp)
2597 if (ptid_match (tp->ptid, ptid))
2599 tp->btrace.flags &= ~BTHR_MOVE;
2600 tp->btrace.flags |= BTHR_STOP;
2605 /* The to_can_execute_reverse method of target record-btrace. */
2608 record_btrace_can_execute_reverse (struct target_ops *self)
2613 /* The to_stopped_by_sw_breakpoint method of target record-btrace. */
2616 record_btrace_stopped_by_sw_breakpoint (struct target_ops *ops)
2618 if (record_btrace_is_replaying (ops, minus_one_ptid))
2620 struct thread_info *tp = inferior_thread ();
2622 return tp->btrace.stop_reason == TARGET_STOPPED_BY_SW_BREAKPOINT;
2625 return ops->beneath->to_stopped_by_sw_breakpoint (ops->beneath);
2628 /* The to_supports_stopped_by_sw_breakpoint method of target
2632 record_btrace_supports_stopped_by_sw_breakpoint (struct target_ops *ops)
2634 if (record_btrace_is_replaying (ops, minus_one_ptid))
2637 return ops->beneath->to_supports_stopped_by_sw_breakpoint (ops->beneath);
2640 /* The to_stopped_by_sw_breakpoint method of target record-btrace. */
2643 record_btrace_stopped_by_hw_breakpoint (struct target_ops *ops)
2645 if (record_btrace_is_replaying (ops, minus_one_ptid))
2647 struct thread_info *tp = inferior_thread ();
2649 return tp->btrace.stop_reason == TARGET_STOPPED_BY_HW_BREAKPOINT;
2652 return ops->beneath->to_stopped_by_hw_breakpoint (ops->beneath);
2655 /* The to_supports_stopped_by_hw_breakpoint method of target
2659 record_btrace_supports_stopped_by_hw_breakpoint (struct target_ops *ops)
2661 if (record_btrace_is_replaying (ops, minus_one_ptid))
2664 return ops->beneath->to_supports_stopped_by_hw_breakpoint (ops->beneath);
2667 /* The to_update_thread_list method of target record-btrace. */
2670 record_btrace_update_thread_list (struct target_ops *ops)
2672 /* We don't add or remove threads during replay. */
2673 if (record_btrace_is_replaying (ops, minus_one_ptid))
2676 /* Forward the request. */
2678 ops->to_update_thread_list (ops);
2681 /* The to_thread_alive method of target record-btrace. */
2684 record_btrace_thread_alive (struct target_ops *ops, ptid_t ptid)
2686 /* We don't add or remove threads during replay. */
2687 if (record_btrace_is_replaying (ops, minus_one_ptid))
2688 return find_thread_ptid (ptid) != NULL;
2690 /* Forward the request. */
2692 return ops->to_thread_alive (ops, ptid);
2695 /* Set the replay branch trace instruction iterator. If IT is NULL, replay
2699 record_btrace_set_replay (struct thread_info *tp,
2700 const struct btrace_insn_iterator *it)
2702 struct btrace_thread_info *btinfo;
2704 btinfo = &tp->btrace;
2707 record_btrace_stop_replaying (tp);
2710 if (btinfo->replay == NULL)
2711 record_btrace_start_replaying (tp);
2712 else if (btrace_insn_cmp (btinfo->replay, it) == 0)
2715 *btinfo->replay = *it;
2716 registers_changed_ptid (tp->ptid);
2719 /* Start anew from the new replay position. */
2720 record_btrace_clear_histories (btinfo);
2722 stop_pc = regcache_read_pc (get_current_regcache ());
2723 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC, 1);
2726 /* The to_goto_record_begin method of target record-btrace. */
2729 record_btrace_goto_begin (struct target_ops *self)
2731 struct thread_info *tp;
2732 struct btrace_insn_iterator begin;
2734 tp = require_btrace_thread ();
2736 btrace_insn_begin (&begin, &tp->btrace);
2738 /* Skip gaps at the beginning of the trace. */
2739 while (btrace_insn_get (&begin) == NULL)
2743 steps = btrace_insn_next (&begin, 1);
2745 error (_("No trace."));
2748 record_btrace_set_replay (tp, &begin);
2751 /* The to_goto_record_end method of target record-btrace. */
2754 record_btrace_goto_end (struct target_ops *ops)
2756 struct thread_info *tp;
2758 tp = require_btrace_thread ();
2760 record_btrace_set_replay (tp, NULL);
2763 /* The to_goto_record method of target record-btrace. */
2766 record_btrace_goto (struct target_ops *self, ULONGEST insn)
2768 struct thread_info *tp;
2769 struct btrace_insn_iterator it;
2770 unsigned int number;
2775 /* Check for wrap-arounds. */
2777 error (_("Instruction number out of range."));
2779 tp = require_btrace_thread ();
2781 found = btrace_find_insn_by_number (&it, &tp->btrace, number);
2783 /* Check if the instruction could not be found or is a gap. */
2784 if (found == 0 || btrace_insn_get (&it) == NULL)
2785 error (_("No such instruction."));
2787 record_btrace_set_replay (tp, &it);
2790 /* The to_record_stop_replaying method of target record-btrace. */
2793 record_btrace_stop_replaying_all (struct target_ops *self)
2795 struct thread_info *tp;
2797 ALL_NON_EXITED_THREADS (tp)
2798 record_btrace_stop_replaying (tp);
2801 /* The to_execution_direction target method. */
2803 static enum exec_direction_kind
2804 record_btrace_execution_direction (struct target_ops *self)
2806 return record_btrace_resume_exec_dir;
2809 /* The to_prepare_to_generate_core target method. */
2812 record_btrace_prepare_to_generate_core (struct target_ops *self)
2814 record_btrace_generating_corefile = 1;
2817 /* The to_done_generating_core target method. */
2820 record_btrace_done_generating_core (struct target_ops *self)
2822 record_btrace_generating_corefile = 0;
2825 /* Initialize the record-btrace target ops. */
2828 init_record_btrace_ops (void)
2830 struct target_ops *ops;
2832 ops = &record_btrace_ops;
2833 ops->to_shortname = "record-btrace";
2834 ops->to_longname = "Branch tracing target";
2835 ops->to_doc = "Collect control-flow trace and provide the execution history.";
2836 ops->to_open = record_btrace_open;
2837 ops->to_close = record_btrace_close;
2838 ops->to_async = record_btrace_async;
2839 ops->to_detach = record_detach;
2840 ops->to_disconnect = record_btrace_disconnect;
2841 ops->to_mourn_inferior = record_mourn_inferior;
2842 ops->to_kill = record_kill;
2843 ops->to_stop_recording = record_btrace_stop_recording;
2844 ops->to_info_record = record_btrace_info;
2845 ops->to_insn_history = record_btrace_insn_history;
2846 ops->to_insn_history_from = record_btrace_insn_history_from;
2847 ops->to_insn_history_range = record_btrace_insn_history_range;
2848 ops->to_call_history = record_btrace_call_history;
2849 ops->to_call_history_from = record_btrace_call_history_from;
2850 ops->to_call_history_range = record_btrace_call_history_range;
2851 ops->to_record_method = record_btrace_record_method;
2852 ops->to_record_is_replaying = record_btrace_is_replaying;
2853 ops->to_record_will_replay = record_btrace_will_replay;
2854 ops->to_record_stop_replaying = record_btrace_stop_replaying_all;
2855 ops->to_xfer_partial = record_btrace_xfer_partial;
2856 ops->to_remove_breakpoint = record_btrace_remove_breakpoint;
2857 ops->to_insert_breakpoint = record_btrace_insert_breakpoint;
2858 ops->to_fetch_registers = record_btrace_fetch_registers;
2859 ops->to_store_registers = record_btrace_store_registers;
2860 ops->to_prepare_to_store = record_btrace_prepare_to_store;
2861 ops->to_get_unwinder = &record_btrace_to_get_unwinder;
2862 ops->to_get_tailcall_unwinder = &record_btrace_to_get_tailcall_unwinder;
2863 ops->to_resume = record_btrace_resume;
2864 ops->to_commit_resume = record_btrace_commit_resume;
2865 ops->to_wait = record_btrace_wait;
2866 ops->to_stop = record_btrace_stop;
2867 ops->to_update_thread_list = record_btrace_update_thread_list;
2868 ops->to_thread_alive = record_btrace_thread_alive;
2869 ops->to_goto_record_begin = record_btrace_goto_begin;
2870 ops->to_goto_record_end = record_btrace_goto_end;
2871 ops->to_goto_record = record_btrace_goto;
2872 ops->to_can_execute_reverse = record_btrace_can_execute_reverse;
2873 ops->to_stopped_by_sw_breakpoint = record_btrace_stopped_by_sw_breakpoint;
2874 ops->to_supports_stopped_by_sw_breakpoint
2875 = record_btrace_supports_stopped_by_sw_breakpoint;
2876 ops->to_stopped_by_hw_breakpoint = record_btrace_stopped_by_hw_breakpoint;
2877 ops->to_supports_stopped_by_hw_breakpoint
2878 = record_btrace_supports_stopped_by_hw_breakpoint;
2879 ops->to_execution_direction = record_btrace_execution_direction;
2880 ops->to_prepare_to_generate_core = record_btrace_prepare_to_generate_core;
2881 ops->to_done_generating_core = record_btrace_done_generating_core;
2882 ops->to_stratum = record_stratum;
2883 ops->to_magic = OPS_MAGIC;
2886 /* Start recording in BTS format. */
2889 cmd_record_btrace_bts_start (char *args, int from_tty)
2891 if (args != NULL && *args != 0)
2892 error (_("Invalid argument."));
2894 record_btrace_conf.format = BTRACE_FORMAT_BTS;
2898 execute_command ((char *) "target record-btrace", from_tty);
2900 CATCH (exception, RETURN_MASK_ALL)
2902 record_btrace_conf.format = BTRACE_FORMAT_NONE;
2903 throw_exception (exception);
2908 /* Start recording in Intel Processor Trace format. */
2911 cmd_record_btrace_pt_start (char *args, int from_tty)
2913 if (args != NULL && *args != 0)
2914 error (_("Invalid argument."));
2916 record_btrace_conf.format = BTRACE_FORMAT_PT;
2920 execute_command ((char *) "target record-btrace", from_tty);
2922 CATCH (exception, RETURN_MASK_ALL)
2924 record_btrace_conf.format = BTRACE_FORMAT_NONE;
2925 throw_exception (exception);
2930 /* Alias for "target record". */
2933 cmd_record_btrace_start (char *args, int from_tty)
2935 if (args != NULL && *args != 0)
2936 error (_("Invalid argument."));
2938 record_btrace_conf.format = BTRACE_FORMAT_PT;
2942 execute_command ((char *) "target record-btrace", from_tty);
2944 CATCH (exception, RETURN_MASK_ALL)
2946 record_btrace_conf.format = BTRACE_FORMAT_BTS;
2950 execute_command ((char *) "target record-btrace", from_tty);
2952 CATCH (exception, RETURN_MASK_ALL)
2954 record_btrace_conf.format = BTRACE_FORMAT_NONE;
2955 throw_exception (exception);
2962 /* The "set record btrace" command. */
2965 cmd_set_record_btrace (char *args, int from_tty)
2967 cmd_show_list (set_record_btrace_cmdlist, from_tty, "");
2970 /* The "show record btrace" command. */
2973 cmd_show_record_btrace (char *args, int from_tty)
2975 cmd_show_list (show_record_btrace_cmdlist, from_tty, "");
2978 /* The "show record btrace replay-memory-access" command. */
2981 cmd_show_replay_memory_access (struct ui_file *file, int from_tty,
2982 struct cmd_list_element *c, const char *value)
2984 fprintf_filtered (gdb_stdout, _("Replay memory access is %s.\n"),
2985 replay_memory_access);
2988 /* The "set record btrace bts" command. */
2991 cmd_set_record_btrace_bts (char *args, int from_tty)
2993 printf_unfiltered (_("\"set record btrace bts\" must be followed "
2994 "by an appropriate subcommand.\n"));
2995 help_list (set_record_btrace_bts_cmdlist, "set record btrace bts ",
2996 all_commands, gdb_stdout);
2999 /* The "show record btrace bts" command. */
3002 cmd_show_record_btrace_bts (char *args, int from_tty)
3004 cmd_show_list (show_record_btrace_bts_cmdlist, from_tty, "");
3007 /* The "set record btrace pt" command. */
3010 cmd_set_record_btrace_pt (char *args, int from_tty)
3012 printf_unfiltered (_("\"set record btrace pt\" must be followed "
3013 "by an appropriate subcommand.\n"));
3014 help_list (set_record_btrace_pt_cmdlist, "set record btrace pt ",
3015 all_commands, gdb_stdout);
3018 /* The "show record btrace pt" command. */
3021 cmd_show_record_btrace_pt (char *args, int from_tty)
3023 cmd_show_list (show_record_btrace_pt_cmdlist, from_tty, "");
3026 /* The "record bts buffer-size" show value function. */
3029 show_record_bts_buffer_size_value (struct ui_file *file, int from_tty,
3030 struct cmd_list_element *c,
3033 fprintf_filtered (file, _("The record/replay bts buffer size is %s.\n"),
3037 /* The "record pt buffer-size" show value function. */
3040 show_record_pt_buffer_size_value (struct ui_file *file, int from_tty,
3041 struct cmd_list_element *c,
3044 fprintf_filtered (file, _("The record/replay pt buffer size is %s.\n"),
3048 void _initialize_record_btrace (void);
3050 /* Initialize btrace commands. */
3053 _initialize_record_btrace (void)
3055 add_prefix_cmd ("btrace", class_obscure, cmd_record_btrace_start,
3056 _("Start branch trace recording."), &record_btrace_cmdlist,
3057 "record btrace ", 0, &record_cmdlist);
3058 add_alias_cmd ("b", "btrace", class_obscure, 1, &record_cmdlist);
3060 add_cmd ("bts", class_obscure, cmd_record_btrace_bts_start,
3062 Start branch trace recording in Branch Trace Store (BTS) format.\n\n\
3063 The processor stores a from/to record for each branch into a cyclic buffer.\n\
3064 This format may not be available on all processors."),
3065 &record_btrace_cmdlist);
3066 add_alias_cmd ("bts", "btrace bts", class_obscure, 1, &record_cmdlist);
3068 add_cmd ("pt", class_obscure, cmd_record_btrace_pt_start,
3070 Start branch trace recording in Intel Processor Trace format.\n\n\
3071 This format may not be available on all processors."),
3072 &record_btrace_cmdlist);
3073 add_alias_cmd ("pt", "btrace pt", class_obscure, 1, &record_cmdlist);
3075 add_prefix_cmd ("btrace", class_support, cmd_set_record_btrace,
3076 _("Set record options"), &set_record_btrace_cmdlist,
3077 "set record btrace ", 0, &set_record_cmdlist);
3079 add_prefix_cmd ("btrace", class_support, cmd_show_record_btrace,
3080 _("Show record options"), &show_record_btrace_cmdlist,
3081 "show record btrace ", 0, &show_record_cmdlist);
3083 add_setshow_enum_cmd ("replay-memory-access", no_class,
3084 replay_memory_access_types, &replay_memory_access, _("\
3085 Set what memory accesses are allowed during replay."), _("\
3086 Show what memory accesses are allowed during replay."),
3087 _("Default is READ-ONLY.\n\n\
3088 The btrace record target does not trace data.\n\
3089 The memory therefore corresponds to the live target and not \
3090 to the current replay position.\n\n\
3091 When READ-ONLY, allow accesses to read-only memory during replay.\n\
3092 When READ-WRITE, allow accesses to read-only and read-write memory during \
3094 NULL, cmd_show_replay_memory_access,
3095 &set_record_btrace_cmdlist,
3096 &show_record_btrace_cmdlist);
3098 add_prefix_cmd ("bts", class_support, cmd_set_record_btrace_bts,
3099 _("Set record btrace bts options"),
3100 &set_record_btrace_bts_cmdlist,
3101 "set record btrace bts ", 0, &set_record_btrace_cmdlist);
3103 add_prefix_cmd ("bts", class_support, cmd_show_record_btrace_bts,
3104 _("Show record btrace bts options"),
3105 &show_record_btrace_bts_cmdlist,
3106 "show record btrace bts ", 0, &show_record_btrace_cmdlist);
3108 add_setshow_uinteger_cmd ("buffer-size", no_class,
3109 &record_btrace_conf.bts.size,
3110 _("Set the record/replay bts buffer size."),
3111 _("Show the record/replay bts buffer size."), _("\
3112 When starting recording request a trace buffer of this size. \
3113 The actual buffer size may differ from the requested size. \
3114 Use \"info record\" to see the actual buffer size.\n\n\
3115 Bigger buffers allow longer recording but also take more time to process \
3116 the recorded execution trace.\n\n\
3117 The trace buffer size may not be changed while recording."), NULL,
3118 show_record_bts_buffer_size_value,
3119 &set_record_btrace_bts_cmdlist,
3120 &show_record_btrace_bts_cmdlist);
3122 add_prefix_cmd ("pt", class_support, cmd_set_record_btrace_pt,
3123 _("Set record btrace pt options"),
3124 &set_record_btrace_pt_cmdlist,
3125 "set record btrace pt ", 0, &set_record_btrace_cmdlist);
3127 add_prefix_cmd ("pt", class_support, cmd_show_record_btrace_pt,
3128 _("Show record btrace pt options"),
3129 &show_record_btrace_pt_cmdlist,
3130 "show record btrace pt ", 0, &show_record_btrace_cmdlist);
3132 add_setshow_uinteger_cmd ("buffer-size", no_class,
3133 &record_btrace_conf.pt.size,
3134 _("Set the record/replay pt buffer size."),
3135 _("Show the record/replay pt buffer size."), _("\
3136 Bigger buffers allow longer recording but also take more time to process \
3137 the recorded execution.\n\
3138 The actual buffer size may differ from the requested size. Use \"info record\" \
3139 to see the actual buffer size."), NULL, show_record_pt_buffer_size_value,
3140 &set_record_btrace_pt_cmdlist,
3141 &show_record_btrace_pt_cmdlist);
3143 init_record_btrace_ops ();
3144 add_target (&record_btrace_ops);
3146 bfcache = htab_create_alloc (50, bfcache_hash, bfcache_eq, NULL,
3149 record_btrace_conf.bts.size = 64 * 1024;
3150 record_btrace_conf.pt.size = 16 * 1024;