GDB (xrefs)

/tmp/gdb-8.1/gdb/btrace.c
Go to the documentation of this file.
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 if (!target_supports_btrace (conf->format))
1586 error (_("Target does not support branch tracing."));
1587
1588 DEBUG ("enable thread %s (%s)", print_thread_id (tp),
1589 target_pid_to_str (tp->ptid));
1590
1591 tp->btrace.target = target_enable_btrace (tp->ptid, conf);
1592
1593 /* We're done if we failed to enable tracing. */
1594 if (tp->btrace.target == NULL)
1595 return;
1596
1597 /* We need to undo the enable in case of errors. */
1598 TRY
1599 {
1600 /* Add an entry for the current PC so we start tracing from where we
1601 enabled it.
1602
1603 If we can't access TP's registers, TP is most likely running. In this
1604 case, we can't really say where tracing was enabled so it should be
1605 safe to simply skip this step.
1606
1607 This is not relevant for BTRACE_FORMAT_PT since the trace will already
1608 start at the PC at which tracing was enabled. */
1609 if (conf->format != BTRACE_FORMAT_PT
1610 && can_access_registers_ptid (tp->ptid))
1611 btrace_add_pc (tp);
1612 }
1613 CATCH (exception, RETURN_MASK_ALL)
1614 {
1615 btrace_disable (tp);
1616
1617 throw_exception (exception);
1618 }
1619 END_CATCH
1620 }
1621
1622 /* See btrace.h. */
1623
1624 const struct btrace_config *
1625 btrace_conf (const struct btrace_thread_info *btinfo)
1626 {
1627 if (btinfo->target == NULL)
1628 return NULL;
1629
1630 return target_btrace_conf (btinfo->target);
1631 }
1632
1633 /* See btrace.h. */
1634
1635 void
1636 btrace_disable (struct thread_info *tp)
1637 {
1638 struct btrace_thread_info *btp = &tp->btrace;
1639
1640 if (btp->target == NULL)
1641 return;
1642
1643 DEBUG ("disable thread %s (%s)", print_thread_id (tp),
1644 target_pid_to_str (tp->ptid));
1645
1646 target_disable_btrace (btp->target);
1647 btp->target = NULL;
1648
1649 btrace_clear (tp);
1650 }
1651
1652 /* See btrace.h. */
1653
1654 void
1655 btrace_teardown (struct thread_info *tp)
1656 {
1657 struct btrace_thread_info *btp = &tp->btrace;
1658
1659 if (btp->target == NULL)
1660 return;
1661
1662 DEBUG ("teardown thread %s (%s)", print_thread_id (tp),
1663 target_pid_to_str (tp->ptid));
1664
1665 target_teardown_btrace (btp->target);
1666 btp->target = NULL;
1667
1668 btrace_clear (tp);
1669 }
1670
1671 /* Stitch branch trace in BTS format. */
1672
1673 static int
1674 btrace_stitch_bts (struct btrace_data_bts *btrace, struct thread_info *tp)
1675 {
1676 struct btrace_thread_info *btinfo;
1677 struct btrace_function *last_bfun;
1678 btrace_block_s *first_new_block;
1679
1680 btinfo = &tp->btrace;
1681 gdb_assert (!btinfo->functions.empty ());
1682 gdb_assert (!VEC_empty (btrace_block_s, btrace->blocks));
1683
1684 last_bfun = &btinfo->functions.back ();
1685
1686 /* If the existing trace ends with a gap, we just glue the traces
1687 together. We need to drop the last (i.e. chronologically first) block
1688 of the new trace, though, since we can't fill in the start address.*/
1689 if (last_bfun->insn.empty ())
1690 {
1691 VEC_pop (btrace_block_s, btrace->blocks);
1692 return 0;
1693 }
1694
1695 /* Beware that block trace starts with the most recent block, so the
1696 chronologically first block in the new trace is the last block in
1697 the new trace's block vector. */
1698 first_new_block = VEC_last (btrace_block_s, btrace->blocks);
1699 const btrace_insn &last_insn = last_bfun->insn.back ();
1700
1701 /* If the current PC at the end of the block is the same as in our current
1702 trace, there are two explanations:
1703 1. we executed the instruction and some branch brought us back.
1704 2. we have not made any progress.
1705 In the first case, the delta trace vector should contain at least two
1706 entries.
1707 In the second case, the delta trace vector should contain exactly one
1708 entry for the partial block containing the current PC. Remove it. */
1709 if (first_new_block->end == last_insn.pc
1710 && VEC_length (btrace_block_s, btrace->blocks) == 1)
1711 {
1712 VEC_pop (btrace_block_s, btrace->blocks);
1713 return 0;
1714 }
1715
1716 DEBUG ("stitching %s to %s", ftrace_print_insn_addr (&last_insn),
1717 core_addr_to_string_nz (first_new_block->end));
1718
1719 /* Do a simple sanity check to make sure we don't accidentally end up
1720 with a bad block. This should not occur in practice. */
1721 if (first_new_block->end < last_insn.pc)
1722 {
1723 warning (_("Error while trying to read delta trace. Falling back to "
1724 "a full read."));
1725 return -1;
1726 }
1727
1728 /* We adjust the last block to start at the end of our current trace. */
1729 gdb_assert (first_new_block->begin == 0);
1730 first_new_block->begin = last_insn.pc;
1731
1732 /* We simply pop the last insn so we can insert it again as part of
1733 the normal branch trace computation.
1734 Since instruction iterators are based on indices in the instructions
1735 vector, we don't leave any pointers dangling. */
1736 DEBUG ("pruning insn at %s for stitching",
1737 ftrace_print_insn_addr (&last_insn));
1738
1739 last_bfun->insn.pop_back ();
1740
1741 /* The instructions vector may become empty temporarily if this has
1742 been the only instruction in this function segment.
1743 This violates the invariant but will be remedied shortly by
1744 btrace_compute_ftrace when we add the new trace. */
1745
1746 /* The only case where this would hurt is if the entire trace consisted
1747 of just that one instruction. If we remove it, we might turn the now
1748 empty btrace function segment into a gap. But we don't want gaps at
1749 the beginning. To avoid this, we remove the entire old trace. */
1750 if (last_bfun->number == 1 && last_bfun->insn.empty ())
1751 btrace_clear (tp);
1752
1753 return 0;
1754 }
1755
1756 /* Adjust the block trace in order to stitch old and new trace together.
1757 BTRACE is the new delta trace between the last and the current stop.
1758 TP is the traced thread.
1759 May modifx BTRACE as well as the existing trace in TP.
1760 Return 0 on success, -1 otherwise. */
1761
1762 static int
1763 btrace_stitch_trace (struct btrace_data *btrace, struct thread_info *tp)
1764 {
1765 /* If we don't have trace, there's nothing to do. */
1766 if (btrace_data_empty (btrace))
1767 return 0;
1768
1769 switch (btrace->format)
1770 {
1771 case BTRACE_FORMAT_NONE:
1772 return 0;
1773
1774 case BTRACE_FORMAT_BTS:
1775 return btrace_stitch_bts (&btrace->variant.bts, tp);
1776
1777 case BTRACE_FORMAT_PT:
1778 /* Delta reads are not supported. */
1779 return -1;
1780 }
1781
1782 internal_error (__FILE__, __LINE__, _("Unkown branch trace format."));
1783 }
1784
1785 /* Clear the branch trace histories in BTINFO. */
1786
1787 static void
1788 btrace_clear_history (struct btrace_thread_info *btinfo)
1789 {
1790 xfree (btinfo->insn_history);
1791 xfree (btinfo->call_history);
1792 xfree (btinfo->replay);
1793
1794 btinfo->insn_history = NULL;
1795 btinfo->call_history = NULL;
1796 btinfo->replay = NULL;
1797 }
1798
1799 /* Clear the branch trace maintenance histories in BTINFO. */
1800
1801 static void
1802 btrace_maint_clear (struct btrace_thread_info *btinfo)
1803 {
1804 switch (btinfo->data.format)
1805 {
1806 default:
1807 break;
1808
1809 case BTRACE_FORMAT_BTS:
1810 btinfo->maint.variant.bts.packet_history.begin = 0;
1811 btinfo->maint.variant.bts.packet_history.end = 0;
1812 break;
1813
1814 #if defined (HAVE_LIBIPT)
1815 case BTRACE_FORMAT_PT:
1816 xfree (btinfo->maint.variant.pt.packets);
1817
1818 btinfo->maint.variant.pt.packets = NULL;
1819 btinfo->maint.variant.pt.packet_history.begin = 0;
1820 btinfo->maint.variant.pt.packet_history.end = 0;
1821 break;
1822 #endif /* defined (HAVE_LIBIPT) */
1823 }
1824 }
1825
1826 /* See btrace.h. */
1827
1828 const char *
1829 btrace_decode_error (enum btrace_format format, int errcode)
1830 {
1831 switch (format)
1832 {
1833 case BTRACE_FORMAT_BTS:
1834 switch (errcode)
1835 {
1836 case BDE_BTS_OVERFLOW:
1837 return _("instruction overflow");
1838
1839 case BDE_BTS_INSN_SIZE:
1840 return _("unknown instruction");
1841
1842 default:
1843 break;
1844 }
1845 break;
1846
1847 #if defined (HAVE_LIBIPT)
1848 case BTRACE_FORMAT_PT:
1849 switch (errcode)
1850 {
1851 case BDE_PT_USER_QUIT:
1852 return _("trace decode cancelled");
1853
1854 case BDE_PT_DISABLED:
1855 return _("disabled");
1856
1857 case BDE_PT_OVERFLOW:
1858 return _("overflow");
1859
1860 default:
1861 if (errcode < 0)
1862 return pt_errstr (pt_errcode (errcode));
1863 break;
1864 }
1865 break;
1866 #endif /* defined (HAVE_LIBIPT) */
1867
1868 default:
1869 break;
1870 }
1871
1872 return _("unknown");
1873 }
1874
1875 /* See btrace.h. */
1876
1877 void
1878 btrace_fetch (struct thread_info *tp)
1879 {
1880 struct btrace_thread_info *btinfo;
1881 struct btrace_target_info *tinfo;
1882 struct btrace_data btrace;
1883 struct cleanup *cleanup;
1884 int errcode;
1885
1886 DEBUG ("fetch thread %s (%s)", print_thread_id (tp),
1887 target_pid_to_str (tp->ptid));
1888
1889 btinfo = &tp->btrace;
1890 tinfo = btinfo->target;
1891 if (tinfo == NULL)
1892 return;
1893
1894 /* There's no way we could get new trace while replaying.
1895 On the other hand, delta trace would return a partial record with the
1896 current PC, which is the replay PC, not the last PC, as expected. */
1897 if (btinfo->replay != NULL)
1898 return;
1899
1900 /* With CLI usage, TP->PTID always equals INFERIOR_PTID here. Now that we
1901 can store a gdb.Record object in Python referring to a different thread
1902 than the current one, temporarily set INFERIOR_PTID. */
1903 scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid);
1904 inferior_ptid = tp->ptid;
1905
1906 /* We should not be called on running or exited threads. */
1907 gdb_assert (can_access_registers_ptid (tp->ptid));
1908
1909 btrace_data_init (&btrace);
1910 cleanup = make_cleanup_btrace_data (&btrace);
1911
1912 /* Let's first try to extend the trace we already have. */
1913 if (!btinfo->functions.empty ())
1914 {
1915 errcode = target_read_btrace (&btrace, tinfo, BTRACE_READ_DELTA);
1916 if (errcode == 0)
1917 {
1918 /* Success. Let's try to stitch the traces together. */
1919 errcode = btrace_stitch_trace (&btrace, tp);
1920 }
1921 else
1922 {
1923 /* We failed to read delta trace. Let's try to read new trace. */
1924 errcode = target_read_btrace (&btrace, tinfo, BTRACE_READ_NEW);
1925
1926 /* If we got any new trace, discard what we have. */
1927 if (errcode == 0 && !btrace_data_empty (&btrace))
1928 btrace_clear (tp);
1929 }
1930
1931 /* If we were not able to read the trace, we start over. */
1932 if (errcode != 0)
1933 {
1934 btrace_clear (tp);
1935 errcode = target_read_btrace (&btrace, tinfo, BTRACE_READ_ALL);
1936 }
1937 }
1938 else
1939 errcode = target_read_btrace (&btrace, tinfo, BTRACE_READ_ALL);
1940
1941 /* If we were not able to read the branch trace, signal an error. */
1942 if (errcode != 0)
1943 error (_("Failed to read branch trace."));
1944
1945 /* Compute the trace, provided we have any. */
1946 if (!btrace_data_empty (&btrace))
1947 {
1948 /* Store the raw trace data. The stored data will be cleared in
1949 btrace_clear, so we always append the new trace. */
1950 btrace_data_append (&btinfo->data, &btrace);
1951 btrace_maint_clear (btinfo);
1952
1953 btrace_clear_history (btinfo);
1954 btrace_compute_ftrace (tp, &btrace);
1955 }
1956
1957 do_cleanups (cleanup);
1958 }
1959
1960 /* See btrace.h. */
1961
1962 void
1963 btrace_clear (struct thread_info *tp)
1964 {
1965 struct btrace_thread_info *btinfo;
1966
1967 DEBUG ("clear thread %s (%s)", print_thread_id (tp),
1968 target_pid_to_str (tp->ptid));
1969
1970 /* Make sure btrace frames that may hold a pointer into the branch
1971 trace data are destroyed. */
1972 reinit_frame_cache ();
1973
1974 btinfo = &tp->btrace;
1975
1976 btinfo->functions.clear ();
1977 btinfo->ngaps = 0;
1978
1979 /* Must clear the maint data before - it depends on BTINFO->DATA. */
1980 btrace_maint_clear (btinfo);
1981 btrace_data_clear (&btinfo->data);
1982 btrace_clear_history (btinfo);
1983 }
1984
1985 /* See btrace.h. */
1986
1987 void
1988 btrace_free_objfile (struct objfile *objfile)
1989 {
1990 struct thread_info *tp;
1991
1992 DEBUG ("free objfile");
1993
1994 ALL_NON_EXITED_THREADS (tp)
1995 btrace_clear (tp);
1996 }
1997
1998 #if defined (HAVE_LIBEXPAT)
1999
2000 /* Check the btrace document version. */
2001
2002 static void
2003 check_xml_btrace_version (struct gdb_xml_parser *parser,
2004 const struct gdb_xml_element *element,
2005 void *user_data, VEC (gdb_xml_value_s) *attributes)
2006 {
2007 const char *version
2008 = (const char *) xml_find_attribute (attributes, "version")->value;
2009
2010 if (strcmp (version, "1.0") != 0)
2011 gdb_xml_error (parser, _("Unsupported btrace version: \"%s\""), version);
2012 }
2013
2014 /* Parse a btrace "block" xml record. */
2015
2016 static void
2017 parse_xml_btrace_block (struct gdb_xml_parser *parser,
2018 const struct gdb_xml_element *element,
2019 void *user_data, VEC (gdb_xml_value_s) *attributes)
2020 {
2021 struct btrace_data *btrace;
2022 struct btrace_block *block;
2023 ULONGEST *begin, *end;
2024
2025 btrace = (struct btrace_data *) user_data;
2026
2027 switch (btrace->format)
2028 {
2029 case BTRACE_FORMAT_BTS:
2030 break;
2031
2032 case BTRACE_FORMAT_NONE:
2033 btrace->format = BTRACE_FORMAT_BTS;
2034 btrace->variant.bts.blocks = NULL;
2035 break;
2036
2037 default:
2038 gdb_xml_error (parser, _("Btrace format error."));
2039 }
2040
2041 begin = (ULONGEST *) xml_find_attribute (attributes, "begin")->value;
2042 end = (ULONGEST *) xml_find_attribute (attributes, "end")->value;
2043
2044 block = VEC_safe_push (btrace_block_s, btrace->variant.bts.blocks, NULL);
2045 block->begin = *begin;
2046 block->end = *end;
2047 }
2048
2049 /* Parse a "raw" xml record. */
2050
2051 static void
2052 parse_xml_raw (struct gdb_xml_parser *parser, const char *body_text,
2053 gdb_byte **pdata, size_t *psize)
2054 {
2055 struct cleanup *cleanup;
2056 gdb_byte *data, *bin;
2057 size_t len, size;
2058
2059 len = strlen (body_text);
2060 if (len % 2 != 0)
2061 gdb_xml_error (parser, _("Bad raw data size."));
2062
2063 size = len / 2;
2064
2065 bin = data = (gdb_byte *) xmalloc (size);
2066 cleanup = make_cleanup (xfree, data);
2067
2068 /* We use hex encoding - see common/rsp-low.h. */
2069 while (len > 0)
2070 {
2071 char hi, lo;
2072
2073 hi = *body_text++;
2074 lo = *body_text++;
2075
2076 if (hi == 0 || lo == 0)
2077 gdb_xml_error (parser, _("Bad hex encoding."));
2078
2079 *bin++ = fromhex (hi) * 16 + fromhex (lo);
2080 len -= 2;
2081 }
2082
2083 discard_cleanups (cleanup);
2084
2085 *pdata = data;
2086 *psize = size;
2087 }
2088
2089 /* Parse a btrace pt-config "cpu" xml record. */
2090
2091 static void
2092 parse_xml_btrace_pt_config_cpu (struct gdb_xml_parser *parser,
2093 const struct gdb_xml_element *element,
2094 void *user_data,
2095 VEC (gdb_xml_value_s) *attributes)
2096 {
2097 struct btrace_data *btrace;
2098 const char *vendor;
2099 ULONGEST *family, *model, *stepping;
2100
2101 vendor = (const char *) xml_find_attribute (attributes, "vendor")->value;
2102 family = (ULONGEST *) xml_find_attribute (attributes, "family")->value;
2103 model = (ULONGEST *) xml_find_attribute (attributes, "model")->value;
2104 stepping = (ULONGEST *) xml_find_attribute (attributes, "stepping")->value;
2105
2106 btrace = (struct btrace_data *) user_data;
2107
2108 if (strcmp (vendor, "GenuineIntel") == 0)
2109 btrace->variant.pt.config.cpu.vendor = CV_INTEL;
2110
2111 btrace->variant.pt.config.cpu.family = *family;
2112 btrace->variant.pt.config.cpu.model = *model;
2113 btrace->variant.pt.config.cpu.stepping = *stepping;
2114 }
2115
2116 /* Parse a btrace pt "raw" xml record. */
2117
2118 static void
2119 parse_xml_btrace_pt_raw (struct gdb_xml_parser *parser,
2120 const struct gdb_xml_element *element,
2121 void *user_data, const char *body_text)
2122 {
2123 struct btrace_data *btrace;
2124
2125 btrace = (struct btrace_data *) user_data;
2126 parse_xml_raw (parser, body_text, &btrace->variant.pt.data,
2127 &btrace->variant.pt.size);
2128 }
2129
2130 /* Parse a btrace "pt" xml record. */
2131
2132 static void
2133 parse_xml_btrace_pt (struct gdb_xml_parser *parser,
2134 const struct gdb_xml_element *element,
2135 void *user_data, VEC (gdb_xml_value_s) *attributes)
2136 {
2137 struct btrace_data *btrace;
2138
2139 btrace = (struct btrace_data *) user_data;
2140 btrace->format = BTRACE_FORMAT_PT;
2141 btrace->variant.pt.config.cpu.vendor = CV_UNKNOWN;
2142 btrace->variant.pt.data = NULL;
2143 btrace->variant.pt.size = 0;
2144 }
2145
2146 static const struct gdb_xml_attribute block_attributes[] = {
2147 { "begin", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
2148 { "end", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
2149 { NULL, GDB_XML_AF_NONE, NULL, NULL }
2150 };
2151
2152 static const struct gdb_xml_attribute btrace_pt_config_cpu_attributes[] = {
2153 { "vendor", GDB_XML_AF_NONE, NULL, NULL },
2154 { "family", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
2155 { "model", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
2156 { "stepping", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
2157 { NULL, GDB_XML_AF_NONE, NULL, NULL }
2158 };
2159
2160 static const struct gdb_xml_element btrace_pt_config_children[] = {
2161 { "cpu", btrace_pt_config_cpu_attributes, NULL, GDB_XML_EF_OPTIONAL,
2162 parse_xml_btrace_pt_config_cpu, NULL },
2163 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
2164 };
2165
2166 static const struct gdb_xml_element btrace_pt_children[] = {
2167 { "pt-config", NULL, btrace_pt_config_children, GDB_XML_EF_OPTIONAL, NULL,
2168 NULL },
2169 { "raw", NULL, NULL, GDB_XML_EF_OPTIONAL, NULL, parse_xml_btrace_pt_raw },
2170 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
2171 };
2172
2173 static const struct gdb_xml_attribute btrace_attributes[] = {
2174 { "version", GDB_XML_AF_NONE, NULL, NULL },
2175 { NULL, GDB_XML_AF_NONE, NULL, NULL }
2176 };
2177
2178 static const struct gdb_xml_element btrace_children[] = {
2179 { "block", block_attributes, NULL,
2180 GDB_XML_EF_REPEATABLE | GDB_XML_EF_OPTIONAL, parse_xml_btrace_block, NULL },
2181 { "pt", NULL, btrace_pt_children, GDB_XML_EF_OPTIONAL, parse_xml_btrace_pt,
2182 NULL },
2183 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
2184 };
2185
2186 static const struct gdb_xml_element btrace_elements[] = {
2187 { "btrace", btrace_attributes, btrace_children, GDB_XML_EF_NONE,
2188 check_xml_btrace_version, NULL },
2189 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
2190 };
2191
2192 #endif /* defined (HAVE_LIBEXPAT) */
2193
2194 /* See btrace.h. */
2195
2196 void
2197 parse_xml_btrace (struct btrace_data *btrace, const char *buffer)
2198 {
2199 struct cleanup *cleanup;
2200 int errcode;
2201
2202 #if defined (HAVE_LIBEXPAT)
2203
2204 btrace->format = BTRACE_FORMAT_NONE;
2205
2206 cleanup = make_cleanup_btrace_data (btrace);
2207 errcode = gdb_xml_parse_quick (_("btrace"), "btrace.dtd", btrace_elements,
2208 buffer, btrace);
2209 if (errcode != 0)
2210 error (_("Error parsing branch trace."));
2211
2212 /* Keep parse results. */
2213 discard_cleanups (cleanup);
2214
2215 #else /* !defined (HAVE_LIBEXPAT) */
2216
2217 error (_("Cannot process branch trace. XML parsing is not supported."));
2218
2219 #endif /* !defined (HAVE_LIBEXPAT) */
2220 }
2221
2222 #if defined (HAVE_LIBEXPAT)
2223
2224 /* Parse a btrace-conf "bts" xml record. */
2225
2226 static void
2227 parse_xml_btrace_conf_bts (struct gdb_xml_parser *parser,
2228 const struct gdb_xml_element *element,
2229 void *user_data, VEC (gdb_xml_value_s) *attributes)
2230 {
2231 struct btrace_config *conf;
2232 struct gdb_xml_value *size;
2233
2234 conf = (struct btrace_config *) user_data;
2235 conf->format = BTRACE_FORMAT_BTS;
2236 conf->bts.size = 0;
2237
2238 size = xml_find_attribute (attributes, "size");
2239 if (size != NULL)
2240 conf->bts.size = (unsigned int) *(ULONGEST *) size->value;
2241 }
2242
2243 /* Parse a btrace-conf "pt" xml record. */
2244
2245 static void
2246 parse_xml_btrace_conf_pt (struct gdb_xml_parser *parser,
2247 const struct gdb_xml_element *element,
2248 void *user_data, VEC (gdb_xml_value_s) *attributes)
2249 {
2250 struct btrace_config *conf;
2251 struct gdb_xml_value *size;
2252
2253 conf = (struct btrace_config *) user_data;
2254 conf->format = BTRACE_FORMAT_PT;
2255 conf->pt.size = 0;
2256
2257 size = xml_find_attribute (attributes, "size");
2258 if (size != NULL)
2259 conf->pt.size = (unsigned int) *(ULONGEST *) size->value;
2260 }
2261
2262 static const struct gdb_xml_attribute btrace_conf_pt_attributes[] = {
2263 { "size", GDB_XML_AF_OPTIONAL, gdb_xml_parse_attr_ulongest, NULL },
2264 { NULL, GDB_XML_AF_NONE, NULL, NULL }
2265 };
2266
2267 static const struct gdb_xml_attribute btrace_conf_bts_attributes[] = {
2268 { "size", GDB_XML_AF_OPTIONAL, gdb_xml_parse_attr_ulongest, NULL },
2269 { NULL, GDB_XML_AF_NONE, NULL, NULL }
2270 };
2271
2272 static const struct gdb_xml_element btrace_conf_children[] = {
2273 { "bts", btrace_conf_bts_attributes, NULL, GDB_XML_EF_OPTIONAL,
2274 parse_xml_btrace_conf_bts, NULL },
2275 { "pt", btrace_conf_pt_attributes, NULL, GDB_XML_EF_OPTIONAL,
2276 parse_xml_btrace_conf_pt, NULL },
2277 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
2278 };
2279
2280 static const struct gdb_xml_attribute btrace_conf_attributes[] = {
2281 { "version", GDB_XML_AF_NONE, NULL, NULL },
2282 { NULL, GDB_XML_AF_NONE, NULL, NULL }
2283 };
2284
2285 static const struct gdb_xml_element btrace_conf_elements[] = {
2286 { "btrace-conf", btrace_conf_attributes, btrace_conf_children,
2287 GDB_XML_EF_NONE, NULL, NULL },
2288 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
2289 };
2290
2291 #endif /* defined (HAVE_LIBEXPAT) */
2292
2293 /* See btrace.h. */
2294
2295 void
2296 parse_xml_btrace_conf (struct btrace_config *conf, const char *xml)
2297 {
2298 int errcode;
2299
2300 #if defined (HAVE_LIBEXPAT)
2301
2302 errcode = gdb_xml_parse_quick (_("btrace-conf"), "btrace-conf.dtd",
2303 btrace_conf_elements, xml, conf);
2304 if (errcode != 0)
2305 error (_("Error parsing branch trace configuration."));
2306
2307 #else /* !defined (HAVE_LIBEXPAT) */
2308
2309 error (_("XML parsing is not supported."));
2310
2311 #endif /* !defined (HAVE_LIBEXPAT) */
2312 }
2313
2314 /* See btrace.h. */
2315
2316 const struct btrace_insn *
2317 btrace_insn_get (const struct btrace_insn_iterator *it)
2318 {
2319 const struct btrace_function *bfun;
2320 unsigned int index, end;
2321
2322 index = it->insn_index;
2323 bfun = &it->btinfo->functions[it->call_index];
2324
2325 /* Check if the iterator points to a gap in the trace. */
2326 if (bfun->errcode != 0)
2327 return NULL;
2328
2329 /* The index is within the bounds of this function's instruction vector. */
2330 end = bfun->insn.size ();
2331 gdb_assert (0 < end);
2332 gdb_assert (index < end);
2333
2334 return &bfun->insn[index];
2335 }
2336
2337 /* See btrace.h. */
2338
2339 int
2340 btrace_insn_get_error (const struct btrace_insn_iterator *it)
2341 {
2342 return it->btinfo->functions[it->call_index].errcode;
2343 }
2344
2345 /* See btrace.h. */
2346
2347 unsigned int
2348 btrace_insn_number (const struct btrace_insn_iterator *it)
2349 {
2350 return it->btinfo->functions[it->call_index].insn_offset + it->insn_index;
2351 }
2352
2353 /* See btrace.h. */
2354
2355 void
2356 btrace_insn_begin (struct btrace_insn_iterator *it,
2357 const struct btrace_thread_info *btinfo)
2358 {
2359 if (btinfo->functions.empty ())
2360 error (_("No trace."));
2361
2362 it->btinfo = btinfo;
2363 it->call_index = 0;
2364 it->insn_index = 0;
2365 }
2366
2367 /* See btrace.h. */
2368
2369 void
2370 btrace_insn_end (struct btrace_insn_iterator *it,
2371 const struct btrace_thread_info *btinfo)
2372 {
2373 const struct btrace_function *bfun;
2374 unsigned int length;
2375
2376 if (btinfo->functions.empty ())
2377 error (_("No trace."));
2378
2379 bfun = &btinfo->functions.back ();
2380 length = bfun->insn.size ();
2381
2382 /* The last function may either be a gap or it contains the current
2383 instruction, which is one past the end of the execution trace; ignore
2384 it. */
2385 if (length > 0)
2386 length -= 1;
2387
2388 it->btinfo = btinfo;
2389 it->call_index = bfun->number - 1;
2390 it->insn_index = length;
2391 }
2392
2393 /* See btrace.h. */
2394
2395 unsigned int
2396 btrace_insn_next (struct btrace_insn_iterator *it, unsigned int stride)
2397 {
2398 const struct btrace_function *bfun;
2399 unsigned int index, steps;
2400
2401 bfun = &it->btinfo->functions[it->call_index];
2402 steps = 0;
2403 index = it->insn_index;
2404
2405 while (stride != 0)
2406 {
2407 unsigned int end, space, adv;
2408
2409 end = bfun->insn.size ();
2410
2411 /* An empty function segment represents a gap in the trace. We count
2412 it as one instruction. */
2413 if (end == 0)
2414 {
2415 const struct btrace_function *next;
2416
2417 next = ftrace_find_call_by_number (it->btinfo, bfun->number + 1);
2418 if (next == NULL)
2419 break;
2420
2421 stride -= 1;
2422 steps += 1;
2423
2424 bfun = next;
2425 index = 0;
2426
2427 continue;
2428 }
2429
2430 gdb_assert (0 < end);
2431 gdb_assert (index < end);
2432
2433 /* Compute the number of instructions remaining in this segment. */
2434 space = end - index;
2435
2436 /* Advance the iterator as far as possible within this segment. */
2437 adv = std::min (space, stride);
2438 stride -= adv;
2439 index += adv;
2440 steps += adv;
2441
2442 /* Move to the next function if we're at the end of this one. */
2443 if (index == end)
2444 {
2445 const struct btrace_function *next;
2446
2447 next = ftrace_find_call_by_number (it->btinfo, bfun->number + 1);
2448 if (next == NULL)
2449 {
2450 /* We stepped past the last function.
2451
2452 Let's adjust the index to point to the last instruction in
2453 the previous function. */
2454 index -= 1;
2455 steps -= 1;
2456 break;
2457 }
2458
2459 /* We now point to the first instruction in the new function. */
2460 bfun = next;
2461 index = 0;
2462 }
2463
2464 /* We did make progress. */
2465 gdb_assert (adv > 0);
2466 }
2467
2468 /* Update the iterator. */
2469 it->call_index = bfun->number - 1;
2470 it->insn_index = index;
2471
2472 return steps;
2473 }
2474
2475 /* See btrace.h. */
2476
2477 unsigned int
2478 btrace_insn_prev (struct btrace_insn_iterator *it, unsigned int stride)
2479 {
2480 const struct btrace_function *bfun;
2481 unsigned int index, steps;
2482
2483 bfun = &it->btinfo->functions[it->call_index];
2484 steps = 0;
2485 index = it->insn_index;
2486
2487 while (stride != 0)
2488 {
2489 unsigned int adv;
2490
2491 /* Move to the previous function if we're at the start of this one. */
2492 if (index == 0)
2493 {
2494 const struct btrace_function *prev;
2495
2496 prev = ftrace_find_call_by_number (it->btinfo, bfun->number - 1);
2497 if (prev == NULL)
2498 break;
2499
2500 /* We point to one after the last instruction in the new function. */
2501 bfun = prev;
2502 index = bfun->insn.size ();
2503
2504 /* An empty function segment represents a gap in the trace. We count
2505 it as one instruction. */
2506 if (index == 0)
2507 {
2508 stride -= 1;
2509 steps += 1;
2510
2511 continue;
2512 }
2513 }
2514
2515 /* Advance the iterator as far as possible within this segment. */
2516 adv = std::min (index, stride);
2517
2518 stride -= adv;
2519 index -= adv;
2520 steps += adv;
2521
2522 /* We did make progress. */
2523 gdb_assert (adv > 0);
2524 }
2525
2526 /* Update the iterator. */
2527 it->call_index = bfun->number - 1;
2528 it->insn_index = index;
2529
2530 return steps;
2531 }
2532
2533 /* See btrace.h. */
2534
2535 int
2536 btrace_insn_cmp (const struct btrace_insn_iterator *lhs,
2537 const struct btrace_insn_iterator *rhs)
2538 {
2539 gdb_assert (lhs->btinfo == rhs->btinfo);
2540
2541 if (lhs->call_index != rhs->call_index)
2542 return lhs->call_index - rhs->call_index;
2543
2544 return lhs->insn_index - rhs->insn_index;
2545 }
2546
2547 /* See btrace.h. */
2548
2549 int
2550 btrace_find_insn_by_number (struct btrace_insn_iterator *it,
2551 const struct btrace_thread_info *btinfo,
2552 unsigned int number)
2553 {
2554 const struct btrace_function *bfun;
2555 unsigned int upper, lower;
2556
2557 if (btinfo->functions.empty ())
2558 return 0;
2559
2560 lower = 0;
2561 bfun = &btinfo->functions[lower];
2562 if (number < bfun->insn_offset)
2563 return 0;
2564
2565 upper = btinfo->functions.size () - 1;
2566 bfun = &btinfo->functions[upper];
2567 if (number >= bfun->insn_offset + ftrace_call_num_insn (bfun))
2568 return 0;
2569
2570 /* We assume that there are no holes in the numbering. */
2571 for (;;)
2572 {
2573 const unsigned int average = lower + (upper - lower) / 2;
2574
2575 bfun = &btinfo->functions[average];
2576
2577 if (number < bfun->insn_offset)
2578 {
2579 upper = average - 1;
2580 continue;
2581 }
2582
2583 if (number >= bfun->insn_offset + ftrace_call_num_insn (bfun))
2584 {
2585 lower = average + 1;
2586 continue;
2587 }
2588
2589 break;
2590 }
2591
2592 it->btinfo = btinfo;
2593 it->call_index = bfun->number - 1;
2594 it->insn_index = number - bfun->insn_offset;
2595 return 1;
2596 }
2597
2598 /* Returns true if the recording ends with a function segment that
2599 contains only a single (i.e. the current) instruction. */
2600
2601 static bool
2602 btrace_ends_with_single_insn (const struct btrace_thread_info *btinfo)
2603 {
2604 const btrace_function *bfun;
2605
2606 if (btinfo->functions.empty ())
2607 return false;
2608
2609 bfun = &btinfo->functions.back ();
2610 if (bfun->errcode != 0)
2611 return false;
2612
2613 return ftrace_call_num_insn (bfun) == 1;
2614 }
2615
2616 /* See btrace.h. */
2617
2618 const struct btrace_function *
2619 btrace_call_get (const struct btrace_call_iterator *it)
2620 {
2621 if (it->index >= it->btinfo->functions.size ())
2622 return NULL;
2623
2624 return &it->btinfo->functions[it->index];
2625 }
2626
2627 /* See btrace.h. */
2628
2629 unsigned int
2630 btrace_call_number (const struct btrace_call_iterator *it)
2631 {
2632 const unsigned int length = it->btinfo->functions.size ();
2633
2634 /* If the last function segment contains only a single instruction (i.e. the
2635 current instruction), skip it. */
2636 if ((it->index == length) && btrace_ends_with_single_insn (it->btinfo))
2637 return length;
2638
2639 return it->index + 1;
2640 }
2641
2642 /* See btrace.h. */
2643
2644 void
2645 btrace_call_begin (struct btrace_call_iterator *it,
2646 const struct btrace_thread_info *btinfo)
2647 {
2648 if (btinfo->functions.empty ())
2649 error (_("No trace."));
2650
2651 it->btinfo = btinfo;
2652 it->index = 0;
2653 }
2654
2655 /* See btrace.h. */
2656
2657 void
2658 btrace_call_end (struct btrace_call_iterator *it,
2659 const struct btrace_thread_info *btinfo)
2660 {
2661 if (btinfo->functions.empty ())
2662 error (_("No trace."));
2663
2664 it->btinfo = btinfo;
2665 it->index = btinfo->functions.size ();
2666 }
2667
2668 /* See btrace.h. */
2669
2670 unsigned int
2671 btrace_call_next (struct btrace_call_iterator *it, unsigned int stride)
2672 {
2673 const unsigned int length = it->btinfo->functions.size ();
2674
2675 if (it->index + stride < length - 1)
2676 /* Default case: Simply advance the iterator. */
2677 it->index += stride;
2678 else if (it->index + stride == length - 1)
2679 {
2680 /* We land exactly at the last function segment. If it contains only one
2681 instruction (i.e. the current instruction) it is not actually part of
2682 the trace. */
2683 if (btrace_ends_with_single_insn (it->btinfo))
2684 it->index = length;
2685 else
2686 it->index = length - 1;
2687 }
2688 else
2689 {
2690 /* We land past the last function segment and have to adjust the stride.
2691 If the last function segment contains only one instruction (i.e. the
2692 current instruction) it is not actually part of the trace. */
2693 if (btrace_ends_with_single_insn (it->btinfo))
2694 stride = length - it->index - 1;
2695 else
2696 stride = length - it->index;
2697
2698 it->index = length;
2699 }
2700
2701 return stride;
2702 }
2703
2704 /* See btrace.h. */
2705
2706 unsigned int
2707 btrace_call_prev (struct btrace_call_iterator *it, unsigned int stride)
2708 {
2709 const unsigned int length = it->btinfo->functions.size ();
2710 int steps = 0;
2711
2712 gdb_assert (it->index <= length);
2713
2714 if (stride == 0 || it->index == 0)
2715 return 0;
2716
2717 /* If we are at the end, the first step is a special case. If the last
2718 function segment contains only one instruction (i.e. the current
2719 instruction) it is not actually part of the trace. To be able to step
2720 over this instruction, we need at least one more function segment. */
2721 if ((it->index == length) && (length > 1))
2722 {
2723 if (btrace_ends_with_single_insn (it->btinfo))
2724 it->index = length - 2;
2725 else
2726 it->index = length - 1;
2727
2728 steps = 1;
2729 stride -= 1;
2730 }
2731
2732 stride = std::min (stride, it->index);
2733
2734 it->index -= stride;
2735 return steps + stride;
2736 }
2737
2738 /* See btrace.h. */
2739
2740 int
2741 btrace_call_cmp (const struct btrace_call_iterator *lhs,
2742 const struct btrace_call_iterator *rhs)
2743 {
2744 gdb_assert (lhs->btinfo == rhs->btinfo);
2745 return (int) (lhs->index - rhs->index);
2746 }
2747
2748 /* See btrace.h. */
2749
2750 int
2751 btrace_find_call_by_number (struct btrace_call_iterator *it,
2752 const struct btrace_thread_info *btinfo,
2753 unsigned int number)
2754 {
2755 const unsigned int length = btinfo->functions.size ();
2756
2757 if ((number == 0) || (number > length))
2758 return 0;
2759
2760 it->btinfo = btinfo;
2761 it->index = number - 1;
2762 return 1;
2763 }
2764
2765 /* See btrace.h. */
2766
2767 void
2768 btrace_set_insn_history (struct btrace_thread_info *btinfo,
2769 const struct btrace_insn_iterator *begin,
2770 const struct btrace_insn_iterator *end)
2771 {
2772 if (btinfo->insn_history == NULL)
2773 btinfo->insn_history = XCNEW (struct btrace_insn_history);
2774
2775 btinfo->insn_history->begin = *begin;
2776 btinfo->insn_history->end = *end;
2777 }
2778
2779 /* See btrace.h. */
2780
2781 void
2782 btrace_set_call_history (struct btrace_thread_info *btinfo,
2783 const struct btrace_call_iterator *begin,
2784 const struct btrace_call_iterator *end)
2785 {
2786 gdb_assert (begin->btinfo == end->btinfo);
2787
2788 if (btinfo->call_history == NULL)
2789 btinfo->call_history = XCNEW (struct btrace_call_history);
2790
2791 btinfo->call_history->begin = *begin;
2792 btinfo->call_history->end = *end;
2793 }
2794
2795 /* See btrace.h. */
2796
2797 int
2798 btrace_is_replaying (struct thread_info *tp)
2799 {
2800 return tp->btrace.replay != NULL;
2801 }
2802
2803 /* See btrace.h. */
2804
2805 int
2806 btrace_is_empty (struct thread_info *tp)
2807 {
2808 struct btrace_insn_iterator begin, end;
2809 struct btrace_thread_info *btinfo;
2810
2811 btinfo = &tp->btrace;
2812
2813 if (btinfo->functions.empty ())
2814 return 1;
2815
2816 btrace_insn_begin (&begin, btinfo);
2817 btrace_insn_end (&end, btinfo);
2818
2819 return btrace_insn_cmp (&begin, &end) == 0;
2820 }
2821
2822 /* Forward the cleanup request. */
2823
2824 static void
2825 do_btrace_data_cleanup (void *arg)
2826 {
2827 btrace_data_fini ((struct btrace_data *) arg);
2828 }
2829
2830 /* See btrace.h. */
2831
2832 struct cleanup *
2833 make_cleanup_btrace_data (struct btrace_data *data)
2834 {
2835 return make_cleanup (do_btrace_data_cleanup, data);
2836 }
2837
2838 #if defined (HAVE_LIBIPT)
2839
2840 /* Print a single packet. */
2841
2842 static void
2843 pt_print_packet (const struct pt_packet *packet)
2844 {
2845 switch (packet->type)
2846 {
2847 default:
2848 printf_unfiltered (("[??: %x]"), packet->type);
2849 break;
2850
2851 case ppt_psb:
2852 printf_unfiltered (("psb"));
2853 break;
2854
2855 case ppt_psbend:
2856 printf_unfiltered (("psbend"));
2857 break;
2858
2859 case ppt_pad:
2860 printf_unfiltered (("pad"));
2861 break;
2862
2863 case ppt_tip:
2864 printf_unfiltered (("tip %u: 0x%" PRIx64 ""),
2865 packet->payload.ip.ipc,
2866 packet->payload.ip.ip);
2867 break;
2868
2869 case ppt_tip_pge:
2870 printf_unfiltered (("tip.pge %u: 0x%" PRIx64 ""),
2871 packet->payload.ip.ipc,
2872 packet->payload.ip.ip);
2873 break;
2874
2875 case ppt_tip_pgd:
2876 printf_unfiltered (("tip.pgd %u: 0x%" PRIx64 ""),
2877 packet->payload.ip.ipc,
2878 packet->payload.ip.ip);
2879 break;
2880
2881 case ppt_fup:
2882 printf_unfiltered (("fup %u: 0x%" PRIx64 ""),
2883 packet->payload.ip.ipc,
2884 packet->payload.ip.ip);
2885 break;
2886
2887 case ppt_tnt_8:
2888 printf_unfiltered (("tnt-8 %u: 0x%" PRIx64 ""),
2889 packet->payload.tnt.bit_size,
2890 packet->payload.tnt.payload);
2891 break;
2892
2893 case ppt_tnt_64:
2894 printf_unfiltered (("tnt-64 %u: 0x%" PRIx64 ""),
2895 packet->payload.tnt.bit_size,
2896 packet->payload.tnt.payload);
2897 break;
2898
2899 case ppt_pip:
2900 printf_unfiltered (("pip %" PRIx64 "%s"), packet->payload.pip.cr3,
2901 packet->payload.pip.nr ? (" nr") : (""));
2902 break;
2903
2904 case ppt_tsc:
2905 printf_unfiltered (("tsc %" PRIx64 ""), packet->payload.tsc.tsc);
2906 break;
2907
2908 case ppt_cbr:
2909 printf_unfiltered (("cbr %u"), packet->payload.cbr.ratio);
2910 break;
2911
2912 case ppt_mode:
2913 switch (packet->payload.mode.leaf)
2914 {
2915 default:
2916 printf_unfiltered (("mode %u"), packet->payload.mode.leaf);
2917 break;
2918
2919 case pt_mol_exec:
2920 printf_unfiltered (("mode.exec%s%s"),
2921 packet->payload.mode.bits.exec.csl
2922 ? (" cs.l") : (""),
2923 packet->payload.mode.bits.exec.csd
2924 ? (" cs.d") : (""));
2925 break;
2926
2927 case pt_mol_tsx:
2928 printf_unfiltered (("mode.tsx%s%s"),
2929 packet->payload.mode.bits.tsx.intx
2930 ? (" intx") : (""),
2931 packet->payload.mode.bits.tsx.abrt
2932 ? (" abrt") : (""));
2933 break;
2934 }
2935 break;
2936
2937 case ppt_ovf:
2938 printf_unfiltered (("ovf"));
2939 break;
2940
2941 case ppt_stop:
2942 printf_unfiltered (("stop"));
2943 break;
2944
2945 case ppt_vmcs:
2946 printf_unfiltered (("vmcs %" PRIx64 ""), packet->payload.vmcs.base);
2947 break;
2948
2949 case ppt_tma:
2950 printf_unfiltered (("tma %x %x"), packet->payload.tma.ctc,
2951 packet->payload.tma.fc);
2952 break;
2953
2954 case ppt_mtc:
2955 printf_unfiltered (("mtc %x"), packet->payload.mtc.ctc);
2956 break;
2957
2958 case ppt_cyc:
2959 printf_unfiltered (("cyc %" PRIx64 ""), packet->payload.cyc.value);
2960 break;
2961
2962 case ppt_mnt:
2963 printf_unfiltered (("mnt %" PRIx64 ""), packet->payload.mnt.payload);
2964 break;
2965 }
2966 }
2967
2968 /* Decode packets into MAINT using DECODER. */
2969
2970 static void
2971 btrace_maint_decode_pt (struct btrace_maint_info *maint,
2972 struct pt_packet_decoder *decoder)
2973 {
2974 int errcode;
2975
2976 for (;;)
2977 {
2978 struct btrace_pt_packet packet;
2979
2980 errcode = pt_pkt_sync_forward (decoder);
2981 if (errcode < 0)
2982 break;
2983
2984 for (;;)
2985 {
2986 pt_pkt_get_offset (decoder, &packet.offset);
2987
2988 errcode = pt_pkt_next (decoder, &packet.packet,
2989 sizeof(packet.packet));
2990 if (errcode < 0)
2991 break;
2992
2993 if (maint_btrace_pt_skip_pad == 0 || packet.packet.type != ppt_pad)
2994 {
2995 packet.errcode = pt_errcode (errcode);
2996 VEC_safe_push (btrace_pt_packet_s, maint->variant.pt.packets,
2997 &packet);
2998 }
2999 }
3000
3001 if (errcode == -pte_eos)
3002 break;
3003
3004 packet.errcode = pt_errcode (errcode);
3005 VEC_safe_push (btrace_pt_packet_s, maint->variant.pt.packets,
3006 &packet);
3007
3008 warning (_("Error at trace offset 0x%" PRIx64 ": %s."),
3009 packet.offset, pt_errstr (packet.errcode));
3010 }
3011
3012 if (errcode != -pte_eos)
3013 warning (_("Failed to synchronize onto the Intel Processor Trace "
3014 "stream: %s."), pt_errstr (pt_errcode (errcode)));
3015 }
3016
3017 /* Update the packet history in BTINFO. */
3018
3019 static void
3020 btrace_maint_update_pt_packets (struct btrace_thread_info *btinfo)
3021 {
3022 struct pt_packet_decoder *decoder;
3023 struct btrace_data_pt *pt;
3024 struct pt_config config;
3025 int errcode;
3026
3027 pt = &btinfo->data.variant.pt;
3028
3029 /* Nothing to do if there is no trace. */
3030 if (pt->size == 0)
3031 return;
3032
3033 memset (&config, 0, sizeof(config));
3034
3035 config.size = sizeof (config);
3036 config.begin = pt->data;
3037 config.end = pt->data + pt->size;
3038
3039 config.cpu.vendor = pt_translate_cpu_vendor (pt->config.cpu.vendor);
3040 config.cpu.family = pt->config.cpu.family;
3041 config.cpu.model = pt->config.cpu.model;
3042 config.cpu.stepping = pt->config.cpu.stepping;
3043
3044 errcode = pt_cpu_errata (&config.errata, &config.cpu);
3045 if (errcode < 0)
3046 error (_("Failed to configure the Intel Processor Trace decoder: %s."),
3047 pt_errstr (pt_errcode (errcode)));
3048
3049 decoder = pt_pkt_alloc_decoder (&config);
3050 if (decoder == NULL)
3051 error (_("Failed to allocate the Intel Processor Trace decoder."));
3052
3053 TRY
3054 {
3055 btrace_maint_decode_pt (&btinfo->maint, decoder);
3056 }
3057 CATCH (except, RETURN_MASK_ALL)
3058 {
3059 pt_pkt_free_decoder (decoder);
3060
3061 if (except.reason < 0)
3062 throw_exception (except);
3063 }
3064 END_CATCH
3065
3066 pt_pkt_free_decoder (decoder);
3067 }
3068
3069 #endif /* !defined (HAVE_LIBIPT) */
3070
3071 /* Update the packet maintenance information for BTINFO and store the
3072 low and high bounds into BEGIN and END, respectively.
3073 Store the current iterator state into FROM and TO. */
3074
3075 static void
3076 btrace_maint_update_packets (struct btrace_thread_info *btinfo,
3077 unsigned int *begin, unsigned int *end,
3078 unsigned int *from, unsigned int *to)
3079 {
3080 switch (btinfo->data.format)
3081 {
3082 default:
3083 *begin = 0;
3084 *end = 0;
3085 *from = 0;
3086 *to = 0;
3087 break;
3088
3089 case BTRACE_FORMAT_BTS:
3090 /* Nothing to do - we operate directly on BTINFO->DATA. */
3091 *begin = 0;
3092 *end = VEC_length (btrace_block_s, btinfo->data.variant.bts.blocks);
3093 *from = btinfo->maint.variant.bts.packet_history.begin;
3094 *to = btinfo->maint.variant.bts.packet_history.end;
3095 break;
3096
3097 #if defined (HAVE_LIBIPT)
3098 case BTRACE_FORMAT_PT:
3099 if (VEC_empty (btrace_pt_packet_s, btinfo->maint.variant.pt.packets))
3100 btrace_maint_update_pt_packets (btinfo);
3101
3102 *begin = 0;
3103 *end = VEC_length (btrace_pt_packet_s, btinfo->maint.variant.pt.packets);
3104 *from = btinfo->maint.variant.pt.packet_history.begin;
3105 *to = btinfo->maint.variant.pt.packet_history.end;
3106 break;
3107 #endif /* defined (HAVE_LIBIPT) */
3108 }
3109 }
3110
3111 /* Print packets in BTINFO from BEGIN (inclusive) until END (exclusive) and
3112 update the current iterator position. */
3113
3114 static void
3115 btrace_maint_print_packets (struct btrace_thread_info *btinfo,
3116 unsigned int begin, unsigned int end)
3117 {
3118 switch (btinfo->data.format)
3119 {
3120 default:
3121 break;
3122
3123 case BTRACE_FORMAT_BTS:
3124 {
3125 VEC (btrace_block_s) *blocks;
3126 unsigned int blk;
3127
3128 blocks = btinfo->data.variant.bts.blocks;
3129 for (blk = begin; blk < end; ++blk)
3130 {
3131 const btrace_block_s *block;
3132
3133 block = VEC_index (btrace_block_s, blocks, blk);
3134
3135 printf_unfiltered ("%u\tbegin: %s, end: %s\n", blk,
3136 core_addr_to_string_nz (block->begin),
3137 core_addr_to_string_nz (block->end));
3138 }
3139
3140 btinfo->maint.variant.bts.packet_history.begin = begin;
3141 btinfo->maint.variant.bts.packet_history.end = end;
3142 }
3143 break;
3144
3145 #if defined (HAVE_LIBIPT)
3146 case BTRACE_FORMAT_PT:
3147 {
3148 VEC (btrace_pt_packet_s) *packets;
3149 unsigned int pkt;
3150
3151 packets = btinfo->maint.variant.pt.packets;
3152 for (pkt = begin; pkt < end; ++pkt)
3153 {
3154 const struct btrace_pt_packet *packet;
3155
3156 packet = VEC_index (btrace_pt_packet_s, packets, pkt);
3157
3158 printf_unfiltered ("%u\t", pkt);
3159 printf_unfiltered ("0x%" PRIx64 "\t", packet->offset);
3160
3161 if (packet->errcode == pte_ok)
3162 pt_print_packet (&packet->packet);
3163 else
3164 printf_unfiltered ("[error: %s]", pt_errstr (packet->errcode));
3165
3166 printf_unfiltered ("\n");
3167 }
3168
3169 btinfo->maint.variant.pt.packet_history.begin = begin;
3170 btinfo->maint.variant.pt.packet_history.end = end;
3171 }
3172 break;
3173 #endif /* defined (HAVE_LIBIPT) */
3174 }
3175 }
3176
3177 /* Read a number from an argument string. */
3178
3179 static unsigned int
3180 get_uint (const char **arg)
3181 {
3182 const char *begin, *pos;
3183 char *end;
3184 unsigned long number;
3185
3186 begin = *arg;
3187 pos = skip_spaces (begin);
3188
3189 if (!isdigit (*pos))
3190 error (_("Expected positive number, got: %s."), pos);
3191
3192 number = strtoul (pos, &end, 10);
3193 if (number > UINT_MAX)
3194 error (_("Number too big."));
3195
3196 *arg += (end - begin);
3197
3198 return (unsigned int) number;
3199 }
3200
3201 /* Read a context size from an argument string. */
3202
3203 static int
3204 get_context_size (const char **arg)
3205 {
3206 const char *pos = skip_spaces (*arg);
3207
3208 if (!isdigit (*pos))
3209 error (_("Expected positive number, got: %s."), pos);
3210
3211 char *end;
3212 long result = strtol (pos, &end, 10);
3213 *arg = end;
3214 return result;
3215 }
3216
3217 /* Complain about junk at the end of an argument string. */
3218
3219 static void
3220 no_chunk (const char *arg)
3221 {
3222 if (*arg != 0)
3223 error (_("Junk after argument: %s."), arg);
3224 }
3225
3226 /* The "maintenance btrace packet-history" command. */
3227
3228 static void
3229 maint_btrace_packet_history_cmd (const char *arg, int from_tty)
3230 {
3231 struct btrace_thread_info *btinfo;
3232 struct thread_info *tp;
3233 unsigned int size, begin, end, from, to;
3234
3235 tp = find_thread_ptid (inferior_ptid);
3236 if (tp == NULL)
3237 error (_("No thread."));
3238
3239 size = 10;
3240 btinfo = &tp->btrace;
3241
3242 btrace_maint_update_packets (btinfo, &begin, &end, &from, &to);
3243 if (begin == end)
3244 {
3245 printf_unfiltered (_("No trace.\n"));
3246 return;
3247 }
3248
3249 if (arg == NULL || *arg == 0 || strcmp (arg, "+") == 0)
3250 {
3251 from = to;
3252
3253 if (end - from < size)
3254 size = end - from;
3255 to = from + size;
3256 }
3257 else if (strcmp (arg, "-") == 0)
3258 {
3259 to = from;
3260
3261 if (to - begin < size)
3262 size = to - begin;
3263 from = to - size;
3264 }
3265 else
3266 {
3267 from = get_uint (&arg);
3268 if (end <= from)
3269 error (_("'%u' is out of range."), from);
3270
3271 arg = skip_spaces (arg);
3272 if (*arg == ',')
3273 {
3274 arg = skip_spaces (++arg);
3275
3276 if (*arg == '+')
3277 {
3278 arg += 1;
3279 size = get_context_size (&arg);
3280
3281 no_chunk (arg);
3282
3283 if (end - from < size)
3284 size = end - from;
3285 to = from + size;
3286 }
3287 else if (*arg == '-')
3288 {
3289 arg += 1;
3290 size = get_context_size (&arg);
3291
3292 no_chunk (arg);
3293
3294 /* Include the packet given as first argument. */
3295 from += 1;
3296 to = from;
3297
3298 if (to - begin < size)
3299 size = to - begin;
3300 from = to - size;
3301 }
3302 else
3303 {
3304 to = get_uint (&arg);
3305
3306 /* Include the packet at the second argument and silently
3307 truncate the range. */
3308 if (to < end)
3309 to += 1;
3310 else
3311 to = end;
3312
3313 no_chunk (arg);
3314 }
3315 }
3316 else
3317 {
3318 no_chunk (arg);
3319
3320 if (end - from < size)
3321 size = end - from;
3322 to = from + size;
3323 }
3324
3325 dont_repeat ();
3326 }
3327
3328 btrace_maint_print_packets (btinfo, from, to);
3329 }
3330
3331 /* The "maintenance btrace clear-packet-history" command. */
3332
3333 static void
3334 maint_btrace_clear_packet_history_cmd (const char *args, int from_tty)
3335 {
3336 struct btrace_thread_info *btinfo;
3337 struct thread_info *tp;
3338
3339 if (args != NULL && *args != 0)
3340 error (_("Invalid argument."));
3341
3342 tp = find_thread_ptid (inferior_ptid);
3343 if (tp == NULL)
3344 error (_("No thread."));
3345
3346 btinfo = &tp->btrace;
3347
3348 /* Must clear the maint data before - it depends on BTINFO->DATA. */
3349 btrace_maint_clear (btinfo);
3350 btrace_data_clear (&btinfo->data);
3351 }
3352
3353 /* The "maintenance btrace clear" command. */
3354
3355 static void
3356 maint_btrace_clear_cmd (const char *args, int from_tty)
3357 {
3358 struct thread_info *tp;
3359
3360 if (args != NULL && *args != 0)
3361 error (_("Invalid argument."));
3362
3363 tp = find_thread_ptid (inferior_ptid);
3364 if (tp == NULL)
3365 error (_("No thread."));
3366
3367 btrace_clear (tp);
3368 }
3369
3370 /* The "maintenance btrace" command. */
3371
3372 static void
3373 maint_btrace_cmd (const char *args, int from_tty)
3374 {
3375 help_list (maint_btrace_cmdlist, "maintenance btrace ", all_commands,
3376 gdb_stdout);
3377 }
3378
3379 /* The "maintenance set btrace" command. */
3380
3381 static void
3382 maint_btrace_set_cmd (const char *args, int from_tty)
3383 {
3384 help_list (maint_btrace_set_cmdlist, "maintenance set btrace ", all_commands,
3385 gdb_stdout);
3386 }
3387
3388 /* The "maintenance show btrace" command. */
3389
3390 static void
3391 maint_btrace_show_cmd (const char *args, int from_tty)
3392 {
3393 help_list (maint_btrace_show_cmdlist, "maintenance show btrace ",
3394 all_commands, gdb_stdout);
3395 }
3396
3397 /* The "maintenance set btrace pt" command. */
3398
3399 static void
3400 maint_btrace_pt_set_cmd (const char *args, int from_tty)
3401 {
3402 help_list (maint_btrace_pt_set_cmdlist, "maintenance set btrace pt ",
3403 all_commands, gdb_stdout);
3404 }
3405
3406 /* The "maintenance show btrace pt" command. */
3407
3408 static void
3409 maint_btrace_pt_show_cmd (const char *args, int from_tty)
3410 {
3411 help_list (maint_btrace_pt_show_cmdlist, "maintenance show btrace pt ",
3412 all_commands, gdb_stdout);
3413 }
3414
3415 /* The "maintenance info btrace" command. */
3416
3417 static void
3418 maint_info_btrace_cmd (const char *args, int from_tty)
3419 {
3420 struct btrace_thread_info *btinfo;
3421 struct thread_info *tp;
3422 const struct btrace_config *conf;
3423
3424 if (args != NULL && *args != 0)
3425 error (_("Invalid argument."));
3426
3427 tp = find_thread_ptid (inferior_ptid);
3428 if (tp == NULL)
3429 error (_("No thread."));
3430
3431 btinfo = &tp->btrace;
3432
3433 conf = btrace_conf (btinfo);
3434 if (conf == NULL)
3435 error (_("No btrace configuration."));
3436
3437 printf_unfiltered (_("Format: %s.\n"),
3438 btrace_format_string (conf->format));
3439
3440 switch (conf->format)
3441 {
3442 default:
3443 break;
3444
3445 case BTRACE_FORMAT_BTS:
3446 printf_unfiltered (_("Number of packets: %u.\n"),
3447 VEC_length (btrace_block_s,
3448 btinfo->data.variant.bts.blocks));
3449 break;
3450
3451 #if defined (HAVE_LIBIPT)
3452 case BTRACE_FORMAT_PT:
3453 {
3454 struct pt_version version;
3455
3456 version = pt_library_version ();
3457 printf_unfiltered (_("Version: %u.%u.%u%s.\n"), version.major,
3458 version.minor, version.build,
3459 version.ext != NULL ? version.ext : "");
3460
3461 btrace_maint_update_pt_packets (btinfo);
3462 printf_unfiltered (_("Number of packets: %u.\n"),
3463 VEC_length (btrace_pt_packet_s,
3464 btinfo->maint.variant.pt.packets));
3465 }
3466 break;
3467 #endif /* defined (HAVE_LIBIPT) */
3468 }
3469 }
3470
3471 /* The "maint show btrace pt skip-pad" show value function. */
3472
3473 static void
3474 show_maint_btrace_pt_skip_pad (struct ui_file *file, int from_tty,
3475 struct cmd_list_element *c,
3476 const char *value)
3477 {
3478 fprintf_filtered (file, _("Skip PAD packets is %s.\n"), value);
3479 }
3480
3481
3482 /* Initialize btrace maintenance commands. */
3483
3484 void
3485 _initialize_btrace (void)
3486 {
3487 add_cmd ("btrace", class_maintenance, maint_info_btrace_cmd,
3488 _("Info about branch tracing data."), &maintenanceinfolist);
3489
3490 add_prefix_cmd ("btrace", class_maintenance, maint_btrace_cmd,
3491 _("Branch tracing maintenance commands."),
3492 &maint_btrace_cmdlist, "maintenance btrace ",
3493 0, &maintenancelist);
3494
3495 add_prefix_cmd ("btrace", class_maintenance, maint_btrace_set_cmd, _("\
3496 Set branch tracing specific variables."),
3497 &maint_btrace_set_cmdlist, "maintenance set btrace ",
3498 0, &maintenance_set_cmdlist);
3499
3500 add_prefix_cmd ("pt", class_maintenance, maint_btrace_pt_set_cmd, _("\
3501 Set Intel Processor Trace specific variables."),
3502 &maint_btrace_pt_set_cmdlist, "maintenance set btrace pt ",
3503 0, &maint_btrace_set_cmdlist);
3504
3505 add_prefix_cmd ("btrace", class_maintenance, maint_btrace_show_cmd, _("\
3506 Show branch tracing specific variables."),
3507 &maint_btrace_show_cmdlist, "maintenance show btrace ",
3508 0, &maintenance_show_cmdlist);
3509
3510 add_prefix_cmd ("pt", class_maintenance, maint_btrace_pt_show_cmd, _("\
3511 Show Intel Processor Trace specific variables."),
3512 &maint_btrace_pt_show_cmdlist, "maintenance show btrace pt ",
3513 0, &maint_btrace_show_cmdlist);
3514
3515 add_setshow_boolean_cmd ("skip-pad", class_maintenance,
3516 &maint_btrace_pt_skip_pad, _("\
3517 Set whether PAD packets should be skipped in the btrace packet history."), _("\
3518 Show whether PAD packets should be skipped in the btrace packet history."),_("\
3519 When enabled, PAD packets are ignored in the btrace packet history."),
3520 NULL, show_maint_btrace_pt_skip_pad,
3521 &maint_btrace_pt_set_cmdlist,
3522 &maint_btrace_pt_show_cmdlist);
3523
3524 add_cmd ("packet-history", class_maintenance, maint_btrace_packet_history_cmd,
3525 _("Print the raw branch tracing data.\n\
3526 With no argument, print ten more packets after the previous ten-line print.\n\
3527 With '-' as argument print ten packets before a previous ten-line print.\n\
3528 One argument specifies the starting packet of a ten-line print.\n\
3529 Two arguments with comma between specify starting and ending packets to \
3530 print.\n\
3531 Preceded with '+'/'-' the second argument specifies the distance from the \
3532 first.\n"),
3533 &maint_btrace_cmdlist);
3534
3535 add_cmd ("clear-packet-history", class_maintenance,
3536 maint_btrace_clear_packet_history_cmd,
3537 _("Clears the branch tracing packet history.\n\
3538 Discards the raw branch tracing data but not the execution history data.\n\
3539 "),
3540 &maint_btrace_cmdlist);
3541
3542 add_cmd ("clear", class_maintenance, maint_btrace_clear_cmd,
3543 _("Clears the branch tracing data.\n\
3544 Discards the raw branch tracing data and the execution history data.\n\
3545 The next 'record' command will fetch the branch tracing data anew.\n\
3546 "),
3547 &maint_btrace_cmdlist);
3548
3549 }
ftrace_print_function_name
static const char * ftrace_print_function_name(const struct btrace_function *bfun)
Definition: btrace.c:72
target_gdbarch
struct gdbarch * target_gdbarch(void)
Definition: gdbarch.c:5467
maint_btrace_cmdlist
static struct cmd_list_element * maint_btrace_cmdlist
Definition: btrace.c:43
gdbarch
Definition: gdbarch.c:127
ftrace_print_insn_addr
static const char * ftrace_print_insn_addr(const struct btrace_insn *insn)
Definition: btrace.c:112
btrace_data::variant
union btrace_data::@24 variant
no_chunk
static void no_chunk(const char *arg)
Definition: btrace.c:3220
btrace_config::bts
struct btrace_config_bts bts
Definition: btrace-common.h:130
ftrace_compute_global_level_offset
static void ftrace_compute_global_level_offset(struct btrace_thread_info *btinfo)
Definition: btrace.c:728
btrace_insn_prev
unsigned int btrace_insn_prev(struct btrace_insn_iterator *it, unsigned int stride)
Definition: btrace.c:2478
symtab_to_filename_for_display
const char * symtab_to_filename_for_display(struct symtab *symtab)
Definition: source.c:1168
target_disable_btrace
void target_disable_btrace(struct btrace_target_info *btinfo)
Definition: target.c:3569
btrace_call_iterator
Definition: btrace.h:203
btrace_function::errcode
int errcode
Definition: btrace.h:164
btrace_conf_bts_attributes
static const struct gdb_xml_attribute btrace_conf_bts_attributes[]
Definition: btrace.c:2267
btrace_pt_config_cpu_attributes
static const struct gdb_xml_attribute btrace_pt_config_cpu_attributes[]
Definition: btrace.c:2152
find_thread_ptid
struct thread_info * find_thread_ptid(ptid_t ptid)
Definition: thread.c:514
maint_btrace_set_cmdlist
static struct cmd_list_element * maint_btrace_set_cmdlist
Definition: btrace.c:44
maint_btrace_cmd
static void maint_btrace_cmd(const char *args, int from_tty)
Definition: btrace.c:3373
BTRACE_INSN_RETURN
Definition: btrace.h:52
maint_btrace_show_cmdlist
static struct cmd_list_element * maint_btrace_show_cmdlist
Definition: btrace.c:45
BTRACE_READ_NEW
Definition: btrace-common.h:190
parse_xml_raw
static void parse_xml_raw(struct gdb_xml_parser *parser, const char *body_text, gdb_byte **pdata, size_t *psize)
Definition: btrace.c:2052
btrace_data_pt_config::cpu
struct btrace_cpu cpu
Definition: btrace-common.h:148
target_teardown_btrace
void target_teardown_btrace(struct btrace_target_info *btinfo)
Definition: target.c:3577
SYMBOL_PRINT_NAME
#define SYMBOL_PRINT_NAME(symbol)
Definition: symtab.h:542
btrace_cpu::family
unsigned short family
Definition: btrace-common.h:86
parse_xml_btrace
void parse_xml_btrace(struct btrace_data *btrace, const char *buffer)
Definition: btrace.c:2197
btrace_target_info
Definition: linux-btrace.h:85
MSYMBOL_LINKAGE_NAME
#define MSYMBOL_LINKAGE_NAME(symbol)
Definition: symtab.h:707
CORE_ADDR
bfd_vma CORE_ADDR
Definition: common-types.h:41
gdb_xml_value::value
void * value
Definition: xml-support.h:78
can_access_registers_ptid
bool can_access_registers_ptid(ptid_t ptid)
Definition: thread.c:1123
ftrace_new_gap
static struct btrace_function * ftrace_new_gap(struct btrace_thread_info *btinfo, int errcode, std::vector< unsigned int > &gaps)
Definition: btrace.c:518
RETURN_MASK_ALL
Definition: common-exceptions.h:44
get_context_size
static int get_context_size(const char **arg)
Definition: btrace.c:3204
get_thread_regcache
struct regcache * get_thread_regcache(ptid_t ptid)
Definition: regcache.c:434
ftrace_connect_backtrace
static void ftrace_connect_backtrace(struct btrace_thread_info *btinfo, struct btrace_function *lhs, struct btrace_function *rhs)
Definition: btrace.c:869
btrace_maint_packet_history::end
unsigned int end
Definition: btrace.h:278
btrace_block::begin
CORE_ADDR begin
Definition: btrace-common.h:42
xfree
void xfree(void *)
target_enable_btrace
struct btrace_target_info * target_enable_btrace(ptid_t ptid, const struct btrace_config *conf)
Definition: target.c:3561
maint_info_btrace_cmd
static void maint_info_btrace_cmd(const char *args, int from_tty)
Definition: btrace.c:3418
BTRACE_INSN_OTHER
Definition: btrace.h:46
btrace_function::sym
struct symbol * sym
Definition: btrace.h:143
cmd_list_element
Definition: cli-decode.h:46
INT_MAX
#define INT_MAX
Definition: defs.h:477
warning
void warning(const char *fmt,...)
Definition: errors.c:26
btrace_stitch_bts
static int btrace_stitch_bts(struct btrace_data_bts *btrace, struct thread_info *tp)
Definition: btrace.c:1674
regcache::regcache
regcache(gdbarch *gdbarch)
Definition: regcache.h:235
target_supports_btrace
int target_supports_btrace(enum btrace_format format)
Definition: target.c:3553
btrace_clear_history
static void btrace_clear_history(struct btrace_thread_info *btinfo)
Definition: btrace.c:1788
btrace_data_fini
void btrace_data_fini(struct btrace_data *data)
Definition: btrace-common.c:75
block_attributes
static const struct gdb_xml_attribute block_attributes[]
Definition: btrace.c:2146
btrace_thread_info::replay
struct btrace_insn_iterator * replay
Definition: btrace.h:356
maintenanceinfolist
struct cmd_list_element * maintenanceinfolist
Definition: cli-cmds.c:139
btrace_thread_info::call_history
struct btrace_call_history * call_history
Definition: btrace.h:351
ftrace_function_switched
static int ftrace_function_switched(const struct btrace_function *bfun, const struct minimal_symbol *mfun, const struct symbol *fun)
Definition: btrace.c:184
gdb_insn_length
int gdb_insn_length(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition: disasm.c:826
gdb_xml_parser
Definition: xml-support.c:68
btrace_stitch_trace
static int btrace_stitch_trace(struct btrace_data *btrace, struct thread_info *tp)
Definition: btrace.c:1763
btrace_config_pt::size
unsigned int size
Definition: btrace-common.h:114
parse_xml_btrace_block
static void parse_xml_btrace_block(struct gdb_xml_parser *parser, const struct gdb_xml_element *element, void *user_data, VEC(gdb_xml_value_s) *attributes)
Definition: btrace.c:2017
btrace_data::bts
struct btrace_data_bts bts
Definition: btrace-common.h:172
RETURN_MASK_ERROR
Definition: common-exceptions.h:43
btrace_clear
void btrace_clear(struct thread_info *tp)
Definition: btrace.c:1963
gdb_xml_value
Definition: xml-support.h:75
btrace_block::end
CORE_ADDR end
Definition: btrace-common.h:45
memset
void * memset(T *s, int c, size_t n)=delete
internal_error
void internal_error(const char *file, int line, const char *fmt,...)
Definition: errors.c:50
record_debug
unsigned int record_debug
Definition: record.c:33
maint_btrace_pt_set_cmdlist
static struct cmd_list_element * maint_btrace_pt_set_cmdlist
Definition: btrace.c:46
btrace_call_number
unsigned int btrace_call_number(const struct btrace_call_iterator *it)
Definition: btrace.c:2630
btrace_insn_class
btrace_insn_class
Definition: btrace.h:43
disasm.h
add_cmd
struct cmd_list_element * add_cmd(const char *name, enum command_class theclass, const char *doc, struct cmd_list_element **list)
Definition: cli-decode.c:262
btrace_call_iterator::btinfo
const struct btrace_thread_info * btinfo
Definition: btrace.h:206
btrace_insn_get_error
int btrace_insn_get_error(const struct btrace_insn_iterator *it)
Definition: btrace.c:2340
btrace.h
BTRACE_READ_DELTA
Definition: btrace-common.h:194
btrace_elements
static const struct gdb_xml_element btrace_elements[]
Definition: btrace.c:2186
CV_INTEL
Definition: btrace-common.h:75
VEC_safe_push
#define VEC_safe_push(T, V, O)
Definition: vec.h:276
VEC
#define VEC(T)
Definition: vec.h:414
btrace_maint_print_packets
static void btrace_maint_print_packets(struct btrace_thread_info *btinfo, unsigned int begin, unsigned int end)
Definition: btrace.c:3115
skip_spaces
char * skip_spaces(char *chp)
Definition: common-utils.c:337
cleanup
Definition: cleanups.c:38
btrace_call_history::begin
struct btrace_call_iterator begin
Definition: btrace.h:226
DEBUG_FTRACE
#define DEBUG_FTRACE(msg, args...)
Definition: btrace.c:66
_
#define _(String)
Definition: gdb_locale.h:35
btrace_maint_packet_history::begin
unsigned int begin
Definition: btrace.h:277
ui_file
Definition: ui-file.h:26
ftrace_fixup_level
static void ftrace_fixup_level(struct btrace_thread_info *btinfo, struct btrace_function *bfun, int adjustment)
Definition: btrace.c:708
btrace_thread_info::insn_history
struct btrace_insn_history * insn_history
Definition: btrace.h:348
btrace_call_cmp
int btrace_call_cmp(const struct btrace_call_iterator *lhs, const struct btrace_call_iterator *rhs)
Definition: btrace.c:2741
defs.h
parse_xml_btrace_conf_bts
static void parse_xml_btrace_conf_bts(struct gdb_xml_parser *parser, const struct gdb_xml_element *element, void *user_data, VEC(gdb_xml_value_s) *attributes)
Definition: btrace.c:2227
gdbarch_insn_is_jump
int gdbarch_insn_is_jump(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition: gdbarch.c:4887
maint_btrace_packet_history_cmd
static void maint_btrace_packet_history_cmd(const char *arg, int from_tty)
Definition: btrace.c:3229
btrace_insn_begin
void btrace_insn_begin(struct btrace_insn_iterator *it, const struct btrace_thread_info *btinfo)
Definition: btrace.c:2356
BTRACE_READ_ALL
Definition: btrace-common.h:187
RETURN_QUIT
Definition: common-exceptions.h:33
btrace_format
btrace_format
Definition: btrace-common.h:54
btrace_set_call_history
void btrace_set_call_history(struct btrace_thread_info *btinfo, const struct btrace_call_iterator *begin, const struct btrace_call_iterator *end)
Definition: btrace.c:2782
END_CATCH
#define END_CATCH
Definition: common-exceptions.h:259
btrace_disable
void btrace_disable(struct thread_info *tp)
Definition: btrace.c:1636
maintenance_set_cmdlist
struct cmd_list_element * maintenance_set_cmdlist
Definition: maint.c:634
ftrace_find_caller
static struct btrace_function * ftrace_find_caller(struct btrace_thread_info *btinfo, struct btrace_function *bfun, struct minimal_symbol *mfun, struct symbol *fun)
Definition: btrace.c:364
GDB_XML_AF_NONE
Definition: xml-support.h:106
maint_btrace_pt_show_cmd
static void maint_btrace_pt_show_cmd(const char *args, int from_tty)
Definition: btrace.c:3409
ftrace_connect_bfun
static void ftrace_connect_bfun(struct btrace_thread_info *btinfo, struct btrace_function *prev, struct btrace_function *next)
Definition: btrace.c:758
btrace_insn_history::end
struct btrace_insn_iterator end
Definition: btrace.h:218
symtab_to_fullname
const char * symtab_to_fullname(struct symtab *s)
Definition: source.c:1131
get_uint
static unsigned int get_uint(const char **arg)
Definition: btrace.c:3180
add_prefix_cmd
struct cmd_list_element * add_prefix_cmd(const char *name, enum command_class theclass, cmd_const_cfunc_ftype *fun, const char *doc, struct cmd_list_element **prefixlist, const char *prefixname, int allow_unknown, struct cmd_list_element **list)
Definition: cli-decode.c:367
target_read_code
int target_read_code(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition: target.c:1433
make_scoped_restore
scoped_restore_tmpl< T > make_scoped_restore(T *var)
Definition: scoped_restore.h:105
btrace_insn_iterator::btinfo
const struct btrace_thread_info * btinfo
Definition: btrace.h:193
btrace_insn_number
unsigned int btrace_insn_number(const struct btrace_insn_iterator *it)
Definition: btrace.c:2348
flags
mach_port_t kern_return_t mach_port_t msgports mach_port_t kern_return_t pid_t pid mach_port_t kern_return_t mach_port_t task mach_port_t kern_return_t int flags
Definition: gnu-nat.c:1891
btrace_cpu::vendor
enum btrace_cpu_vendor vendor
Definition: btrace-common.h:83
rsp-low.h
ftrace_classify_insn
static enum btrace_insn_class ftrace_classify_insn(struct gdbarch *gdbarch, CORE_ADDR pc)
Definition: btrace.c:659
TRY
#define TRY
Definition: common-exceptions.h:246
symtab.h
btrace_data_pt
Definition: btrace-common.h:152
MSYMBOL_PRINT_NAME
#define MSYMBOL_PRINT_NAME(symbol)
Definition: symtab.h:708
ftrace_print_filename
static const char * ftrace_print_filename(const struct btrace_function *bfun)
Definition: btrace.c:93
ftrace_find_call_by_number
static struct btrace_function * ftrace_find_call_by_number(struct btrace_thread_info *btinfo, unsigned int number)
Definition: btrace.c:159
BDE_PT_OVERFLOW
Definition: btrace.h:118
btrace_block
Definition: btrace-common.h:37
ftrace_update_function
static struct btrace_function * ftrace_update_function(struct btrace_thread_info *btinfo, CORE_ADDR pc)
Definition: btrace.c:546
GDB_XML_AF_OPTIONAL
Definition: xml-support.h:107
BDE_BTS_INSN_SIZE
Definition: btrace.h:105
btrace_compute_ftrace
static void btrace_compute_ftrace(struct thread_info *tp, struct btrace_data *btrace)
Definition: btrace.c:1524
btrace_data_bts
Definition: btrace-common.h:137
ftrace_call_num_insn
static unsigned int ftrace_call_num_insn(const struct btrace_function *bfun)
Definition: btrace.c:143
CATCH
#define CATCH(EXCEPTION, MASK)
Definition: common-exceptions.h:254
GDB_XML_EF_NONE
Definition: xml-support.h:127
ftrace_new_tailcall
static struct btrace_function * ftrace_new_tailcall(struct btrace_thread_info *btinfo, struct minimal_symbol *mfun, struct symbol *fun)
Definition: btrace.c:329
BFUN_UP_LINKS_TO_RET
Definition: btrace.h:90
btrace_teardown
void btrace_teardown(struct thread_info *tp)
Definition: btrace.c:1655
btrace_function::flags
btrace_function_flags flags
Definition: btrace.h:186
btrace_function::insn
std::vector< btrace_insn > insn
Definition: btrace.h:160
gdb_xml_parse_quick
int gdb_xml_parse_quick(const char *name, const char *dtd_name, const struct gdb_xml_element *elements, const char *document, void *user_data)
Definition: xml-support.c:647
xml_find_attribute
struct gdb_xml_value * xml_find_attribute(VEC(gdb_xml_value_s) *attributes, const char *name)
Definition: xml-support.c:231
make_cleanup_btrace_data
struct cleanup * make_cleanup_btrace_data(struct btrace_data *data)
Definition: btrace.c:2833
btrace_data_clear
void btrace_data_clear(struct btrace_data *data)
Definition: btrace-common.c:118
btrace_format_string
const char * btrace_format_string(enum btrace_format format)
Definition: btrace-common.c:27
btrace_ends_with_single_insn
static bool btrace_ends_with_single_insn(const struct btrace_thread_info *btinfo)
Definition: btrace.c:2602
UINT_MAX
#define UINT_MAX
Definition: defs.h:473
btrace_insn_end
void btrace_insn_end(struct btrace_insn_iterator *it, const struct btrace_thread_info *btinfo)
Definition: btrace.c:2370
fprintf_filtered
void fprintf_filtered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2008
find_pc_function
struct symbol * find_pc_function(CORE_ADDR pc)
Definition: blockframe.c:150
regcache.h
bound_minimal_symbol
Definition: minsyms.h:29
btrace_thread_info::data
struct btrace_data data
Definition: btrace.h:329
cli-utils.h
btrace_data::format
enum btrace_format format
Definition: btrace-common.h:167
btrace_call_prev
unsigned int btrace_call_prev(struct btrace_call_iterator *it, unsigned int stride)
Definition: btrace.c:2707
btrace_maint_info::packet_history
struct btrace_maint_packet_history packet_history
Definition: btrace.h:295
BTRACE_INSN_FLAG_SPECULATIVE
Definition: btrace.h:62
btrace_thread_info::maint
struct btrace_maint_info maint
Definition: btrace.h:362
VEC_length
#define VEC_length(T, V)
Definition: vec.h:140
gdbthread.h
inferior.h
make_cleanup
struct cleanup * make_cleanup(make_cleanup_ftype *function, void *arg)
Definition: cleanups.c:116
btrace_maint_clear
static void btrace_maint_clear(struct btrace_thread_info *btinfo)
Definition: btrace.c:1802
do_btrace_data_cleanup
static void do_btrace_data_cleanup(void *arg)
Definition: btrace.c:2825
BTRACE_FORMAT_NONE
Definition: btrace-common.h:57
version
const char version[]
Definition: version.c:2
btrace_insn_iterator::insn_index
unsigned int insn_index
Definition: btrace.h:199
scoped_restore_base
Definition: scoped_restore.h:24
btrace_call_iterator::index
unsigned int index
Definition: btrace.h:209
ftrace_update_caller
static void ftrace_update_caller(struct btrace_function *bfun, struct btrace_function *caller, enum btrace_function_flag flags)
Definition: btrace.c:262
btrace_children
static const struct gdb_xml_element btrace_children[]
Definition: btrace.c:2178
btrace_thread_info::target
struct btrace_target_info * target
Definition: btrace.h:326
parse_xml_btrace_pt
static void parse_xml_btrace_pt(struct gdb_xml_parser *parser, const struct gdb_xml_element *element, void *user_data, VEC(gdb_xml_value_s) *attributes)
Definition: btrace.c:2133
ftrace_get_caller
static struct btrace_function * ftrace_get_caller(struct btrace_thread_info *btinfo, struct btrace_function *bfun)
Definition: btrace.c:349
btrace_call_end
void btrace_call_end(struct btrace_call_iterator *it, const struct btrace_thread_info *btinfo)
Definition: btrace.c:2658
btrace_cpu::model
unsigned char model
Definition: btrace-common.h:89
xml-support.h
VEC_index
#define VEC_index(T, V, I)
Definition: vec.h:167
btrace_data::pt
struct btrace_data_pt pt
Definition: btrace-common.h:175
maint_btrace_pt_show_cmdlist
static struct cmd_list_element * maint_btrace_pt_show_cmdlist
Definition: btrace.c:47
btrace_decode_error
const char * btrace_decode_error(enum btrace_format format, int errcode)
Definition: btrace.c:1829
maint_btrace_set_cmd
static void maint_btrace_set_cmd(const char *args, int from_tty)
Definition: btrace.c:3382
SYMBOL_LINKAGE_NAME
#define SYMBOL_LINKAGE_NAME(symbol)
Definition: symtab.h:523
status
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t int status
Definition: gnu-nat.c:1822
print_thread_id
const char * print_thread_id(struct thread_info *thr)
Definition: thread.c:1602
BTRACE_FORMAT_PT
Definition: btrace-common.h:64
btrace_add_pc
static void btrace_add_pc(struct thread_info *tp)
Definition: btrace.c:1546
VEC_pop
#define VEC_pop(T, V)
Definition: vec.h:286
BDE_BTS_OVERFLOW
Definition: btrace.h:102
btrace_conf
const struct btrace_config * btrace_conf(const struct btrace_thread_info *btinfo)
Definition: btrace.c:1625
btrace_insn_get
const struct btrace_insn * btrace_insn_get(const struct btrace_insn_iterator *it)
Definition: btrace.c:2317
btrace_insn_iterator::call_index
unsigned int call_index
Definition: btrace.h:196
GDB_XML_EF_REPEATABLE
Definition: xml-support.h:129
btrace_function
Definition: btrace.h:132
thread_info::ptid
ptid_t ptid
Definition: gdbthread.h:219
btrace_pt_config_children
static const struct gdb_xml_element btrace_pt_config_children[]
Definition: btrace.c:2160
btrace_conf_elements
static const struct gdb_xml_element btrace_conf_elements[]
Definition: btrace.c:2285
btrace_function::msym
struct minimal_symbol * msym
Definition: btrace.h:142
parse_xml_btrace_conf_pt
static void parse_xml_btrace_conf_pt(struct gdb_xml_parser *parser, const struct gdb_xml_element *element, void *user_data, VEC(gdb_xml_value_s) *attributes)
Definition: btrace.c:2246
printf_unfiltered
void printf_unfiltered(const char *format,...)
Definition: utils.c:2056
btrace_thread_info::ngaps
unsigned int ngaps
Definition: btrace.h:342
btrace_maint_info
Definition: btrace.h:284
fromhex
int fromhex(int a)
Definition: rsp-low.c:26
btrace_finalize_ftrace
static void btrace_finalize_ftrace(struct thread_info *tp, std::vector< unsigned int > &gaps)
Definition: btrace.c:1514
xmalloc
void * xmalloc(YYSIZE_T)
gdb_xml_element
Definition: xml-support.h:165
ftrace_new_function
static struct btrace_function * ftrace_new_function(struct btrace_thread_info *btinfo, struct minimal_symbol *mfun, struct symbol *fun)
Definition: btrace.c:233
btrace_function::insn_offset
unsigned int insn_offset
Definition: btrace.h:170
show_maint_btrace_pt_skip_pad
static void show_maint_btrace_pt_skip_pad(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: btrace.c:3474
target_read_btrace
enum btrace_error target_read_btrace(struct btrace_data *btrace, struct btrace_target_info *btinfo, enum btrace_read_type type)
Definition: target.c:3585
btrace_data_empty
int btrace_data_empty(struct btrace_data *data)
Definition: btrace-common.c:98
btrace_insn::pc
CORE_ADDR pc
Definition: btrace.h:72
gdb_xml_error
void gdb_xml_error(struct gdb_xml_parser *parser, const char *format,...)
Definition: xml-support.c:219
VEC_last
#define VEC_last(T, V)
Definition: vec.h:158
maint_btrace_pt_skip_pad
static int maint_btrace_pt_skip_pad
Definition: btrace.c:50
gdb_assert
#define gdb_assert(expr)
Definition: gdb_assert.h:32
block
Definition: block.h:60
VEC_empty
#define VEC_empty(T, V)
Definition: vec.h:148
value
Definition: value.c:169
btrace_maint_info::variant
union btrace_maint_info::@16 variant
btrace_is_empty
int btrace_is_empty(struct thread_info *tp)
Definition: btrace.c:2806
btrace_insn_next
unsigned int btrace_insn_next(struct btrace_insn_iterator *it, unsigned int stride)
Definition: btrace.c:2396
btrace_insn::iclass
enum btrace_insn_class iclass
Definition: btrace.h:78
CV_UNKNOWN
Definition: btrace-common.h:72
btrace_insn_history::begin
struct btrace_insn_iterator begin
Definition: btrace.h:217
btrace_attributes
static const struct gdb_xml_attribute btrace_attributes[]
Definition: btrace.c:2173
btrace_config::pt
struct btrace_config_pt pt
Definition: btrace-common.h:133
ftrace_new_call
static struct btrace_function * ftrace_new_call(struct btrace_thread_info *btinfo, struct minimal_symbol *mfun, struct symbol *fun)
Definition: btrace.c:309
objfile
Definition: objfiles.h:286
throw_exception
void throw_exception(struct gdb_exception exception)
Definition: common-exceptions.c:312
_initialize_btrace
void _initialize_btrace(void)
Definition: btrace.c:3485
btrace_insn::flags
btrace_insn_flags flags
Definition: btrace.h:81
gdb_byte
bfd_byte gdb_byte
Definition: common-types.h:38
btrace_fetch
void btrace_fetch(struct thread_info *tp)
Definition: btrace.c:1878
btrace_call_next
unsigned int btrace_call_next(struct btrace_call_iterator *it, unsigned int stride)
Definition: btrace.c:2671
btrace_thread_info
Definition: btrace.h:319
help_list
void help_list(struct cmd_list_element *list, const char *cmdtype, enum command_class theclass, struct ui_file *stream)
Definition: cli-decode.c:1071
BTRACE_FORMAT_BTS
Definition: btrace-common.h:61
discard_cleanups
void discard_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:212
btrace_config
Definition: btrace-common.h:124
btrace_function::next
unsigned int next
Definition: btrace.h:150
btrace_enable
void btrace_enable(struct thread_info *tp, const struct btrace_config *conf)
Definition: btrace.c:1575
btrace_config_bts::size
unsigned int size
Definition: btrace-common.h:103
source.h
btrace_maint_info::bts
struct btrace_maint_info::@16::@17 bts
record.h
lookup_minimal_symbol_by_pc
struct bound_minimal_symbol lookup_minimal_symbol_by_pc(CORE_ADDR pc)
Definition: minsyms.c:928
btrace_cpu_vendor
btrace_cpu_vendor
Definition: btrace-common.h:69
ALL_NON_EXITED_THREADS
#define ALL_NON_EXITED_THREADS(T)
Definition: gdbthread.h:490
maint_btrace_clear_packet_history_cmd
static void maint_btrace_clear_packet_history_cmd(const char *args, int from_tty)
Definition: btrace.c:3334
btrace_insn_cmp
int btrace_insn_cmp(const struct btrace_insn_iterator *lhs, const struct btrace_insn_iterator *rhs)
Definition: btrace.c:2536
btrace_call_begin
void btrace_call_begin(struct btrace_call_iterator *it, const struct btrace_thread_info *btinfo)
Definition: btrace.c:2645
XCNEW
#define XCNEW(T)
Definition: poison.h:121
btrace_compute_ftrace_pt
static void btrace_compute_ftrace_pt(struct thread_info *tp, const struct btrace_data_pt *btrace, std::vector< unsigned int > &gaps)
Definition: btrace.c:1478
gdbarch_insn_is_call
int gdbarch_insn_is_call(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition: gdbarch.c:4853
btrace_pt_children
static const struct gdb_xml_element btrace_pt_children[]
Definition: btrace.c:2166
btrace_compute_ftrace_bts
static void btrace_compute_ftrace_bts(struct thread_info *tp, const struct btrace_data_bts *btrace, std::vector< unsigned int > &gaps)
Definition: btrace.c:1034
btrace_conf_attributes
static const struct gdb_xml_attribute btrace_conf_attributes[]
Definition: btrace.c:2280
btrace_free_objfile
void btrace_free_objfile(struct objfile *objfile)
Definition: btrace.c:1988
check_xml_btrace_version
static void check_xml_btrace_version(struct gdb_xml_parser *parser, const struct gdb_xml_element *element, void *user_data, VEC(gdb_xml_value_s) *attributes)
Definition: btrace.c:2003
regcache_read_pc
CORE_ADDR regcache_read_pc(struct regcache *regcache)
Definition: regcache.c:1229
inferior_ptid
ptid_t inferior_ptid
Definition: infcmd.c:94
btrace_data_pt::config
struct btrace_data_pt_config config
Definition: btrace-common.h:155
bound_minimal_symbol::minsym
struct minimal_symbol * minsym
Definition: minsyms.h:34
btrace_bridge_gaps
static void btrace_bridge_gaps(struct thread_info *tp, std::vector< unsigned int > &gaps)
Definition: btrace.c:957
BDE_PT_USER_QUIT
Definition: btrace.h:112
parse_xml_btrace_pt_config_cpu
static void parse_xml_btrace_pt_config_cpu(struct gdb_xml_parser *parser, const struct gdb_xml_element *element, void *user_data, VEC(gdb_xml_value_s) *attributes)
Definition: btrace.c:2092
target_pid_to_str
const char * target_pid_to_str(ptid_t ptid)
Definition: target.c:2194
btrace_function::prev
unsigned int prev
Definition: btrace.h:149
ftrace_match_backtrace
static int ftrace_match_backtrace(struct btrace_thread_info *btinfo, struct btrace_function *lhs, struct btrace_function *rhs)
Definition: btrace.c:686
offset
int offset
Definition: agent.c:65
add_setshow_boolean_cmd
void add_setshow_boolean_cmd(const char *name, enum command_class theclass, int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_const_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:569
thread_info::btrace
Definition: gdbthread.h:357
buffer
Definition: buffer.h:23
maint_btrace_clear_cmd
static void maint_btrace_clear_cmd(const char *args, int from_tty)
Definition: btrace.c:3356
btrace_data_pt::data
gdb_byte * data
Definition: btrace-common.h:158
btrace_call_get
const struct btrace_function * btrace_call_get(const struct btrace_call_iterator *it)
Definition: btrace.c:2619
btrace_data_pt::size
size_t size
Definition: btrace-common.h:161
target.h
BTRACE_INSN_CALL
Definition: btrace.h:49
btrace_thread_info::level
int level
Definition: btrace.h:339
ftrace_update_insns
static void ftrace_update_insns(struct btrace_function *bfun, const btrace_insn &insn)
Definition: btrace.c:648
ftrace_new_return
static struct btrace_function * ftrace_new_return(struct btrace_thread_info *btinfo, struct minimal_symbol *mfun, struct symbol *fun)
Definition: btrace.c:412
parse_xml_btrace_conf
void parse_xml_btrace_conf(struct btrace_config *conf, const char *xml)
Definition: btrace.c:2296
maint_btrace_show_cmd
static void maint_btrace_show_cmd(const char *args, int from_tty)
Definition: btrace.c:3391
btrace_is_replaying
int btrace_is_replaying(struct thread_info *tp)
Definition: btrace.c:2798
btrace_insn_history
Definition: btrace.h:213
gdb_xml_parse_attr_ulongest
gdb_xml_attribute_handler gdb_xml_parse_attr_ulongest
btrace_thread_info::functions
std::vector< btrace_function > functions
Definition: btrace.h:334
btrace_cpu::stepping
unsigned char stepping
Definition: btrace-common.h:92
ULONGEST
unsigned long long ULONGEST
Definition: common-types.h:53
regcache
Definition: regcache.h:232
btrace_insn
Definition: btrace.h:69
gdb_xml_attribute
Definition: xml-support.h:114
ftrace_find_call
static struct btrace_function * ftrace_find_call(struct btrace_thread_info *btinfo, struct btrace_function *bfun)
Definition: btrace.c:388
btrace_insn::size
gdb_byte size
Definition: btrace.h:75
symbol
Definition: symtab.h:1049
maintenancelist
struct cmd_list_element * maintenancelist
Definition: cli-cmds.c:135
GDB_XML_EF_OPTIONAL
Definition: xml-support.h:128
all_commands
Definition: command.h:39
btrace_set_insn_history
void btrace_set_insn_history(struct btrace_thread_info *btinfo, const struct btrace_insn_iterator *begin, const struct btrace_insn_iterator *end)
Definition: btrace.c:2768
btrace_find_insn_by_number
int btrace_find_insn_by_number(struct btrace_insn_iterator *it, const struct btrace_thread_info *btinfo, unsigned int number)
Definition: btrace.c:2550
btrace_config::format
enum btrace_format format
Definition: btrace-common.h:127
minimal_symbol
Definition: symtab.h:623
btrace_function_flag
btrace_function_flag
Definition: btrace.h:85
BDE_PT_DISABLED
Definition: btrace.h:115
btrace_insn_iterator
Definition: btrace.h:190
btrace_function::number
unsigned int number
Definition: btrace.h:175
dont_repeat
void dont_repeat(void)
Definition: top.c:695
reinit_frame_cache
void reinit_frame_cache(void)
Definition: frame.c:1809
class_maintenance
Definition: command.h:43
get_pc_function_start
CORE_ADDR get_pc_function_start(CORE_ADDR pc)
Definition: blockframe.c:86
BFUN_UP_LINKS_TO_TAILCALL
Definition: btrace.h:94
ftrace_fixup_caller
static void ftrace_fixup_caller(struct btrace_thread_info *btinfo, struct btrace_function *bfun, struct btrace_function *caller, enum btrace_function_flag flags)
Definition: btrace.c:279
btrace_call_history
Definition: btrace.h:222
btrace_data_init
void btrace_data_init(struct btrace_data *data)
Definition: btrace-common.c:67
ftrace_debug
static void ftrace_debug(const struct btrace_function *bfun, const char *prefix)
Definition: btrace.c:123
btrace_maint_update_packets
static void btrace_maint_update_packets(struct btrace_thread_info *btinfo, unsigned int *begin, unsigned int *end, unsigned int *from, unsigned int *to)
Definition: btrace.c:3076
btrace_call_history::end
struct btrace_call_iterator end
Definition: btrace.h:227
symbol_symtab
struct symtab * symbol_symtab(const struct symbol *symbol)
Definition: symtab.c:5803
btrace_compute_ftrace_1
static void btrace_compute_ftrace_1(struct thread_info *tp, struct btrace_data *btrace, std::vector< unsigned int > &gaps)
Definition: btrace.c:1491
btrace_find_call_by_number
int btrace_find_call_by_number(struct btrace_call_iterator *it, const struct btrace_thread_info *btinfo, unsigned int number)
Definition: btrace.c:2751
core_addr_to_string_nz
const char * core_addr_to_string_nz(const CORE_ADDR addr)
Definition: print-utils.c:307
maintenance_show_cmdlist
struct cmd_list_element * maintenance_show_cmdlist
Definition: maint.c:635
gdbcmd.h
btrace_conf_children
static const struct gdb_xml_element btrace_conf_children[]
Definition: btrace.c:2272
target_btrace_conf
const struct btrace_config * target_btrace_conf(const struct btrace_target_info *btinfo)
Definition: target.c:3595
DEBUG
#define DEBUG(msg, args...)
Definition: btrace.c:57
thread_info
Definition: gdbthread.h:205
error
void error(const char *fmt,...)
Definition: errors.c:38
size
size_t size
Definition: go32-nat.c:242
ftrace_new_switch
static struct btrace_function * ftrace_new_switch(struct btrace_thread_info *btinfo, struct minimal_symbol *mfun, struct symbol *fun)
Definition: btrace.c:494
btrace_function::level
int level
Definition: btrace.h:183
maint_btrace_pt_set_cmd
static void maint_btrace_pt_set_cmd(const char *args, int from_tty)
Definition: btrace.c:3400
do_cleanups
void do_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:174
parse_xml_btrace_pt_raw
static void parse_xml_btrace_pt_raw(struct gdb_xml_parser *parser, const struct gdb_xml_element *element, void *user_data, const char *body_text)
Definition: btrace.c:2119
gdbarch_insn_is_ret
int gdbarch_insn_is_ret(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition: gdbarch.c:4870
btrace_data_append
int btrace_data_append(struct btrace_data *dst, const struct btrace_data *src)
Definition: btrace-common.c:127
btrace_conf_pt_attributes
static const struct gdb_xml_attribute btrace_conf_pt_attributes[]
Definition: btrace.c:2262
btrace_function::up
unsigned int up
Definition: btrace.h:155
gdb_stdout
#define gdb_stdout
Definition: utils.h:340
btrace_data
Definition: btrace-common.h:165
ftrace_bridge_gap
static int ftrace_bridge_gap(struct btrace_thread_info *btinfo, struct btrace_function *lhs, struct btrace_function *rhs, int min_matches)
Definition: btrace.c:897
BTRACE_INSN_JUMP
Definition: btrace.h:55