2b031a4b6d0bd3e1e4e6d6a0836cec9b007ee654
[external/binutils.git] / gdb / btrace.c
1 /* Branch trace support for GDB, the GNU debugger.
2
3    Copyright (C) 2013-2018 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 "btrace.h"
24 #include "gdbthread.h"
25 #include "inferior.h"
26 #include "target.h"
27 #include "record.h"
28 #include "symtab.h"
29 #include "disasm.h"
30 #include "source.h"
31 #include "filenames.h"
32 #include "xml-support.h"
33 #include "regcache.h"
34 #include "rsp-low.h"
35 #include "gdbcmd.h"
36 #include "cli/cli-utils.h"
37
38 #include <inttypes.h>
39 #include <ctype.h>
40 #include <algorithm>
41
42 /* Command lists for btrace maintenance commands.  */
43 static struct cmd_list_element *maint_btrace_cmdlist;
44 static struct cmd_list_element *maint_btrace_set_cmdlist;
45 static struct cmd_list_element *maint_btrace_show_cmdlist;
46 static struct cmd_list_element *maint_btrace_pt_set_cmdlist;
47 static struct cmd_list_element *maint_btrace_pt_show_cmdlist;
48
49 /* Control whether to skip PAD packets when computing the packet history.  */
50 static int maint_btrace_pt_skip_pad = 1;
51
52 static void btrace_add_pc (struct thread_info *tp);
53
54 /* Print a record debug message.  Use do ... while (0) to avoid ambiguities
55    when used in if statements.  */
56
57 #define DEBUG(msg, args...)                                             \
58   do                                                                    \
59     {                                                                   \
60       if (record_debug != 0)                                            \
61         fprintf_unfiltered (gdb_stdlog,                                 \
62                             "[btrace] " msg "\n", ##args);              \
63     }                                                                   \
64   while (0)
65
66 #define DEBUG_FTRACE(msg, args...) DEBUG ("[ftrace] " msg, ##args)
67
68 /* Return the function name of a recorded function segment for printing.
69    This function never returns NULL.  */
70
71 static const char *
72 ftrace_print_function_name (const struct btrace_function *bfun)
73 {
74   struct minimal_symbol *msym;
75   struct symbol *sym;
76
77   msym = bfun->msym;
78   sym = bfun->sym;
79
80   if (sym != NULL)
81     return SYMBOL_PRINT_NAME (sym);
82
83   if (msym != NULL)
84     return MSYMBOL_PRINT_NAME (msym);
85
86   return "<unknown>";
87 }
88
89 /* Return the file name of a recorded function segment for printing.
90    This function never returns NULL.  */
91
92 static const char *
93 ftrace_print_filename (const struct btrace_function *bfun)
94 {
95   struct symbol *sym;
96   const char *filename;
97
98   sym = bfun->sym;
99
100   if (sym != NULL)
101     filename = symtab_to_filename_for_display (symbol_symtab (sym));
102   else
103     filename = "<unknown>";
104
105   return filename;
106 }
107
108 /* Return a string representation of the address of an instruction.
109    This function never returns NULL.  */
110
111 static const char *
112 ftrace_print_insn_addr (const struct btrace_insn *insn)
113 {
114   if (insn == NULL)
115     return "<nil>";
116
117   return core_addr_to_string_nz (insn->pc);
118 }
119
120 /* Print an ftrace debug status message.  */
121
122 static void
123 ftrace_debug (const struct btrace_function *bfun, const char *prefix)
124 {
125   const char *fun, *file;
126   unsigned int ibegin, iend;
127   int level;
128
129   fun = ftrace_print_function_name (bfun);
130   file = ftrace_print_filename (bfun);
131   level = bfun->level;
132
133   ibegin = bfun->insn_offset;
134   iend = ibegin + bfun->insn.size ();
135
136   DEBUG_FTRACE ("%s: fun = %s, file = %s, level = %d, insn = [%u; %u)",
137                 prefix, fun, file, level, ibegin, iend);
138 }
139
140 /* Return the number of instructions in a given function call segment.  */
141
142 static unsigned int
143 ftrace_call_num_insn (const struct btrace_function* bfun)
144 {
145   if (bfun == NULL)
146     return 0;
147
148   /* A gap is always counted as one instruction.  */
149   if (bfun->errcode != 0)
150     return 1;
151
152   return bfun->insn.size ();
153 }
154
155 /* Return the function segment with the given NUMBER or NULL if no such segment
156    exists.  BTINFO is the branch trace information for the current thread.  */
157
158 static struct btrace_function *
159 ftrace_find_call_by_number (struct btrace_thread_info *btinfo,
160                             unsigned int number)
161 {
162   if (number == 0 || number > btinfo->functions.size ())
163     return NULL;
164
165   return &btinfo->functions[number - 1];
166 }
167
168 /* A const version of the function above.  */
169
170 static const struct btrace_function *
171 ftrace_find_call_by_number (const struct btrace_thread_info *btinfo,
172                             unsigned int number)
173 {
174   if (number == 0 || number > btinfo->functions.size ())
175     return NULL;
176
177   return &btinfo->functions[number - 1];
178 }
179
180 /* Return non-zero if BFUN does not match MFUN and FUN,
181    return zero otherwise.  */
182
183 static int
184 ftrace_function_switched (const struct btrace_function *bfun,
185                           const struct minimal_symbol *mfun,
186                           const struct symbol *fun)
187 {
188   struct minimal_symbol *msym;
189   struct symbol *sym;
190
191   msym = bfun->msym;
192   sym = bfun->sym;
193
194   /* If the minimal symbol changed, we certainly switched functions.  */
195   if (mfun != NULL && msym != NULL
196       && strcmp (MSYMBOL_LINKAGE_NAME (mfun), MSYMBOL_LINKAGE_NAME (msym)) != 0)
197     return 1;
198
199   /* If the symbol changed, we certainly switched functions.  */
200   if (fun != NULL && sym != NULL)
201     {
202       const char *bfname, *fname;
203
204       /* Check the function name.  */
205       if (strcmp (SYMBOL_LINKAGE_NAME (fun), SYMBOL_LINKAGE_NAME (sym)) != 0)
206         return 1;
207
208       /* Check the location of those functions, as well.  */
209       bfname = symtab_to_fullname (symbol_symtab (sym));
210       fname = symtab_to_fullname (symbol_symtab (fun));
211       if (filename_cmp (fname, bfname) != 0)
212         return 1;
213     }
214
215   /* If we lost symbol information, we switched functions.  */
216   if (!(msym == NULL && sym == NULL) && mfun == NULL && fun == NULL)
217     return 1;
218
219   /* If we gained symbol information, we switched functions.  */
220   if (msym == NULL && sym == NULL && !(mfun == NULL && fun == NULL))
221     return 1;
222
223   return 0;
224 }
225
226 /* Allocate and initialize a new branch trace function segment at the end of
227    the trace.
228    BTINFO is the branch trace information for the current thread.
229    MFUN and FUN are the symbol information we have for this function.
230    This invalidates all struct btrace_function pointer currently held.  */
231
232 static struct btrace_function *
233 ftrace_new_function (struct btrace_thread_info *btinfo,
234                      struct minimal_symbol *mfun,
235                      struct symbol *fun)
236 {
237   int level;
238   unsigned int number, insn_offset;
239
240   if (btinfo->functions.empty ())
241     {
242       /* Start counting NUMBER and INSN_OFFSET at one.  */
243       level = 0;
244       number = 1;
245       insn_offset = 1;
246     }
247   else
248     {
249       const struct btrace_function *prev = &btinfo->functions.back ();
250       level = prev->level;
251       number = prev->number + 1;
252       insn_offset = prev->insn_offset + ftrace_call_num_insn (prev);
253     }
254
255   btinfo->functions.emplace_back (mfun, fun, number, insn_offset, level);
256   return &btinfo->functions.back ();
257 }
258
259 /* Update the UP field of a function segment.  */
260
261 static void
262 ftrace_update_caller (struct btrace_function *bfun,
263                       struct btrace_function *caller,
264                       enum btrace_function_flag flags)
265 {
266   if (bfun->up != 0)
267     ftrace_debug (bfun, "updating caller");
268
269   bfun->up = caller->number;
270   bfun->flags = flags;
271
272   ftrace_debug (bfun, "set caller");
273   ftrace_debug (caller, "..to");
274 }
275
276 /* Fix up the caller for all segments of a function.  */
277
278 static void
279 ftrace_fixup_caller (struct btrace_thread_info *btinfo,
280                      struct btrace_function *bfun,
281                      struct btrace_function *caller,
282                      enum btrace_function_flag flags)
283 {
284   unsigned int prev, next;
285
286   prev = bfun->prev;
287   next = bfun->next;
288   ftrace_update_caller (bfun, caller, flags);
289
290   /* Update all function segments belonging to the same function.  */
291   for (; prev != 0; prev = bfun->prev)
292     {
293       bfun = ftrace_find_call_by_number (btinfo, prev);
294       ftrace_update_caller (bfun, caller, flags);
295     }
296
297   for (; next != 0; next = bfun->next)
298     {
299       bfun = ftrace_find_call_by_number (btinfo, next);
300       ftrace_update_caller (bfun, caller, flags);
301     }
302 }
303
304 /* Add a new function segment for a call at the end of the trace.
305    BTINFO is the branch trace information for the current thread.
306    MFUN and FUN are the symbol information we have for this function.  */
307
308 static struct btrace_function *
309 ftrace_new_call (struct btrace_thread_info *btinfo,
310                  struct minimal_symbol *mfun,
311                  struct symbol *fun)
312 {
313   const unsigned int length = btinfo->functions.size ();
314   struct btrace_function *bfun = ftrace_new_function (btinfo, mfun, fun);
315
316   bfun->up = length;
317   bfun->level += 1;
318
319   ftrace_debug (bfun, "new call");
320
321   return bfun;
322 }
323
324 /* Add a new function segment for a tail call at the end of the trace.
325    BTINFO is the branch trace information for the current thread.
326    MFUN and FUN are the symbol information we have for this function.  */
327
328 static struct btrace_function *
329 ftrace_new_tailcall (struct btrace_thread_info *btinfo,
330                      struct minimal_symbol *mfun,
331                      struct symbol *fun)
332 {
333   const unsigned int length = btinfo->functions.size ();
334   struct btrace_function *bfun = ftrace_new_function (btinfo, mfun, fun);
335
336   bfun->up = length;
337   bfun->level += 1;
338   bfun->flags |= BFUN_UP_LINKS_TO_TAILCALL;
339
340   ftrace_debug (bfun, "new tail call");
341
342   return bfun;
343 }
344
345 /* Return the caller of BFUN or NULL if there is none.  This function skips
346    tail calls in the call chain.  BTINFO is the branch trace information for
347    the current thread.  */
348 static struct btrace_function *
349 ftrace_get_caller (struct btrace_thread_info *btinfo,
350                    struct btrace_function *bfun)
351 {
352   for (; bfun != NULL; bfun = ftrace_find_call_by_number (btinfo, bfun->up))
353     if ((bfun->flags & BFUN_UP_LINKS_TO_TAILCALL) == 0)
354       return ftrace_find_call_by_number (btinfo, bfun->up);
355
356   return NULL;
357 }
358
359 /* Find the innermost caller in the back trace of BFUN with MFUN/FUN
360    symbol information.  BTINFO is the branch trace information for the current
361    thread.  */
362
363 static struct btrace_function *
364 ftrace_find_caller (struct btrace_thread_info *btinfo,
365                     struct btrace_function *bfun,
366                     struct minimal_symbol *mfun,
367                     struct symbol *fun)
368 {
369   for (; bfun != NULL; bfun = ftrace_find_call_by_number (btinfo, bfun->up))
370     {
371       /* Skip functions with incompatible symbol information.  */
372       if (ftrace_function_switched (bfun, mfun, fun))
373         continue;
374
375       /* This is the function segment we're looking for.  */
376       break;
377     }
378
379   return bfun;
380 }
381
382 /* Find the innermost caller in the back trace of BFUN, skipping all
383    function segments that do not end with a call instruction (e.g.
384    tail calls ending with a jump).  BTINFO is the branch trace information for
385    the current thread.  */
386
387 static struct btrace_function *
388 ftrace_find_call (struct btrace_thread_info *btinfo,
389                   struct btrace_function *bfun)
390 {
391   for (; bfun != NULL; bfun = ftrace_find_call_by_number (btinfo, bfun->up))
392     {
393       /* Skip gaps.  */
394       if (bfun->errcode != 0)
395         continue;
396
397       btrace_insn &last = bfun->insn.back ();
398
399       if (last.iclass == BTRACE_INSN_CALL)
400         break;
401     }
402
403   return bfun;
404 }
405
406 /* Add a continuation segment for a function into which we return at the end of
407    the trace.
408    BTINFO is the branch trace information for the current thread.
409    MFUN and FUN are the symbol information we have for this function.  */
410
411 static struct btrace_function *
412 ftrace_new_return (struct btrace_thread_info *btinfo,
413                    struct minimal_symbol *mfun,
414                    struct symbol *fun)
415 {
416   struct btrace_function *prev, *bfun, *caller;
417
418   bfun = ftrace_new_function (btinfo, mfun, fun);
419   prev = ftrace_find_call_by_number (btinfo, bfun->number - 1);
420
421   /* It is important to start at PREV's caller.  Otherwise, we might find
422      PREV itself, if PREV is a recursive function.  */
423   caller = ftrace_find_call_by_number (btinfo, prev->up);
424   caller = ftrace_find_caller (btinfo, caller, mfun, fun);
425   if (caller != NULL)
426     {
427       /* The caller of PREV is the preceding btrace function segment in this
428          function instance.  */
429       gdb_assert (caller->next == 0);
430
431       caller->next = bfun->number;
432       bfun->prev = caller->number;
433
434       /* Maintain the function level.  */
435       bfun->level = caller->level;
436
437       /* Maintain the call stack.  */
438       bfun->up = caller->up;
439       bfun->flags = caller->flags;
440
441       ftrace_debug (bfun, "new return");
442     }
443   else
444     {
445       /* We did not find a caller.  This could mean that something went
446          wrong or that the call is simply not included in the trace.  */
447
448       /* Let's search for some actual call.  */
449       caller = ftrace_find_call_by_number (btinfo, prev->up);
450       caller = ftrace_find_call (btinfo, caller);
451       if (caller == NULL)
452         {
453           /* There is no call in PREV's back trace.  We assume that the
454              branch trace did not include it.  */
455
456           /* Let's find the topmost function and add a new caller for it.
457              This should handle a series of initial tail calls.  */
458           while (prev->up != 0)
459             prev = ftrace_find_call_by_number (btinfo, prev->up);
460
461           bfun->level = prev->level - 1;
462
463           /* Fix up the call stack for PREV.  */
464           ftrace_fixup_caller (btinfo, prev, bfun, BFUN_UP_LINKS_TO_RET);
465
466           ftrace_debug (bfun, "new return - no caller");
467         }
468       else
469         {
470           /* There is a call in PREV's back trace to which we should have
471              returned but didn't.  Let's start a new, separate back trace
472              from PREV's level.  */
473           bfun->level = prev->level - 1;
474
475           /* We fix up the back trace for PREV but leave other function segments
476              on the same level as they are.
477              This should handle things like schedule () correctly where we're
478              switching contexts.  */
479           prev->up = bfun->number;
480           prev->flags = BFUN_UP_LINKS_TO_RET;
481
482           ftrace_debug (bfun, "new return - unknown caller");
483         }
484     }
485
486   return bfun;
487 }
488
489 /* Add a new function segment for a function switch at the end of the trace.
490    BTINFO is the branch trace information for the current thread.
491    MFUN and FUN are the symbol information we have for this function.  */
492
493 static struct btrace_function *
494 ftrace_new_switch (struct btrace_thread_info *btinfo,
495                    struct minimal_symbol *mfun,
496                    struct symbol *fun)
497 {
498   struct btrace_function *prev, *bfun;
499
500   /* This is an unexplained function switch.  We can't really be sure about the
501      call stack, yet the best I can think of right now is to preserve it.  */
502   bfun = ftrace_new_function (btinfo, mfun, fun);
503   prev = ftrace_find_call_by_number (btinfo, bfun->number - 1);
504   bfun->up = prev->up;
505   bfun->flags = prev->flags;
506
507   ftrace_debug (bfun, "new switch");
508
509   return bfun;
510 }
511
512 /* Add a new function segment for a gap in the trace due to a decode error at
513    the end of the trace.
514    BTINFO is the branch trace information for the current thread.
515    ERRCODE is the format-specific error code.  */
516
517 static struct btrace_function *
518 ftrace_new_gap (struct btrace_thread_info *btinfo, int errcode,
519                 std::vector<unsigned int> &gaps)
520 {
521   struct btrace_function *bfun;
522
523   if (btinfo->functions.empty ())
524     bfun = ftrace_new_function (btinfo, NULL, NULL);
525   else
526     {
527       /* We hijack the previous function segment if it was empty.  */
528       bfun = &btinfo->functions.back ();
529       if (bfun->errcode != 0 || !bfun->insn.empty ())
530         bfun = ftrace_new_function (btinfo, NULL, NULL);
531     }
532
533   bfun->errcode = errcode;
534   gaps.push_back (bfun->number);
535
536   ftrace_debug (bfun, "new gap");
537
538   return bfun;
539 }
540
541 /* Update the current function segment at the end of the trace in BTINFO with
542    respect to the instruction at PC.  This may create new function segments.
543    Return the chronologically latest function segment, never NULL.  */
544
545 static struct btrace_function *
546 ftrace_update_function (struct btrace_thread_info *btinfo, CORE_ADDR pc)
547 {
548   struct bound_minimal_symbol bmfun;
549   struct minimal_symbol *mfun;
550   struct symbol *fun;
551   struct btrace_function *bfun;
552
553   /* Try to determine the function we're in.  We use both types of symbols
554      to avoid surprises when we sometimes get a full symbol and sometimes
555      only a minimal symbol.  */
556   fun = find_pc_function (pc);
557   bmfun = lookup_minimal_symbol_by_pc (pc);
558   mfun = bmfun.minsym;
559
560   if (fun == NULL && mfun == NULL)
561     DEBUG_FTRACE ("no symbol at %s", core_addr_to_string_nz (pc));
562
563   /* If we didn't have a function, we create one.  */
564   if (btinfo->functions.empty ())
565     return ftrace_new_function (btinfo, mfun, fun);
566
567   /* If we had a gap before, we create a function.  */
568   bfun = &btinfo->functions.back ();
569   if (bfun->errcode != 0)
570     return ftrace_new_function (btinfo, mfun, fun);
571
572   /* Check the last instruction, if we have one.
573      We do this check first, since it allows us to fill in the call stack
574      links in addition to the normal flow links.  */
575   btrace_insn *last = NULL;
576   if (!bfun->insn.empty ())
577     last = &bfun->insn.back ();
578
579   if (last != NULL)
580     {
581       switch (last->iclass)
582         {
583         case BTRACE_INSN_RETURN:
584           {
585             const char *fname;
586
587             /* On some systems, _dl_runtime_resolve returns to the resolved
588                function instead of jumping to it.  From our perspective,
589                however, this is a tailcall.
590                If we treated it as return, we wouldn't be able to find the
591                resolved function in our stack back trace.  Hence, we would
592                lose the current stack back trace and start anew with an empty
593                back trace.  When the resolved function returns, we would then
594                create a stack back trace with the same function names but
595                different frame id's.  This will confuse stepping.  */
596             fname = ftrace_print_function_name (bfun);
597             if (strcmp (fname, "_dl_runtime_resolve") == 0)
598               return ftrace_new_tailcall (btinfo, mfun, fun);
599
600             return ftrace_new_return (btinfo, mfun, fun);
601           }
602
603         case BTRACE_INSN_CALL:
604           /* Ignore calls to the next instruction.  They are used for PIC.  */
605           if (last->pc + last->size == pc)
606             break;
607
608           return ftrace_new_call (btinfo, mfun, fun);
609
610         case BTRACE_INSN_JUMP:
611           {
612             CORE_ADDR start;
613
614             start = get_pc_function_start (pc);
615
616             /* A jump to the start of a function is (typically) a tail call.  */
617             if (start == pc)
618               return ftrace_new_tailcall (btinfo, mfun, fun);
619
620             /* If we can't determine the function for PC, we treat a jump at
621                the end of the block as tail call if we're switching functions
622                and as an intra-function branch if we don't.  */
623             if (start == 0 && ftrace_function_switched (bfun, mfun, fun))
624               return ftrace_new_tailcall (btinfo, mfun, fun);
625
626             break;
627           }
628         }
629     }
630
631   /* Check if we're switching functions for some other reason.  */
632   if (ftrace_function_switched (bfun, mfun, fun))
633     {
634       DEBUG_FTRACE ("switching from %s in %s at %s",
635                     ftrace_print_insn_addr (last),
636                     ftrace_print_function_name (bfun),
637                     ftrace_print_filename (bfun));
638
639       return ftrace_new_switch (btinfo, mfun, fun);
640     }
641
642   return bfun;
643 }
644
645 /* Add the instruction at PC to BFUN's instructions.  */
646
647 static void
648 ftrace_update_insns (struct btrace_function *bfun, const btrace_insn &insn)
649 {
650   bfun->insn.push_back (insn);
651
652   if (record_debug > 1)
653     ftrace_debug (bfun, "update insn");
654 }
655
656 /* Classify the instruction at PC.  */
657
658 static enum btrace_insn_class
659 ftrace_classify_insn (struct gdbarch *gdbarch, CORE_ADDR pc)
660 {
661   enum btrace_insn_class iclass;
662
663   iclass = BTRACE_INSN_OTHER;
664   TRY
665     {
666       if (gdbarch_insn_is_call (gdbarch, pc))
667         iclass = BTRACE_INSN_CALL;
668       else if (gdbarch_insn_is_ret (gdbarch, pc))
669         iclass = BTRACE_INSN_RETURN;
670       else if (gdbarch_insn_is_jump (gdbarch, pc))
671         iclass = BTRACE_INSN_JUMP;
672     }
673   CATCH (error, RETURN_MASK_ERROR)
674     {
675     }
676   END_CATCH
677
678   return iclass;
679 }
680
681 /* Try to match the back trace at LHS to the back trace at RHS.  Returns the
682    number of matching function segments or zero if the back traces do not
683    match.  BTINFO is the branch trace information for the current thread.  */
684
685 static int
686 ftrace_match_backtrace (struct btrace_thread_info *btinfo,
687                         struct btrace_function *lhs,
688                         struct btrace_function *rhs)
689 {
690   int matches;
691
692   for (matches = 0; lhs != NULL && rhs != NULL; ++matches)
693     {
694       if (ftrace_function_switched (lhs, rhs->msym, rhs->sym))
695         return 0;
696
697       lhs = ftrace_get_caller (btinfo, lhs);
698       rhs = ftrace_get_caller (btinfo, rhs);
699     }
700
701   return matches;
702 }
703
704 /* Add ADJUSTMENT to the level of BFUN and succeeding function segments.
705    BTINFO is the branch trace information for the current thread.  */
706
707 static void
708 ftrace_fixup_level (struct btrace_thread_info *btinfo,
709                     struct btrace_function *bfun, int adjustment)
710 {
711   if (adjustment == 0)
712     return;
713
714   DEBUG_FTRACE ("fixup level (%+d)", adjustment);
715   ftrace_debug (bfun, "..bfun");
716
717   while (bfun != NULL)
718     {
719       bfun->level += adjustment;
720       bfun = ftrace_find_call_by_number (btinfo, bfun->number + 1);
721     }
722 }
723
724 /* Recompute the global level offset.  Traverse the function trace and compute
725    the global level offset as the negative of the minimal function level.  */
726
727 static void
728 ftrace_compute_global_level_offset (struct btrace_thread_info *btinfo)
729 {
730   int level = INT_MAX;
731
732   if (btinfo == NULL)
733     return;
734
735   if (btinfo->functions.empty ())
736     return;
737
738   unsigned int length = btinfo->functions.size() - 1;
739   for (unsigned int i = 0; i < length; ++i)
740     level = std::min (level, btinfo->functions[i].level);
741
742   /* The last function segment contains the current instruction, which is not
743      really part of the trace.  If it contains just this one instruction, we
744      ignore the segment.  */
745   struct btrace_function *last = &btinfo->functions.back();
746   if (last->insn.size () != 1)
747     level = std::min (level, last->level);
748
749   DEBUG_FTRACE ("setting global level offset: %d", -level);
750   btinfo->level = -level;
751 }
752
753 /* Connect the function segments PREV and NEXT in a bottom-to-top walk as in
754    ftrace_connect_backtrace.  BTINFO is the branch trace information for the
755    current thread.  */
756
757 static void
758 ftrace_connect_bfun (struct btrace_thread_info *btinfo,
759                      struct btrace_function *prev,
760                      struct btrace_function *next)
761 {
762   DEBUG_FTRACE ("connecting...");
763   ftrace_debug (prev, "..prev");
764   ftrace_debug (next, "..next");
765
766   /* The function segments are not yet connected.  */
767   gdb_assert (prev->next == 0);
768   gdb_assert (next->prev == 0);
769
770   prev->next = next->number;
771   next->prev = prev->number;
772
773   /* We may have moved NEXT to a different function level.  */
774   ftrace_fixup_level (btinfo, next, prev->level - next->level);
775
776   /* If we run out of back trace for one, let's use the other's.  */
777   if (prev->up == 0)
778     {
779       const btrace_function_flags flags = next->flags;
780
781       next = ftrace_find_call_by_number (btinfo, next->up);
782       if (next != NULL)
783         {
784           DEBUG_FTRACE ("using next's callers");
785           ftrace_fixup_caller (btinfo, prev, next, flags);
786         }
787     }
788   else if (next->up == 0)
789     {
790       const btrace_function_flags flags = prev->flags;
791
792       prev = ftrace_find_call_by_number (btinfo, prev->up);
793       if (prev != NULL)
794         {
795           DEBUG_FTRACE ("using prev's callers");
796           ftrace_fixup_caller (btinfo, next, prev, flags);
797         }
798     }
799   else
800     {
801       /* PREV may have a tailcall caller, NEXT can't.  If it does, fixup the up
802          link to add the tail callers to NEXT's back trace.
803
804          This removes NEXT->UP from NEXT's back trace.  It will be added back
805          when connecting NEXT and PREV's callers - provided they exist.
806
807          If PREV's back trace consists of a series of tail calls without an
808          actual call, there will be no further connection and NEXT's caller will
809          be removed for good.  To catch this case, we handle it here and connect
810          the top of PREV's back trace to NEXT's caller.  */
811       if ((prev->flags & BFUN_UP_LINKS_TO_TAILCALL) != 0)
812         {
813           struct btrace_function *caller;
814           btrace_function_flags next_flags, prev_flags;
815
816           /* We checked NEXT->UP above so CALLER can't be NULL.  */
817           caller = ftrace_find_call_by_number (btinfo, next->up);
818           next_flags = next->flags;
819           prev_flags = prev->flags;
820
821           DEBUG_FTRACE ("adding prev's tail calls to next");
822
823           prev = ftrace_find_call_by_number (btinfo, prev->up);
824           ftrace_fixup_caller (btinfo, next, prev, prev_flags);
825
826           for (; prev != NULL; prev = ftrace_find_call_by_number (btinfo,
827                                                                   prev->up))
828             {
829               /* At the end of PREV's back trace, continue with CALLER.  */
830               if (prev->up == 0)
831                 {
832                   DEBUG_FTRACE ("fixing up link for tailcall chain");
833                   ftrace_debug (prev, "..top");
834                   ftrace_debug (caller, "..up");
835
836                   ftrace_fixup_caller (btinfo, prev, caller, next_flags);
837
838                   /* If we skipped any tail calls, this may move CALLER to a
839                      different function level.
840
841                      Note that changing CALLER's level is only OK because we
842                      know that this is the last iteration of the bottom-to-top
843                      walk in ftrace_connect_backtrace.
844
845                      Otherwise we will fix up CALLER's level when we connect it
846                      to PREV's caller in the next iteration.  */
847                   ftrace_fixup_level (btinfo, caller,
848                                       prev->level - caller->level - 1);
849                   break;
850                 }
851
852               /* There's nothing to do if we find a real call.  */
853               if ((prev->flags & BFUN_UP_LINKS_TO_TAILCALL) == 0)
854                 {
855                   DEBUG_FTRACE ("will fix up link in next iteration");
856                   break;
857                 }
858             }
859         }
860     }
861 }
862
863 /* Connect function segments on the same level in the back trace at LHS and RHS.
864    The back traces at LHS and RHS are expected to match according to
865    ftrace_match_backtrace.  BTINFO is the branch trace information for the
866    current thread.  */
867
868 static void
869 ftrace_connect_backtrace (struct btrace_thread_info *btinfo,
870                           struct btrace_function *lhs,
871                           struct btrace_function *rhs)
872 {
873   while (lhs != NULL && rhs != NULL)
874     {
875       struct btrace_function *prev, *next;
876
877       gdb_assert (!ftrace_function_switched (lhs, rhs->msym, rhs->sym));
878
879       /* Connecting LHS and RHS may change the up link.  */
880       prev = lhs;
881       next = rhs;
882
883       lhs = ftrace_get_caller (btinfo, lhs);
884       rhs = ftrace_get_caller (btinfo, rhs);
885
886       ftrace_connect_bfun (btinfo, prev, next);
887     }
888 }
889
890 /* Bridge the gap between two function segments left and right of a gap if their
891    respective back traces match in at least MIN_MATCHES functions.  BTINFO is
892    the branch trace information for the current thread.
893
894    Returns non-zero if the gap could be bridged, zero otherwise.  */
895
896 static int
897 ftrace_bridge_gap (struct btrace_thread_info *btinfo,
898                    struct btrace_function *lhs, struct btrace_function *rhs,
899                    int min_matches)
900 {
901   struct btrace_function *best_l, *best_r, *cand_l, *cand_r;
902   int best_matches;
903
904   DEBUG_FTRACE ("checking gap at insn %u (req matches: %d)",
905                 rhs->insn_offset - 1, min_matches);
906
907   best_matches = 0;
908   best_l = NULL;
909   best_r = NULL;
910
911   /* We search the back traces of LHS and RHS for valid connections and connect
912      the two functon segments that give the longest combined back trace.  */
913
914   for (cand_l = lhs; cand_l != NULL;
915        cand_l = ftrace_get_caller (btinfo, cand_l))
916     for (cand_r = rhs; cand_r != NULL;
917          cand_r = ftrace_get_caller (btinfo, cand_r))
918       {
919         int matches;
920
921         matches = ftrace_match_backtrace (btinfo, cand_l, cand_r);
922         if (best_matches < matches)
923           {
924             best_matches = matches;
925             best_l = cand_l;
926             best_r = cand_r;
927           }
928       }
929
930   /* We need at least MIN_MATCHES matches.  */
931   gdb_assert (min_matches > 0);
932   if (best_matches < min_matches)
933     return 0;
934
935   DEBUG_FTRACE ("..matches: %d", best_matches);
936
937   /* We will fix up the level of BEST_R and succeeding function segments such
938      that BEST_R's level matches BEST_L's when we connect BEST_L to BEST_R.
939
940      This will ignore the level of RHS and following if BEST_R != RHS.  I.e. if
941      BEST_R is a successor of RHS in the back trace of RHS (phases 1 and 3).
942
943      To catch this, we already fix up the level here where we can start at RHS
944      instead of at BEST_R.  We will ignore the level fixup when connecting
945      BEST_L to BEST_R as they will already be on the same level.  */
946   ftrace_fixup_level (btinfo, rhs, best_l->level - best_r->level);
947
948   ftrace_connect_backtrace (btinfo, best_l, best_r);
949
950   return best_matches;
951 }
952
953 /* Try to bridge gaps due to overflow or decode errors by connecting the
954    function segments that are separated by the gap.  */
955
956 static void
957 btrace_bridge_gaps (struct thread_info *tp, std::vector<unsigned int> &gaps)
958 {
959   struct btrace_thread_info *btinfo = &tp->btrace;
960   std::vector<unsigned int> remaining;
961   int min_matches;
962
963   DEBUG ("bridge gaps");
964
965   /* We require a minimum amount of matches for bridging a gap.  The number of
966      required matches will be lowered with each iteration.
967
968      The more matches the higher our confidence that the bridging is correct.
969      For big gaps or small traces, however, it may not be feasible to require a
970      high number of matches.  */
971   for (min_matches = 5; min_matches > 0; --min_matches)
972     {
973       /* Let's try to bridge as many gaps as we can.  In some cases, we need to
974          skip a gap and revisit it again after we closed later gaps.  */
975       while (!gaps.empty ())
976         {
977           for (const unsigned int number : gaps)
978             {
979               struct btrace_function *gap, *lhs, *rhs;
980               int bridged;
981
982               gap = ftrace_find_call_by_number (btinfo, number);
983
984               /* We may have a sequence of gaps if we run from one error into
985                  the next as we try to re-sync onto the trace stream.  Ignore
986                  all but the leftmost gap in such a sequence.
987
988                  Also ignore gaps at the beginning of the trace.  */
989               lhs = ftrace_find_call_by_number (btinfo, gap->number - 1);
990               if (lhs == NULL || lhs->errcode != 0)
991                 continue;
992
993               /* Skip gaps to the right.  */
994               rhs = ftrace_find_call_by_number (btinfo, gap->number + 1);
995               while (rhs != NULL && rhs->errcode != 0)
996                 rhs = ftrace_find_call_by_number (btinfo, rhs->number + 1);
997
998               /* Ignore gaps at the end of the trace.  */
999               if (rhs == NULL)
1000                 continue;
1001
1002               bridged = ftrace_bridge_gap (btinfo, lhs, rhs, min_matches);
1003
1004               /* Keep track of gaps we were not able to bridge and try again.
1005                  If we just pushed them to the end of GAPS we would risk an
1006                  infinite loop in case we simply cannot bridge a gap.  */
1007               if (bridged == 0)
1008                 remaining.push_back (number);
1009             }
1010
1011           /* Let's see if we made any progress.  */
1012           if (remaining.size () == gaps.size ())
1013             break;
1014
1015           gaps.clear ();
1016           gaps.swap (remaining);
1017         }
1018
1019       /* We get here if either GAPS is empty or if GAPS equals REMAINING.  */
1020       if (gaps.empty ())
1021         break;
1022
1023       remaining.clear ();
1024     }
1025
1026   /* We may omit this in some cases.  Not sure it is worth the extra
1027      complication, though.  */
1028   ftrace_compute_global_level_offset (btinfo);
1029 }
1030
1031 /* Compute the function branch trace from BTS trace.  */
1032
1033 static void
1034 btrace_compute_ftrace_bts (struct thread_info *tp,
1035                            const struct btrace_data_bts *btrace,
1036                            std::vector<unsigned int> &gaps)
1037 {
1038   struct btrace_thread_info *btinfo;
1039   struct gdbarch *gdbarch;
1040   unsigned int blk;
1041   int level;
1042
1043   gdbarch = target_gdbarch ();
1044   btinfo = &tp->btrace;
1045   blk = VEC_length (btrace_block_s, btrace->blocks);
1046
1047   if (btinfo->functions.empty ())
1048     level = INT_MAX;
1049   else
1050     level = -btinfo->level;
1051
1052   while (blk != 0)
1053     {
1054       btrace_block_s *block;
1055       CORE_ADDR pc;
1056
1057       blk -= 1;
1058
1059       block = VEC_index (btrace_block_s, btrace->blocks, blk);
1060       pc = block->begin;
1061
1062       for (;;)
1063         {
1064           struct btrace_function *bfun;
1065           struct btrace_insn insn;
1066           int size;
1067
1068           /* We should hit the end of the block.  Warn if we went too far.  */
1069           if (block->end < pc)
1070             {
1071               /* Indicate the gap in the trace.  */
1072               bfun = ftrace_new_gap (btinfo, BDE_BTS_OVERFLOW, gaps);
1073
1074               warning (_("Recorded trace may be corrupted at instruction "
1075                          "%u (pc = %s)."), bfun->insn_offset - 1,
1076                        core_addr_to_string_nz (pc));
1077
1078               break;
1079             }
1080
1081           bfun = ftrace_update_function (btinfo, pc);
1082
1083           /* Maintain the function level offset.
1084              For all but the last block, we do it here.  */
1085           if (blk != 0)
1086             level = std::min (level, bfun->level);
1087
1088           size = 0;
1089           TRY
1090             {
1091               size = gdb_insn_length (gdbarch, pc);
1092             }
1093           CATCH (error, RETURN_MASK_ERROR)
1094             {
1095             }
1096           END_CATCH
1097
1098           insn.pc = pc;
1099           insn.size = size;
1100           insn.iclass = ftrace_classify_insn (gdbarch, pc);
1101           insn.flags = 0;
1102
1103           ftrace_update_insns (bfun, insn);
1104
1105           /* We're done once we pushed the instruction at the end.  */
1106           if (block->end == pc)
1107             break;
1108
1109           /* We can't continue if we fail to compute the size.  */
1110           if (size <= 0)
1111             {
1112               /* Indicate the gap in the trace.  We just added INSN so we're
1113                  not at the beginning.  */
1114               bfun = ftrace_new_gap (btinfo, BDE_BTS_INSN_SIZE, gaps);
1115
1116               warning (_("Recorded trace may be incomplete at instruction %u "
1117                          "(pc = %s)."), bfun->insn_offset - 1,
1118                        core_addr_to_string_nz (pc));
1119
1120               break;
1121             }
1122
1123           pc += size;
1124
1125           /* Maintain the function level offset.
1126              For the last block, we do it here to not consider the last
1127              instruction.
1128              Since the last instruction corresponds to the current instruction
1129              and is not really part of the execution history, it shouldn't
1130              affect the level.  */
1131           if (blk == 0)
1132             level = std::min (level, bfun->level);
1133         }
1134     }
1135
1136   /* LEVEL is the minimal function level of all btrace function segments.
1137      Define the global level offset to -LEVEL so all function levels are
1138      normalized to start at zero.  */
1139   btinfo->level = -level;
1140 }
1141
1142 #if defined (HAVE_LIBIPT)
1143
1144 static enum btrace_insn_class
1145 pt_reclassify_insn (enum pt_insn_class iclass)
1146 {
1147   switch (iclass)
1148     {
1149     case ptic_call:
1150       return BTRACE_INSN_CALL;
1151
1152     case ptic_return:
1153       return BTRACE_INSN_RETURN;
1154
1155     case ptic_jump:
1156       return BTRACE_INSN_JUMP;
1157
1158     default:
1159       return BTRACE_INSN_OTHER;
1160     }
1161 }
1162
1163 /* Return the btrace instruction flags for INSN.  */
1164
1165 static btrace_insn_flags
1166 pt_btrace_insn_flags (const struct pt_insn &insn)
1167 {
1168   btrace_insn_flags flags = 0;
1169
1170   if (insn.speculative)
1171     flags |= BTRACE_INSN_FLAG_SPECULATIVE;
1172
1173   return flags;
1174 }
1175
1176 /* Return the btrace instruction for INSN.  */
1177
1178 static btrace_insn
1179 pt_btrace_insn (const struct pt_insn &insn)
1180 {
1181   return {(CORE_ADDR) insn.ip, (gdb_byte) insn.size,
1182           pt_reclassify_insn (insn.iclass),
1183           pt_btrace_insn_flags (insn)};
1184 }
1185
1186 /* Handle instruction decode events (libipt-v2).  */
1187
1188 static int
1189 handle_pt_insn_events (struct btrace_thread_info *btinfo,
1190                        struct pt_insn_decoder *decoder,
1191                        std::vector<unsigned int> &gaps, int status)
1192 {
1193 #if defined (HAVE_PT_INSN_EVENT)
1194   while (status & pts_event_pending)
1195     {
1196       struct btrace_function *bfun;
1197       struct pt_event event;
1198       uint64_t offset;
1199
1200       status = pt_insn_event (decoder, &event, sizeof (event));
1201       if (status < 0)
1202         break;
1203
1204       switch (event.type)
1205         {
1206         default:
1207           break;
1208
1209         case ptev_enabled:
1210           if (event.variant.enabled.resumed == 0 && !btinfo->functions.empty ())
1211             {
1212               bfun = ftrace_new_gap (btinfo, BDE_PT_DISABLED, gaps);
1213
1214               pt_insn_get_offset (decoder, &offset);
1215
1216               warning (_("Non-contiguous trace at instruction %u (offset = 0x%"
1217                          PRIx64 ")."), bfun->insn_offset - 1, offset);
1218             }
1219
1220           break;
1221
1222         case ptev_overflow:
1223           bfun = ftrace_new_gap (btinfo, BDE_PT_OVERFLOW, gaps);
1224
1225           pt_insn_get_offset (decoder, &offset);
1226
1227           warning (_("Overflow at instruction %u (offset = 0x%" PRIx64 ")."),
1228                    bfun->insn_offset - 1, offset);
1229
1230           break;
1231         }
1232     }
1233 #endif /* defined (HAVE_PT_INSN_EVENT) */
1234
1235   return status;
1236 }
1237
1238 /* Handle events indicated by flags in INSN (libipt-v1).  */
1239
1240 static void
1241 handle_pt_insn_event_flags (struct btrace_thread_info *btinfo,
1242                             struct pt_insn_decoder *decoder,
1243                             const struct pt_insn &insn,
1244                             std::vector<unsigned int> &gaps)
1245 {
1246 #if defined (HAVE_STRUCT_PT_INSN_ENABLED)
1247   /* Tracing is disabled and re-enabled each time we enter the kernel.  Most
1248      times, we continue from the same instruction we stopped before.  This is
1249      indicated via the RESUMED instruction flag.  The ENABLED instruction flag
1250      means that we continued from some other instruction.  Indicate this as a
1251      trace gap except when tracing just started.  */
1252   if (insn.enabled && !btinfo->functions.empty ())
1253     {
1254       struct btrace_function *bfun;
1255       uint64_t offset;
1256
1257       bfun = ftrace_new_gap (btinfo, BDE_PT_DISABLED, gaps);
1258
1259       pt_insn_get_offset (decoder, &offset);
1260
1261       warning (_("Non-contiguous trace at instruction %u (offset = 0x%" PRIx64
1262                  ", pc = 0x%" PRIx64 ")."), bfun->insn_offset - 1, offset,
1263                insn.ip);
1264     }
1265 #endif /* defined (HAVE_STRUCT_PT_INSN_ENABLED) */
1266
1267 #if defined (HAVE_STRUCT_PT_INSN_RESYNCED)
1268   /* Indicate trace overflows.  */
1269   if (insn.resynced)
1270     {
1271       struct btrace_function *bfun;
1272       uint64_t offset;
1273
1274       bfun = ftrace_new_gap (btinfo, BDE_PT_OVERFLOW, gaps);
1275
1276       pt_insn_get_offset (decoder, &offset);
1277
1278       warning (_("Overflow at instruction %u (offset = 0x%" PRIx64 ", pc = 0x%"
1279                  PRIx64 ")."), bfun->insn_offset - 1, offset, insn.ip);
1280     }
1281 #endif /* defined (HAVE_STRUCT_PT_INSN_RESYNCED) */
1282 }
1283
1284 /* Add function branch trace to BTINFO using DECODER.  */
1285
1286 static void
1287 ftrace_add_pt (struct btrace_thread_info *btinfo,
1288                struct pt_insn_decoder *decoder,
1289                int *plevel,
1290                std::vector<unsigned int> &gaps)
1291 {
1292   struct btrace_function *bfun;
1293   uint64_t offset;
1294   int status;
1295
1296   for (;;)
1297     {
1298       struct pt_insn insn;
1299
1300       status = pt_insn_sync_forward (decoder);
1301       if (status < 0)
1302         {
1303           if (status != -pte_eos)
1304             warning (_("Failed to synchronize onto the Intel Processor "
1305                        "Trace stream: %s."), pt_errstr (pt_errcode (status)));
1306           break;
1307         }
1308
1309       for (;;)
1310         {
1311           /* Handle events from the previous iteration or synchronization.  */
1312           status = handle_pt_insn_events (btinfo, decoder, gaps, status);
1313           if (status < 0)
1314             break;
1315
1316           status = pt_insn_next (decoder, &insn, sizeof(insn));
1317           if (status < 0)
1318             break;
1319
1320           /* Handle events indicated by flags in INSN.  */
1321           handle_pt_insn_event_flags (btinfo, decoder, insn, gaps);
1322
1323           bfun = ftrace_update_function (btinfo, insn.ip);
1324
1325           /* Maintain the function level offset.  */
1326           *plevel = std::min (*plevel, bfun->level);
1327
1328           ftrace_update_insns (bfun, pt_btrace_insn (insn));
1329         }
1330
1331       if (status == -pte_eos)
1332         break;
1333
1334       /* Indicate the gap in the trace.  */
1335       bfun = ftrace_new_gap (btinfo, status, gaps);
1336
1337       pt_insn_get_offset (decoder, &offset);
1338
1339       warning (_("Decode error (%d) at instruction %u (offset = 0x%" PRIx64
1340                  ", pc = 0x%" PRIx64 "): %s."), status, bfun->insn_offset - 1,
1341                offset, insn.ip, pt_errstr (pt_errcode (status)));
1342     }
1343 }
1344
1345 /* A callback function to allow the trace decoder to read the inferior's
1346    memory.  */
1347
1348 static int
1349 btrace_pt_readmem_callback (gdb_byte *buffer, size_t size,
1350                             const struct pt_asid *asid, uint64_t pc,
1351                             void *context)
1352 {
1353   int result, errcode;
1354
1355   result = (int) size;
1356   TRY
1357     {
1358       errcode = target_read_code ((CORE_ADDR) pc, buffer, size);
1359       if (errcode != 0)
1360         result = -pte_nomap;
1361     }
1362   CATCH (error, RETURN_MASK_ERROR)
1363     {
1364       result = -pte_nomap;
1365     }
1366   END_CATCH
1367
1368   return result;
1369 }
1370
1371 /* Translate the vendor from one enum to another.  */
1372
1373 static enum pt_cpu_vendor
1374 pt_translate_cpu_vendor (enum btrace_cpu_vendor vendor)
1375 {
1376   switch (vendor)
1377     {
1378     default:
1379       return pcv_unknown;
1380
1381     case CV_INTEL:
1382       return pcv_intel;
1383     }
1384 }
1385
1386 /* Finalize the function branch trace after decode.  */
1387
1388 static void btrace_finalize_ftrace_pt (struct pt_insn_decoder *decoder,
1389                                        struct thread_info *tp, int level)
1390 {
1391   pt_insn_free_decoder (decoder);
1392
1393   /* LEVEL is the minimal function level of all btrace function segments.
1394      Define the global level offset to -LEVEL so all function levels are
1395      normalized to start at zero.  */
1396   tp->btrace.level = -level;
1397
1398   /* Add a single last instruction entry for the current PC.
1399      This allows us to compute the backtrace at the current PC using both
1400      standard unwind and btrace unwind.
1401      This extra entry is ignored by all record commands.  */
1402   btrace_add_pc (tp);
1403 }
1404
1405 /* Compute the function branch trace from Intel Processor Trace
1406    format.  */
1407
1408 static void
1409 btrace_compute_ftrace_pt (struct thread_info *tp,
1410                           const struct btrace_data_pt *btrace,
1411                           std::vector<unsigned int> &gaps)
1412 {
1413   struct btrace_thread_info *btinfo;
1414   struct pt_insn_decoder *decoder;
1415   struct pt_config config;
1416   int level, errcode;
1417
1418   if (btrace->size == 0)
1419     return;
1420
1421   btinfo = &tp->btrace;
1422   if (btinfo->functions.empty ())
1423     level = INT_MAX;
1424   else
1425     level = -btinfo->level;
1426
1427   pt_config_init(&config);
1428   config.begin = btrace->data;
1429   config.end = btrace->data + btrace->size;
1430
1431   config.cpu.vendor = pt_translate_cpu_vendor (btrace->config.cpu.vendor);
1432   config.cpu.family = btrace->config.cpu.family;
1433   config.cpu.model = btrace->config.cpu.model;
1434   config.cpu.stepping = btrace->config.cpu.stepping;
1435
1436   errcode = pt_cpu_errata (&config.errata, &config.cpu);
1437   if (errcode < 0)
1438     error (_("Failed to configure the Intel Processor Trace decoder: %s."),
1439            pt_errstr (pt_errcode (errcode)));
1440
1441   decoder = pt_insn_alloc_decoder (&config);
1442   if (decoder == NULL)
1443     error (_("Failed to allocate the Intel Processor Trace decoder."));
1444
1445   TRY
1446     {
1447       struct pt_image *image;
1448
1449       image = pt_insn_get_image(decoder);
1450       if (image == NULL)
1451         error (_("Failed to configure the Intel Processor Trace decoder."));
1452
1453       errcode = pt_image_set_callback(image, btrace_pt_readmem_callback, NULL);
1454       if (errcode < 0)
1455         error (_("Failed to configure the Intel Processor Trace decoder: "
1456                  "%s."), pt_errstr (pt_errcode (errcode)));
1457
1458       ftrace_add_pt (btinfo, decoder, &level, gaps);
1459     }
1460   CATCH (error, RETURN_MASK_ALL)
1461     {
1462       /* Indicate a gap in the trace if we quit trace processing.  */
1463       if (error.reason == RETURN_QUIT && !btinfo->functions.empty ())
1464         ftrace_new_gap (btinfo, BDE_PT_USER_QUIT, gaps);
1465
1466       btrace_finalize_ftrace_pt (decoder, tp, level);
1467
1468       throw_exception (error);
1469     }
1470   END_CATCH
1471
1472   btrace_finalize_ftrace_pt (decoder, tp, level);
1473 }
1474
1475 #else /* defined (HAVE_LIBIPT)  */
1476
1477 static void
1478 btrace_compute_ftrace_pt (struct thread_info *tp,
1479                           const struct btrace_data_pt *btrace,
1480                           std::vector<unsigned int> &gaps)
1481 {
1482   internal_error (__FILE__, __LINE__, _("Unexpected branch trace format."));
1483 }
1484
1485 #endif /* defined (HAVE_LIBIPT)  */
1486
1487 /* Compute the function branch trace from a block branch trace BTRACE for
1488    a thread given by BTINFO.  */
1489
1490 static void
1491 btrace_compute_ftrace_1 (struct thread_info *tp, struct btrace_data *btrace,
1492                          std::vector<unsigned int> &gaps)
1493 {
1494   DEBUG ("compute ftrace");
1495
1496   switch (btrace->format)
1497     {
1498     case BTRACE_FORMAT_NONE:
1499       return;
1500
1501     case BTRACE_FORMAT_BTS:
1502       btrace_compute_ftrace_bts (tp, &btrace->variant.bts, gaps);
1503       return;
1504
1505     case BTRACE_FORMAT_PT:
1506       btrace_compute_ftrace_pt (tp, &btrace->variant.pt, gaps);
1507       return;
1508     }
1509
1510   internal_error (__FILE__, __LINE__, _("Unkown branch trace format."));
1511 }
1512
1513 static void
1514 btrace_finalize_ftrace (struct thread_info *tp, std::vector<unsigned int> &gaps)
1515 {
1516   if (!gaps.empty ())
1517     {
1518       tp->btrace.ngaps += gaps.size ();
1519       btrace_bridge_gaps (tp, gaps);
1520     }
1521 }
1522
1523 static void
1524 btrace_compute_ftrace (struct thread_info *tp, struct btrace_data *btrace)
1525 {
1526   std::vector<unsigned int> gaps;
1527
1528   TRY
1529     {
1530       btrace_compute_ftrace_1 (tp, btrace, gaps);
1531     }
1532   CATCH (error, RETURN_MASK_ALL)
1533     {
1534       btrace_finalize_ftrace (tp, gaps);
1535
1536       throw_exception (error);
1537     }
1538   END_CATCH
1539
1540   btrace_finalize_ftrace (tp, gaps);
1541 }
1542
1543 /* Add an entry for the current PC.  */
1544
1545 static void
1546 btrace_add_pc (struct thread_info *tp)
1547 {
1548   struct btrace_data btrace;
1549   struct btrace_block *block;
1550   struct regcache *regcache;
1551   struct cleanup *cleanup;
1552   CORE_ADDR pc;
1553
1554   regcache = get_thread_regcache (tp->ptid);
1555   pc = regcache_read_pc (regcache);
1556
1557   btrace_data_init (&btrace);
1558   btrace.format = BTRACE_FORMAT_BTS;
1559   btrace.variant.bts.blocks = NULL;
1560
1561   cleanup = make_cleanup_btrace_data (&btrace);
1562
1563   block = VEC_safe_push (btrace_block_s, btrace.variant.bts.blocks, NULL);
1564   block->begin = pc;
1565   block->end = pc;
1566
1567   btrace_compute_ftrace (tp, &btrace);
1568
1569   do_cleanups (cleanup);
1570 }
1571
1572 /* See btrace.h.  */
1573
1574 void
1575 btrace_enable (struct thread_info *tp, const struct btrace_config *conf)
1576 {
1577   if (tp->btrace.target != NULL)
1578     return;
1579
1580 #if !defined (HAVE_LIBIPT)
1581   if (conf->format == BTRACE_FORMAT_PT)
1582     error (_("GDB does not support Intel Processor Trace."));
1583 #endif /* !defined (HAVE_LIBIPT) */
1584
1585   DEBUG ("enable thread %s (%s)", print_thread_id (tp),
1586          target_pid_to_str (tp->ptid));
1587
1588   tp->btrace.target = target_enable_btrace (tp->ptid, conf);
1589
1590   /* We're done if we failed to enable tracing.  */
1591   if (tp->btrace.target == NULL)
1592     return;
1593
1594   /* We need to undo the enable in case of errors.  */
1595   TRY
1596     {
1597       /* Add an entry for the current PC so we start tracing from where we
1598          enabled it.
1599
1600          If we can't access TP's registers, TP is most likely running.  In this
1601          case, we can't really say where tracing was enabled so it should be
1602          safe to simply skip this step.
1603
1604          This is not relevant for BTRACE_FORMAT_PT since the trace will already
1605          start at the PC at which tracing was enabled.  */
1606       if (conf->format != BTRACE_FORMAT_PT
1607           && can_access_registers_ptid (tp->ptid))
1608         btrace_add_pc (tp);
1609     }
1610   CATCH (exception, RETURN_MASK_ALL)
1611     {
1612       btrace_disable (tp);
1613
1614       throw_exception (exception);
1615     }
1616   END_CATCH
1617 }
1618
1619 /* See btrace.h.  */
1620
1621 const struct btrace_config *
1622 btrace_conf (const struct btrace_thread_info *btinfo)
1623 {
1624   if (btinfo->target == NULL)
1625     return NULL;
1626
1627   return target_btrace_conf (btinfo->target);
1628 }
1629
1630 /* See btrace.h.  */
1631
1632 void
1633 btrace_disable (struct thread_info *tp)
1634 {
1635   struct btrace_thread_info *btp = &tp->btrace;
1636
1637   if (btp->target == NULL)
1638     return;
1639
1640   DEBUG ("disable thread %s (%s)", print_thread_id (tp),
1641          target_pid_to_str (tp->ptid));
1642
1643   target_disable_btrace (btp->target);
1644   btp->target = NULL;
1645
1646   btrace_clear (tp);
1647 }
1648
1649 /* See btrace.h.  */
1650
1651 void
1652 btrace_teardown (struct thread_info *tp)
1653 {
1654   struct btrace_thread_info *btp = &tp->btrace;
1655
1656   if (btp->target == NULL)
1657     return;
1658
1659   DEBUG ("teardown thread %s (%s)", print_thread_id (tp),
1660          target_pid_to_str (tp->ptid));
1661
1662   target_teardown_btrace (btp->target);
1663   btp->target = NULL;
1664
1665   btrace_clear (tp);
1666 }
1667
1668 /* Stitch branch trace in BTS format.  */
1669
1670 static int
1671 btrace_stitch_bts (struct btrace_data_bts *btrace, struct thread_info *tp)
1672 {
1673   struct btrace_thread_info *btinfo;
1674   struct btrace_function *last_bfun;
1675   btrace_block_s *first_new_block;
1676
1677   btinfo = &tp->btrace;
1678   gdb_assert (!btinfo->functions.empty ());
1679   gdb_assert (!VEC_empty (btrace_block_s, btrace->blocks));
1680
1681   last_bfun = &btinfo->functions.back ();
1682
1683   /* If the existing trace ends with a gap, we just glue the traces
1684      together.  We need to drop the last (i.e. chronologically first) block
1685      of the new trace,  though, since we can't fill in the start address.*/
1686   if (last_bfun->insn.empty ())
1687     {
1688       VEC_pop (btrace_block_s, btrace->blocks);
1689       return 0;
1690     }
1691
1692   /* Beware that block trace starts with the most recent block, so the
1693      chronologically first block in the new trace is the last block in
1694      the new trace's block vector.  */
1695   first_new_block = VEC_last (btrace_block_s, btrace->blocks);
1696   const btrace_insn &last_insn = last_bfun->insn.back ();
1697
1698   /* If the current PC at the end of the block is the same as in our current
1699      trace, there are two explanations:
1700        1. we executed the instruction and some branch brought us back.
1701        2. we have not made any progress.
1702      In the first case, the delta trace vector should contain at least two
1703      entries.
1704      In the second case, the delta trace vector should contain exactly one
1705      entry for the partial block containing the current PC.  Remove it.  */
1706   if (first_new_block->end == last_insn.pc
1707       && VEC_length (btrace_block_s, btrace->blocks) == 1)
1708     {
1709       VEC_pop (btrace_block_s, btrace->blocks);
1710       return 0;
1711     }
1712
1713   DEBUG ("stitching %s to %s", ftrace_print_insn_addr (&last_insn),
1714          core_addr_to_string_nz (first_new_block->end));
1715
1716   /* Do a simple sanity check to make sure we don't accidentally end up
1717      with a bad block.  This should not occur in practice.  */
1718   if (first_new_block->end < last_insn.pc)
1719     {
1720       warning (_("Error while trying to read delta trace.  Falling back to "
1721                  "a full read."));
1722       return -1;
1723     }
1724
1725   /* We adjust the last block to start at the end of our current trace.  */
1726   gdb_assert (first_new_block->begin == 0);
1727   first_new_block->begin = last_insn.pc;
1728
1729   /* We simply pop the last insn so we can insert it again as part of
1730      the normal branch trace computation.
1731      Since instruction iterators are based on indices in the instructions
1732      vector, we don't leave any pointers dangling.  */
1733   DEBUG ("pruning insn at %s for stitching",
1734          ftrace_print_insn_addr (&last_insn));
1735
1736   last_bfun->insn.pop_back ();
1737
1738   /* The instructions vector may become empty temporarily if this has
1739      been the only instruction in this function segment.
1740      This violates the invariant but will be remedied shortly by
1741      btrace_compute_ftrace when we add the new trace.  */
1742
1743   /* The only case where this would hurt is if the entire trace consisted
1744      of just that one instruction.  If we remove it, we might turn the now
1745      empty btrace function segment into a gap.  But we don't want gaps at
1746      the beginning.  To avoid this, we remove the entire old trace.  */
1747   if (last_bfun->number == 1 && last_bfun->insn.empty ())
1748     btrace_clear (tp);
1749
1750   return 0;
1751 }
1752
1753 /* Adjust the block trace in order to stitch old and new trace together.
1754    BTRACE is the new delta trace between the last and the current stop.
1755    TP is the traced thread.
1756    May modifx BTRACE as well as the existing trace in TP.
1757    Return 0 on success, -1 otherwise.  */
1758
1759 static int
1760 btrace_stitch_trace (struct btrace_data *btrace, struct thread_info *tp)
1761 {
1762   /* If we don't have trace, there's nothing to do.  */
1763   if (btrace_data_empty (btrace))
1764     return 0;
1765
1766   switch (btrace->format)
1767     {
1768     case BTRACE_FORMAT_NONE:
1769       return 0;
1770
1771     case BTRACE_FORMAT_BTS:
1772       return btrace_stitch_bts (&btrace->variant.bts, tp);
1773
1774     case BTRACE_FORMAT_PT:
1775       /* Delta reads are not supported.  */
1776       return -1;
1777     }
1778
1779   internal_error (__FILE__, __LINE__, _("Unkown branch trace format."));
1780 }
1781
1782 /* Clear the branch trace histories in BTINFO.  */
1783
1784 static void
1785 btrace_clear_history (struct btrace_thread_info *btinfo)
1786 {
1787   xfree (btinfo->insn_history);
1788   xfree (btinfo->call_history);
1789   xfree (btinfo->replay);
1790
1791   btinfo->insn_history = NULL;
1792   btinfo->call_history = NULL;
1793   btinfo->replay = NULL;
1794 }
1795
1796 /* Clear the branch trace maintenance histories in BTINFO.  */
1797
1798 static void
1799 btrace_maint_clear (struct btrace_thread_info *btinfo)
1800 {
1801   switch (btinfo->data.format)
1802     {
1803     default:
1804       break;
1805
1806     case BTRACE_FORMAT_BTS:
1807       btinfo->maint.variant.bts.packet_history.begin = 0;
1808       btinfo->maint.variant.bts.packet_history.end = 0;
1809       break;
1810
1811 #if defined (HAVE_LIBIPT)
1812     case BTRACE_FORMAT_PT:
1813       xfree (btinfo->maint.variant.pt.packets);
1814
1815       btinfo->maint.variant.pt.packets = NULL;
1816       btinfo->maint.variant.pt.packet_history.begin = 0;
1817       btinfo->maint.variant.pt.packet_history.end = 0;
1818       break;
1819 #endif /* defined (HAVE_LIBIPT)  */
1820     }
1821 }
1822
1823 /* See btrace.h.  */
1824
1825 const char *
1826 btrace_decode_error (enum btrace_format format, int errcode)
1827 {
1828   switch (format)
1829     {
1830     case BTRACE_FORMAT_BTS:
1831       switch (errcode)
1832         {
1833         case BDE_BTS_OVERFLOW:
1834           return _("instruction overflow");
1835
1836         case BDE_BTS_INSN_SIZE:
1837           return _("unknown instruction");
1838
1839         default:
1840           break;
1841         }
1842       break;
1843
1844 #if defined (HAVE_LIBIPT)
1845     case BTRACE_FORMAT_PT:
1846       switch (errcode)
1847         {
1848         case BDE_PT_USER_QUIT:
1849           return _("trace decode cancelled");
1850
1851         case BDE_PT_DISABLED:
1852           return _("disabled");
1853
1854         case BDE_PT_OVERFLOW:
1855           return _("overflow");
1856
1857         default:
1858           if (errcode < 0)
1859             return pt_errstr (pt_errcode (errcode));
1860           break;
1861         }
1862       break;
1863 #endif /* defined (HAVE_LIBIPT)  */
1864
1865     default:
1866       break;
1867     }
1868
1869   return _("unknown");
1870 }
1871
1872 /* See btrace.h.  */
1873
1874 void
1875 btrace_fetch (struct thread_info *tp)
1876 {
1877   struct btrace_thread_info *btinfo;
1878   struct btrace_target_info *tinfo;
1879   struct btrace_data btrace;
1880   struct cleanup *cleanup;
1881   int errcode;
1882
1883   DEBUG ("fetch thread %s (%s)", print_thread_id (tp),
1884          target_pid_to_str (tp->ptid));
1885
1886   btinfo = &tp->btrace;
1887   tinfo = btinfo->target;
1888   if (tinfo == NULL)
1889     return;
1890
1891   /* There's no way we could get new trace while replaying.
1892      On the other hand, delta trace would return a partial record with the
1893      current PC, which is the replay PC, not the last PC, as expected.  */
1894   if (btinfo->replay != NULL)
1895     return;
1896
1897   /* With CLI usage, TP->PTID always equals INFERIOR_PTID here.  Now that we
1898      can store a gdb.Record object in Python referring to a different thread
1899      than the current one, temporarily set INFERIOR_PTID.  */
1900   scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid);
1901   inferior_ptid = tp->ptid;
1902
1903   /* We should not be called on running or exited threads.  */
1904   gdb_assert (can_access_registers_ptid (tp->ptid));
1905
1906   btrace_data_init (&btrace);
1907   cleanup = make_cleanup_btrace_data (&btrace);
1908
1909   /* Let's first try to extend the trace we already have.  */
1910   if (!btinfo->functions.empty ())
1911     {
1912       errcode = target_read_btrace (&btrace, tinfo, BTRACE_READ_DELTA);
1913       if (errcode == 0)
1914         {
1915           /* Success.  Let's try to stitch the traces together.  */
1916           errcode = btrace_stitch_trace (&btrace, tp);
1917         }
1918       else
1919         {
1920           /* We failed to read delta trace.  Let's try to read new trace.  */
1921           errcode = target_read_btrace (&btrace, tinfo, BTRACE_READ_NEW);
1922
1923           /* If we got any new trace, discard what we have.  */
1924           if (errcode == 0 && !btrace_data_empty (&btrace))
1925             btrace_clear (tp);
1926         }
1927
1928       /* If we were not able to read the trace, we start over.  */
1929       if (errcode != 0)
1930         {
1931           btrace_clear (tp);
1932           errcode = target_read_btrace (&btrace, tinfo, BTRACE_READ_ALL);
1933         }
1934     }
1935   else
1936     errcode = target_read_btrace (&btrace, tinfo, BTRACE_READ_ALL);
1937
1938   /* If we were not able to read the branch trace, signal an error.  */
1939   if (errcode != 0)
1940     error (_("Failed to read branch trace."));
1941
1942   /* Compute the trace, provided we have any.  */
1943   if (!btrace_data_empty (&btrace))
1944     {
1945       /* Store the raw trace data.  The stored data will be cleared in
1946          btrace_clear, so we always append the new trace.  */
1947       btrace_data_append (&btinfo->data, &btrace);
1948       btrace_maint_clear (btinfo);
1949
1950       btrace_clear_history (btinfo);
1951       btrace_compute_ftrace (tp, &btrace);
1952     }
1953
1954   do_cleanups (cleanup);
1955 }
1956
1957 /* See btrace.h.  */
1958
1959 void
1960 btrace_clear (struct thread_info *tp)
1961 {
1962   struct btrace_thread_info *btinfo;
1963
1964   DEBUG ("clear thread %s (%s)", print_thread_id (tp),
1965          target_pid_to_str (tp->ptid));
1966
1967   /* Make sure btrace frames that may hold a pointer into the branch
1968      trace data are destroyed.  */
1969   reinit_frame_cache ();
1970
1971   btinfo = &tp->btrace;
1972
1973   btinfo->functions.clear ();
1974   btinfo->ngaps = 0;
1975
1976   /* Must clear the maint data before - it depends on BTINFO->DATA.  */
1977   btrace_maint_clear (btinfo);
1978   btrace_data_clear (&btinfo->data);
1979   btrace_clear_history (btinfo);
1980 }
1981
1982 /* See btrace.h.  */
1983
1984 void
1985 btrace_free_objfile (struct objfile *objfile)
1986 {
1987   struct thread_info *tp;
1988
1989   DEBUG ("free objfile");
1990
1991   ALL_NON_EXITED_THREADS (tp)
1992     btrace_clear (tp);
1993 }
1994
1995 #if defined (HAVE_LIBEXPAT)
1996
1997 /* Check the btrace document version.  */
1998
1999 static void
2000 check_xml_btrace_version (struct gdb_xml_parser *parser,
2001                           const struct gdb_xml_element *element,
2002                           void *user_data,
2003                           std::vector<gdb_xml_value> &attributes)
2004 {
2005   const char *version
2006     = (const char *) xml_find_attribute (attributes, "version")->value.get ();
2007
2008   if (strcmp (version, "1.0") != 0)
2009     gdb_xml_error (parser, _("Unsupported btrace version: \"%s\""), version);
2010 }
2011
2012 /* Parse a btrace "block" xml record.  */
2013
2014 static void
2015 parse_xml_btrace_block (struct gdb_xml_parser *parser,
2016                         const struct gdb_xml_element *element,
2017                         void *user_data,
2018                         std::vector<gdb_xml_value> &attributes)
2019 {
2020   struct btrace_data *btrace;
2021   struct btrace_block *block;
2022   ULONGEST *begin, *end;
2023
2024   btrace = (struct btrace_data *) user_data;
2025
2026   switch (btrace->format)
2027     {
2028     case BTRACE_FORMAT_BTS:
2029       break;
2030
2031     case BTRACE_FORMAT_NONE:
2032       btrace->format = BTRACE_FORMAT_BTS;
2033       btrace->variant.bts.blocks = NULL;
2034       break;
2035
2036     default:
2037       gdb_xml_error (parser, _("Btrace format error."));
2038     }
2039
2040   begin = (ULONGEST *) xml_find_attribute (attributes, "begin")->value.get ();
2041   end = (ULONGEST *) xml_find_attribute (attributes, "end")->value.get ();
2042
2043   block = VEC_safe_push (btrace_block_s, btrace->variant.bts.blocks, NULL);
2044   block->begin = *begin;
2045   block->end = *end;
2046 }
2047
2048 /* Parse a "raw" xml record.  */
2049
2050 static void
2051 parse_xml_raw (struct gdb_xml_parser *parser, const char *body_text,
2052                gdb_byte **pdata, size_t *psize)
2053 {
2054   struct cleanup *cleanup;
2055   gdb_byte *data, *bin;
2056   size_t len, size;
2057
2058   len = strlen (body_text);
2059   if (len % 2 != 0)
2060     gdb_xml_error (parser, _("Bad raw data size."));
2061
2062   size = len / 2;
2063
2064   bin = data = (gdb_byte *) xmalloc (size);
2065   cleanup = make_cleanup (xfree, data);
2066
2067   /* We use hex encoding - see common/rsp-low.h.  */
2068   while (len > 0)
2069     {
2070       char hi, lo;
2071
2072       hi = *body_text++;
2073       lo = *body_text++;
2074
2075       if (hi == 0 || lo == 0)
2076         gdb_xml_error (parser, _("Bad hex encoding."));
2077
2078       *bin++ = fromhex (hi) * 16 + fromhex (lo);
2079       len -= 2;
2080     }
2081
2082   discard_cleanups (cleanup);
2083
2084   *pdata = data;
2085   *psize = size;
2086 }
2087
2088 /* Parse a btrace pt-config "cpu" xml record.  */
2089
2090 static void
2091 parse_xml_btrace_pt_config_cpu (struct gdb_xml_parser *parser,
2092                                 const struct gdb_xml_element *element,
2093                                 void *user_data,
2094                                 std::vector<gdb_xml_value> &attributes)
2095 {
2096   struct btrace_data *btrace;
2097   const char *vendor;
2098   ULONGEST *family, *model, *stepping;
2099
2100   vendor =
2101     (const char *) xml_find_attribute (attributes, "vendor")->value.get ();
2102   family
2103     = (ULONGEST *) xml_find_attribute (attributes, "family")->value.get ();
2104   model
2105     = (ULONGEST *) xml_find_attribute (attributes, "model")->value.get ();
2106   stepping
2107     = (ULONGEST *) xml_find_attribute (attributes, "stepping")->value.get ();
2108
2109   btrace = (struct btrace_data *) user_data;
2110
2111   if (strcmp (vendor, "GenuineIntel") == 0)
2112     btrace->variant.pt.config.cpu.vendor = CV_INTEL;
2113
2114   btrace->variant.pt.config.cpu.family = *family;
2115   btrace->variant.pt.config.cpu.model = *model;
2116   btrace->variant.pt.config.cpu.stepping = *stepping;
2117 }
2118
2119 /* Parse a btrace pt "raw" xml record.  */
2120
2121 static void
2122 parse_xml_btrace_pt_raw (struct gdb_xml_parser *parser,
2123                          const struct gdb_xml_element *element,
2124                          void *user_data, const char *body_text)
2125 {
2126   struct btrace_data *btrace;
2127
2128   btrace = (struct btrace_data *) user_data;
2129   parse_xml_raw (parser, body_text, &btrace->variant.pt.data,
2130                  &btrace->variant.pt.size);
2131 }
2132
2133 /* Parse a btrace "pt" xml record.  */
2134
2135 static void
2136 parse_xml_btrace_pt (struct gdb_xml_parser *parser,
2137                      const struct gdb_xml_element *element,
2138                      void *user_data,
2139                      std::vector<gdb_xml_value> &attributes)
2140 {
2141   struct btrace_data *btrace;
2142
2143   btrace = (struct btrace_data *) user_data;
2144   btrace->format = BTRACE_FORMAT_PT;
2145   btrace->variant.pt.config.cpu.vendor = CV_UNKNOWN;
2146   btrace->variant.pt.data = NULL;
2147   btrace->variant.pt.size = 0;
2148 }
2149
2150 static const struct gdb_xml_attribute block_attributes[] = {
2151   { "begin", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
2152   { "end", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
2153   { NULL, GDB_XML_AF_NONE, NULL, NULL }
2154 };
2155
2156 static const struct gdb_xml_attribute btrace_pt_config_cpu_attributes[] = {
2157   { "vendor", GDB_XML_AF_NONE, NULL, NULL },
2158   { "family", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
2159   { "model", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
2160   { "stepping", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
2161   { NULL, GDB_XML_AF_NONE, NULL, NULL }
2162 };
2163
2164 static const struct gdb_xml_element btrace_pt_config_children[] = {
2165   { "cpu", btrace_pt_config_cpu_attributes, NULL, GDB_XML_EF_OPTIONAL,
2166     parse_xml_btrace_pt_config_cpu, NULL },
2167   { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
2168 };
2169
2170 static const struct gdb_xml_element btrace_pt_children[] = {
2171   { "pt-config", NULL, btrace_pt_config_children, GDB_XML_EF_OPTIONAL, NULL,
2172     NULL },
2173   { "raw", NULL, NULL, GDB_XML_EF_OPTIONAL, NULL, parse_xml_btrace_pt_raw },
2174   { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
2175 };
2176
2177 static const struct gdb_xml_attribute btrace_attributes[] = {
2178   { "version", GDB_XML_AF_NONE, NULL, NULL },
2179   { NULL, GDB_XML_AF_NONE, NULL, NULL }
2180 };
2181
2182 static const struct gdb_xml_element btrace_children[] = {
2183   { "block", block_attributes, NULL,
2184     GDB_XML_EF_REPEATABLE | GDB_XML_EF_OPTIONAL, parse_xml_btrace_block, NULL },
2185   { "pt", NULL, btrace_pt_children, GDB_XML_EF_OPTIONAL, parse_xml_btrace_pt,
2186     NULL },
2187   { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
2188 };
2189
2190 static const struct gdb_xml_element btrace_elements[] = {
2191   { "btrace", btrace_attributes, btrace_children, GDB_XML_EF_NONE,
2192     check_xml_btrace_version, NULL },
2193   { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
2194 };
2195
2196 #endif /* defined (HAVE_LIBEXPAT) */
2197
2198 /* See btrace.h.  */
2199
2200 void
2201 parse_xml_btrace (struct btrace_data *btrace, const char *buffer)
2202 {
2203   struct cleanup *cleanup;
2204   int errcode;
2205
2206 #if defined (HAVE_LIBEXPAT)
2207
2208   btrace->format = BTRACE_FORMAT_NONE;
2209
2210   cleanup = make_cleanup_btrace_data (btrace);
2211   errcode = gdb_xml_parse_quick (_("btrace"), "btrace.dtd", btrace_elements,
2212                                  buffer, btrace);
2213   if (errcode != 0)
2214     error (_("Error parsing branch trace."));
2215
2216   /* Keep parse results.  */
2217   discard_cleanups (cleanup);
2218
2219 #else  /* !defined (HAVE_LIBEXPAT) */
2220
2221   error (_("Cannot process branch trace.  XML parsing is not supported."));
2222
2223 #endif  /* !defined (HAVE_LIBEXPAT) */
2224 }
2225
2226 #if defined (HAVE_LIBEXPAT)
2227
2228 /* Parse a btrace-conf "bts" xml record.  */
2229
2230 static void
2231 parse_xml_btrace_conf_bts (struct gdb_xml_parser *parser,
2232                           const struct gdb_xml_element *element,
2233                           void *user_data,
2234                           std::vector<gdb_xml_value> &attributes)
2235 {
2236   struct btrace_config *conf;
2237   struct gdb_xml_value *size;
2238
2239   conf = (struct btrace_config *) user_data;
2240   conf->format = BTRACE_FORMAT_BTS;
2241   conf->bts.size = 0;
2242
2243   size = xml_find_attribute (attributes, "size");
2244   if (size != NULL)
2245     conf->bts.size = (unsigned int) *(ULONGEST *) size->value.get ();
2246 }
2247
2248 /* Parse a btrace-conf "pt" xml record.  */
2249
2250 static void
2251 parse_xml_btrace_conf_pt (struct gdb_xml_parser *parser,
2252                           const struct gdb_xml_element *element,
2253                           void *user_data,
2254                           std::vector<gdb_xml_value> &attributes)
2255 {
2256   struct btrace_config *conf;
2257   struct gdb_xml_value *size;
2258
2259   conf = (struct btrace_config *) user_data;
2260   conf->format = BTRACE_FORMAT_PT;
2261   conf->pt.size = 0;
2262
2263   size = xml_find_attribute (attributes, "size");
2264   if (size != NULL)
2265     conf->pt.size = (unsigned int) *(ULONGEST *) size->value.get ();
2266 }
2267
2268 static const struct gdb_xml_attribute btrace_conf_pt_attributes[] = {
2269   { "size", GDB_XML_AF_OPTIONAL, gdb_xml_parse_attr_ulongest, NULL },
2270   { NULL, GDB_XML_AF_NONE, NULL, NULL }
2271 };
2272
2273 static const struct gdb_xml_attribute btrace_conf_bts_attributes[] = {
2274   { "size", GDB_XML_AF_OPTIONAL, gdb_xml_parse_attr_ulongest, NULL },
2275   { NULL, GDB_XML_AF_NONE, NULL, NULL }
2276 };
2277
2278 static const struct gdb_xml_element btrace_conf_children[] = {
2279   { "bts", btrace_conf_bts_attributes, NULL, GDB_XML_EF_OPTIONAL,
2280     parse_xml_btrace_conf_bts, NULL },
2281   { "pt", btrace_conf_pt_attributes, NULL, GDB_XML_EF_OPTIONAL,
2282     parse_xml_btrace_conf_pt, NULL },
2283   { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
2284 };
2285
2286 static const struct gdb_xml_attribute btrace_conf_attributes[] = {
2287   { "version", GDB_XML_AF_NONE, NULL, NULL },
2288   { NULL, GDB_XML_AF_NONE, NULL, NULL }
2289 };
2290
2291 static const struct gdb_xml_element btrace_conf_elements[] = {
2292   { "btrace-conf", btrace_conf_attributes, btrace_conf_children,
2293     GDB_XML_EF_NONE, NULL, NULL },
2294   { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
2295 };
2296
2297 #endif /* defined (HAVE_LIBEXPAT) */
2298
2299 /* See btrace.h.  */
2300
2301 void
2302 parse_xml_btrace_conf (struct btrace_config *conf, const char *xml)
2303 {
2304   int errcode;
2305
2306 #if defined (HAVE_LIBEXPAT)
2307
2308   errcode = gdb_xml_parse_quick (_("btrace-conf"), "btrace-conf.dtd",
2309                                  btrace_conf_elements, xml, conf);
2310   if (errcode != 0)
2311     error (_("Error parsing branch trace configuration."));
2312
2313 #else  /* !defined (HAVE_LIBEXPAT) */
2314
2315   error (_("XML parsing is not supported."));
2316
2317 #endif  /* !defined (HAVE_LIBEXPAT) */
2318 }
2319
2320 /* See btrace.h.  */
2321
2322 const struct btrace_insn *
2323 btrace_insn_get (const struct btrace_insn_iterator *it)
2324 {
2325   const struct btrace_function *bfun;
2326   unsigned int index, end;
2327
2328   index = it->insn_index;
2329   bfun = &it->btinfo->functions[it->call_index];
2330
2331   /* Check if the iterator points to a gap in the trace.  */
2332   if (bfun->errcode != 0)
2333     return NULL;
2334
2335   /* The index is within the bounds of this function's instruction vector.  */
2336   end = bfun->insn.size ();
2337   gdb_assert (0 < end);
2338   gdb_assert (index < end);
2339
2340   return &bfun->insn[index];
2341 }
2342
2343 /* See btrace.h.  */
2344
2345 int
2346 btrace_insn_get_error (const struct btrace_insn_iterator *it)
2347 {
2348   return it->btinfo->functions[it->call_index].errcode;
2349 }
2350
2351 /* See btrace.h.  */
2352
2353 unsigned int
2354 btrace_insn_number (const struct btrace_insn_iterator *it)
2355 {
2356   return it->btinfo->functions[it->call_index].insn_offset + it->insn_index;
2357 }
2358
2359 /* See btrace.h.  */
2360
2361 void
2362 btrace_insn_begin (struct btrace_insn_iterator *it,
2363                    const struct btrace_thread_info *btinfo)
2364 {
2365   if (btinfo->functions.empty ())
2366     error (_("No trace."));
2367
2368   it->btinfo = btinfo;
2369   it->call_index = 0;
2370   it->insn_index = 0;
2371 }
2372
2373 /* See btrace.h.  */
2374
2375 void
2376 btrace_insn_end (struct btrace_insn_iterator *it,
2377                  const struct btrace_thread_info *btinfo)
2378 {
2379   const struct btrace_function *bfun;
2380   unsigned int length;
2381
2382   if (btinfo->functions.empty ())
2383     error (_("No trace."));
2384
2385   bfun = &btinfo->functions.back ();
2386   length = bfun->insn.size ();
2387
2388   /* The last function may either be a gap or it contains the current
2389      instruction, which is one past the end of the execution trace; ignore
2390      it.  */
2391   if (length > 0)
2392     length -= 1;
2393
2394   it->btinfo = btinfo;
2395   it->call_index = bfun->number - 1;
2396   it->insn_index = length;
2397 }
2398
2399 /* See btrace.h.  */
2400
2401 unsigned int
2402 btrace_insn_next (struct btrace_insn_iterator *it, unsigned int stride)
2403 {
2404   const struct btrace_function *bfun;
2405   unsigned int index, steps;
2406
2407   bfun = &it->btinfo->functions[it->call_index];
2408   steps = 0;
2409   index = it->insn_index;
2410
2411   while (stride != 0)
2412     {
2413       unsigned int end, space, adv;
2414
2415       end = bfun->insn.size ();
2416
2417       /* An empty function segment represents a gap in the trace.  We count
2418          it as one instruction.  */
2419       if (end == 0)
2420         {
2421           const struct btrace_function *next;
2422
2423           next = ftrace_find_call_by_number (it->btinfo, bfun->number + 1);
2424           if (next == NULL)
2425             break;
2426
2427           stride -= 1;
2428           steps += 1;
2429
2430           bfun = next;
2431           index = 0;
2432
2433           continue;
2434         }
2435
2436       gdb_assert (0 < end);
2437       gdb_assert (index < end);
2438
2439       /* Compute the number of instructions remaining in this segment.  */
2440       space = end - index;
2441
2442       /* Advance the iterator as far as possible within this segment.  */
2443       adv = std::min (space, stride);
2444       stride -= adv;
2445       index += adv;
2446       steps += adv;
2447
2448       /* Move to the next function if we're at the end of this one.  */
2449       if (index == end)
2450         {
2451           const struct btrace_function *next;
2452
2453           next = ftrace_find_call_by_number (it->btinfo, bfun->number + 1);
2454           if (next == NULL)
2455             {
2456               /* We stepped past the last function.
2457
2458                  Let's adjust the index to point to the last instruction in
2459                  the previous function.  */
2460               index -= 1;
2461               steps -= 1;
2462               break;
2463             }
2464
2465           /* We now point to the first instruction in the new function.  */
2466           bfun = next;
2467           index = 0;
2468         }
2469
2470       /* We did make progress.  */
2471       gdb_assert (adv > 0);
2472     }
2473
2474   /* Update the iterator.  */
2475   it->call_index = bfun->number - 1;
2476   it->insn_index = index;
2477
2478   return steps;
2479 }
2480
2481 /* See btrace.h.  */
2482
2483 unsigned int
2484 btrace_insn_prev (struct btrace_insn_iterator *it, unsigned int stride)
2485 {
2486   const struct btrace_function *bfun;
2487   unsigned int index, steps;
2488
2489   bfun = &it->btinfo->functions[it->call_index];
2490   steps = 0;
2491   index = it->insn_index;
2492
2493   while (stride != 0)
2494     {
2495       unsigned int adv;
2496
2497       /* Move to the previous function if we're at the start of this one.  */
2498       if (index == 0)
2499         {
2500           const struct btrace_function *prev;
2501
2502           prev = ftrace_find_call_by_number (it->btinfo, bfun->number - 1);
2503           if (prev == NULL)
2504             break;
2505
2506           /* We point to one after the last instruction in the new function.  */
2507           bfun = prev;
2508           index = bfun->insn.size ();
2509
2510           /* An empty function segment represents a gap in the trace.  We count
2511              it as one instruction.  */
2512           if (index == 0)
2513             {
2514               stride -= 1;
2515               steps += 1;
2516
2517               continue;
2518             }
2519         }
2520
2521       /* Advance the iterator as far as possible within this segment.  */
2522       adv = std::min (index, stride);
2523
2524       stride -= adv;
2525       index -= adv;
2526       steps += adv;
2527
2528       /* We did make progress.  */
2529       gdb_assert (adv > 0);
2530     }
2531
2532   /* Update the iterator.  */
2533   it->call_index = bfun->number - 1;
2534   it->insn_index = index;
2535
2536   return steps;
2537 }
2538
2539 /* See btrace.h.  */
2540
2541 int
2542 btrace_insn_cmp (const struct btrace_insn_iterator *lhs,
2543                  const struct btrace_insn_iterator *rhs)
2544 {
2545   gdb_assert (lhs->btinfo == rhs->btinfo);
2546
2547   if (lhs->call_index != rhs->call_index)
2548     return lhs->call_index - rhs->call_index;
2549
2550   return lhs->insn_index - rhs->insn_index;
2551 }
2552
2553 /* See btrace.h.  */
2554
2555 int
2556 btrace_find_insn_by_number (struct btrace_insn_iterator *it,
2557                             const struct btrace_thread_info *btinfo,
2558                             unsigned int number)
2559 {
2560   const struct btrace_function *bfun;
2561   unsigned int upper, lower;
2562
2563   if (btinfo->functions.empty ())
2564       return 0;
2565
2566   lower = 0;
2567   bfun = &btinfo->functions[lower];
2568   if (number < bfun->insn_offset)
2569     return 0;
2570
2571   upper = btinfo->functions.size () - 1;
2572   bfun = &btinfo->functions[upper];
2573   if (number >= bfun->insn_offset + ftrace_call_num_insn (bfun))
2574     return 0;
2575
2576   /* We assume that there are no holes in the numbering.  */
2577   for (;;)
2578     {
2579       const unsigned int average = lower + (upper - lower) / 2;
2580
2581       bfun = &btinfo->functions[average];
2582
2583       if (number < bfun->insn_offset)
2584         {
2585           upper = average - 1;
2586           continue;
2587         }
2588
2589       if (number >= bfun->insn_offset + ftrace_call_num_insn (bfun))
2590         {
2591           lower = average + 1;
2592           continue;
2593         }
2594
2595       break;
2596     }
2597
2598   it->btinfo = btinfo;
2599   it->call_index = bfun->number - 1;
2600   it->insn_index = number - bfun->insn_offset;
2601   return 1;
2602 }
2603
2604 /* Returns true if the recording ends with a function segment that
2605    contains only a single (i.e. the current) instruction.  */
2606
2607 static bool
2608 btrace_ends_with_single_insn (const struct btrace_thread_info *btinfo)
2609 {
2610   const btrace_function *bfun;
2611
2612   if (btinfo->functions.empty ())
2613     return false;
2614
2615   bfun = &btinfo->functions.back ();
2616   if (bfun->errcode != 0)
2617     return false;
2618
2619   return ftrace_call_num_insn (bfun) == 1;
2620 }
2621
2622 /* See btrace.h.  */
2623
2624 const struct btrace_function *
2625 btrace_call_get (const struct btrace_call_iterator *it)
2626 {
2627   if (it->index >= it->btinfo->functions.size ())
2628     return NULL;
2629
2630   return &it->btinfo->functions[it->index];
2631 }
2632
2633 /* See btrace.h.  */
2634
2635 unsigned int
2636 btrace_call_number (const struct btrace_call_iterator *it)
2637 {
2638   const unsigned int length = it->btinfo->functions.size ();
2639
2640   /* If the last function segment contains only a single instruction (i.e. the
2641      current instruction), skip it.  */
2642   if ((it->index == length) && btrace_ends_with_single_insn (it->btinfo))
2643     return length;
2644
2645   return it->index + 1;
2646 }
2647
2648 /* See btrace.h.  */
2649
2650 void
2651 btrace_call_begin (struct btrace_call_iterator *it,
2652                    const struct btrace_thread_info *btinfo)
2653 {
2654   if (btinfo->functions.empty ())
2655     error (_("No trace."));
2656
2657   it->btinfo = btinfo;
2658   it->index = 0;
2659 }
2660
2661 /* See btrace.h.  */
2662
2663 void
2664 btrace_call_end (struct btrace_call_iterator *it,
2665                  const struct btrace_thread_info *btinfo)
2666 {
2667   if (btinfo->functions.empty ())
2668     error (_("No trace."));
2669
2670   it->btinfo = btinfo;
2671   it->index = btinfo->functions.size ();
2672 }
2673
2674 /* See btrace.h.  */
2675
2676 unsigned int
2677 btrace_call_next (struct btrace_call_iterator *it, unsigned int stride)
2678 {
2679   const unsigned int length = it->btinfo->functions.size ();
2680
2681   if (it->index + stride < length - 1)
2682     /* Default case: Simply advance the iterator.  */
2683     it->index += stride;
2684   else if (it->index + stride == length - 1)
2685     {
2686       /* We land exactly at the last function segment.  If it contains only one
2687          instruction (i.e. the current instruction) it is not actually part of
2688          the trace.  */
2689       if (btrace_ends_with_single_insn (it->btinfo))
2690         it->index = length;
2691       else
2692         it->index = length - 1;
2693     }
2694   else
2695     {
2696       /* We land past the last function segment and have to adjust the stride.
2697          If the last function segment contains only one instruction (i.e. the
2698          current instruction) it is not actually part of the trace.  */
2699       if (btrace_ends_with_single_insn (it->btinfo))
2700         stride = length - it->index - 1;
2701       else
2702         stride = length - it->index;
2703
2704       it->index = length;
2705     }
2706
2707   return stride;
2708 }
2709
2710 /* See btrace.h.  */
2711
2712 unsigned int
2713 btrace_call_prev (struct btrace_call_iterator *it, unsigned int stride)
2714 {
2715   const unsigned int length = it->btinfo->functions.size ();
2716   int steps = 0;
2717
2718   gdb_assert (it->index <= length);
2719
2720   if (stride == 0 || it->index == 0)
2721     return 0;
2722
2723   /* If we are at the end, the first step is a special case.  If the last
2724      function segment contains only one instruction (i.e. the current
2725      instruction) it is not actually part of the trace.  To be able to step
2726      over this instruction, we need at least one more function segment.  */
2727   if ((it->index == length)  && (length > 1))
2728     {
2729       if (btrace_ends_with_single_insn (it->btinfo))
2730         it->index = length - 2;
2731       else
2732         it->index = length - 1;
2733
2734       steps = 1;
2735       stride -= 1;
2736     }
2737
2738   stride = std::min (stride, it->index);
2739
2740   it->index -= stride;
2741   return steps + stride;
2742 }
2743
2744 /* See btrace.h.  */
2745
2746 int
2747 btrace_call_cmp (const struct btrace_call_iterator *lhs,
2748                  const struct btrace_call_iterator *rhs)
2749 {
2750   gdb_assert (lhs->btinfo == rhs->btinfo);
2751   return (int) (lhs->index - rhs->index);
2752 }
2753
2754 /* See btrace.h.  */
2755
2756 int
2757 btrace_find_call_by_number (struct btrace_call_iterator *it,
2758                             const struct btrace_thread_info *btinfo,
2759                             unsigned int number)
2760 {
2761   const unsigned int length = btinfo->functions.size ();
2762
2763   if ((number == 0) || (number > length))
2764     return 0;
2765
2766   it->btinfo = btinfo;
2767   it->index = number - 1;
2768   return 1;
2769 }
2770
2771 /* See btrace.h.  */
2772
2773 void
2774 btrace_set_insn_history (struct btrace_thread_info *btinfo,
2775                          const struct btrace_insn_iterator *begin,
2776                          const struct btrace_insn_iterator *end)
2777 {
2778   if (btinfo->insn_history == NULL)
2779     btinfo->insn_history = XCNEW (struct btrace_insn_history);
2780
2781   btinfo->insn_history->begin = *begin;
2782   btinfo->insn_history->end = *end;
2783 }
2784
2785 /* See btrace.h.  */
2786
2787 void
2788 btrace_set_call_history (struct btrace_thread_info *btinfo,
2789                          const struct btrace_call_iterator *begin,
2790                          const struct btrace_call_iterator *end)
2791 {
2792   gdb_assert (begin->btinfo == end->btinfo);
2793
2794   if (btinfo->call_history == NULL)
2795     btinfo->call_history = XCNEW (struct btrace_call_history);
2796
2797   btinfo->call_history->begin = *begin;
2798   btinfo->call_history->end = *end;
2799 }
2800
2801 /* See btrace.h.  */
2802
2803 int
2804 btrace_is_replaying (struct thread_info *tp)
2805 {
2806   return tp->btrace.replay != NULL;
2807 }
2808
2809 /* See btrace.h.  */
2810
2811 int
2812 btrace_is_empty (struct thread_info *tp)
2813 {
2814   struct btrace_insn_iterator begin, end;
2815   struct btrace_thread_info *btinfo;
2816
2817   btinfo = &tp->btrace;
2818
2819   if (btinfo->functions.empty ())
2820     return 1;
2821
2822   btrace_insn_begin (&begin, btinfo);
2823   btrace_insn_end (&end, btinfo);
2824
2825   return btrace_insn_cmp (&begin, &end) == 0;
2826 }
2827
2828 /* Forward the cleanup request.  */
2829
2830 static void
2831 do_btrace_data_cleanup (void *arg)
2832 {
2833   btrace_data_fini ((struct btrace_data *) arg);
2834 }
2835
2836 /* See btrace.h.  */
2837
2838 struct cleanup *
2839 make_cleanup_btrace_data (struct btrace_data *data)
2840 {
2841   return make_cleanup (do_btrace_data_cleanup, data);
2842 }
2843
2844 #if defined (HAVE_LIBIPT)
2845
2846 /* Print a single packet.  */
2847
2848 static void
2849 pt_print_packet (const struct pt_packet *packet)
2850 {
2851   switch (packet->type)
2852     {
2853     default:
2854       printf_unfiltered (("[??: %x]"), packet->type);
2855       break;
2856
2857     case ppt_psb:
2858       printf_unfiltered (("psb"));
2859       break;
2860
2861     case ppt_psbend:
2862       printf_unfiltered (("psbend"));
2863       break;
2864
2865     case ppt_pad:
2866       printf_unfiltered (("pad"));
2867       break;
2868
2869     case ppt_tip:
2870       printf_unfiltered (("tip %u: 0x%" PRIx64 ""),
2871                          packet->payload.ip.ipc,
2872                          packet->payload.ip.ip);
2873       break;
2874
2875     case ppt_tip_pge:
2876       printf_unfiltered (("tip.pge %u: 0x%" PRIx64 ""),
2877                          packet->payload.ip.ipc,
2878                          packet->payload.ip.ip);
2879       break;
2880
2881     case ppt_tip_pgd:
2882       printf_unfiltered (("tip.pgd %u: 0x%" PRIx64 ""),
2883                          packet->payload.ip.ipc,
2884                          packet->payload.ip.ip);
2885       break;
2886
2887     case ppt_fup:
2888       printf_unfiltered (("fup %u: 0x%" PRIx64 ""),
2889                          packet->payload.ip.ipc,
2890                          packet->payload.ip.ip);
2891       break;
2892
2893     case ppt_tnt_8:
2894       printf_unfiltered (("tnt-8 %u: 0x%" PRIx64 ""),
2895                          packet->payload.tnt.bit_size,
2896                          packet->payload.tnt.payload);
2897       break;
2898
2899     case ppt_tnt_64:
2900       printf_unfiltered (("tnt-64 %u: 0x%" PRIx64 ""),
2901                          packet->payload.tnt.bit_size,
2902                          packet->payload.tnt.payload);
2903       break;
2904
2905     case ppt_pip:
2906       printf_unfiltered (("pip %" PRIx64 "%s"), packet->payload.pip.cr3,
2907                          packet->payload.pip.nr ? (" nr") : (""));
2908       break;
2909
2910     case ppt_tsc:
2911       printf_unfiltered (("tsc %" PRIx64 ""), packet->payload.tsc.tsc);
2912       break;
2913
2914     case ppt_cbr:
2915       printf_unfiltered (("cbr %u"), packet->payload.cbr.ratio);
2916       break;
2917
2918     case ppt_mode:
2919       switch (packet->payload.mode.leaf)
2920         {
2921         default:
2922           printf_unfiltered (("mode %u"), packet->payload.mode.leaf);
2923           break;
2924
2925         case pt_mol_exec:
2926           printf_unfiltered (("mode.exec%s%s"),
2927                              packet->payload.mode.bits.exec.csl
2928                              ? (" cs.l") : (""),
2929                              packet->payload.mode.bits.exec.csd
2930                              ? (" cs.d") : (""));
2931           break;
2932
2933         case pt_mol_tsx:
2934           printf_unfiltered (("mode.tsx%s%s"),
2935                              packet->payload.mode.bits.tsx.intx
2936                              ? (" intx") : (""),
2937                              packet->payload.mode.bits.tsx.abrt
2938                              ? (" abrt") : (""));
2939           break;
2940         }
2941       break;
2942
2943     case ppt_ovf:
2944       printf_unfiltered (("ovf"));
2945       break;
2946
2947     case ppt_stop:
2948       printf_unfiltered (("stop"));
2949       break;
2950
2951     case ppt_vmcs:
2952       printf_unfiltered (("vmcs %" PRIx64 ""), packet->payload.vmcs.base);
2953       break;
2954
2955     case ppt_tma:
2956       printf_unfiltered (("tma %x %x"), packet->payload.tma.ctc,
2957                          packet->payload.tma.fc);
2958       break;
2959
2960     case ppt_mtc:
2961       printf_unfiltered (("mtc %x"), packet->payload.mtc.ctc);
2962       break;
2963
2964     case ppt_cyc:
2965       printf_unfiltered (("cyc %" PRIx64 ""), packet->payload.cyc.value);
2966       break;
2967
2968     case ppt_mnt:
2969       printf_unfiltered (("mnt %" PRIx64 ""), packet->payload.mnt.payload);
2970       break;
2971     }
2972 }
2973
2974 /* Decode packets into MAINT using DECODER.  */
2975
2976 static void
2977 btrace_maint_decode_pt (struct btrace_maint_info *maint,
2978                         struct pt_packet_decoder *decoder)
2979 {
2980   int errcode;
2981
2982   for (;;)
2983     {
2984       struct btrace_pt_packet packet;
2985
2986       errcode = pt_pkt_sync_forward (decoder);
2987       if (errcode < 0)
2988         break;
2989
2990       for (;;)
2991         {
2992           pt_pkt_get_offset (decoder, &packet.offset);
2993
2994           errcode = pt_pkt_next (decoder, &packet.packet,
2995                                  sizeof(packet.packet));
2996           if (errcode < 0)
2997             break;
2998
2999           if (maint_btrace_pt_skip_pad == 0 || packet.packet.type != ppt_pad)
3000             {
3001               packet.errcode = pt_errcode (errcode);
3002               VEC_safe_push (btrace_pt_packet_s, maint->variant.pt.packets,
3003                              &packet);
3004             }
3005         }
3006
3007       if (errcode == -pte_eos)
3008         break;
3009
3010       packet.errcode = pt_errcode (errcode);
3011       VEC_safe_push (btrace_pt_packet_s, maint->variant.pt.packets,
3012                      &packet);
3013
3014       warning (_("Error at trace offset 0x%" PRIx64 ": %s."),
3015                packet.offset, pt_errstr (packet.errcode));
3016     }
3017
3018   if (errcode != -pte_eos)
3019     warning (_("Failed to synchronize onto the Intel Processor Trace "
3020                "stream: %s."), pt_errstr (pt_errcode (errcode)));
3021 }
3022
3023 /* Update the packet history in BTINFO.  */
3024
3025 static void
3026 btrace_maint_update_pt_packets (struct btrace_thread_info *btinfo)
3027 {
3028   struct pt_packet_decoder *decoder;
3029   struct btrace_data_pt *pt;
3030   struct pt_config config;
3031   int errcode;
3032
3033   pt = &btinfo->data.variant.pt;
3034
3035   /* Nothing to do if there is no trace.  */
3036   if (pt->size == 0)
3037     return;
3038
3039   memset (&config, 0, sizeof(config));
3040
3041   config.size = sizeof (config);
3042   config.begin = pt->data;
3043   config.end = pt->data + pt->size;
3044
3045   config.cpu.vendor = pt_translate_cpu_vendor (pt->config.cpu.vendor);
3046   config.cpu.family = pt->config.cpu.family;
3047   config.cpu.model = pt->config.cpu.model;
3048   config.cpu.stepping = pt->config.cpu.stepping;
3049
3050   errcode = pt_cpu_errata (&config.errata, &config.cpu);
3051   if (errcode < 0)
3052     error (_("Failed to configure the Intel Processor Trace decoder: %s."),
3053            pt_errstr (pt_errcode (errcode)));
3054
3055   decoder = pt_pkt_alloc_decoder (&config);
3056   if (decoder == NULL)
3057     error (_("Failed to allocate the Intel Processor Trace decoder."));
3058
3059   TRY
3060     {
3061       btrace_maint_decode_pt (&btinfo->maint, decoder);
3062     }
3063   CATCH (except, RETURN_MASK_ALL)
3064     {
3065       pt_pkt_free_decoder (decoder);
3066
3067       if (except.reason < 0)
3068         throw_exception (except);
3069     }
3070   END_CATCH
3071
3072   pt_pkt_free_decoder (decoder);
3073 }
3074
3075 #endif /* !defined (HAVE_LIBIPT)  */
3076
3077 /* Update the packet maintenance information for BTINFO and store the
3078    low and high bounds into BEGIN and END, respectively.
3079    Store the current iterator state into FROM and TO.  */
3080
3081 static void
3082 btrace_maint_update_packets (struct btrace_thread_info *btinfo,
3083                              unsigned int *begin, unsigned int *end,
3084                              unsigned int *from, unsigned int *to)
3085 {
3086   switch (btinfo->data.format)
3087     {
3088     default:
3089       *begin = 0;
3090       *end = 0;
3091       *from = 0;
3092       *to = 0;
3093       break;
3094
3095     case BTRACE_FORMAT_BTS:
3096       /* Nothing to do - we operate directly on BTINFO->DATA.  */
3097       *begin = 0;
3098       *end = VEC_length (btrace_block_s, btinfo->data.variant.bts.blocks);
3099       *from = btinfo->maint.variant.bts.packet_history.begin;
3100       *to = btinfo->maint.variant.bts.packet_history.end;
3101       break;
3102
3103 #if defined (HAVE_LIBIPT)
3104     case BTRACE_FORMAT_PT:
3105       if (VEC_empty (btrace_pt_packet_s, btinfo->maint.variant.pt.packets))
3106         btrace_maint_update_pt_packets (btinfo);
3107
3108       *begin = 0;
3109       *end = VEC_length (btrace_pt_packet_s, btinfo->maint.variant.pt.packets);
3110       *from = btinfo->maint.variant.pt.packet_history.begin;
3111       *to = btinfo->maint.variant.pt.packet_history.end;
3112       break;
3113 #endif /* defined (HAVE_LIBIPT)  */
3114     }
3115 }
3116
3117 /* Print packets in BTINFO from BEGIN (inclusive) until END (exclusive) and
3118    update the current iterator position.  */
3119
3120 static void
3121 btrace_maint_print_packets (struct btrace_thread_info *btinfo,
3122                             unsigned int begin, unsigned int end)
3123 {
3124   switch (btinfo->data.format)
3125     {
3126     default:
3127       break;
3128
3129     case BTRACE_FORMAT_BTS:
3130       {
3131         VEC (btrace_block_s) *blocks;
3132         unsigned int blk;
3133
3134         blocks = btinfo->data.variant.bts.blocks;
3135         for (blk = begin; blk < end; ++blk)
3136           {
3137             const btrace_block_s *block;
3138
3139             block = VEC_index (btrace_block_s, blocks, blk);
3140
3141             printf_unfiltered ("%u\tbegin: %s, end: %s\n", blk,
3142                                core_addr_to_string_nz (block->begin),
3143                                core_addr_to_string_nz (block->end));
3144           }
3145
3146         btinfo->maint.variant.bts.packet_history.begin = begin;
3147         btinfo->maint.variant.bts.packet_history.end = end;
3148       }
3149       break;
3150
3151 #if defined (HAVE_LIBIPT)
3152     case BTRACE_FORMAT_PT:
3153       {
3154         VEC (btrace_pt_packet_s) *packets;
3155         unsigned int pkt;
3156
3157         packets = btinfo->maint.variant.pt.packets;
3158         for (pkt = begin; pkt < end; ++pkt)
3159           {
3160             const struct btrace_pt_packet *packet;
3161
3162             packet = VEC_index (btrace_pt_packet_s, packets, pkt);
3163
3164             printf_unfiltered ("%u\t", pkt);
3165             printf_unfiltered ("0x%" PRIx64 "\t", packet->offset);
3166
3167             if (packet->errcode == pte_ok)
3168               pt_print_packet (&packet->packet);
3169             else
3170               printf_unfiltered ("[error: %s]", pt_errstr (packet->errcode));
3171
3172             printf_unfiltered ("\n");
3173           }
3174
3175         btinfo->maint.variant.pt.packet_history.begin = begin;
3176         btinfo->maint.variant.pt.packet_history.end = end;
3177       }
3178       break;
3179 #endif /* defined (HAVE_LIBIPT)  */
3180     }
3181 }
3182
3183 /* Read a number from an argument string.  */
3184
3185 static unsigned int
3186 get_uint (const char **arg)
3187 {
3188   const char *begin, *pos;
3189   char *end;
3190   unsigned long number;
3191
3192   begin = *arg;
3193   pos = skip_spaces (begin);
3194
3195   if (!isdigit (*pos))
3196     error (_("Expected positive number, got: %s."), pos);
3197
3198   number = strtoul (pos, &end, 10);
3199   if (number > UINT_MAX)
3200     error (_("Number too big."));
3201
3202   *arg += (end - begin);
3203
3204   return (unsigned int) number;
3205 }
3206
3207 /* Read a context size from an argument string.  */
3208
3209 static int
3210 get_context_size (const char **arg)
3211 {
3212   const char *pos = skip_spaces (*arg);
3213
3214   if (!isdigit (*pos))
3215     error (_("Expected positive number, got: %s."), pos);
3216
3217   char *end;
3218   long result = strtol (pos, &end, 10);
3219   *arg = end;
3220   return result;
3221 }
3222
3223 /* Complain about junk at the end of an argument string.  */
3224
3225 static void
3226 no_chunk (const char *arg)
3227 {
3228   if (*arg != 0)
3229     error (_("Junk after argument: %s."), arg);
3230 }
3231
3232 /* The "maintenance btrace packet-history" command.  */
3233
3234 static void
3235 maint_btrace_packet_history_cmd (const char *arg, int from_tty)
3236 {
3237   struct btrace_thread_info *btinfo;
3238   struct thread_info *tp;
3239   unsigned int size, begin, end, from, to;
3240
3241   tp = find_thread_ptid (inferior_ptid);
3242   if (tp == NULL)
3243     error (_("No thread."));
3244
3245   size = 10;
3246   btinfo = &tp->btrace;
3247
3248   btrace_maint_update_packets (btinfo, &begin, &end, &from, &to);
3249   if (begin == end)
3250     {
3251       printf_unfiltered (_("No trace.\n"));
3252       return;
3253     }
3254
3255   if (arg == NULL || *arg == 0 || strcmp (arg, "+") == 0)
3256     {
3257       from = to;
3258
3259       if (end - from < size)
3260         size = end - from;
3261       to = from + size;
3262     }
3263   else if (strcmp (arg, "-") == 0)
3264     {
3265       to = from;
3266
3267       if (to - begin < size)
3268         size = to - begin;
3269       from = to - size;
3270     }
3271   else
3272     {
3273       from = get_uint (&arg);
3274       if (end <= from)
3275         error (_("'%u' is out of range."), from);
3276
3277       arg = skip_spaces (arg);
3278       if (*arg == ',')
3279         {
3280           arg = skip_spaces (++arg);
3281
3282           if (*arg == '+')
3283             {
3284               arg += 1;
3285               size = get_context_size (&arg);
3286
3287               no_chunk (arg);
3288
3289               if (end - from < size)
3290                 size = end - from;
3291               to = from + size;
3292             }
3293           else if (*arg == '-')
3294             {
3295               arg += 1;
3296               size = get_context_size (&arg);
3297
3298               no_chunk (arg);
3299
3300               /* Include the packet given as first argument.  */
3301               from += 1;
3302               to = from;
3303
3304               if (to - begin < size)
3305                 size = to - begin;
3306               from = to - size;
3307             }
3308           else
3309             {
3310               to = get_uint (&arg);
3311
3312               /* Include the packet at the second argument and silently
3313                  truncate the range.  */
3314               if (to < end)
3315                 to += 1;
3316               else
3317                 to = end;
3318
3319               no_chunk (arg);
3320             }
3321         }
3322       else
3323         {
3324           no_chunk (arg);
3325
3326           if (end - from < size)
3327             size = end - from;
3328           to = from + size;
3329         }
3330
3331       dont_repeat ();
3332     }
3333
3334   btrace_maint_print_packets (btinfo, from, to);
3335 }
3336
3337 /* The "maintenance btrace clear-packet-history" command.  */
3338
3339 static void
3340 maint_btrace_clear_packet_history_cmd (const char *args, int from_tty)
3341 {
3342   struct btrace_thread_info *btinfo;
3343   struct thread_info *tp;
3344
3345   if (args != NULL && *args != 0)
3346     error (_("Invalid argument."));
3347
3348   tp = find_thread_ptid (inferior_ptid);
3349   if (tp == NULL)
3350     error (_("No thread."));
3351
3352   btinfo = &tp->btrace;
3353
3354   /* Must clear the maint data before - it depends on BTINFO->DATA.  */
3355   btrace_maint_clear (btinfo);
3356   btrace_data_clear (&btinfo->data);
3357 }
3358
3359 /* The "maintenance btrace clear" command.  */
3360
3361 static void
3362 maint_btrace_clear_cmd (const char *args, int from_tty)
3363 {
3364   struct thread_info *tp;
3365
3366   if (args != NULL && *args != 0)
3367     error (_("Invalid argument."));
3368
3369   tp = find_thread_ptid (inferior_ptid);
3370   if (tp == NULL)
3371     error (_("No thread."));
3372
3373   btrace_clear (tp);
3374 }
3375
3376 /* The "maintenance btrace" command.  */
3377
3378 static void
3379 maint_btrace_cmd (const char *args, int from_tty)
3380 {
3381   help_list (maint_btrace_cmdlist, "maintenance btrace ", all_commands,
3382              gdb_stdout);
3383 }
3384
3385 /* The "maintenance set btrace" command.  */
3386
3387 static void
3388 maint_btrace_set_cmd (const char *args, int from_tty)
3389 {
3390   help_list (maint_btrace_set_cmdlist, "maintenance set btrace ", all_commands,
3391              gdb_stdout);
3392 }
3393
3394 /* The "maintenance show btrace" command.  */
3395
3396 static void
3397 maint_btrace_show_cmd (const char *args, int from_tty)
3398 {
3399   help_list (maint_btrace_show_cmdlist, "maintenance show btrace ",
3400              all_commands, gdb_stdout);
3401 }
3402
3403 /* The "maintenance set btrace pt" command.  */
3404
3405 static void
3406 maint_btrace_pt_set_cmd (const char *args, int from_tty)
3407 {
3408   help_list (maint_btrace_pt_set_cmdlist, "maintenance set btrace pt ",
3409              all_commands, gdb_stdout);
3410 }
3411
3412 /* The "maintenance show btrace pt" command.  */
3413
3414 static void
3415 maint_btrace_pt_show_cmd (const char *args, int from_tty)
3416 {
3417   help_list (maint_btrace_pt_show_cmdlist, "maintenance show btrace pt ",
3418              all_commands, gdb_stdout);
3419 }
3420
3421 /* The "maintenance info btrace" command.  */
3422
3423 static void
3424 maint_info_btrace_cmd (const char *args, int from_tty)
3425 {
3426   struct btrace_thread_info *btinfo;
3427   struct thread_info *tp;
3428   const struct btrace_config *conf;
3429
3430   if (args != NULL && *args != 0)
3431     error (_("Invalid argument."));
3432
3433   tp = find_thread_ptid (inferior_ptid);
3434   if (tp == NULL)
3435     error (_("No thread."));
3436
3437   btinfo = &tp->btrace;
3438
3439   conf = btrace_conf (btinfo);
3440   if (conf == NULL)
3441     error (_("No btrace configuration."));
3442
3443   printf_unfiltered (_("Format: %s.\n"),
3444                      btrace_format_string (conf->format));
3445
3446   switch (conf->format)
3447     {
3448     default:
3449       break;
3450
3451     case BTRACE_FORMAT_BTS:
3452       printf_unfiltered (_("Number of packets: %u.\n"),
3453                          VEC_length (btrace_block_s,
3454                                      btinfo->data.variant.bts.blocks));
3455       break;
3456
3457 #if defined (HAVE_LIBIPT)
3458     case BTRACE_FORMAT_PT:
3459       {
3460         struct pt_version version;
3461
3462         version = pt_library_version ();
3463         printf_unfiltered (_("Version: %u.%u.%u%s.\n"), version.major,
3464                            version.minor, version.build,
3465                            version.ext != NULL ? version.ext : "");
3466
3467         btrace_maint_update_pt_packets (btinfo);
3468         printf_unfiltered (_("Number of packets: %u.\n"),
3469                            VEC_length (btrace_pt_packet_s,
3470                                        btinfo->maint.variant.pt.packets));
3471       }
3472       break;
3473 #endif /* defined (HAVE_LIBIPT)  */
3474     }
3475 }
3476
3477 /* The "maint show btrace pt skip-pad" show value function. */
3478
3479 static void
3480 show_maint_btrace_pt_skip_pad  (struct ui_file *file, int from_tty,
3481                                   struct cmd_list_element *c,
3482                                   const char *value)
3483 {
3484   fprintf_filtered (file, _("Skip PAD packets is %s.\n"), value);
3485 }
3486
3487
3488 /* Initialize btrace maintenance commands.  */
3489
3490 void
3491 _initialize_btrace (void)
3492 {
3493   add_cmd ("btrace", class_maintenance, maint_info_btrace_cmd,
3494            _("Info about branch tracing data."), &maintenanceinfolist);
3495
3496   add_prefix_cmd ("btrace", class_maintenance, maint_btrace_cmd,
3497                   _("Branch tracing maintenance commands."),
3498                   &maint_btrace_cmdlist, "maintenance btrace ",
3499                   0, &maintenancelist);
3500
3501   add_prefix_cmd ("btrace", class_maintenance, maint_btrace_set_cmd, _("\
3502 Set branch tracing specific variables."),
3503                   &maint_btrace_set_cmdlist, "maintenance set btrace ",
3504                   0, &maintenance_set_cmdlist);
3505
3506   add_prefix_cmd ("pt", class_maintenance, maint_btrace_pt_set_cmd, _("\
3507 Set Intel Processor Trace specific variables."),
3508                   &maint_btrace_pt_set_cmdlist, "maintenance set btrace pt ",
3509                   0, &maint_btrace_set_cmdlist);
3510
3511   add_prefix_cmd ("btrace", class_maintenance, maint_btrace_show_cmd, _("\
3512 Show branch tracing specific variables."),
3513                   &maint_btrace_show_cmdlist, "maintenance show btrace ",
3514                   0, &maintenance_show_cmdlist);
3515
3516   add_prefix_cmd ("pt", class_maintenance, maint_btrace_pt_show_cmd, _("\
3517 Show Intel Processor Trace specific variables."),
3518                   &maint_btrace_pt_show_cmdlist, "maintenance show btrace pt ",
3519                   0, &maint_btrace_show_cmdlist);
3520
3521   add_setshow_boolean_cmd ("skip-pad", class_maintenance,
3522                            &maint_btrace_pt_skip_pad, _("\
3523 Set whether PAD packets should be skipped in the btrace packet history."), _("\
3524 Show whether PAD packets should be skipped in the btrace packet history."),_("\
3525 When enabled, PAD packets are ignored in the btrace packet history."),
3526                            NULL, show_maint_btrace_pt_skip_pad,
3527                            &maint_btrace_pt_set_cmdlist,
3528                            &maint_btrace_pt_show_cmdlist);
3529
3530   add_cmd ("packet-history", class_maintenance, maint_btrace_packet_history_cmd,
3531            _("Print the raw branch tracing data.\n\
3532 With no argument, print ten more packets after the previous ten-line print.\n\
3533 With '-' as argument print ten packets before a previous ten-line print.\n\
3534 One argument specifies the starting packet of a ten-line print.\n\
3535 Two arguments with comma between specify starting and ending packets to \
3536 print.\n\
3537 Preceded with '+'/'-' the second argument specifies the distance from the \
3538 first.\n"),
3539            &maint_btrace_cmdlist);
3540
3541   add_cmd ("clear-packet-history", class_maintenance,
3542            maint_btrace_clear_packet_history_cmd,
3543            _("Clears the branch tracing packet history.\n\
3544 Discards the raw branch tracing data but not the execution history data.\n\
3545 "),
3546            &maint_btrace_cmdlist);
3547
3548   add_cmd ("clear", class_maintenance, maint_btrace_clear_cmd,
3549            _("Clears the branch tracing data.\n\
3550 Discards the raw branch tracing data and the execution history data.\n\
3551 The next 'record' command will fetch the branch tracing data anew.\n\
3552 "),
3553            &maint_btrace_cmdlist);
3554
3555 }