target: add to_record_stop_replaying target method
[external/binutils.git] / gdb / record-btrace.c
1 /* Branch trace support for GDB, the GNU debugger.
2
3    Copyright (C) 2013-2015 Free Software Foundation, Inc.
4
5    Contributed by Intel Corp. <markus.t.metzger@intel.com>
6
7    This file is part of GDB.
8
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.
13
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.
18
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/>.  */
21
22 #include "defs.h"
23 #include "record.h"
24 #include "gdbthread.h"
25 #include "target.h"
26 #include "gdbcmd.h"
27 #include "disasm.h"
28 #include "observer.h"
29 #include "cli/cli-utils.h"
30 #include "source.h"
31 #include "ui-out.h"
32 #include "symtab.h"
33 #include "filenames.h"
34 #include "regcache.h"
35 #include "frame-unwind.h"
36 #include "hashtab.h"
37 #include "infrun.h"
38 #include "event-loop.h"
39 #include "inf-loop.h"
40 #include "vec.h"
41
42 /* The target_ops of record-btrace.  */
43 static struct target_ops record_btrace_ops;
44
45 /* A new thread observer enabling branch tracing for the new thread.  */
46 static struct observer *record_btrace_thread_observer;
47
48 /* Memory access types used in set/show record btrace replay-memory-access.  */
49 static const char replay_memory_access_read_only[] = "read-only";
50 static const char replay_memory_access_read_write[] = "read-write";
51 static const char *const replay_memory_access_types[] =
52 {
53   replay_memory_access_read_only,
54   replay_memory_access_read_write,
55   NULL
56 };
57
58 /* The currently allowed replay memory access type.  */
59 static const char *replay_memory_access = replay_memory_access_read_only;
60
61 /* Command lists for "set/show record btrace".  */
62 static struct cmd_list_element *set_record_btrace_cmdlist;
63 static struct cmd_list_element *show_record_btrace_cmdlist;
64
65 /* The execution direction of the last resume we got.  See record-full.c.  */
66 static enum exec_direction_kind record_btrace_resume_exec_dir = EXEC_FORWARD;
67
68 /* The async event handler for reverse/replay execution.  */
69 static struct async_event_handler *record_btrace_async_inferior_event_handler;
70
71 /* A flag indicating that we are currently generating a core file.  */
72 static int record_btrace_generating_corefile;
73
74 /* The current branch trace configuration.  */
75 static struct btrace_config record_btrace_conf;
76
77 /* Command list for "record btrace".  */
78 static struct cmd_list_element *record_btrace_cmdlist;
79
80 /* Command lists for "set/show record btrace bts".  */
81 static struct cmd_list_element *set_record_btrace_bts_cmdlist;
82 static struct cmd_list_element *show_record_btrace_bts_cmdlist;
83
84 /* Command lists for "set/show record btrace pt".  */
85 static struct cmd_list_element *set_record_btrace_pt_cmdlist;
86 static struct cmd_list_element *show_record_btrace_pt_cmdlist;
87
88 /* Print a record-btrace debug message.  Use do ... while (0) to avoid
89    ambiguities when used in if statements.  */
90
91 #define DEBUG(msg, args...)                                             \
92   do                                                                    \
93     {                                                                   \
94       if (record_debug != 0)                                            \
95         fprintf_unfiltered (gdb_stdlog,                                 \
96                             "[record-btrace] " msg "\n", ##args);       \
97     }                                                                   \
98   while (0)
99
100
101 /* Update the branch trace for the current thread and return a pointer to its
102    thread_info.
103
104    Throws an error if there is no thread or no trace.  This function never
105    returns NULL.  */
106
107 static struct thread_info *
108 require_btrace_thread (void)
109 {
110   struct thread_info *tp;
111
112   DEBUG ("require");
113
114   tp = find_thread_ptid (inferior_ptid);
115   if (tp == NULL)
116     error (_("No thread."));
117
118   btrace_fetch (tp);
119
120   if (btrace_is_empty (tp))
121     error (_("No trace."));
122
123   return tp;
124 }
125
126 /* Update the branch trace for the current thread and return a pointer to its
127    branch trace information struct.
128
129    Throws an error if there is no thread or no trace.  This function never
130    returns NULL.  */
131
132 static struct btrace_thread_info *
133 require_btrace (void)
134 {
135   struct thread_info *tp;
136
137   tp = require_btrace_thread ();
138
139   return &tp->btrace;
140 }
141
142 /* Enable branch tracing for one thread.  Warn on errors.  */
143
144 static void
145 record_btrace_enable_warn (struct thread_info *tp)
146 {
147   TRY
148     {
149       btrace_enable (tp, &record_btrace_conf);
150     }
151   CATCH (error, RETURN_MASK_ERROR)
152     {
153       warning ("%s", error.message);
154     }
155   END_CATCH
156 }
157
158 /* Callback function to disable branch tracing for one thread.  */
159
160 static void
161 record_btrace_disable_callback (void *arg)
162 {
163   struct thread_info *tp;
164
165   tp = arg;
166
167   btrace_disable (tp);
168 }
169
170 /* Enable automatic tracing of new threads.  */
171
172 static void
173 record_btrace_auto_enable (void)
174 {
175   DEBUG ("attach thread observer");
176
177   record_btrace_thread_observer
178     = observer_attach_new_thread (record_btrace_enable_warn);
179 }
180
181 /* Disable automatic tracing of new threads.  */
182
183 static void
184 record_btrace_auto_disable (void)
185 {
186   /* The observer may have been detached, already.  */
187   if (record_btrace_thread_observer == NULL)
188     return;
189
190   DEBUG ("detach thread observer");
191
192   observer_detach_new_thread (record_btrace_thread_observer);
193   record_btrace_thread_observer = NULL;
194 }
195
196 /* The record-btrace async event handler function.  */
197
198 static void
199 record_btrace_handle_async_inferior_event (gdb_client_data data)
200 {
201   inferior_event_handler (INF_REG_EVENT, NULL);
202 }
203
204 /* The to_open method of target record-btrace.  */
205
206 static void
207 record_btrace_open (const char *args, int from_tty)
208 {
209   struct cleanup *disable_chain;
210   struct thread_info *tp;
211
212   DEBUG ("open");
213
214   record_preopen ();
215
216   if (!target_has_execution)
217     error (_("The program is not being run."));
218
219   gdb_assert (record_btrace_thread_observer == NULL);
220
221   disable_chain = make_cleanup (null_cleanup, NULL);
222   ALL_NON_EXITED_THREADS (tp)
223     if (args == NULL || *args == 0 || number_is_in_list (args, tp->num))
224       {
225         btrace_enable (tp, &record_btrace_conf);
226
227         make_cleanup (record_btrace_disable_callback, tp);
228       }
229
230   record_btrace_auto_enable ();
231
232   push_target (&record_btrace_ops);
233
234   record_btrace_async_inferior_event_handler
235     = create_async_event_handler (record_btrace_handle_async_inferior_event,
236                                   NULL);
237   record_btrace_generating_corefile = 0;
238
239   observer_notify_record_changed (current_inferior (),  1);
240
241   discard_cleanups (disable_chain);
242 }
243
244 /* The to_stop_recording method of target record-btrace.  */
245
246 static void
247 record_btrace_stop_recording (struct target_ops *self)
248 {
249   struct thread_info *tp;
250
251   DEBUG ("stop recording");
252
253   record_btrace_auto_disable ();
254
255   ALL_NON_EXITED_THREADS (tp)
256     if (tp->btrace.target != NULL)
257       btrace_disable (tp);
258 }
259
260 /* The to_close method of target record-btrace.  */
261
262 static void
263 record_btrace_close (struct target_ops *self)
264 {
265   struct thread_info *tp;
266
267   if (record_btrace_async_inferior_event_handler != NULL)
268     delete_async_event_handler (&record_btrace_async_inferior_event_handler);
269
270   /* Make sure automatic recording gets disabled even if we did not stop
271      recording before closing the record-btrace target.  */
272   record_btrace_auto_disable ();
273
274   /* We should have already stopped recording.
275      Tear down btrace in case we have not.  */
276   ALL_NON_EXITED_THREADS (tp)
277     btrace_teardown (tp);
278 }
279
280 /* The to_async method of target record-btrace.  */
281
282 static void
283 record_btrace_async (struct target_ops *ops, int enable)
284 {
285   if (enable)
286     mark_async_event_handler (record_btrace_async_inferior_event_handler);
287   else
288     clear_async_event_handler (record_btrace_async_inferior_event_handler);
289
290   ops->beneath->to_async (ops->beneath, enable);
291 }
292
293 /* Adjusts the size and returns a human readable size suffix.  */
294
295 static const char *
296 record_btrace_adjust_size (unsigned int *size)
297 {
298   unsigned int sz;
299
300   sz = *size;
301
302   if ((sz & ((1u << 30) - 1)) == 0)
303     {
304       *size = sz >> 30;
305       return "GB";
306     }
307   else if ((sz & ((1u << 20) - 1)) == 0)
308     {
309       *size = sz >> 20;
310       return "MB";
311     }
312   else if ((sz & ((1u << 10) - 1)) == 0)
313     {
314       *size = sz >> 10;
315       return "kB";
316     }
317   else
318     return "";
319 }
320
321 /* Print a BTS configuration.  */
322
323 static void
324 record_btrace_print_bts_conf (const struct btrace_config_bts *conf)
325 {
326   const char *suffix;
327   unsigned int size;
328
329   size = conf->size;
330   if (size > 0)
331     {
332       suffix = record_btrace_adjust_size (&size);
333       printf_unfiltered (_("Buffer size: %u%s.\n"), size, suffix);
334     }
335 }
336
337 /* Print an Intel(R) Processor Trace configuration.  */
338
339 static void
340 record_btrace_print_pt_conf (const struct btrace_config_pt *conf)
341 {
342   const char *suffix;
343   unsigned int size;
344
345   size = conf->size;
346   if (size > 0)
347     {
348       suffix = record_btrace_adjust_size (&size);
349       printf_unfiltered (_("Buffer size: %u%s.\n"), size, suffix);
350     }
351 }
352
353 /* Print a branch tracing configuration.  */
354
355 static void
356 record_btrace_print_conf (const struct btrace_config *conf)
357 {
358   printf_unfiltered (_("Recording format: %s.\n"),
359                      btrace_format_string (conf->format));
360
361   switch (conf->format)
362     {
363     case BTRACE_FORMAT_NONE:
364       return;
365
366     case BTRACE_FORMAT_BTS:
367       record_btrace_print_bts_conf (&conf->bts);
368       return;
369
370     case BTRACE_FORMAT_PT:
371       record_btrace_print_pt_conf (&conf->pt);
372       return;
373     }
374
375   internal_error (__FILE__, __LINE__, _("Unkown branch trace format."));
376 }
377
378 /* The to_info_record method of target record-btrace.  */
379
380 static void
381 record_btrace_info (struct target_ops *self)
382 {
383   struct btrace_thread_info *btinfo;
384   const struct btrace_config *conf;
385   struct thread_info *tp;
386   unsigned int insns, calls, gaps;
387
388   DEBUG ("info");
389
390   tp = find_thread_ptid (inferior_ptid);
391   if (tp == NULL)
392     error (_("No thread."));
393
394   btinfo = &tp->btrace;
395
396   conf = btrace_conf (btinfo);
397   if (conf != NULL)
398     record_btrace_print_conf (conf);
399
400   btrace_fetch (tp);
401
402   insns = 0;
403   calls = 0;
404   gaps = 0;
405
406   if (!btrace_is_empty (tp))
407     {
408       struct btrace_call_iterator call;
409       struct btrace_insn_iterator insn;
410
411       btrace_call_end (&call, btinfo);
412       btrace_call_prev (&call, 1);
413       calls = btrace_call_number (&call);
414
415       btrace_insn_end (&insn, btinfo);
416
417       insns = btrace_insn_number (&insn);
418       if (insns != 0)
419         {
420           /* The last instruction does not really belong to the trace.  */
421           insns -= 1;
422         }
423       else
424         {
425           unsigned int steps;
426
427           /* Skip gaps at the end.  */
428           do
429             {
430               steps = btrace_insn_prev (&insn, 1);
431               if (steps == 0)
432                 break;
433
434               insns = btrace_insn_number (&insn);
435             }
436           while (insns == 0);
437         }
438
439       gaps = btinfo->ngaps;
440     }
441
442   printf_unfiltered (_("Recorded %u instructions in %u functions (%u gaps) "
443                        "for thread %d (%s).\n"), insns, calls, gaps,
444                      tp->num, target_pid_to_str (tp->ptid));
445
446   if (btrace_is_replaying (tp))
447     printf_unfiltered (_("Replay in progress.  At instruction %u.\n"),
448                        btrace_insn_number (btinfo->replay));
449 }
450
451 /* Print a decode error.  */
452
453 static void
454 btrace_ui_out_decode_error (struct ui_out *uiout, int errcode,
455                             enum btrace_format format)
456 {
457   const char *errstr;
458   int is_error;
459
460   errstr = _("unknown");
461   is_error = 1;
462
463   switch (format)
464     {
465     default:
466       break;
467
468     case BTRACE_FORMAT_BTS:
469       switch (errcode)
470         {
471         default:
472           break;
473
474         case BDE_BTS_OVERFLOW:
475           errstr = _("instruction overflow");
476           break;
477
478         case BDE_BTS_INSN_SIZE:
479           errstr = _("unknown instruction");
480           break;
481         }
482       break;
483
484 #if defined (HAVE_LIBIPT)
485     case BTRACE_FORMAT_PT:
486       switch (errcode)
487         {
488         case BDE_PT_USER_QUIT:
489           is_error = 0;
490           errstr = _("trace decode cancelled");
491           break;
492
493         case BDE_PT_DISABLED:
494           is_error = 0;
495           errstr = _("disabled");
496           break;
497
498         case BDE_PT_OVERFLOW:
499           is_error = 0;
500           errstr = _("overflow");
501           break;
502
503         default:
504           if (errcode < 0)
505             errstr = pt_errstr (pt_errcode (errcode));
506           break;
507         }
508       break;
509 #endif /* defined (HAVE_LIBIPT)  */
510     }
511
512   ui_out_text (uiout, _("["));
513   if (is_error)
514     {
515       ui_out_text (uiout, _("decode error ("));
516       ui_out_field_int (uiout, "errcode", errcode);
517       ui_out_text (uiout, _("): "));
518     }
519   ui_out_text (uiout, errstr);
520   ui_out_text (uiout, _("]\n"));
521 }
522
523 /* Print an unsigned int.  */
524
525 static void
526 ui_out_field_uint (struct ui_out *uiout, const char *fld, unsigned int val)
527 {
528   ui_out_field_fmt (uiout, fld, "%u", val);
529 }
530
531 /* Disassemble a section of the recorded instruction trace.  */
532
533 static void
534 btrace_insn_history (struct ui_out *uiout,
535                      const struct btrace_thread_info *btinfo,
536                      const struct btrace_insn_iterator *begin,
537                      const struct btrace_insn_iterator *end, int flags)
538 {
539   struct gdbarch *gdbarch;
540   struct btrace_insn_iterator it;
541
542   DEBUG ("itrace (0x%x): [%u; %u)", flags, btrace_insn_number (begin),
543          btrace_insn_number (end));
544
545   gdbarch = target_gdbarch ();
546
547   for (it = *begin; btrace_insn_cmp (&it, end) != 0; btrace_insn_next (&it, 1))
548     {
549       const struct btrace_insn *insn;
550
551       insn = btrace_insn_get (&it);
552
553       /* A NULL instruction indicates a gap in the trace.  */
554       if (insn == NULL)
555         {
556           const struct btrace_config *conf;
557
558           conf = btrace_conf (btinfo);
559
560           /* We have trace so we must have a configuration.  */
561           gdb_assert (conf != NULL);
562
563           btrace_ui_out_decode_error (uiout, it.function->errcode,
564                                       conf->format);
565         }
566       else
567         {
568           char prefix[4];
569
570           /* We may add a speculation prefix later.  We use the same space
571              that is used for the pc prefix.  */
572           if ((flags & DISASSEMBLY_OMIT_PC) == 0)
573             strncpy (prefix, pc_prefix (insn->pc), 3);
574           else
575             {
576               prefix[0] = ' ';
577               prefix[1] = ' ';
578               prefix[2] = ' ';
579             }
580           prefix[3] = 0;
581
582           /* Print the instruction index.  */
583           ui_out_field_uint (uiout, "index", btrace_insn_number (&it));
584           ui_out_text (uiout, "\t");
585
586           /* Indicate speculative execution by a leading '?'.  */
587           if ((insn->flags & BTRACE_INSN_FLAG_SPECULATIVE) != 0)
588             prefix[0] = '?';
589
590           /* Print the prefix; we tell gdb_disassembly below to omit it.  */
591           ui_out_field_fmt (uiout, "prefix", "%s", prefix);
592
593           /* Disassembly with '/m' flag may not produce the expected result.
594              See PR gdb/11833.  */
595           gdb_disassembly (gdbarch, uiout, NULL, flags | DISASSEMBLY_OMIT_PC,
596                            1, insn->pc, insn->pc + 1);
597         }
598     }
599 }
600
601 /* The to_insn_history method of target record-btrace.  */
602
603 static void
604 record_btrace_insn_history (struct target_ops *self, int size, int flags)
605 {
606   struct btrace_thread_info *btinfo;
607   struct btrace_insn_history *history;
608   struct btrace_insn_iterator begin, end;
609   struct cleanup *uiout_cleanup;
610   struct ui_out *uiout;
611   unsigned int context, covered;
612
613   uiout = current_uiout;
614   uiout_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout,
615                                                        "insn history");
616   context = abs (size);
617   if (context == 0)
618     error (_("Bad record instruction-history-size."));
619
620   btinfo = require_btrace ();
621   history = btinfo->insn_history;
622   if (history == NULL)
623     {
624       struct btrace_insn_iterator *replay;
625
626       DEBUG ("insn-history (0x%x): %d", flags, size);
627
628       /* If we're replaying, we start at the replay position.  Otherwise, we
629          start at the tail of the trace.  */
630       replay = btinfo->replay;
631       if (replay != NULL)
632         begin = *replay;
633       else
634         btrace_insn_end (&begin, btinfo);
635
636       /* We start from here and expand in the requested direction.  Then we
637          expand in the other direction, as well, to fill up any remaining
638          context.  */
639       end = begin;
640       if (size < 0)
641         {
642           /* We want the current position covered, as well.  */
643           covered = btrace_insn_next (&end, 1);
644           covered += btrace_insn_prev (&begin, context - covered);
645           covered += btrace_insn_next (&end, context - covered);
646         }
647       else
648         {
649           covered = btrace_insn_next (&end, context);
650           covered += btrace_insn_prev (&begin, context - covered);
651         }
652     }
653   else
654     {
655       begin = history->begin;
656       end = history->end;
657
658       DEBUG ("insn-history (0x%x): %d, prev: [%u; %u)", flags, size,
659              btrace_insn_number (&begin), btrace_insn_number (&end));
660
661       if (size < 0)
662         {
663           end = begin;
664           covered = btrace_insn_prev (&begin, context);
665         }
666       else
667         {
668           begin = end;
669           covered = btrace_insn_next (&end, context);
670         }
671     }
672
673   if (covered > 0)
674     btrace_insn_history (uiout, btinfo, &begin, &end, flags);
675   else
676     {
677       if (size < 0)
678         printf_unfiltered (_("At the start of the branch trace record.\n"));
679       else
680         printf_unfiltered (_("At the end of the branch trace record.\n"));
681     }
682
683   btrace_set_insn_history (btinfo, &begin, &end);
684   do_cleanups (uiout_cleanup);
685 }
686
687 /* The to_insn_history_range method of target record-btrace.  */
688
689 static void
690 record_btrace_insn_history_range (struct target_ops *self,
691                                   ULONGEST from, ULONGEST to, int flags)
692 {
693   struct btrace_thread_info *btinfo;
694   struct btrace_insn_history *history;
695   struct btrace_insn_iterator begin, end;
696   struct cleanup *uiout_cleanup;
697   struct ui_out *uiout;
698   unsigned int low, high;
699   int found;
700
701   uiout = current_uiout;
702   uiout_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout,
703                                                        "insn history");
704   low = from;
705   high = to;
706
707   DEBUG ("insn-history (0x%x): [%u; %u)", flags, low, high);
708
709   /* Check for wrap-arounds.  */
710   if (low != from || high != to)
711     error (_("Bad range."));
712
713   if (high < low)
714     error (_("Bad range."));
715
716   btinfo = require_btrace ();
717
718   found = btrace_find_insn_by_number (&begin, btinfo, low);
719   if (found == 0)
720     error (_("Range out of bounds."));
721
722   found = btrace_find_insn_by_number (&end, btinfo, high);
723   if (found == 0)
724     {
725       /* Silently truncate the range.  */
726       btrace_insn_end (&end, btinfo);
727     }
728   else
729     {
730       /* We want both begin and end to be inclusive.  */
731       btrace_insn_next (&end, 1);
732     }
733
734   btrace_insn_history (uiout, btinfo, &begin, &end, flags);
735   btrace_set_insn_history (btinfo, &begin, &end);
736
737   do_cleanups (uiout_cleanup);
738 }
739
740 /* The to_insn_history_from method of target record-btrace.  */
741
742 static void
743 record_btrace_insn_history_from (struct target_ops *self,
744                                  ULONGEST from, int size, int flags)
745 {
746   ULONGEST begin, end, context;
747
748   context = abs (size);
749   if (context == 0)
750     error (_("Bad record instruction-history-size."));
751
752   if (size < 0)
753     {
754       end = from;
755
756       if (from < context)
757         begin = 0;
758       else
759         begin = from - context + 1;
760     }
761   else
762     {
763       begin = from;
764       end = from + context - 1;
765
766       /* Check for wrap-around.  */
767       if (end < begin)
768         end = ULONGEST_MAX;
769     }
770
771   record_btrace_insn_history_range (self, begin, end, flags);
772 }
773
774 /* Print the instruction number range for a function call history line.  */
775
776 static void
777 btrace_call_history_insn_range (struct ui_out *uiout,
778                                 const struct btrace_function *bfun)
779 {
780   unsigned int begin, end, size;
781
782   size = VEC_length (btrace_insn_s, bfun->insn);
783   gdb_assert (size > 0);
784
785   begin = bfun->insn_offset;
786   end = begin + size - 1;
787
788   ui_out_field_uint (uiout, "insn begin", begin);
789   ui_out_text (uiout, ",");
790   ui_out_field_uint (uiout, "insn end", end);
791 }
792
793 /* Compute the lowest and highest source line for the instructions in BFUN
794    and return them in PBEGIN and PEND.
795    Ignore instructions that can't be mapped to BFUN, e.g. instructions that
796    result from inlining or macro expansion.  */
797
798 static void
799 btrace_compute_src_line_range (const struct btrace_function *bfun,
800                                int *pbegin, int *pend)
801 {
802   struct btrace_insn *insn;
803   struct symtab *symtab;
804   struct symbol *sym;
805   unsigned int idx;
806   int begin, end;
807
808   begin = INT_MAX;
809   end = INT_MIN;
810
811   sym = bfun->sym;
812   if (sym == NULL)
813     goto out;
814
815   symtab = symbol_symtab (sym);
816
817   for (idx = 0; VEC_iterate (btrace_insn_s, bfun->insn, idx, insn); ++idx)
818     {
819       struct symtab_and_line sal;
820
821       sal = find_pc_line (insn->pc, 0);
822       if (sal.symtab != symtab || sal.line == 0)
823         continue;
824
825       begin = min (begin, sal.line);
826       end = max (end, sal.line);
827     }
828
829  out:
830   *pbegin = begin;
831   *pend = end;
832 }
833
834 /* Print the source line information for a function call history line.  */
835
836 static void
837 btrace_call_history_src_line (struct ui_out *uiout,
838                               const struct btrace_function *bfun)
839 {
840   struct symbol *sym;
841   int begin, end;
842
843   sym = bfun->sym;
844   if (sym == NULL)
845     return;
846
847   ui_out_field_string (uiout, "file",
848                        symtab_to_filename_for_display (symbol_symtab (sym)));
849
850   btrace_compute_src_line_range (bfun, &begin, &end);
851   if (end < begin)
852     return;
853
854   ui_out_text (uiout, ":");
855   ui_out_field_int (uiout, "min line", begin);
856
857   if (end == begin)
858     return;
859
860   ui_out_text (uiout, ",");
861   ui_out_field_int (uiout, "max line", end);
862 }
863
864 /* Get the name of a branch trace function.  */
865
866 static const char *
867 btrace_get_bfun_name (const struct btrace_function *bfun)
868 {
869   struct minimal_symbol *msym;
870   struct symbol *sym;
871
872   if (bfun == NULL)
873     return "??";
874
875   msym = bfun->msym;
876   sym = bfun->sym;
877
878   if (sym != NULL)
879     return SYMBOL_PRINT_NAME (sym);
880   else if (msym != NULL)
881     return MSYMBOL_PRINT_NAME (msym);
882   else
883     return "??";
884 }
885
886 /* Disassemble a section of the recorded function trace.  */
887
888 static void
889 btrace_call_history (struct ui_out *uiout,
890                      const struct btrace_thread_info *btinfo,
891                      const struct btrace_call_iterator *begin,
892                      const struct btrace_call_iterator *end,
893                      enum record_print_flag flags)
894 {
895   struct btrace_call_iterator it;
896
897   DEBUG ("ftrace (0x%x): [%u; %u)", flags, btrace_call_number (begin),
898          btrace_call_number (end));
899
900   for (it = *begin; btrace_call_cmp (&it, end) < 0; btrace_call_next (&it, 1))
901     {
902       const struct btrace_function *bfun;
903       struct minimal_symbol *msym;
904       struct symbol *sym;
905
906       bfun = btrace_call_get (&it);
907       sym = bfun->sym;
908       msym = bfun->msym;
909
910       /* Print the function index.  */
911       ui_out_field_uint (uiout, "index", bfun->number);
912       ui_out_text (uiout, "\t");
913
914       /* Indicate gaps in the trace.  */
915       if (bfun->errcode != 0)
916         {
917           const struct btrace_config *conf;
918
919           conf = btrace_conf (btinfo);
920
921           /* We have trace so we must have a configuration.  */
922           gdb_assert (conf != NULL);
923
924           btrace_ui_out_decode_error (uiout, bfun->errcode, conf->format);
925
926           continue;
927         }
928
929       if ((flags & RECORD_PRINT_INDENT_CALLS) != 0)
930         {
931           int level = bfun->level + btinfo->level, i;
932
933           for (i = 0; i < level; ++i)
934             ui_out_text (uiout, "  ");
935         }
936
937       if (sym != NULL)
938         ui_out_field_string (uiout, "function", SYMBOL_PRINT_NAME (sym));
939       else if (msym != NULL)
940         ui_out_field_string (uiout, "function", MSYMBOL_PRINT_NAME (msym));
941       else if (!ui_out_is_mi_like_p (uiout))
942         ui_out_field_string (uiout, "function", "??");
943
944       if ((flags & RECORD_PRINT_INSN_RANGE) != 0)
945         {
946           ui_out_text (uiout, _("\tinst "));
947           btrace_call_history_insn_range (uiout, bfun);
948         }
949
950       if ((flags & RECORD_PRINT_SRC_LINE) != 0)
951         {
952           ui_out_text (uiout, _("\tat "));
953           btrace_call_history_src_line (uiout, bfun);
954         }
955
956       ui_out_text (uiout, "\n");
957     }
958 }
959
960 /* The to_call_history method of target record-btrace.  */
961
962 static void
963 record_btrace_call_history (struct target_ops *self, int size, int flags)
964 {
965   struct btrace_thread_info *btinfo;
966   struct btrace_call_history *history;
967   struct btrace_call_iterator begin, end;
968   struct cleanup *uiout_cleanup;
969   struct ui_out *uiout;
970   unsigned int context, covered;
971
972   uiout = current_uiout;
973   uiout_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout,
974                                                        "insn history");
975   context = abs (size);
976   if (context == 0)
977     error (_("Bad record function-call-history-size."));
978
979   btinfo = require_btrace ();
980   history = btinfo->call_history;
981   if (history == NULL)
982     {
983       struct btrace_insn_iterator *replay;
984
985       DEBUG ("call-history (0x%x): %d", flags, size);
986
987       /* If we're replaying, we start at the replay position.  Otherwise, we
988          start at the tail of the trace.  */
989       replay = btinfo->replay;
990       if (replay != NULL)
991         {
992           begin.function = replay->function;
993           begin.btinfo = btinfo;
994         }
995       else
996         btrace_call_end (&begin, btinfo);
997
998       /* We start from here and expand in the requested direction.  Then we
999          expand in the other direction, as well, to fill up any remaining
1000          context.  */
1001       end = begin;
1002       if (size < 0)
1003         {
1004           /* We want the current position covered, as well.  */
1005           covered = btrace_call_next (&end, 1);
1006           covered += btrace_call_prev (&begin, context - covered);
1007           covered += btrace_call_next (&end, context - covered);
1008         }
1009       else
1010         {
1011           covered = btrace_call_next (&end, context);
1012           covered += btrace_call_prev (&begin, context- covered);
1013         }
1014     }
1015   else
1016     {
1017       begin = history->begin;
1018       end = history->end;
1019
1020       DEBUG ("call-history (0x%x): %d, prev: [%u; %u)", flags, size,
1021              btrace_call_number (&begin), btrace_call_number (&end));
1022
1023       if (size < 0)
1024         {
1025           end = begin;
1026           covered = btrace_call_prev (&begin, context);
1027         }
1028       else
1029         {
1030           begin = end;
1031           covered = btrace_call_next (&end, context);
1032         }
1033     }
1034
1035   if (covered > 0)
1036     btrace_call_history (uiout, btinfo, &begin, &end, flags);
1037   else
1038     {
1039       if (size < 0)
1040         printf_unfiltered (_("At the start of the branch trace record.\n"));
1041       else
1042         printf_unfiltered (_("At the end of the branch trace record.\n"));
1043     }
1044
1045   btrace_set_call_history (btinfo, &begin, &end);
1046   do_cleanups (uiout_cleanup);
1047 }
1048
1049 /* The to_call_history_range method of target record-btrace.  */
1050
1051 static void
1052 record_btrace_call_history_range (struct target_ops *self,
1053                                   ULONGEST from, ULONGEST to, int flags)
1054 {
1055   struct btrace_thread_info *btinfo;
1056   struct btrace_call_history *history;
1057   struct btrace_call_iterator begin, end;
1058   struct cleanup *uiout_cleanup;
1059   struct ui_out *uiout;
1060   unsigned int low, high;
1061   int found;
1062
1063   uiout = current_uiout;
1064   uiout_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout,
1065                                                        "func history");
1066   low = from;
1067   high = to;
1068
1069   DEBUG ("call-history (0x%x): [%u; %u)", flags, low, high);
1070
1071   /* Check for wrap-arounds.  */
1072   if (low != from || high != to)
1073     error (_("Bad range."));
1074
1075   if (high < low)
1076     error (_("Bad range."));
1077
1078   btinfo = require_btrace ();
1079
1080   found = btrace_find_call_by_number (&begin, btinfo, low);
1081   if (found == 0)
1082     error (_("Range out of bounds."));
1083
1084   found = btrace_find_call_by_number (&end, btinfo, high);
1085   if (found == 0)
1086     {
1087       /* Silently truncate the range.  */
1088       btrace_call_end (&end, btinfo);
1089     }
1090   else
1091     {
1092       /* We want both begin and end to be inclusive.  */
1093       btrace_call_next (&end, 1);
1094     }
1095
1096   btrace_call_history (uiout, btinfo, &begin, &end, flags);
1097   btrace_set_call_history (btinfo, &begin, &end);
1098
1099   do_cleanups (uiout_cleanup);
1100 }
1101
1102 /* The to_call_history_from method of target record-btrace.  */
1103
1104 static void
1105 record_btrace_call_history_from (struct target_ops *self,
1106                                  ULONGEST from, int size, int flags)
1107 {
1108   ULONGEST begin, end, context;
1109
1110   context = abs (size);
1111   if (context == 0)
1112     error (_("Bad record function-call-history-size."));
1113
1114   if (size < 0)
1115     {
1116       end = from;
1117
1118       if (from < context)
1119         begin = 0;
1120       else
1121         begin = from - context + 1;
1122     }
1123   else
1124     {
1125       begin = from;
1126       end = from + context - 1;
1127
1128       /* Check for wrap-around.  */
1129       if (end < begin)
1130         end = ULONGEST_MAX;
1131     }
1132
1133   record_btrace_call_history_range (self, begin, end, flags);
1134 }
1135
1136 /* The to_record_is_replaying method of target record-btrace.  */
1137
1138 static int
1139 record_btrace_is_replaying (struct target_ops *self, ptid_t ptid)
1140 {
1141   struct thread_info *tp;
1142
1143   ALL_NON_EXITED_THREADS (tp)
1144     if (ptid_match (tp->ptid, ptid) && btrace_is_replaying (tp))
1145       return 1;
1146
1147   return 0;
1148 }
1149
1150 /* The to_xfer_partial method of target record-btrace.  */
1151
1152 static enum target_xfer_status
1153 record_btrace_xfer_partial (struct target_ops *ops, enum target_object object,
1154                             const char *annex, gdb_byte *readbuf,
1155                             const gdb_byte *writebuf, ULONGEST offset,
1156                             ULONGEST len, ULONGEST *xfered_len)
1157 {
1158   struct target_ops *t;
1159
1160   /* Filter out requests that don't make sense during replay.  */
1161   if (replay_memory_access == replay_memory_access_read_only
1162       && !record_btrace_generating_corefile
1163       && record_btrace_is_replaying (ops, inferior_ptid))
1164     {
1165       switch (object)
1166         {
1167         case TARGET_OBJECT_MEMORY:
1168           {
1169             struct target_section *section;
1170
1171             /* We do not allow writing memory in general.  */
1172             if (writebuf != NULL)
1173               {
1174                 *xfered_len = len;
1175                 return TARGET_XFER_UNAVAILABLE;
1176               }
1177
1178             /* We allow reading readonly memory.  */
1179             section = target_section_by_addr (ops, offset);
1180             if (section != NULL)
1181               {
1182                 /* Check if the section we found is readonly.  */
1183                 if ((bfd_get_section_flags (section->the_bfd_section->owner,
1184                                             section->the_bfd_section)
1185                      & SEC_READONLY) != 0)
1186                   {
1187                     /* Truncate the request to fit into this section.  */
1188                     len = min (len, section->endaddr - offset);
1189                     break;
1190                   }
1191               }
1192
1193             *xfered_len = len;
1194             return TARGET_XFER_UNAVAILABLE;
1195           }
1196         }
1197     }
1198
1199   /* Forward the request.  */
1200   ops = ops->beneath;
1201   return ops->to_xfer_partial (ops, object, annex, readbuf, writebuf,
1202                                offset, len, xfered_len);
1203 }
1204
1205 /* The to_insert_breakpoint method of target record-btrace.  */
1206
1207 static int
1208 record_btrace_insert_breakpoint (struct target_ops *ops,
1209                                  struct gdbarch *gdbarch,
1210                                  struct bp_target_info *bp_tgt)
1211 {
1212   const char *old;
1213   int ret;
1214
1215   /* Inserting breakpoints requires accessing memory.  Allow it for the
1216      duration of this function.  */
1217   old = replay_memory_access;
1218   replay_memory_access = replay_memory_access_read_write;
1219
1220   ret = 0;
1221   TRY
1222     {
1223       ret = ops->beneath->to_insert_breakpoint (ops->beneath, gdbarch, bp_tgt);
1224     }
1225   CATCH (except, RETURN_MASK_ALL)
1226     {
1227       replay_memory_access = old;
1228       throw_exception (except);
1229     }
1230   END_CATCH
1231   replay_memory_access = old;
1232
1233   return ret;
1234 }
1235
1236 /* The to_remove_breakpoint method of target record-btrace.  */
1237
1238 static int
1239 record_btrace_remove_breakpoint (struct target_ops *ops,
1240                                  struct gdbarch *gdbarch,
1241                                  struct bp_target_info *bp_tgt)
1242 {
1243   const char *old;
1244   int ret;
1245
1246   /* Removing breakpoints requires accessing memory.  Allow it for the
1247      duration of this function.  */
1248   old = replay_memory_access;
1249   replay_memory_access = replay_memory_access_read_write;
1250
1251   ret = 0;
1252   TRY
1253     {
1254       ret = ops->beneath->to_remove_breakpoint (ops->beneath, gdbarch, bp_tgt);
1255     }
1256   CATCH (except, RETURN_MASK_ALL)
1257     {
1258       replay_memory_access = old;
1259       throw_exception (except);
1260     }
1261   END_CATCH
1262   replay_memory_access = old;
1263
1264   return ret;
1265 }
1266
1267 /* The to_fetch_registers method of target record-btrace.  */
1268
1269 static void
1270 record_btrace_fetch_registers (struct target_ops *ops,
1271                                struct regcache *regcache, int regno)
1272 {
1273   struct btrace_insn_iterator *replay;
1274   struct thread_info *tp;
1275
1276   tp = find_thread_ptid (inferior_ptid);
1277   gdb_assert (tp != NULL);
1278
1279   replay = tp->btrace.replay;
1280   if (replay != NULL && !record_btrace_generating_corefile)
1281     {
1282       const struct btrace_insn *insn;
1283       struct gdbarch *gdbarch;
1284       int pcreg;
1285
1286       gdbarch = get_regcache_arch (regcache);
1287       pcreg = gdbarch_pc_regnum (gdbarch);
1288       if (pcreg < 0)
1289         return;
1290
1291       /* We can only provide the PC register.  */
1292       if (regno >= 0 && regno != pcreg)
1293         return;
1294
1295       insn = btrace_insn_get (replay);
1296       gdb_assert (insn != NULL);
1297
1298       regcache_raw_supply (regcache, regno, &insn->pc);
1299     }
1300   else
1301     {
1302       struct target_ops *t = ops->beneath;
1303
1304       t->to_fetch_registers (t, regcache, regno);
1305     }
1306 }
1307
1308 /* The to_store_registers method of target record-btrace.  */
1309
1310 static void
1311 record_btrace_store_registers (struct target_ops *ops,
1312                                struct regcache *regcache, int regno)
1313 {
1314   struct target_ops *t;
1315
1316   if (!record_btrace_generating_corefile
1317       && record_btrace_is_replaying (ops, inferior_ptid))
1318     error (_("Cannot write registers while replaying."));
1319
1320   gdb_assert (may_write_registers != 0);
1321
1322   t = ops->beneath;
1323   t->to_store_registers (t, regcache, regno);
1324 }
1325
1326 /* The to_prepare_to_store method of target record-btrace.  */
1327
1328 static void
1329 record_btrace_prepare_to_store (struct target_ops *ops,
1330                                 struct regcache *regcache)
1331 {
1332   struct target_ops *t;
1333
1334   if (!record_btrace_generating_corefile
1335       && record_btrace_is_replaying (ops, inferior_ptid))
1336     return;
1337
1338   t = ops->beneath;
1339   t->to_prepare_to_store (t, regcache);
1340 }
1341
1342 /* The branch trace frame cache.  */
1343
1344 struct btrace_frame_cache
1345 {
1346   /* The thread.  */
1347   struct thread_info *tp;
1348
1349   /* The frame info.  */
1350   struct frame_info *frame;
1351
1352   /* The branch trace function segment.  */
1353   const struct btrace_function *bfun;
1354 };
1355
1356 /* A struct btrace_frame_cache hash table indexed by NEXT.  */
1357
1358 static htab_t bfcache;
1359
1360 /* hash_f for htab_create_alloc of bfcache.  */
1361
1362 static hashval_t
1363 bfcache_hash (const void *arg)
1364 {
1365   const struct btrace_frame_cache *cache = arg;
1366
1367   return htab_hash_pointer (cache->frame);
1368 }
1369
1370 /* eq_f for htab_create_alloc of bfcache.  */
1371
1372 static int
1373 bfcache_eq (const void *arg1, const void *arg2)
1374 {
1375   const struct btrace_frame_cache *cache1 = arg1;
1376   const struct btrace_frame_cache *cache2 = arg2;
1377
1378   return cache1->frame == cache2->frame;
1379 }
1380
1381 /* Create a new btrace frame cache.  */
1382
1383 static struct btrace_frame_cache *
1384 bfcache_new (struct frame_info *frame)
1385 {
1386   struct btrace_frame_cache *cache;
1387   void **slot;
1388
1389   cache = FRAME_OBSTACK_ZALLOC (struct btrace_frame_cache);
1390   cache->frame = frame;
1391
1392   slot = htab_find_slot (bfcache, cache, INSERT);
1393   gdb_assert (*slot == NULL);
1394   *slot = cache;
1395
1396   return cache;
1397 }
1398
1399 /* Extract the branch trace function from a branch trace frame.  */
1400
1401 static const struct btrace_function *
1402 btrace_get_frame_function (struct frame_info *frame)
1403 {
1404   const struct btrace_frame_cache *cache;
1405   const struct btrace_function *bfun;
1406   struct btrace_frame_cache pattern;
1407   void **slot;
1408
1409   pattern.frame = frame;
1410
1411   slot = htab_find_slot (bfcache, &pattern, NO_INSERT);
1412   if (slot == NULL)
1413     return NULL;
1414
1415   cache = *slot;
1416   return cache->bfun;
1417 }
1418
1419 /* Implement stop_reason method for record_btrace_frame_unwind.  */
1420
1421 static enum unwind_stop_reason
1422 record_btrace_frame_unwind_stop_reason (struct frame_info *this_frame,
1423                                         void **this_cache)
1424 {
1425   const struct btrace_frame_cache *cache;
1426   const struct btrace_function *bfun;
1427
1428   cache = *this_cache;
1429   bfun = cache->bfun;
1430   gdb_assert (bfun != NULL);
1431
1432   if (bfun->up == NULL)
1433     return UNWIND_UNAVAILABLE;
1434
1435   return UNWIND_NO_REASON;
1436 }
1437
1438 /* Implement this_id method for record_btrace_frame_unwind.  */
1439
1440 static void
1441 record_btrace_frame_this_id (struct frame_info *this_frame, void **this_cache,
1442                              struct frame_id *this_id)
1443 {
1444   const struct btrace_frame_cache *cache;
1445   const struct btrace_function *bfun;
1446   CORE_ADDR code, special;
1447
1448   cache = *this_cache;
1449
1450   bfun = cache->bfun;
1451   gdb_assert (bfun != NULL);
1452
1453   while (bfun->segment.prev != NULL)
1454     bfun = bfun->segment.prev;
1455
1456   code = get_frame_func (this_frame);
1457   special = bfun->number;
1458
1459   *this_id = frame_id_build_unavailable_stack_special (code, special);
1460
1461   DEBUG ("[frame] %s id: (!stack, pc=%s, special=%s)",
1462          btrace_get_bfun_name (cache->bfun),
1463          core_addr_to_string_nz (this_id->code_addr),
1464          core_addr_to_string_nz (this_id->special_addr));
1465 }
1466
1467 /* Implement prev_register method for record_btrace_frame_unwind.  */
1468
1469 static struct value *
1470 record_btrace_frame_prev_register (struct frame_info *this_frame,
1471                                    void **this_cache,
1472                                    int regnum)
1473 {
1474   const struct btrace_frame_cache *cache;
1475   const struct btrace_function *bfun, *caller;
1476   const struct btrace_insn *insn;
1477   struct gdbarch *gdbarch;
1478   CORE_ADDR pc;
1479   int pcreg;
1480
1481   gdbarch = get_frame_arch (this_frame);
1482   pcreg = gdbarch_pc_regnum (gdbarch);
1483   if (pcreg < 0 || regnum != pcreg)
1484     throw_error (NOT_AVAILABLE_ERROR,
1485                  _("Registers are not available in btrace record history"));
1486
1487   cache = *this_cache;
1488   bfun = cache->bfun;
1489   gdb_assert (bfun != NULL);
1490
1491   caller = bfun->up;
1492   if (caller == NULL)
1493     throw_error (NOT_AVAILABLE_ERROR,
1494                  _("No caller in btrace record history"));
1495
1496   if ((bfun->flags & BFUN_UP_LINKS_TO_RET) != 0)
1497     {
1498       insn = VEC_index (btrace_insn_s, caller->insn, 0);
1499       pc = insn->pc;
1500     }
1501   else
1502     {
1503       insn = VEC_last (btrace_insn_s, caller->insn);
1504       pc = insn->pc;
1505
1506       pc += gdb_insn_length (gdbarch, pc);
1507     }
1508
1509   DEBUG ("[frame] unwound PC in %s on level %d: %s",
1510          btrace_get_bfun_name (bfun), bfun->level,
1511          core_addr_to_string_nz (pc));
1512
1513   return frame_unwind_got_address (this_frame, regnum, pc);
1514 }
1515
1516 /* Implement sniffer method for record_btrace_frame_unwind.  */
1517
1518 static int
1519 record_btrace_frame_sniffer (const struct frame_unwind *self,
1520                              struct frame_info *this_frame,
1521                              void **this_cache)
1522 {
1523   const struct btrace_function *bfun;
1524   struct btrace_frame_cache *cache;
1525   struct thread_info *tp;
1526   struct frame_info *next;
1527
1528   /* THIS_FRAME does not contain a reference to its thread.  */
1529   tp = find_thread_ptid (inferior_ptid);
1530   gdb_assert (tp != NULL);
1531
1532   bfun = NULL;
1533   next = get_next_frame (this_frame);
1534   if (next == NULL)
1535     {
1536       const struct btrace_insn_iterator *replay;
1537
1538       replay = tp->btrace.replay;
1539       if (replay != NULL)
1540         bfun = replay->function;
1541     }
1542   else
1543     {
1544       const struct btrace_function *callee;
1545
1546       callee = btrace_get_frame_function (next);
1547       if (callee != NULL && (callee->flags & BFUN_UP_LINKS_TO_TAILCALL) == 0)
1548         bfun = callee->up;
1549     }
1550
1551   if (bfun == NULL)
1552     return 0;
1553
1554   DEBUG ("[frame] sniffed frame for %s on level %d",
1555          btrace_get_bfun_name (bfun), bfun->level);
1556
1557   /* This is our frame.  Initialize the frame cache.  */
1558   cache = bfcache_new (this_frame);
1559   cache->tp = tp;
1560   cache->bfun = bfun;
1561
1562   *this_cache = cache;
1563   return 1;
1564 }
1565
1566 /* Implement sniffer method for record_btrace_tailcall_frame_unwind.  */
1567
1568 static int
1569 record_btrace_tailcall_frame_sniffer (const struct frame_unwind *self,
1570                                       struct frame_info *this_frame,
1571                                       void **this_cache)
1572 {
1573   const struct btrace_function *bfun, *callee;
1574   struct btrace_frame_cache *cache;
1575   struct frame_info *next;
1576
1577   next = get_next_frame (this_frame);
1578   if (next == NULL)
1579     return 0;
1580
1581   callee = btrace_get_frame_function (next);
1582   if (callee == NULL)
1583     return 0;
1584
1585   if ((callee->flags & BFUN_UP_LINKS_TO_TAILCALL) == 0)
1586     return 0;
1587
1588   bfun = callee->up;
1589   if (bfun == NULL)
1590     return 0;
1591
1592   DEBUG ("[frame] sniffed tailcall frame for %s on level %d",
1593          btrace_get_bfun_name (bfun), bfun->level);
1594
1595   /* This is our frame.  Initialize the frame cache.  */
1596   cache = bfcache_new (this_frame);
1597   cache->tp = find_thread_ptid (inferior_ptid);
1598   cache->bfun = bfun;
1599
1600   *this_cache = cache;
1601   return 1;
1602 }
1603
1604 static void
1605 record_btrace_frame_dealloc_cache (struct frame_info *self, void *this_cache)
1606 {
1607   struct btrace_frame_cache *cache;
1608   void **slot;
1609
1610   cache = this_cache;
1611
1612   slot = htab_find_slot (bfcache, cache, NO_INSERT);
1613   gdb_assert (slot != NULL);
1614
1615   htab_remove_elt (bfcache, cache);
1616 }
1617
1618 /* btrace recording does not store previous memory content, neither the stack
1619    frames content.  Any unwinding would return errorneous results as the stack
1620    contents no longer matches the changed PC value restored from history.
1621    Therefore this unwinder reports any possibly unwound registers as
1622    <unavailable>.  */
1623
1624 const struct frame_unwind record_btrace_frame_unwind =
1625 {
1626   NORMAL_FRAME,
1627   record_btrace_frame_unwind_stop_reason,
1628   record_btrace_frame_this_id,
1629   record_btrace_frame_prev_register,
1630   NULL,
1631   record_btrace_frame_sniffer,
1632   record_btrace_frame_dealloc_cache
1633 };
1634
1635 const struct frame_unwind record_btrace_tailcall_frame_unwind =
1636 {
1637   TAILCALL_FRAME,
1638   record_btrace_frame_unwind_stop_reason,
1639   record_btrace_frame_this_id,
1640   record_btrace_frame_prev_register,
1641   NULL,
1642   record_btrace_tailcall_frame_sniffer,
1643   record_btrace_frame_dealloc_cache
1644 };
1645
1646 /* Implement the to_get_unwinder method.  */
1647
1648 static const struct frame_unwind *
1649 record_btrace_to_get_unwinder (struct target_ops *self)
1650 {
1651   return &record_btrace_frame_unwind;
1652 }
1653
1654 /* Implement the to_get_tailcall_unwinder method.  */
1655
1656 static const struct frame_unwind *
1657 record_btrace_to_get_tailcall_unwinder (struct target_ops *self)
1658 {
1659   return &record_btrace_tailcall_frame_unwind;
1660 }
1661
1662 /* Return a human-readable string for FLAG.  */
1663
1664 static const char *
1665 btrace_thread_flag_to_str (enum btrace_thread_flag flag)
1666 {
1667   switch (flag)
1668     {
1669     case BTHR_STEP:
1670       return "step";
1671
1672     case BTHR_RSTEP:
1673       return "reverse-step";
1674
1675     case BTHR_CONT:
1676       return "cont";
1677
1678     case BTHR_RCONT:
1679       return "reverse-cont";
1680
1681     case BTHR_STOP:
1682       return "stop";
1683     }
1684
1685   return "<invalid>";
1686 }
1687
1688 /* Indicate that TP should be resumed according to FLAG.  */
1689
1690 static void
1691 record_btrace_resume_thread (struct thread_info *tp,
1692                              enum btrace_thread_flag flag)
1693 {
1694   struct btrace_thread_info *btinfo;
1695
1696   DEBUG ("resuming thread %d (%s): %x (%s)", tp->num,
1697          target_pid_to_str (tp->ptid), flag, btrace_thread_flag_to_str (flag));
1698
1699   btinfo = &tp->btrace;
1700
1701   /* Fetch the latest branch trace.  */
1702   btrace_fetch (tp);
1703
1704   /* A resume request overwrites a preceding resume or stop request.  */
1705   btinfo->flags &= ~(BTHR_MOVE | BTHR_STOP);
1706   btinfo->flags |= flag;
1707 }
1708
1709 /* Get the current frame for TP.  */
1710
1711 static struct frame_info *
1712 get_thread_current_frame (struct thread_info *tp)
1713 {
1714   struct frame_info *frame;
1715   ptid_t old_inferior_ptid;
1716   int executing;
1717
1718   /* Set INFERIOR_PTID, which is implicitly used by get_current_frame.  */
1719   old_inferior_ptid = inferior_ptid;
1720   inferior_ptid = tp->ptid;
1721
1722   /* Clear the executing flag to allow changes to the current frame.
1723      We are not actually running, yet.  We just started a reverse execution
1724      command or a record goto command.
1725      For the latter, EXECUTING is false and this has no effect.
1726      For the former, EXECUTING is true and we're in to_wait, about to
1727      move the thread.  Since we need to recompute the stack, we temporarily
1728      set EXECUTING to flase.  */
1729   executing = is_executing (inferior_ptid);
1730   set_executing (inferior_ptid, 0);
1731
1732   frame = NULL;
1733   TRY
1734     {
1735       frame = get_current_frame ();
1736     }
1737   CATCH (except, RETURN_MASK_ALL)
1738     {
1739       /* Restore the previous execution state.  */
1740       set_executing (inferior_ptid, executing);
1741
1742       /* Restore the previous inferior_ptid.  */
1743       inferior_ptid = old_inferior_ptid;
1744
1745       throw_exception (except);
1746     }
1747   END_CATCH
1748
1749   /* Restore the previous execution state.  */
1750   set_executing (inferior_ptid, executing);
1751
1752   /* Restore the previous inferior_ptid.  */
1753   inferior_ptid = old_inferior_ptid;
1754
1755   return frame;
1756 }
1757
1758 /* Start replaying a thread.  */
1759
1760 static struct btrace_insn_iterator *
1761 record_btrace_start_replaying (struct thread_info *tp)
1762 {
1763   struct btrace_insn_iterator *replay;
1764   struct btrace_thread_info *btinfo;
1765
1766   btinfo = &tp->btrace;
1767   replay = NULL;
1768
1769   /* We can't start replaying without trace.  */
1770   if (btinfo->begin == NULL)
1771     return NULL;
1772
1773   /* GDB stores the current frame_id when stepping in order to detects steps
1774      into subroutines.
1775      Since frames are computed differently when we're replaying, we need to
1776      recompute those stored frames and fix them up so we can still detect
1777      subroutines after we started replaying.  */
1778   TRY
1779     {
1780       struct frame_info *frame;
1781       struct frame_id frame_id;
1782       int upd_step_frame_id, upd_step_stack_frame_id;
1783
1784       /* The current frame without replaying - computed via normal unwind.  */
1785       frame = get_thread_current_frame (tp);
1786       frame_id = get_frame_id (frame);
1787
1788       /* Check if we need to update any stepping-related frame id's.  */
1789       upd_step_frame_id = frame_id_eq (frame_id,
1790                                        tp->control.step_frame_id);
1791       upd_step_stack_frame_id = frame_id_eq (frame_id,
1792                                              tp->control.step_stack_frame_id);
1793
1794       /* We start replaying at the end of the branch trace.  This corresponds
1795          to the current instruction.  */
1796       replay = XNEW (struct btrace_insn_iterator);
1797       btrace_insn_end (replay, btinfo);
1798
1799       /* Skip gaps at the end of the trace.  */
1800       while (btrace_insn_get (replay) == NULL)
1801         {
1802           unsigned int steps;
1803
1804           steps = btrace_insn_prev (replay, 1);
1805           if (steps == 0)
1806             error (_("No trace."));
1807         }
1808
1809       /* We're not replaying, yet.  */
1810       gdb_assert (btinfo->replay == NULL);
1811       btinfo->replay = replay;
1812
1813       /* Make sure we're not using any stale registers.  */
1814       registers_changed_ptid (tp->ptid);
1815
1816       /* The current frame with replaying - computed via btrace unwind.  */
1817       frame = get_thread_current_frame (tp);
1818       frame_id = get_frame_id (frame);
1819
1820       /* Replace stepping related frames where necessary.  */
1821       if (upd_step_frame_id)
1822         tp->control.step_frame_id = frame_id;
1823       if (upd_step_stack_frame_id)
1824         tp->control.step_stack_frame_id = frame_id;
1825     }
1826   CATCH (except, RETURN_MASK_ALL)
1827     {
1828       xfree (btinfo->replay);
1829       btinfo->replay = NULL;
1830
1831       registers_changed_ptid (tp->ptid);
1832
1833       throw_exception (except);
1834     }
1835   END_CATCH
1836
1837   return replay;
1838 }
1839
1840 /* Stop replaying a thread.  */
1841
1842 static void
1843 record_btrace_stop_replaying (struct thread_info *tp)
1844 {
1845   struct btrace_thread_info *btinfo;
1846
1847   btinfo = &tp->btrace;
1848
1849   xfree (btinfo->replay);
1850   btinfo->replay = NULL;
1851
1852   /* Make sure we're not leaving any stale registers.  */
1853   registers_changed_ptid (tp->ptid);
1854 }
1855
1856 /* Stop replaying TP if it is at the end of its execution history.  */
1857
1858 static void
1859 record_btrace_stop_replaying_at_end (struct thread_info *tp)
1860 {
1861   struct btrace_insn_iterator *replay, end;
1862   struct btrace_thread_info *btinfo;
1863
1864   btinfo = &tp->btrace;
1865   replay = btinfo->replay;
1866
1867   if (replay == NULL)
1868     return;
1869
1870   btrace_insn_end (&end, btinfo);
1871
1872   if (btrace_insn_cmp (replay, &end) == 0)
1873     record_btrace_stop_replaying (tp);
1874 }
1875
1876 /* The to_resume method of target record-btrace.  */
1877
1878 static void
1879 record_btrace_resume (struct target_ops *ops, ptid_t ptid, int step,
1880                       enum gdb_signal signal)
1881 {
1882   struct thread_info *tp;
1883   enum btrace_thread_flag flag;
1884   ptid_t orig_ptid;
1885
1886   DEBUG ("resume %s: %s%s", target_pid_to_str (ptid),
1887          execution_direction == EXEC_REVERSE ? "reverse-" : "",
1888          step ? "step" : "cont");
1889
1890   orig_ptid = ptid;
1891
1892   /* Store the execution direction of the last resume.
1893
1894      If there is more than one to_resume call, we have to rely on infrun
1895      to not change the execution direction in-between.  */
1896   record_btrace_resume_exec_dir = execution_direction;
1897
1898   /* For all-stop targets...  */
1899   if (!target_is_non_stop_p ())
1900     {
1901       /* ...we pick the current thread when asked to resume an entire process
1902          or everything.  */
1903       if (ptid_equal (minus_one_ptid, ptid) || ptid_is_pid (ptid))
1904         ptid = inferior_ptid;
1905
1906       tp = find_thread_ptid (ptid);
1907       if (tp == NULL)
1908         error (_("Cannot find thread to resume."));
1909
1910       /* ...and we stop replaying other threads if the thread to resume is not
1911          replaying.  */
1912       if (!btrace_is_replaying (tp) && execution_direction != EXEC_REVERSE)
1913         target_record_stop_replaying ();
1914     }
1915
1916   /* As long as we're not replaying, just forward the request.
1917
1918      For non-stop targets this means that no thread is replaying.  In order to
1919      make progress, we may need to explicitly move replaying threads to the end
1920      of their execution history.  */
1921   if ((execution_direction != EXEC_REVERSE)
1922       && !record_btrace_is_replaying (ops, minus_one_ptid))
1923     {
1924       ops = ops->beneath;
1925       return ops->to_resume (ops, orig_ptid, step, signal);
1926     }
1927
1928   /* Compute the btrace thread flag for the requested move.  */
1929   if (step == 0)
1930     flag = execution_direction == EXEC_REVERSE ? BTHR_RCONT : BTHR_CONT;
1931   else
1932     flag = execution_direction == EXEC_REVERSE ? BTHR_RSTEP : BTHR_STEP;
1933
1934   /* We just indicate the resume intent here.  The actual stepping happens in
1935      record_btrace_wait below.  */
1936   ALL_NON_EXITED_THREADS (tp)
1937     if (ptid_match (tp->ptid, ptid))
1938       record_btrace_resume_thread (tp, flag);
1939
1940   /* Async support.  */
1941   if (target_can_async_p ())
1942     {
1943       target_async (1);
1944       mark_async_event_handler (record_btrace_async_inferior_event_handler);
1945     }
1946 }
1947
1948 /* Cancel resuming TP.  */
1949
1950 static void
1951 record_btrace_cancel_resume (struct thread_info *tp)
1952 {
1953   enum btrace_thread_flag flags;
1954
1955   flags = tp->btrace.flags & (BTHR_MOVE | BTHR_STOP);
1956   if (flags == 0)
1957     return;
1958
1959   DEBUG ("cancel resume thread %d (%s): %x (%s)", tp->num,
1960          target_pid_to_str (tp->ptid), flags,
1961          btrace_thread_flag_to_str (flags));
1962
1963   tp->btrace.flags &= ~(BTHR_MOVE | BTHR_STOP);
1964   record_btrace_stop_replaying_at_end (tp);
1965 }
1966
1967 /* Return a target_waitstatus indicating that we ran out of history.  */
1968
1969 static struct target_waitstatus
1970 btrace_step_no_history (void)
1971 {
1972   struct target_waitstatus status;
1973
1974   status.kind = TARGET_WAITKIND_NO_HISTORY;
1975
1976   return status;
1977 }
1978
1979 /* Return a target_waitstatus indicating that a step finished.  */
1980
1981 static struct target_waitstatus
1982 btrace_step_stopped (void)
1983 {
1984   struct target_waitstatus status;
1985
1986   status.kind = TARGET_WAITKIND_STOPPED;
1987   status.value.sig = GDB_SIGNAL_TRAP;
1988
1989   return status;
1990 }
1991
1992 /* Return a target_waitstatus indicating that a thread was stopped as
1993    requested.  */
1994
1995 static struct target_waitstatus
1996 btrace_step_stopped_on_request (void)
1997 {
1998   struct target_waitstatus status;
1999
2000   status.kind = TARGET_WAITKIND_STOPPED;
2001   status.value.sig = GDB_SIGNAL_0;
2002
2003   return status;
2004 }
2005
2006 /* Return a target_waitstatus indicating a spurious stop.  */
2007
2008 static struct target_waitstatus
2009 btrace_step_spurious (void)
2010 {
2011   struct target_waitstatus status;
2012
2013   status.kind = TARGET_WAITKIND_SPURIOUS;
2014
2015   return status;
2016 }
2017
2018 /* Return a target_waitstatus indicating that the thread was not resumed.  */
2019
2020 static struct target_waitstatus
2021 btrace_step_no_resumed (void)
2022 {
2023   struct target_waitstatus status;
2024
2025   status.kind = TARGET_WAITKIND_NO_RESUMED;
2026
2027   return status;
2028 }
2029
2030 /* Return a target_waitstatus indicating that we should wait again.  */
2031
2032 static struct target_waitstatus
2033 btrace_step_again (void)
2034 {
2035   struct target_waitstatus status;
2036
2037   status.kind = TARGET_WAITKIND_IGNORE;
2038
2039   return status;
2040 }
2041
2042 /* Clear the record histories.  */
2043
2044 static void
2045 record_btrace_clear_histories (struct btrace_thread_info *btinfo)
2046 {
2047   xfree (btinfo->insn_history);
2048   xfree (btinfo->call_history);
2049
2050   btinfo->insn_history = NULL;
2051   btinfo->call_history = NULL;
2052 }
2053
2054 /* Check whether TP's current replay position is at a breakpoint.  */
2055
2056 static int
2057 record_btrace_replay_at_breakpoint (struct thread_info *tp)
2058 {
2059   struct btrace_insn_iterator *replay;
2060   struct btrace_thread_info *btinfo;
2061   const struct btrace_insn *insn;
2062   struct inferior *inf;
2063
2064   btinfo = &tp->btrace;
2065   replay = btinfo->replay;
2066
2067   if (replay == NULL)
2068     return 0;
2069
2070   insn = btrace_insn_get (replay);
2071   if (insn == NULL)
2072     return 0;
2073
2074   inf = find_inferior_ptid (tp->ptid);
2075   if (inf == NULL)
2076     return 0;
2077
2078   return record_check_stopped_by_breakpoint (inf->aspace, insn->pc,
2079                                              &btinfo->stop_reason);
2080 }
2081
2082 /* Step one instruction in forward direction.  */
2083
2084 static struct target_waitstatus
2085 record_btrace_single_step_forward (struct thread_info *tp)
2086 {
2087   struct btrace_insn_iterator *replay, end;
2088   struct btrace_thread_info *btinfo;
2089
2090   btinfo = &tp->btrace;
2091   replay = btinfo->replay;
2092
2093   /* We're done if we're not replaying.  */
2094   if (replay == NULL)
2095     return btrace_step_no_history ();
2096
2097   /* Check if we're stepping a breakpoint.  */
2098   if (record_btrace_replay_at_breakpoint (tp))
2099     return btrace_step_stopped ();
2100
2101   /* Skip gaps during replay.  */
2102   do
2103     {
2104       unsigned int steps;
2105
2106       /* We will bail out here if we continue stepping after reaching the end
2107          of the execution history.  */
2108       steps = btrace_insn_next (replay, 1);
2109       if (steps == 0)
2110         return btrace_step_no_history ();
2111     }
2112   while (btrace_insn_get (replay) == NULL);
2113
2114   /* Determine the end of the instruction trace.  */
2115   btrace_insn_end (&end, btinfo);
2116
2117   /* The execution trace contains (and ends with) the current instruction.
2118      This instruction has not been executed, yet, so the trace really ends
2119      one instruction earlier.  */
2120   if (btrace_insn_cmp (replay, &end) == 0)
2121     return btrace_step_no_history ();
2122
2123   return btrace_step_spurious ();
2124 }
2125
2126 /* Step one instruction in backward direction.  */
2127
2128 static struct target_waitstatus
2129 record_btrace_single_step_backward (struct thread_info *tp)
2130 {
2131   struct btrace_insn_iterator *replay;
2132   struct btrace_thread_info *btinfo;
2133
2134   btinfo = &tp->btrace;
2135   replay = btinfo->replay;
2136
2137   /* Start replaying if we're not already doing so.  */
2138   if (replay == NULL)
2139     replay = record_btrace_start_replaying (tp);
2140
2141   /* If we can't step any further, we reached the end of the history.
2142      Skip gaps during replay.  */
2143   do
2144     {
2145       unsigned int steps;
2146
2147       steps = btrace_insn_prev (replay, 1);
2148       if (steps == 0)
2149         return btrace_step_no_history ();
2150     }
2151   while (btrace_insn_get (replay) == NULL);
2152
2153   /* Check if we're stepping a breakpoint.
2154
2155      For reverse-stepping, this check is after the step.  There is logic in
2156      infrun.c that handles reverse-stepping separately.  See, for example,
2157      proceed and adjust_pc_after_break.
2158
2159      This code assumes that for reverse-stepping, PC points to the last
2160      de-executed instruction, whereas for forward-stepping PC points to the
2161      next to-be-executed instruction.  */
2162   if (record_btrace_replay_at_breakpoint (tp))
2163     return btrace_step_stopped ();
2164
2165   return btrace_step_spurious ();
2166 }
2167
2168 /* Step a single thread.  */
2169
2170 static struct target_waitstatus
2171 record_btrace_step_thread (struct thread_info *tp)
2172 {
2173   struct btrace_thread_info *btinfo;
2174   struct target_waitstatus status;
2175   enum btrace_thread_flag flags;
2176
2177   btinfo = &tp->btrace;
2178
2179   flags = btinfo->flags & (BTHR_MOVE | BTHR_STOP);
2180   btinfo->flags &= ~(BTHR_MOVE | BTHR_STOP);
2181
2182   DEBUG ("stepping thread %d (%s): %x (%s)", tp->num,
2183          target_pid_to_str (tp->ptid), flags,
2184          btrace_thread_flag_to_str (flags));
2185
2186   /* We can't step without an execution history.  */
2187   if ((flags & BTHR_MOVE) != 0 && btrace_is_empty (tp))
2188     return btrace_step_no_history ();
2189
2190   switch (flags)
2191     {
2192     default:
2193       internal_error (__FILE__, __LINE__, _("invalid stepping type."));
2194
2195     case BTHR_STOP:
2196       return btrace_step_stopped_on_request ();
2197
2198     case BTHR_STEP:
2199       status = record_btrace_single_step_forward (tp);
2200       if (status.kind != TARGET_WAITKIND_SPURIOUS)
2201         break;
2202
2203       return btrace_step_stopped ();
2204
2205     case BTHR_RSTEP:
2206       status = record_btrace_single_step_backward (tp);
2207       if (status.kind != TARGET_WAITKIND_SPURIOUS)
2208         break;
2209
2210       return btrace_step_stopped ();
2211
2212     case BTHR_CONT:
2213       status = record_btrace_single_step_forward (tp);
2214       if (status.kind != TARGET_WAITKIND_SPURIOUS)
2215         break;
2216
2217       btinfo->flags |= flags;
2218       return btrace_step_again ();
2219
2220     case BTHR_RCONT:
2221       status = record_btrace_single_step_backward (tp);
2222       if (status.kind != TARGET_WAITKIND_SPURIOUS)
2223         break;
2224
2225       btinfo->flags |= flags;
2226       return btrace_step_again ();
2227     }
2228
2229   /* We keep threads moving at the end of their execution history.  The to_wait
2230      method will stop the thread for whom the event is reported.  */
2231   if (status.kind == TARGET_WAITKIND_NO_HISTORY)
2232     btinfo->flags |= flags;
2233
2234   return status;
2235 }
2236
2237 /* A vector of threads.  */
2238
2239 typedef struct thread_info * tp_t;
2240 DEF_VEC_P (tp_t);
2241
2242 /* Announce further events if necessary.  */
2243
2244 static void
2245 record_btrace_maybe_mark_async_event (const VEC (tp_t) *moving,
2246                                       const VEC (tp_t) *no_history)
2247 {
2248   int more_moving, more_no_history;
2249
2250   more_moving = !VEC_empty (tp_t, moving);
2251   more_no_history = !VEC_empty (tp_t, no_history);
2252
2253   if (!more_moving && !more_no_history)
2254     return;
2255
2256   if (more_moving)
2257     DEBUG ("movers pending");
2258
2259   if (more_no_history)
2260     DEBUG ("no-history pending");
2261
2262   mark_async_event_handler (record_btrace_async_inferior_event_handler);
2263 }
2264
2265 /* The to_wait method of target record-btrace.  */
2266
2267 static ptid_t
2268 record_btrace_wait (struct target_ops *ops, ptid_t ptid,
2269                     struct target_waitstatus *status, int options)
2270 {
2271   VEC (tp_t) *moving, *no_history;
2272   struct thread_info *tp, *eventing;
2273   struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
2274
2275   DEBUG ("wait %s (0x%x)", target_pid_to_str (ptid), options);
2276
2277   /* As long as we're not replaying, just forward the request.  */
2278   if ((execution_direction != EXEC_REVERSE)
2279       && !record_btrace_is_replaying (ops, minus_one_ptid))
2280     {
2281       ops = ops->beneath;
2282       return ops->to_wait (ops, ptid, status, options);
2283     }
2284
2285   moving = NULL;
2286   no_history = NULL;
2287
2288   make_cleanup (VEC_cleanup (tp_t), &moving);
2289   make_cleanup (VEC_cleanup (tp_t), &no_history);
2290
2291   /* Keep a work list of moving threads.  */
2292   ALL_NON_EXITED_THREADS (tp)
2293     if (ptid_match (tp->ptid, ptid)
2294         && ((tp->btrace.flags & (BTHR_MOVE | BTHR_STOP)) != 0))
2295       VEC_safe_push (tp_t, moving, tp);
2296
2297   if (VEC_empty (tp_t, moving))
2298     {
2299       *status = btrace_step_no_resumed ();
2300
2301       DEBUG ("wait ended by %s: %s", target_pid_to_str (null_ptid),
2302              target_waitstatus_to_string (status));
2303
2304       do_cleanups (cleanups);
2305       return null_ptid;
2306     }
2307
2308   /* Step moving threads one by one, one step each, until either one thread
2309      reports an event or we run out of threads to step.
2310
2311      When stepping more than one thread, chances are that some threads reach
2312      the end of their execution history earlier than others.  If we reported
2313      this immediately, all-stop on top of non-stop would stop all threads and
2314      resume the same threads next time.  And we would report the same thread
2315      having reached the end of its execution history again.
2316
2317      In the worst case, this would starve the other threads.  But even if other
2318      threads would be allowed to make progress, this would result in far too
2319      many intermediate stops.
2320
2321      We therefore delay the reporting of "no execution history" until we have
2322      nothing else to report.  By this time, all threads should have moved to
2323      either the beginning or the end of their execution history.  There will
2324      be a single user-visible stop.  */
2325   eventing = NULL;
2326   while ((eventing == NULL) && !VEC_empty (tp_t, moving))
2327     {
2328       unsigned int ix;
2329
2330       ix = 0;
2331       while ((eventing == NULL) && VEC_iterate (tp_t, moving, ix, tp))
2332         {
2333           *status = record_btrace_step_thread (tp);
2334
2335           switch (status->kind)
2336             {
2337             case TARGET_WAITKIND_IGNORE:
2338               ix++;
2339               break;
2340
2341             case TARGET_WAITKIND_NO_HISTORY:
2342               VEC_safe_push (tp_t, no_history,
2343                              VEC_ordered_remove (tp_t, moving, ix));
2344               break;
2345
2346             default:
2347               eventing = VEC_unordered_remove (tp_t, moving, ix);
2348               break;
2349             }
2350         }
2351     }
2352
2353   if (eventing == NULL)
2354     {
2355       /* We started with at least one moving thread.  This thread must have
2356          either stopped or reached the end of its execution history.
2357
2358          In the former case, EVENTING must not be NULL.
2359          In the latter case, NO_HISTORY must not be empty.  */
2360       gdb_assert (!VEC_empty (tp_t, no_history));
2361
2362       /* We kept threads moving at the end of their execution history.  Stop
2363          EVENTING now that we are going to report its stop.  */
2364       eventing = VEC_unordered_remove (tp_t, no_history, 0);
2365       eventing->btrace.flags &= ~BTHR_MOVE;
2366
2367       *status = btrace_step_no_history ();
2368     }
2369
2370   gdb_assert (eventing != NULL);
2371
2372   /* We kept threads replaying at the end of their execution history.  Stop
2373      replaying EVENTING now that we are going to report its stop.  */
2374   record_btrace_stop_replaying_at_end (eventing);
2375
2376   /* Stop all other threads. */
2377   if (!target_is_non_stop_p ())
2378     ALL_NON_EXITED_THREADS (tp)
2379       record_btrace_cancel_resume (tp);
2380
2381   /* In async mode, we need to announce further events.  */
2382   if (target_is_async_p ())
2383     record_btrace_maybe_mark_async_event (moving, no_history);
2384
2385   /* Start record histories anew from the current position.  */
2386   record_btrace_clear_histories (&eventing->btrace);
2387
2388   /* We moved the replay position but did not update registers.  */
2389   registers_changed_ptid (eventing->ptid);
2390
2391   DEBUG ("wait ended by thread %d (%s): %s", eventing->num,
2392          target_pid_to_str (eventing->ptid),
2393          target_waitstatus_to_string (status));
2394
2395   do_cleanups (cleanups);
2396   return eventing->ptid;
2397 }
2398
2399 /* The to_stop method of target record-btrace.  */
2400
2401 static void
2402 record_btrace_stop (struct target_ops *ops, ptid_t ptid)
2403 {
2404   DEBUG ("stop %s", target_pid_to_str (ptid));
2405
2406   /* As long as we're not replaying, just forward the request.  */
2407   if ((execution_direction != EXEC_REVERSE)
2408       && !record_btrace_is_replaying (ops, minus_one_ptid))
2409     {
2410       ops = ops->beneath;
2411       ops->to_stop (ops, ptid);
2412     }
2413   else
2414     {
2415       struct thread_info *tp;
2416
2417       ALL_NON_EXITED_THREADS (tp)
2418        if (ptid_match (tp->ptid, ptid))
2419          {
2420            tp->btrace.flags &= ~BTHR_MOVE;
2421            tp->btrace.flags |= BTHR_STOP;
2422          }
2423     }
2424  }
2425
2426 /* The to_can_execute_reverse method of target record-btrace.  */
2427
2428 static int
2429 record_btrace_can_execute_reverse (struct target_ops *self)
2430 {
2431   return 1;
2432 }
2433
2434 /* The to_stopped_by_sw_breakpoint method of target record-btrace.  */
2435
2436 static int
2437 record_btrace_stopped_by_sw_breakpoint (struct target_ops *ops)
2438 {
2439   if (record_btrace_is_replaying (ops, minus_one_ptid))
2440     {
2441       struct thread_info *tp = inferior_thread ();
2442
2443       return tp->btrace.stop_reason == TARGET_STOPPED_BY_SW_BREAKPOINT;
2444     }
2445
2446   return ops->beneath->to_stopped_by_sw_breakpoint (ops->beneath);
2447 }
2448
2449 /* The to_supports_stopped_by_sw_breakpoint method of target
2450    record-btrace.  */
2451
2452 static int
2453 record_btrace_supports_stopped_by_sw_breakpoint (struct target_ops *ops)
2454 {
2455   if (record_btrace_is_replaying (ops, minus_one_ptid))
2456     return 1;
2457
2458   return ops->beneath->to_supports_stopped_by_sw_breakpoint (ops->beneath);
2459 }
2460
2461 /* The to_stopped_by_sw_breakpoint method of target record-btrace.  */
2462
2463 static int
2464 record_btrace_stopped_by_hw_breakpoint (struct target_ops *ops)
2465 {
2466   if (record_btrace_is_replaying (ops, minus_one_ptid))
2467     {
2468       struct thread_info *tp = inferior_thread ();
2469
2470       return tp->btrace.stop_reason == TARGET_STOPPED_BY_HW_BREAKPOINT;
2471     }
2472
2473   return ops->beneath->to_stopped_by_hw_breakpoint (ops->beneath);
2474 }
2475
2476 /* The to_supports_stopped_by_hw_breakpoint method of target
2477    record-btrace.  */
2478
2479 static int
2480 record_btrace_supports_stopped_by_hw_breakpoint (struct target_ops *ops)
2481 {
2482   if (record_btrace_is_replaying (ops, minus_one_ptid))
2483     return 1;
2484
2485   return ops->beneath->to_supports_stopped_by_hw_breakpoint (ops->beneath);
2486 }
2487
2488 /* The to_update_thread_list method of target record-btrace.  */
2489
2490 static void
2491 record_btrace_update_thread_list (struct target_ops *ops)
2492 {
2493   /* We don't add or remove threads during replay.  */
2494   if (record_btrace_is_replaying (ops, minus_one_ptid))
2495     return;
2496
2497   /* Forward the request.  */
2498   ops = ops->beneath;
2499   ops->to_update_thread_list (ops);
2500 }
2501
2502 /* The to_thread_alive method of target record-btrace.  */
2503
2504 static int
2505 record_btrace_thread_alive (struct target_ops *ops, ptid_t ptid)
2506 {
2507   /* We don't add or remove threads during replay.  */
2508   if (record_btrace_is_replaying (ops, minus_one_ptid))
2509     return find_thread_ptid (ptid) != NULL;
2510
2511   /* Forward the request.  */
2512   ops = ops->beneath;
2513   return ops->to_thread_alive (ops, ptid);
2514 }
2515
2516 /* Set the replay branch trace instruction iterator.  If IT is NULL, replay
2517    is stopped.  */
2518
2519 static void
2520 record_btrace_set_replay (struct thread_info *tp,
2521                           const struct btrace_insn_iterator *it)
2522 {
2523   struct btrace_thread_info *btinfo;
2524
2525   btinfo = &tp->btrace;
2526
2527   if (it == NULL || it->function == NULL)
2528     record_btrace_stop_replaying (tp);
2529   else
2530     {
2531       if (btinfo->replay == NULL)
2532         record_btrace_start_replaying (tp);
2533       else if (btrace_insn_cmp (btinfo->replay, it) == 0)
2534         return;
2535
2536       *btinfo->replay = *it;
2537       registers_changed_ptid (tp->ptid);
2538     }
2539
2540   /* Start anew from the new replay position.  */
2541   record_btrace_clear_histories (btinfo);
2542
2543   stop_pc = regcache_read_pc (get_current_regcache ());
2544   print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC, 1);
2545 }
2546
2547 /* The to_goto_record_begin method of target record-btrace.  */
2548
2549 static void
2550 record_btrace_goto_begin (struct target_ops *self)
2551 {
2552   struct thread_info *tp;
2553   struct btrace_insn_iterator begin;
2554
2555   tp = require_btrace_thread ();
2556
2557   btrace_insn_begin (&begin, &tp->btrace);
2558   record_btrace_set_replay (tp, &begin);
2559 }
2560
2561 /* The to_goto_record_end method of target record-btrace.  */
2562
2563 static void
2564 record_btrace_goto_end (struct target_ops *ops)
2565 {
2566   struct thread_info *tp;
2567
2568   tp = require_btrace_thread ();
2569
2570   record_btrace_set_replay (tp, NULL);
2571 }
2572
2573 /* The to_goto_record method of target record-btrace.  */
2574
2575 static void
2576 record_btrace_goto (struct target_ops *self, ULONGEST insn)
2577 {
2578   struct thread_info *tp;
2579   struct btrace_insn_iterator it;
2580   unsigned int number;
2581   int found;
2582
2583   number = insn;
2584
2585   /* Check for wrap-arounds.  */
2586   if (number != insn)
2587     error (_("Instruction number out of range."));
2588
2589   tp = require_btrace_thread ();
2590
2591   found = btrace_find_insn_by_number (&it, &tp->btrace, number);
2592   if (found == 0)
2593     error (_("No such instruction."));
2594
2595   record_btrace_set_replay (tp, &it);
2596 }
2597
2598 /* The to_record_stop_replaying method of target record-btrace.  */
2599
2600 static void
2601 record_btrace_stop_replaying_all (struct target_ops *self)
2602 {
2603   struct thread_info *tp;
2604
2605   ALL_NON_EXITED_THREADS (tp)
2606     record_btrace_stop_replaying (tp);
2607 }
2608
2609 /* The to_execution_direction target method.  */
2610
2611 static enum exec_direction_kind
2612 record_btrace_execution_direction (struct target_ops *self)
2613 {
2614   return record_btrace_resume_exec_dir;
2615 }
2616
2617 /* The to_prepare_to_generate_core target method.  */
2618
2619 static void
2620 record_btrace_prepare_to_generate_core (struct target_ops *self)
2621 {
2622   record_btrace_generating_corefile = 1;
2623 }
2624
2625 /* The to_done_generating_core target method.  */
2626
2627 static void
2628 record_btrace_done_generating_core (struct target_ops *self)
2629 {
2630   record_btrace_generating_corefile = 0;
2631 }
2632
2633 /* Initialize the record-btrace target ops.  */
2634
2635 static void
2636 init_record_btrace_ops (void)
2637 {
2638   struct target_ops *ops;
2639
2640   ops = &record_btrace_ops;
2641   ops->to_shortname = "record-btrace";
2642   ops->to_longname = "Branch tracing target";
2643   ops->to_doc = "Collect control-flow trace and provide the execution history.";
2644   ops->to_open = record_btrace_open;
2645   ops->to_close = record_btrace_close;
2646   ops->to_async = record_btrace_async;
2647   ops->to_detach = record_detach;
2648   ops->to_disconnect = record_disconnect;
2649   ops->to_mourn_inferior = record_mourn_inferior;
2650   ops->to_kill = record_kill;
2651   ops->to_stop_recording = record_btrace_stop_recording;
2652   ops->to_info_record = record_btrace_info;
2653   ops->to_insn_history = record_btrace_insn_history;
2654   ops->to_insn_history_from = record_btrace_insn_history_from;
2655   ops->to_insn_history_range = record_btrace_insn_history_range;
2656   ops->to_call_history = record_btrace_call_history;
2657   ops->to_call_history_from = record_btrace_call_history_from;
2658   ops->to_call_history_range = record_btrace_call_history_range;
2659   ops->to_record_is_replaying = record_btrace_is_replaying;
2660   ops->to_record_stop_replaying = record_btrace_stop_replaying_all;
2661   ops->to_xfer_partial = record_btrace_xfer_partial;
2662   ops->to_remove_breakpoint = record_btrace_remove_breakpoint;
2663   ops->to_insert_breakpoint = record_btrace_insert_breakpoint;
2664   ops->to_fetch_registers = record_btrace_fetch_registers;
2665   ops->to_store_registers = record_btrace_store_registers;
2666   ops->to_prepare_to_store = record_btrace_prepare_to_store;
2667   ops->to_get_unwinder = &record_btrace_to_get_unwinder;
2668   ops->to_get_tailcall_unwinder = &record_btrace_to_get_tailcall_unwinder;
2669   ops->to_resume = record_btrace_resume;
2670   ops->to_wait = record_btrace_wait;
2671   ops->to_stop = record_btrace_stop;
2672   ops->to_update_thread_list = record_btrace_update_thread_list;
2673   ops->to_thread_alive = record_btrace_thread_alive;
2674   ops->to_goto_record_begin = record_btrace_goto_begin;
2675   ops->to_goto_record_end = record_btrace_goto_end;
2676   ops->to_goto_record = record_btrace_goto;
2677   ops->to_can_execute_reverse = record_btrace_can_execute_reverse;
2678   ops->to_stopped_by_sw_breakpoint = record_btrace_stopped_by_sw_breakpoint;
2679   ops->to_supports_stopped_by_sw_breakpoint
2680     = record_btrace_supports_stopped_by_sw_breakpoint;
2681   ops->to_stopped_by_hw_breakpoint = record_btrace_stopped_by_hw_breakpoint;
2682   ops->to_supports_stopped_by_hw_breakpoint
2683     = record_btrace_supports_stopped_by_hw_breakpoint;
2684   ops->to_execution_direction = record_btrace_execution_direction;
2685   ops->to_prepare_to_generate_core = record_btrace_prepare_to_generate_core;
2686   ops->to_done_generating_core = record_btrace_done_generating_core;
2687   ops->to_stratum = record_stratum;
2688   ops->to_magic = OPS_MAGIC;
2689 }
2690
2691 /* Start recording in BTS format.  */
2692
2693 static void
2694 cmd_record_btrace_bts_start (char *args, int from_tty)
2695 {
2696   if (args != NULL && *args != 0)
2697     error (_("Invalid argument."));
2698
2699   record_btrace_conf.format = BTRACE_FORMAT_BTS;
2700
2701   TRY
2702     {
2703       execute_command ("target record-btrace", from_tty);
2704     }
2705   CATCH (exception, RETURN_MASK_ALL)
2706     {
2707       record_btrace_conf.format = BTRACE_FORMAT_NONE;
2708       throw_exception (exception);
2709     }
2710   END_CATCH
2711 }
2712
2713 /* Start recording Intel(R) Processor Trace.  */
2714
2715 static void
2716 cmd_record_btrace_pt_start (char *args, int from_tty)
2717 {
2718   if (args != NULL && *args != 0)
2719     error (_("Invalid argument."));
2720
2721   record_btrace_conf.format = BTRACE_FORMAT_PT;
2722
2723   TRY
2724     {
2725       execute_command ("target record-btrace", from_tty);
2726     }
2727   CATCH (exception, RETURN_MASK_ALL)
2728     {
2729       record_btrace_conf.format = BTRACE_FORMAT_NONE;
2730       throw_exception (exception);
2731     }
2732   END_CATCH
2733 }
2734
2735 /* Alias for "target record".  */
2736
2737 static void
2738 cmd_record_btrace_start (char *args, int from_tty)
2739 {
2740   if (args != NULL && *args != 0)
2741     error (_("Invalid argument."));
2742
2743   record_btrace_conf.format = BTRACE_FORMAT_PT;
2744
2745   TRY
2746     {
2747       execute_command ("target record-btrace", from_tty);
2748     }
2749   CATCH (exception, RETURN_MASK_ALL)
2750     {
2751       record_btrace_conf.format = BTRACE_FORMAT_BTS;
2752
2753       TRY
2754         {
2755           execute_command ("target record-btrace", from_tty);
2756         }
2757       CATCH (exception, RETURN_MASK_ALL)
2758         {
2759           record_btrace_conf.format = BTRACE_FORMAT_NONE;
2760           throw_exception (exception);
2761         }
2762       END_CATCH
2763     }
2764   END_CATCH
2765 }
2766
2767 /* The "set record btrace" command.  */
2768
2769 static void
2770 cmd_set_record_btrace (char *args, int from_tty)
2771 {
2772   cmd_show_list (set_record_btrace_cmdlist, from_tty, "");
2773 }
2774
2775 /* The "show record btrace" command.  */
2776
2777 static void
2778 cmd_show_record_btrace (char *args, int from_tty)
2779 {
2780   cmd_show_list (show_record_btrace_cmdlist, from_tty, "");
2781 }
2782
2783 /* The "show record btrace replay-memory-access" command.  */
2784
2785 static void
2786 cmd_show_replay_memory_access (struct ui_file *file, int from_tty,
2787                                struct cmd_list_element *c, const char *value)
2788 {
2789   fprintf_filtered (gdb_stdout, _("Replay memory access is %s.\n"),
2790                     replay_memory_access);
2791 }
2792
2793 /* The "set record btrace bts" command.  */
2794
2795 static void
2796 cmd_set_record_btrace_bts (char *args, int from_tty)
2797 {
2798   printf_unfiltered (_("\"set record btrace bts\" must be followed "
2799                        "by an appropriate subcommand.\n"));
2800   help_list (set_record_btrace_bts_cmdlist, "set record btrace bts ",
2801              all_commands, gdb_stdout);
2802 }
2803
2804 /* The "show record btrace bts" command.  */
2805
2806 static void
2807 cmd_show_record_btrace_bts (char *args, int from_tty)
2808 {
2809   cmd_show_list (show_record_btrace_bts_cmdlist, from_tty, "");
2810 }
2811
2812 /* The "set record btrace pt" command.  */
2813
2814 static void
2815 cmd_set_record_btrace_pt (char *args, int from_tty)
2816 {
2817   printf_unfiltered (_("\"set record btrace pt\" must be followed "
2818                        "by an appropriate subcommand.\n"));
2819   help_list (set_record_btrace_pt_cmdlist, "set record btrace pt ",
2820              all_commands, gdb_stdout);
2821 }
2822
2823 /* The "show record btrace pt" command.  */
2824
2825 static void
2826 cmd_show_record_btrace_pt (char *args, int from_tty)
2827 {
2828   cmd_show_list (show_record_btrace_pt_cmdlist, from_tty, "");
2829 }
2830
2831 /* The "record bts buffer-size" show value function.  */
2832
2833 static void
2834 show_record_bts_buffer_size_value (struct ui_file *file, int from_tty,
2835                                    struct cmd_list_element *c,
2836                                    const char *value)
2837 {
2838   fprintf_filtered (file, _("The record/replay bts buffer size is %s.\n"),
2839                     value);
2840 }
2841
2842 /* The "record pt buffer-size" show value function.  */
2843
2844 static void
2845 show_record_pt_buffer_size_value (struct ui_file *file, int from_tty,
2846                                   struct cmd_list_element *c,
2847                                   const char *value)
2848 {
2849   fprintf_filtered (file, _("The record/replay pt buffer size is %s.\n"),
2850                     value);
2851 }
2852
2853 void _initialize_record_btrace (void);
2854
2855 /* Initialize btrace commands.  */
2856
2857 void
2858 _initialize_record_btrace (void)
2859 {
2860   add_prefix_cmd ("btrace", class_obscure, cmd_record_btrace_start,
2861                   _("Start branch trace recording."), &record_btrace_cmdlist,
2862                   "record btrace ", 0, &record_cmdlist);
2863   add_alias_cmd ("b", "btrace", class_obscure, 1, &record_cmdlist);
2864
2865   add_cmd ("bts", class_obscure, cmd_record_btrace_bts_start,
2866            _("\
2867 Start branch trace recording in Branch Trace Store (BTS) format.\n\n\
2868 The processor stores a from/to record for each branch into a cyclic buffer.\n\
2869 This format may not be available on all processors."),
2870            &record_btrace_cmdlist);
2871   add_alias_cmd ("bts", "btrace bts", class_obscure, 1, &record_cmdlist);
2872
2873   add_cmd ("pt", class_obscure, cmd_record_btrace_pt_start,
2874            _("\
2875 Start branch trace recording in Intel(R) Processor Trace format.\n\n\
2876 This format may not be available on all processors."),
2877            &record_btrace_cmdlist);
2878   add_alias_cmd ("pt", "btrace pt", class_obscure, 1, &record_cmdlist);
2879
2880   add_prefix_cmd ("btrace", class_support, cmd_set_record_btrace,
2881                   _("Set record options"), &set_record_btrace_cmdlist,
2882                   "set record btrace ", 0, &set_record_cmdlist);
2883
2884   add_prefix_cmd ("btrace", class_support, cmd_show_record_btrace,
2885                   _("Show record options"), &show_record_btrace_cmdlist,
2886                   "show record btrace ", 0, &show_record_cmdlist);
2887
2888   add_setshow_enum_cmd ("replay-memory-access", no_class,
2889                         replay_memory_access_types, &replay_memory_access, _("\
2890 Set what memory accesses are allowed during replay."), _("\
2891 Show what memory accesses are allowed during replay."),
2892                            _("Default is READ-ONLY.\n\n\
2893 The btrace record target does not trace data.\n\
2894 The memory therefore corresponds to the live target and not \
2895 to the current replay position.\n\n\
2896 When READ-ONLY, allow accesses to read-only memory during replay.\n\
2897 When READ-WRITE, allow accesses to read-only and read-write memory during \
2898 replay."),
2899                            NULL, cmd_show_replay_memory_access,
2900                            &set_record_btrace_cmdlist,
2901                            &show_record_btrace_cmdlist);
2902
2903   add_prefix_cmd ("bts", class_support, cmd_set_record_btrace_bts,
2904                   _("Set record btrace bts options"),
2905                   &set_record_btrace_bts_cmdlist,
2906                   "set record btrace bts ", 0, &set_record_btrace_cmdlist);
2907
2908   add_prefix_cmd ("bts", class_support, cmd_show_record_btrace_bts,
2909                   _("Show record btrace bts options"),
2910                   &show_record_btrace_bts_cmdlist,
2911                   "show record btrace bts ", 0, &show_record_btrace_cmdlist);
2912
2913   add_setshow_uinteger_cmd ("buffer-size", no_class,
2914                             &record_btrace_conf.bts.size,
2915                             _("Set the record/replay bts buffer size."),
2916                             _("Show the record/replay bts buffer size."), _("\
2917 When starting recording request a trace buffer of this size.  \
2918 The actual buffer size may differ from the requested size.  \
2919 Use \"info record\" to see the actual buffer size.\n\n\
2920 Bigger buffers allow longer recording but also take more time to process \
2921 the recorded execution trace.\n\n\
2922 The trace buffer size may not be changed while recording."), NULL,
2923                             show_record_bts_buffer_size_value,
2924                             &set_record_btrace_bts_cmdlist,
2925                             &show_record_btrace_bts_cmdlist);
2926
2927   add_prefix_cmd ("pt", class_support, cmd_set_record_btrace_pt,
2928                   _("Set record btrace pt options"),
2929                   &set_record_btrace_pt_cmdlist,
2930                   "set record btrace pt ", 0, &set_record_btrace_cmdlist);
2931
2932   add_prefix_cmd ("pt", class_support, cmd_show_record_btrace_pt,
2933                   _("Show record btrace pt options"),
2934                   &show_record_btrace_pt_cmdlist,
2935                   "show record btrace pt ", 0, &show_record_btrace_cmdlist);
2936
2937   add_setshow_uinteger_cmd ("buffer-size", no_class,
2938                             &record_btrace_conf.pt.size,
2939                             _("Set the record/replay pt buffer size."),
2940                             _("Show the record/replay pt buffer size."), _("\
2941 Bigger buffers allow longer recording but also take more time to process \
2942 the recorded execution.\n\
2943 The actual buffer size may differ from the requested size.  Use \"info record\" \
2944 to see the actual buffer size."), NULL, show_record_pt_buffer_size_value,
2945                             &set_record_btrace_pt_cmdlist,
2946                             &show_record_btrace_pt_cmdlist);
2947
2948   init_record_btrace_ops ();
2949   add_target (&record_btrace_ops);
2950
2951   bfcache = htab_create_alloc (50, bfcache_hash, bfcache_eq, NULL,
2952                                xcalloc, xfree);
2953
2954   record_btrace_conf.bts.size = 64 * 1024;
2955   record_btrace_conf.pt.size = 16 * 1024;
2956 }