Loading...
1// SPDX-License-Identifier: GPL-2.0
2#include "../browser.h"
3#include "../helpline.h"
4#include "../ui.h"
5#include "../../util/annotate.h"
6#include "../../util/debug.h"
7#include "../../util/dso.h"
8#include "../../util/hist.h"
9#include "../../util/sort.h"
10#include "../../util/map.h"
11#include "../../util/mutex.h"
12#include "../../util/symbol.h"
13#include "../../util/evsel.h"
14#include "../../util/evlist.h"
15#include <inttypes.h>
16#include <linux/kernel.h>
17#include <linux/string.h>
18#include <linux/zalloc.h>
19#include <sys/ttydefaults.h>
20#include <asm/bug.h>
21
22struct arch;
23
24struct annotate_browser {
25 struct ui_browser b;
26 struct rb_root entries;
27 struct rb_node *curr_hot;
28 struct annotation_line *selection;
29 struct arch *arch;
30 bool searching_backwards;
31 char search_bf[128];
32};
33
34static inline struct annotation *browser__annotation(struct ui_browser *browser)
35{
36 struct map_symbol *ms = browser->priv;
37 return symbol__annotation(ms->sym);
38}
39
40static bool disasm_line__filter(struct ui_browser *browser __maybe_unused, void *entry)
41{
42 struct annotation_line *al = list_entry(entry, struct annotation_line, node);
43 return annotation_line__filter(al);
44}
45
46static int ui_browser__jumps_percent_color(struct ui_browser *browser, int nr, bool current)
47{
48 struct annotation *notes = browser__annotation(browser);
49
50 if (current && (!browser->use_navkeypressed || browser->navkeypressed))
51 return HE_COLORSET_SELECTED;
52 if (nr == notes->src->max_jump_sources)
53 return HE_COLORSET_TOP;
54 if (nr > 1)
55 return HE_COLORSET_MEDIUM;
56 return HE_COLORSET_NORMAL;
57}
58
59static int ui_browser__set_jumps_percent_color(void *browser, int nr, bool current)
60{
61 int color = ui_browser__jumps_percent_color(browser, nr, current);
62 return ui_browser__set_color(browser, color);
63}
64
65static int annotate_browser__set_color(void *browser, int color)
66{
67 return ui_browser__set_color(browser, color);
68}
69
70static void annotate_browser__write_graph(void *browser, int graph)
71{
72 ui_browser__write_graph(browser, graph);
73}
74
75static void annotate_browser__set_percent_color(void *browser, double percent, bool current)
76{
77 ui_browser__set_percent_color(browser, percent, current);
78}
79
80static void annotate_browser__printf(void *browser, const char *fmt, ...)
81{
82 va_list args;
83
84 va_start(args, fmt);
85 ui_browser__vprintf(browser, fmt, args);
86 va_end(args);
87}
88
89static void annotate_browser__write(struct ui_browser *browser, void *entry, int row)
90{
91 struct annotate_browser *ab = container_of(browser, struct annotate_browser, b);
92 struct annotation *notes = browser__annotation(browser);
93 struct annotation_line *al = list_entry(entry, struct annotation_line, node);
94 const bool is_current_entry = ui_browser__is_current_entry(browser, row);
95 struct annotation_write_ops ops = {
96 .first_line = row == 0,
97 .current_entry = is_current_entry,
98 .change_color = (!annotate_opts.hide_src_code &&
99 (!is_current_entry ||
100 (browser->use_navkeypressed &&
101 !browser->navkeypressed))),
102 .width = browser->width,
103 .obj = browser,
104 .set_color = annotate_browser__set_color,
105 .set_percent_color = annotate_browser__set_percent_color,
106 .set_jumps_percent_color = ui_browser__set_jumps_percent_color,
107 .printf = annotate_browser__printf,
108 .write_graph = annotate_browser__write_graph,
109 };
110
111 /* The scroll bar isn't being used */
112 if (!browser->navkeypressed)
113 ops.width += 1;
114
115 annotation_line__write(al, notes, &ops);
116
117 if (ops.current_entry)
118 ab->selection = al;
119}
120
121static int is_fused(struct annotate_browser *ab, struct disasm_line *cursor)
122{
123 struct disasm_line *pos = list_prev_entry(cursor, al.node);
124 const char *name;
125 int diff = 1;
126
127 while (pos && pos->al.offset == -1) {
128 pos = list_prev_entry(pos, al.node);
129 if (!annotate_opts.hide_src_code)
130 diff++;
131 }
132
133 if (!pos)
134 return 0;
135
136 if (ins__is_lock(&pos->ins))
137 name = pos->ops.locked.ins.name;
138 else
139 name = pos->ins.name;
140
141 if (!name || !cursor->ins.name)
142 return 0;
143
144 if (ins__is_fused(ab->arch, name, cursor->ins.name))
145 return diff;
146 return 0;
147}
148
149static void annotate_browser__draw_current_jump(struct ui_browser *browser)
150{
151 struct annotate_browser *ab = container_of(browser, struct annotate_browser, b);
152 struct disasm_line *cursor = disasm_line(ab->selection);
153 struct annotation_line *target;
154 unsigned int from, to;
155 struct map_symbol *ms = ab->b.priv;
156 struct symbol *sym = ms->sym;
157 struct annotation *notes = symbol__annotation(sym);
158 u8 pcnt_width = annotation__pcnt_width(notes);
159 u8 cntr_width = annotation__br_cntr_width();
160 int width;
161 int diff = 0;
162
163 /* PLT symbols contain external offsets */
164 if (strstr(sym->name, "@plt"))
165 return;
166
167 if (!disasm_line__is_valid_local_jump(cursor, sym))
168 return;
169
170 /*
171 * This first was seen with a gcc function, _cpp_lex_token, that
172 * has the usual jumps:
173 *
174 * │1159e6c: ↓ jne 115aa32 <_cpp_lex_token@@Base+0xf92>
175 *
176 * I.e. jumps to a label inside that function (_cpp_lex_token), and
177 * those works, but also this kind:
178 *
179 * │1159e8b: ↓ jne c469be <cpp_named_operator2name@@Base+0xa72>
180 *
181 * I.e. jumps to another function, outside _cpp_lex_token, which
182 * are not being correctly handled generating as a side effect references
183 * to ab->offset[] entries that are set to NULL, so to make this code
184 * more robust, check that here.
185 *
186 * A proper fix for will be put in place, looking at the function
187 * name right after the '<' token and probably treating this like a
188 * 'call' instruction.
189 */
190 target = annotated_source__get_line(notes->src, cursor->ops.target.offset);
191 if (target == NULL) {
192 ui_helpline__printf("WARN: jump target inconsistency, press 'o', notes->offsets[%#x] = NULL\n",
193 cursor->ops.target.offset);
194 return;
195 }
196
197 if (annotate_opts.hide_src_code) {
198 from = cursor->al.idx_asm;
199 to = target->idx_asm;
200 } else {
201 from = (u64)cursor->al.idx;
202 to = (u64)target->idx;
203 }
204
205 width = annotation__cycles_width(notes);
206
207 ui_browser__set_color(browser, HE_COLORSET_JUMP_ARROWS);
208 __ui_browser__line_arrow(browser,
209 pcnt_width + 2 + notes->src->widths.addr + width + cntr_width,
210 from, to);
211
212 diff = is_fused(ab, cursor);
213 if (diff > 0) {
214 ui_browser__mark_fused(browser,
215 pcnt_width + 3 + notes->src->widths.addr + width + cntr_width,
216 from - diff, diff, to > from);
217 }
218}
219
220static unsigned int annotate_browser__refresh(struct ui_browser *browser)
221{
222 struct annotation *notes = browser__annotation(browser);
223 int ret = ui_browser__list_head_refresh(browser);
224 int pcnt_width = annotation__pcnt_width(notes);
225
226 if (annotate_opts.jump_arrows)
227 annotate_browser__draw_current_jump(browser);
228
229 ui_browser__set_color(browser, HE_COLORSET_NORMAL);
230 __ui_browser__vline(browser, pcnt_width, 0, browser->rows - 1);
231 return ret;
232}
233
234static double disasm__cmp(struct annotation_line *a, struct annotation_line *b,
235 int percent_type)
236{
237 int i;
238
239 for (i = 0; i < a->data_nr; i++) {
240 if (a->data[i].percent[percent_type] == b->data[i].percent[percent_type])
241 continue;
242 return a->data[i].percent[percent_type] -
243 b->data[i].percent[percent_type];
244 }
245 return 0;
246}
247
248static void disasm_rb_tree__insert(struct annotate_browser *browser,
249 struct annotation_line *al)
250{
251 struct rb_root *root = &browser->entries;
252 struct rb_node **p = &root->rb_node;
253 struct rb_node *parent = NULL;
254 struct annotation_line *l;
255
256 while (*p != NULL) {
257 parent = *p;
258 l = rb_entry(parent, struct annotation_line, rb_node);
259
260 if (disasm__cmp(al, l, annotate_opts.percent_type) < 0)
261 p = &(*p)->rb_left;
262 else
263 p = &(*p)->rb_right;
264 }
265 rb_link_node(&al->rb_node, parent, p);
266 rb_insert_color(&al->rb_node, root);
267}
268
269static void annotate_browser__set_top(struct annotate_browser *browser,
270 struct annotation_line *pos, u32 idx)
271{
272 unsigned back;
273
274 ui_browser__refresh_dimensions(&browser->b);
275 back = browser->b.height / 2;
276 browser->b.top_idx = browser->b.index = idx;
277
278 while (browser->b.top_idx != 0 && back != 0) {
279 pos = list_entry(pos->node.prev, struct annotation_line, node);
280
281 if (annotation_line__filter(pos))
282 continue;
283
284 --browser->b.top_idx;
285 --back;
286 }
287
288 browser->b.top = pos;
289 browser->b.navkeypressed = true;
290}
291
292static void annotate_browser__set_rb_top(struct annotate_browser *browser,
293 struct rb_node *nd)
294{
295 struct annotation_line * pos = rb_entry(nd, struct annotation_line, rb_node);
296 u32 idx = pos->idx;
297
298 if (annotate_opts.hide_src_code)
299 idx = pos->idx_asm;
300 annotate_browser__set_top(browser, pos, idx);
301 browser->curr_hot = nd;
302}
303
304static void annotate_browser__calc_percent(struct annotate_browser *browser,
305 struct evsel *evsel)
306{
307 struct map_symbol *ms = browser->b.priv;
308 struct symbol *sym = ms->sym;
309 struct annotation *notes = symbol__annotation(sym);
310 struct disasm_line *pos;
311
312 browser->entries = RB_ROOT;
313
314 annotation__lock(notes);
315
316 symbol__calc_percent(sym, evsel);
317
318 list_for_each_entry(pos, ¬es->src->source, al.node) {
319 double max_percent = 0.0;
320 int i;
321
322 if (pos->al.offset == -1) {
323 RB_CLEAR_NODE(&pos->al.rb_node);
324 continue;
325 }
326
327 for (i = 0; i < pos->al.data_nr; i++) {
328 double percent;
329
330 percent = annotation_data__percent(&pos->al.data[i],
331 annotate_opts.percent_type);
332
333 if (max_percent < percent)
334 max_percent = percent;
335 }
336
337 if (max_percent < 0.01 && (!pos->al.cycles || pos->al.cycles->ipc == 0)) {
338 RB_CLEAR_NODE(&pos->al.rb_node);
339 continue;
340 }
341 disasm_rb_tree__insert(browser, &pos->al);
342 }
343 annotation__unlock(notes);
344
345 browser->curr_hot = rb_last(&browser->entries);
346}
347
348static struct annotation_line *annotate_browser__find_next_asm_line(
349 struct annotate_browser *browser,
350 struct annotation_line *al)
351{
352 struct annotation_line *it = al;
353
354 /* find next asm line */
355 list_for_each_entry_continue(it, browser->b.entries, node) {
356 if (it->idx_asm >= 0)
357 return it;
358 }
359
360 /* no asm line found forwards, try backwards */
361 it = al;
362 list_for_each_entry_continue_reverse(it, browser->b.entries, node) {
363 if (it->idx_asm >= 0)
364 return it;
365 }
366
367 /* There are no asm lines */
368 return NULL;
369}
370
371static bool annotate_browser__toggle_source(struct annotate_browser *browser)
372{
373 struct annotation *notes = browser__annotation(&browser->b);
374 struct annotation_line *al;
375 off_t offset = browser->b.index - browser->b.top_idx;
376
377 browser->b.seek(&browser->b, offset, SEEK_CUR);
378 al = list_entry(browser->b.top, struct annotation_line, node);
379
380 if (annotate_opts.hide_src_code) {
381 if (al->idx_asm < offset)
382 offset = al->idx;
383
384 browser->b.nr_entries = notes->src->nr_entries;
385 annotate_opts.hide_src_code = false;
386 browser->b.seek(&browser->b, -offset, SEEK_CUR);
387 browser->b.top_idx = al->idx - offset;
388 browser->b.index = al->idx;
389 } else {
390 if (al->idx_asm < 0) {
391 /* move cursor to next asm line */
392 al = annotate_browser__find_next_asm_line(browser, al);
393 if (!al) {
394 browser->b.seek(&browser->b, -offset, SEEK_CUR);
395 return false;
396 }
397 }
398
399 if (al->idx_asm < offset)
400 offset = al->idx_asm;
401
402 browser->b.nr_entries = notes->src->nr_asm_entries;
403 annotate_opts.hide_src_code = true;
404 browser->b.seek(&browser->b, -offset, SEEK_CUR);
405 browser->b.top_idx = al->idx_asm - offset;
406 browser->b.index = al->idx_asm;
407 }
408
409 return true;
410}
411
412#define SYM_TITLE_MAX_SIZE (PATH_MAX + 64)
413
414static void annotate_browser__show_full_location(struct ui_browser *browser)
415{
416 struct annotate_browser *ab = container_of(browser, struct annotate_browser, b);
417 struct disasm_line *cursor = disasm_line(ab->selection);
418 struct annotation_line *al = &cursor->al;
419
420 if (al->offset != -1)
421 ui_helpline__puts("Only available for source code lines.");
422 else if (al->fileloc == NULL)
423 ui_helpline__puts("No source file location.");
424 else {
425 char help_line[SYM_TITLE_MAX_SIZE];
426 sprintf (help_line, "Source file location: %s", al->fileloc);
427 ui_helpline__puts(help_line);
428 }
429}
430
431static void ui_browser__init_asm_mode(struct ui_browser *browser)
432{
433 struct annotation *notes = browser__annotation(browser);
434 ui_browser__reset_index(browser);
435 browser->nr_entries = notes->src->nr_asm_entries;
436}
437
438static int sym_title(struct symbol *sym, struct map *map, char *title,
439 size_t sz, int percent_type)
440{
441 return snprintf(title, sz, "%s %s [Percent: %s]", sym->name,
442 dso__long_name(map__dso(map)),
443 percent_type_str(percent_type));
444}
445
446/*
447 * This can be called from external jumps, i.e. jumps from one function
448 * to another, like from the kernel's entry_SYSCALL_64 function to the
449 * swapgs_restore_regs_and_return_to_usermode() function.
450 *
451 * So all we check here is that dl->ops.target.sym is set, if it is, just
452 * go to that function and when exiting from its disassembly, come back
453 * to the calling function.
454 */
455static bool annotate_browser__callq(struct annotate_browser *browser,
456 struct evsel *evsel,
457 struct hist_browser_timer *hbt)
458{
459 struct map_symbol *ms = browser->b.priv, target_ms;
460 struct disasm_line *dl = disasm_line(browser->selection);
461 struct annotation *notes;
462 char title[SYM_TITLE_MAX_SIZE];
463
464 if (!dl->ops.target.sym) {
465 ui_helpline__puts("The called function was not found.");
466 return true;
467 }
468
469 notes = symbol__annotation(dl->ops.target.sym);
470 annotation__lock(notes);
471
472 if (!symbol__hists(dl->ops.target.sym, evsel->evlist->core.nr_entries)) {
473 annotation__unlock(notes);
474 ui__warning("Not enough memory for annotating '%s' symbol!\n",
475 dl->ops.target.sym->name);
476 return true;
477 }
478
479 target_ms.maps = ms->maps;
480 target_ms.map = ms->map;
481 target_ms.sym = dl->ops.target.sym;
482 annotation__unlock(notes);
483 symbol__tui_annotate(&target_ms, evsel, hbt);
484 sym_title(ms->sym, ms->map, title, sizeof(title), annotate_opts.percent_type);
485 ui_browser__show_title(&browser->b, title);
486 return true;
487}
488
489static
490struct disasm_line *annotate_browser__find_offset(struct annotate_browser *browser,
491 s64 offset, s64 *idx)
492{
493 struct annotation *notes = browser__annotation(&browser->b);
494 struct disasm_line *pos;
495
496 *idx = 0;
497 list_for_each_entry(pos, ¬es->src->source, al.node) {
498 if (pos->al.offset == offset)
499 return pos;
500 if (!annotation_line__filter(&pos->al))
501 ++*idx;
502 }
503
504 return NULL;
505}
506
507static bool annotate_browser__jump(struct annotate_browser *browser,
508 struct evsel *evsel,
509 struct hist_browser_timer *hbt)
510{
511 struct disasm_line *dl = disasm_line(browser->selection);
512 u64 offset;
513 s64 idx;
514
515 if (!ins__is_jump(&dl->ins))
516 return false;
517
518 if (dl->ops.target.outside) {
519 annotate_browser__callq(browser, evsel, hbt);
520 return true;
521 }
522
523 offset = dl->ops.target.offset;
524 dl = annotate_browser__find_offset(browser, offset, &idx);
525 if (dl == NULL) {
526 ui_helpline__printf("Invalid jump offset: %" PRIx64, offset);
527 return true;
528 }
529
530 annotate_browser__set_top(browser, &dl->al, idx);
531
532 return true;
533}
534
535static
536struct annotation_line *annotate_browser__find_string(struct annotate_browser *browser,
537 char *s, s64 *idx)
538{
539 struct annotation *notes = browser__annotation(&browser->b);
540 struct annotation_line *al = browser->selection;
541
542 *idx = browser->b.index;
543 list_for_each_entry_continue(al, ¬es->src->source, node) {
544 if (annotation_line__filter(al))
545 continue;
546
547 ++*idx;
548
549 if (al->line && strstr(al->line, s) != NULL)
550 return al;
551 }
552
553 return NULL;
554}
555
556static bool __annotate_browser__search(struct annotate_browser *browser)
557{
558 struct annotation_line *al;
559 s64 idx;
560
561 al = annotate_browser__find_string(browser, browser->search_bf, &idx);
562 if (al == NULL) {
563 ui_helpline__puts("String not found!");
564 return false;
565 }
566
567 annotate_browser__set_top(browser, al, idx);
568 browser->searching_backwards = false;
569 return true;
570}
571
572static
573struct annotation_line *annotate_browser__find_string_reverse(struct annotate_browser *browser,
574 char *s, s64 *idx)
575{
576 struct annotation *notes = browser__annotation(&browser->b);
577 struct annotation_line *al = browser->selection;
578
579 *idx = browser->b.index;
580 list_for_each_entry_continue_reverse(al, ¬es->src->source, node) {
581 if (annotation_line__filter(al))
582 continue;
583
584 --*idx;
585
586 if (al->line && strstr(al->line, s) != NULL)
587 return al;
588 }
589
590 return NULL;
591}
592
593static bool __annotate_browser__search_reverse(struct annotate_browser *browser)
594{
595 struct annotation_line *al;
596 s64 idx;
597
598 al = annotate_browser__find_string_reverse(browser, browser->search_bf, &idx);
599 if (al == NULL) {
600 ui_helpline__puts("String not found!");
601 return false;
602 }
603
604 annotate_browser__set_top(browser, al, idx);
605 browser->searching_backwards = true;
606 return true;
607}
608
609static bool annotate_browser__search_window(struct annotate_browser *browser,
610 int delay_secs)
611{
612 if (ui_browser__input_window("Search", "String: ", browser->search_bf,
613 "ENTER: OK, ESC: Cancel",
614 delay_secs * 2) != K_ENTER ||
615 !*browser->search_bf)
616 return false;
617
618 return true;
619}
620
621static bool annotate_browser__search(struct annotate_browser *browser, int delay_secs)
622{
623 if (annotate_browser__search_window(browser, delay_secs))
624 return __annotate_browser__search(browser);
625
626 return false;
627}
628
629static bool annotate_browser__continue_search(struct annotate_browser *browser,
630 int delay_secs)
631{
632 if (!*browser->search_bf)
633 return annotate_browser__search(browser, delay_secs);
634
635 return __annotate_browser__search(browser);
636}
637
638static bool annotate_browser__search_reverse(struct annotate_browser *browser,
639 int delay_secs)
640{
641 if (annotate_browser__search_window(browser, delay_secs))
642 return __annotate_browser__search_reverse(browser);
643
644 return false;
645}
646
647static
648bool annotate_browser__continue_search_reverse(struct annotate_browser *browser,
649 int delay_secs)
650{
651 if (!*browser->search_bf)
652 return annotate_browser__search_reverse(browser, delay_secs);
653
654 return __annotate_browser__search_reverse(browser);
655}
656
657static int annotate_browser__show(struct ui_browser *browser, char *title, const char *help)
658{
659 struct map_symbol *ms = browser->priv;
660 struct symbol *sym = ms->sym;
661 char symbol_dso[SYM_TITLE_MAX_SIZE];
662
663 if (ui_browser__show(browser, title, help) < 0)
664 return -1;
665
666 sym_title(sym, ms->map, symbol_dso, sizeof(symbol_dso), annotate_opts.percent_type);
667
668 ui_browser__gotorc_title(browser, 0, 0);
669 ui_browser__set_color(browser, HE_COLORSET_ROOT);
670 ui_browser__write_nstring(browser, symbol_dso, browser->width + 1);
671 return 0;
672}
673
674static void
675switch_percent_type(struct annotation_options *opts, bool base)
676{
677 switch (opts->percent_type) {
678 case PERCENT_HITS_LOCAL:
679 if (base)
680 opts->percent_type = PERCENT_PERIOD_LOCAL;
681 else
682 opts->percent_type = PERCENT_HITS_GLOBAL;
683 break;
684 case PERCENT_HITS_GLOBAL:
685 if (base)
686 opts->percent_type = PERCENT_PERIOD_GLOBAL;
687 else
688 opts->percent_type = PERCENT_HITS_LOCAL;
689 break;
690 case PERCENT_PERIOD_LOCAL:
691 if (base)
692 opts->percent_type = PERCENT_HITS_LOCAL;
693 else
694 opts->percent_type = PERCENT_PERIOD_GLOBAL;
695 break;
696 case PERCENT_PERIOD_GLOBAL:
697 if (base)
698 opts->percent_type = PERCENT_HITS_GLOBAL;
699 else
700 opts->percent_type = PERCENT_PERIOD_LOCAL;
701 break;
702 default:
703 WARN_ON(1);
704 }
705}
706
707static int annotate_browser__run(struct annotate_browser *browser,
708 struct evsel *evsel,
709 struct hist_browser_timer *hbt)
710{
711 struct rb_node *nd = NULL;
712 struct hists *hists = evsel__hists(evsel);
713 struct map_symbol *ms = browser->b.priv;
714 struct symbol *sym = ms->sym;
715 struct annotation *notes = symbol__annotation(ms->sym);
716 const char *help = "Press 'h' for help on key bindings";
717 int delay_secs = hbt ? hbt->refresh : 0;
718 char *br_cntr_text = NULL;
719 char title[256];
720 int key;
721
722 hists__scnprintf_title(hists, title, sizeof(title));
723 if (annotate_browser__show(&browser->b, title, help) < 0)
724 return -1;
725
726 annotate_browser__calc_percent(browser, evsel);
727
728 if (browser->curr_hot) {
729 annotate_browser__set_rb_top(browser, browser->curr_hot);
730 browser->b.navkeypressed = false;
731 }
732
733 nd = browser->curr_hot;
734
735 annotation_br_cntr_abbr_list(&br_cntr_text, evsel, false);
736
737 while (1) {
738 key = ui_browser__run(&browser->b, delay_secs);
739
740 if (delay_secs != 0) {
741 annotate_browser__calc_percent(browser, evsel);
742 /*
743 * Current line focus got out of the list of most active
744 * lines, NULL it so that if TAB|UNTAB is pressed, we
745 * move to curr_hot (current hottest line).
746 */
747 if (nd != NULL && RB_EMPTY_NODE(nd))
748 nd = NULL;
749 }
750
751 switch (key) {
752 case K_TIMER:
753 if (hbt)
754 hbt->timer(hbt->arg);
755
756 if (delay_secs != 0) {
757 symbol__annotate_decay_histogram(sym, evsel->core.idx);
758 hists__scnprintf_title(hists, title, sizeof(title));
759 annotate_browser__show(&browser->b, title, help);
760 }
761 continue;
762 case K_TAB:
763 if (nd != NULL) {
764 nd = rb_prev(nd);
765 if (nd == NULL)
766 nd = rb_last(&browser->entries);
767 } else
768 nd = browser->curr_hot;
769 break;
770 case K_UNTAB:
771 if (nd != NULL) {
772 nd = rb_next(nd);
773 if (nd == NULL)
774 nd = rb_first(&browser->entries);
775 } else
776 nd = browser->curr_hot;
777 break;
778 case K_F1:
779 case 'h':
780 ui_browser__help_window(&browser->b,
781 "UP/DOWN/PGUP\n"
782 "PGDN/SPACE Navigate\n"
783 "</> Move to prev/next symbol\n"
784 "q/ESC/CTRL+C Exit\n\n"
785 "ENTER Go to target\n"
786 "H Go to hottest instruction\n"
787 "TAB/shift+TAB Cycle thru hottest instructions\n"
788 "j Toggle showing jump to target arrows\n"
789 "J Toggle showing number of jump sources on targets\n"
790 "n Search next string\n"
791 "o Toggle disassembler output/simplified view\n"
792 "O Bump offset level (jump targets -> +call -> all -> cycle thru)\n"
793 "s Toggle source code view\n"
794 "t Circulate percent, total period, samples view\n"
795 "c Show min/max cycle\n"
796 "/ Search string\n"
797 "k Toggle line numbers\n"
798 "l Show full source file location\n"
799 "P Print to [symbol_name].annotation file.\n"
800 "r Run available scripts\n"
801 "p Toggle percent type [local/global]\n"
802 "b Toggle percent base [period/hits]\n"
803 "B Branch counter abbr list (Optional)\n"
804 "? Search string backwards\n"
805 "f Toggle showing offsets to full address\n");
806 continue;
807 case 'r':
808 script_browse(NULL, NULL);
809 annotate_browser__show(&browser->b, title, help);
810 continue;
811 case 'k':
812 annotate_opts.show_linenr = !annotate_opts.show_linenr;
813 continue;
814 case 'l':
815 annotate_browser__show_full_location (&browser->b);
816 continue;
817 case 'H':
818 nd = browser->curr_hot;
819 break;
820 case 's':
821 if (annotate_browser__toggle_source(browser))
822 ui_helpline__puts(help);
823 continue;
824 case 'o':
825 annotate_opts.use_offset = !annotate_opts.use_offset;
826 annotation__update_column_widths(notes);
827 continue;
828 case 'O':
829 if (++annotate_opts.offset_level > ANNOTATION__MAX_OFFSET_LEVEL)
830 annotate_opts.offset_level = ANNOTATION__MIN_OFFSET_LEVEL;
831 continue;
832 case 'j':
833 annotate_opts.jump_arrows = !annotate_opts.jump_arrows;
834 continue;
835 case 'J':
836 annotate_opts.show_nr_jumps = !annotate_opts.show_nr_jumps;
837 annotation__update_column_widths(notes);
838 continue;
839 case '/':
840 if (annotate_browser__search(browser, delay_secs)) {
841show_help:
842 ui_helpline__puts(help);
843 }
844 continue;
845 case 'n':
846 if (browser->searching_backwards ?
847 annotate_browser__continue_search_reverse(browser, delay_secs) :
848 annotate_browser__continue_search(browser, delay_secs))
849 goto show_help;
850 continue;
851 case '?':
852 if (annotate_browser__search_reverse(browser, delay_secs))
853 goto show_help;
854 continue;
855 case 'D': {
856 static int seq;
857 ui_helpline__pop();
858 ui_helpline__fpush("%d: nr_ent=%d, height=%d, idx=%d, top_idx=%d, nr_asm_entries=%d",
859 seq++, browser->b.nr_entries,
860 browser->b.height,
861 browser->b.index,
862 browser->b.top_idx,
863 notes->src->nr_asm_entries);
864 }
865 continue;
866 case K_ENTER:
867 case K_RIGHT:
868 {
869 struct disasm_line *dl = disasm_line(browser->selection);
870
871 if (browser->selection == NULL)
872 ui_helpline__puts("Huh? No selection. Report to linux-kernel@vger.kernel.org");
873 else if (browser->selection->offset == -1)
874 ui_helpline__puts("Actions are only available for assembly lines.");
875 else if (!dl->ins.ops)
876 goto show_sup_ins;
877 else if (ins__is_ret(&dl->ins))
878 goto out;
879 else if (!(annotate_browser__jump(browser, evsel, hbt) ||
880 annotate_browser__callq(browser, evsel, hbt))) {
881show_sup_ins:
882 ui_helpline__puts("Actions are only available for function call/return & jump/branch instructions.");
883 }
884 continue;
885 }
886 case 'P':
887 map_symbol__annotation_dump(ms, evsel);
888 continue;
889 case 't':
890 if (symbol_conf.show_total_period) {
891 symbol_conf.show_total_period = false;
892 symbol_conf.show_nr_samples = true;
893 } else if (symbol_conf.show_nr_samples)
894 symbol_conf.show_nr_samples = false;
895 else
896 symbol_conf.show_total_period = true;
897 annotation__update_column_widths(notes);
898 continue;
899 case 'c':
900 if (annotate_opts.show_minmax_cycle)
901 annotate_opts.show_minmax_cycle = false;
902 else
903 annotate_opts.show_minmax_cycle = true;
904 annotation__update_column_widths(notes);
905 continue;
906 case 'p':
907 case 'b':
908 switch_percent_type(&annotate_opts, key == 'b');
909 hists__scnprintf_title(hists, title, sizeof(title));
910 annotate_browser__show(&browser->b, title, help);
911 continue;
912 case 'B':
913 if (br_cntr_text)
914 ui_browser__help_window(&browser->b, br_cntr_text);
915 else {
916 ui_browser__help_window(&browser->b,
917 "\n The branch counter is not available.\n");
918 }
919 continue;
920 case 'f':
921 annotation__toggle_full_addr(notes, ms);
922 continue;
923 case K_LEFT:
924 case '<':
925 case '>':
926 case K_ESC:
927 case 'q':
928 case CTRL('c'):
929 goto out;
930 default:
931 continue;
932 }
933
934 if (nd != NULL)
935 annotate_browser__set_rb_top(browser, nd);
936 }
937out:
938 ui_browser__hide(&browser->b);
939 free(br_cntr_text);
940 return key;
941}
942
943int map_symbol__tui_annotate(struct map_symbol *ms, struct evsel *evsel,
944 struct hist_browser_timer *hbt)
945{
946 return symbol__tui_annotate(ms, evsel, hbt);
947}
948
949int hist_entry__tui_annotate(struct hist_entry *he, struct evsel *evsel,
950 struct hist_browser_timer *hbt)
951{
952 /* reset abort key so that it can get Ctrl-C as a key */
953 SLang_reset_tty();
954 SLang_init_tty(0, 0, 0);
955 SLtty_set_suspend_state(true);
956
957 return map_symbol__tui_annotate(&he->ms, evsel, hbt);
958}
959
960int symbol__tui_annotate(struct map_symbol *ms, struct evsel *evsel,
961 struct hist_browser_timer *hbt)
962{
963 struct symbol *sym = ms->sym;
964 struct annotation *notes = symbol__annotation(sym);
965 struct annotate_browser browser = {
966 .b = {
967 .refresh = annotate_browser__refresh,
968 .seek = ui_browser__list_head_seek,
969 .write = annotate_browser__write,
970 .filter = disasm_line__filter,
971 .extra_title_lines = 1, /* for hists__scnprintf_title() */
972 .priv = ms,
973 .use_navkeypressed = true,
974 },
975 };
976 struct dso *dso;
977 int ret = -1, err;
978 int not_annotated = list_empty(¬es->src->source);
979
980 if (sym == NULL)
981 return -1;
982
983 dso = map__dso(ms->map);
984 if (dso__annotate_warned(dso))
985 return -1;
986
987 if (not_annotated || !sym->annotate2) {
988 err = symbol__annotate2(ms, evsel, &browser.arch);
989 if (err) {
990 char msg[BUFSIZ];
991 dso__set_annotate_warned(dso);
992 symbol__strerror_disassemble(ms, err, msg, sizeof(msg));
993 ui__error("Couldn't annotate %s:\n%s", sym->name, msg);
994 return -1;
995 }
996 }
997
998 ui_helpline__push("Press ESC to exit");
999
1000 browser.b.width = notes->src->widths.max_line_len;
1001 browser.b.nr_entries = notes->src->nr_entries;
1002 browser.b.entries = ¬es->src->source;
1003 browser.b.width += 18; /* Percentage */
1004
1005 if (annotate_opts.hide_src_code)
1006 ui_browser__init_asm_mode(&browser.b);
1007
1008 ret = annotate_browser__run(&browser, evsel, hbt);
1009
1010 if(not_annotated)
1011 annotated_source__purge(notes->src);
1012
1013 return ret;
1014}
1// SPDX-License-Identifier: GPL-2.0
2#include "../browser.h"
3#include "../helpline.h"
4#include "../ui.h"
5#include "../../util/annotate.h"
6#include "../../util/debug.h"
7#include "../../util/dso.h"
8#include "../../util/hist.h"
9#include "../../util/sort.h"
10#include "../../util/map.h"
11#include "../../util/mutex.h"
12#include "../../util/symbol.h"
13#include "../../util/evsel.h"
14#include "../../util/evlist.h"
15#include <inttypes.h>
16#include <linux/kernel.h>
17#include <linux/string.h>
18#include <linux/zalloc.h>
19#include <sys/ttydefaults.h>
20#include <asm/bug.h>
21
22struct arch;
23
24struct annotate_browser {
25 struct ui_browser b;
26 struct rb_root entries;
27 struct rb_node *curr_hot;
28 struct annotation_line *selection;
29 struct arch *arch;
30 struct annotation_options *opts;
31 bool searching_backwards;
32 char search_bf[128];
33};
34
35static inline struct annotation *browser__annotation(struct ui_browser *browser)
36{
37 struct map_symbol *ms = browser->priv;
38 return symbol__annotation(ms->sym);
39}
40
41static bool disasm_line__filter(struct ui_browser *browser, void *entry)
42{
43 struct annotation *notes = browser__annotation(browser);
44 struct annotation_line *al = list_entry(entry, struct annotation_line, node);
45 return annotation_line__filter(al, notes);
46}
47
48static int ui_browser__jumps_percent_color(struct ui_browser *browser, int nr, bool current)
49{
50 struct annotation *notes = browser__annotation(browser);
51
52 if (current && (!browser->use_navkeypressed || browser->navkeypressed))
53 return HE_COLORSET_SELECTED;
54 if (nr == notes->max_jump_sources)
55 return HE_COLORSET_TOP;
56 if (nr > 1)
57 return HE_COLORSET_MEDIUM;
58 return HE_COLORSET_NORMAL;
59}
60
61static int ui_browser__set_jumps_percent_color(void *browser, int nr, bool current)
62{
63 int color = ui_browser__jumps_percent_color(browser, nr, current);
64 return ui_browser__set_color(browser, color);
65}
66
67static int annotate_browser__set_color(void *browser, int color)
68{
69 return ui_browser__set_color(browser, color);
70}
71
72static void annotate_browser__write_graph(void *browser, int graph)
73{
74 ui_browser__write_graph(browser, graph);
75}
76
77static void annotate_browser__set_percent_color(void *browser, double percent, bool current)
78{
79 ui_browser__set_percent_color(browser, percent, current);
80}
81
82static void annotate_browser__printf(void *browser, const char *fmt, ...)
83{
84 va_list args;
85
86 va_start(args, fmt);
87 ui_browser__vprintf(browser, fmt, args);
88 va_end(args);
89}
90
91static void annotate_browser__write(struct ui_browser *browser, void *entry, int row)
92{
93 struct annotate_browser *ab = container_of(browser, struct annotate_browser, b);
94 struct annotation *notes = browser__annotation(browser);
95 struct annotation_line *al = list_entry(entry, struct annotation_line, node);
96 const bool is_current_entry = ui_browser__is_current_entry(browser, row);
97 struct annotation_write_ops ops = {
98 .first_line = row == 0,
99 .current_entry = is_current_entry,
100 .change_color = (!notes->options->hide_src_code &&
101 (!is_current_entry ||
102 (browser->use_navkeypressed &&
103 !browser->navkeypressed))),
104 .width = browser->width,
105 .obj = browser,
106 .set_color = annotate_browser__set_color,
107 .set_percent_color = annotate_browser__set_percent_color,
108 .set_jumps_percent_color = ui_browser__set_jumps_percent_color,
109 .printf = annotate_browser__printf,
110 .write_graph = annotate_browser__write_graph,
111 };
112
113 /* The scroll bar isn't being used */
114 if (!browser->navkeypressed)
115 ops.width += 1;
116
117 annotation_line__write(al, notes, &ops, ab->opts);
118
119 if (ops.current_entry)
120 ab->selection = al;
121}
122
123static int is_fused(struct annotate_browser *ab, struct disasm_line *cursor)
124{
125 struct disasm_line *pos = list_prev_entry(cursor, al.node);
126 const char *name;
127 int diff = 1;
128
129 while (pos && pos->al.offset == -1) {
130 pos = list_prev_entry(pos, al.node);
131 if (!ab->opts->hide_src_code)
132 diff++;
133 }
134
135 if (!pos)
136 return 0;
137
138 if (ins__is_lock(&pos->ins))
139 name = pos->ops.locked.ins.name;
140 else
141 name = pos->ins.name;
142
143 if (!name || !cursor->ins.name)
144 return 0;
145
146 if (ins__is_fused(ab->arch, name, cursor->ins.name))
147 return diff;
148 return 0;
149}
150
151static void annotate_browser__draw_current_jump(struct ui_browser *browser)
152{
153 struct annotate_browser *ab = container_of(browser, struct annotate_browser, b);
154 struct disasm_line *cursor = disasm_line(ab->selection);
155 struct annotation_line *target;
156 unsigned int from, to;
157 struct map_symbol *ms = ab->b.priv;
158 struct symbol *sym = ms->sym;
159 struct annotation *notes = symbol__annotation(sym);
160 u8 pcnt_width = annotation__pcnt_width(notes);
161 int width;
162 int diff = 0;
163
164 /* PLT symbols contain external offsets */
165 if (strstr(sym->name, "@plt"))
166 return;
167
168 if (!disasm_line__is_valid_local_jump(cursor, sym))
169 return;
170
171 /*
172 * This first was seen with a gcc function, _cpp_lex_token, that
173 * has the usual jumps:
174 *
175 * │1159e6c: ↓ jne 115aa32 <_cpp_lex_token@@Base+0xf92>
176 *
177 * I.e. jumps to a label inside that function (_cpp_lex_token), and
178 * those works, but also this kind:
179 *
180 * │1159e8b: ↓ jne c469be <cpp_named_operator2name@@Base+0xa72>
181 *
182 * I.e. jumps to another function, outside _cpp_lex_token, which
183 * are not being correctly handled generating as a side effect references
184 * to ab->offset[] entries that are set to NULL, so to make this code
185 * more robust, check that here.
186 *
187 * A proper fix for will be put in place, looking at the function
188 * name right after the '<' token and probably treating this like a
189 * 'call' instruction.
190 */
191 target = notes->offsets[cursor->ops.target.offset];
192 if (target == NULL) {
193 ui_helpline__printf("WARN: jump target inconsistency, press 'o', notes->offsets[%#x] = NULL\n",
194 cursor->ops.target.offset);
195 return;
196 }
197
198 if (notes->options->hide_src_code) {
199 from = cursor->al.idx_asm;
200 to = target->idx_asm;
201 } else {
202 from = (u64)cursor->al.idx;
203 to = (u64)target->idx;
204 }
205
206 width = annotation__cycles_width(notes);
207
208 ui_browser__set_color(browser, HE_COLORSET_JUMP_ARROWS);
209 __ui_browser__line_arrow(browser,
210 pcnt_width + 2 + notes->widths.addr + width,
211 from, to);
212
213 diff = is_fused(ab, cursor);
214 if (diff > 0) {
215 ui_browser__mark_fused(browser,
216 pcnt_width + 3 + notes->widths.addr + width,
217 from - diff, diff, to > from);
218 }
219}
220
221static unsigned int annotate_browser__refresh(struct ui_browser *browser)
222{
223 struct annotation *notes = browser__annotation(browser);
224 int ret = ui_browser__list_head_refresh(browser);
225 int pcnt_width = annotation__pcnt_width(notes);
226
227 if (notes->options->jump_arrows)
228 annotate_browser__draw_current_jump(browser);
229
230 ui_browser__set_color(browser, HE_COLORSET_NORMAL);
231 __ui_browser__vline(browser, pcnt_width, 0, browser->rows - 1);
232 return ret;
233}
234
235static double disasm__cmp(struct annotation_line *a, struct annotation_line *b,
236 int percent_type)
237{
238 int i;
239
240 for (i = 0; i < a->data_nr; i++) {
241 if (a->data[i].percent[percent_type] == b->data[i].percent[percent_type])
242 continue;
243 return a->data[i].percent[percent_type] -
244 b->data[i].percent[percent_type];
245 }
246 return 0;
247}
248
249static void disasm_rb_tree__insert(struct annotate_browser *browser,
250 struct annotation_line *al)
251{
252 struct rb_root *root = &browser->entries;
253 struct rb_node **p = &root->rb_node;
254 struct rb_node *parent = NULL;
255 struct annotation_line *l;
256
257 while (*p != NULL) {
258 parent = *p;
259 l = rb_entry(parent, struct annotation_line, rb_node);
260
261 if (disasm__cmp(al, l, browser->opts->percent_type) < 0)
262 p = &(*p)->rb_left;
263 else
264 p = &(*p)->rb_right;
265 }
266 rb_link_node(&al->rb_node, parent, p);
267 rb_insert_color(&al->rb_node, root);
268}
269
270static void annotate_browser__set_top(struct annotate_browser *browser,
271 struct annotation_line *pos, u32 idx)
272{
273 struct annotation *notes = browser__annotation(&browser->b);
274 unsigned back;
275
276 ui_browser__refresh_dimensions(&browser->b);
277 back = browser->b.height / 2;
278 browser->b.top_idx = browser->b.index = idx;
279
280 while (browser->b.top_idx != 0 && back != 0) {
281 pos = list_entry(pos->node.prev, struct annotation_line, node);
282
283 if (annotation_line__filter(pos, notes))
284 continue;
285
286 --browser->b.top_idx;
287 --back;
288 }
289
290 browser->b.top = pos;
291 browser->b.navkeypressed = true;
292}
293
294static void annotate_browser__set_rb_top(struct annotate_browser *browser,
295 struct rb_node *nd)
296{
297 struct annotation *notes = browser__annotation(&browser->b);
298 struct annotation_line * pos = rb_entry(nd, struct annotation_line, rb_node);
299 u32 idx = pos->idx;
300
301 if (notes->options->hide_src_code)
302 idx = pos->idx_asm;
303 annotate_browser__set_top(browser, pos, idx);
304 browser->curr_hot = nd;
305}
306
307static void annotate_browser__calc_percent(struct annotate_browser *browser,
308 struct evsel *evsel)
309{
310 struct map_symbol *ms = browser->b.priv;
311 struct symbol *sym = ms->sym;
312 struct annotation *notes = symbol__annotation(sym);
313 struct disasm_line *pos;
314
315 browser->entries = RB_ROOT;
316
317 mutex_lock(¬es->lock);
318
319 symbol__calc_percent(sym, evsel);
320
321 list_for_each_entry(pos, ¬es->src->source, al.node) {
322 double max_percent = 0.0;
323 int i;
324
325 if (pos->al.offset == -1) {
326 RB_CLEAR_NODE(&pos->al.rb_node);
327 continue;
328 }
329
330 for (i = 0; i < pos->al.data_nr; i++) {
331 double percent;
332
333 percent = annotation_data__percent(&pos->al.data[i],
334 browser->opts->percent_type);
335
336 if (max_percent < percent)
337 max_percent = percent;
338 }
339
340 if (max_percent < 0.01 && pos->al.ipc == 0) {
341 RB_CLEAR_NODE(&pos->al.rb_node);
342 continue;
343 }
344 disasm_rb_tree__insert(browser, &pos->al);
345 }
346 mutex_unlock(¬es->lock);
347
348 browser->curr_hot = rb_last(&browser->entries);
349}
350
351static struct annotation_line *annotate_browser__find_next_asm_line(
352 struct annotate_browser *browser,
353 struct annotation_line *al)
354{
355 struct annotation_line *it = al;
356
357 /* find next asm line */
358 list_for_each_entry_continue(it, browser->b.entries, node) {
359 if (it->idx_asm >= 0)
360 return it;
361 }
362
363 /* no asm line found forwards, try backwards */
364 it = al;
365 list_for_each_entry_continue_reverse(it, browser->b.entries, node) {
366 if (it->idx_asm >= 0)
367 return it;
368 }
369
370 /* There are no asm lines */
371 return NULL;
372}
373
374static bool annotate_browser__toggle_source(struct annotate_browser *browser)
375{
376 struct annotation *notes = browser__annotation(&browser->b);
377 struct annotation_line *al;
378 off_t offset = browser->b.index - browser->b.top_idx;
379
380 browser->b.seek(&browser->b, offset, SEEK_CUR);
381 al = list_entry(browser->b.top, struct annotation_line, node);
382
383 if (notes->options->hide_src_code) {
384 if (al->idx_asm < offset)
385 offset = al->idx;
386
387 browser->b.nr_entries = notes->nr_entries;
388 notes->options->hide_src_code = false;
389 browser->b.seek(&browser->b, -offset, SEEK_CUR);
390 browser->b.top_idx = al->idx - offset;
391 browser->b.index = al->idx;
392 } else {
393 if (al->idx_asm < 0) {
394 /* move cursor to next asm line */
395 al = annotate_browser__find_next_asm_line(browser, al);
396 if (!al) {
397 browser->b.seek(&browser->b, -offset, SEEK_CUR);
398 return false;
399 }
400 }
401
402 if (al->idx_asm < offset)
403 offset = al->idx_asm;
404
405 browser->b.nr_entries = notes->nr_asm_entries;
406 notes->options->hide_src_code = true;
407 browser->b.seek(&browser->b, -offset, SEEK_CUR);
408 browser->b.top_idx = al->idx_asm - offset;
409 browser->b.index = al->idx_asm;
410 }
411
412 return true;
413}
414
415#define SYM_TITLE_MAX_SIZE (PATH_MAX + 64)
416
417static void annotate_browser__show_full_location(struct ui_browser *browser)
418{
419 struct annotate_browser *ab = container_of(browser, struct annotate_browser, b);
420 struct disasm_line *cursor = disasm_line(ab->selection);
421 struct annotation_line *al = &cursor->al;
422
423 if (al->offset != -1)
424 ui_helpline__puts("Only available for source code lines.");
425 else if (al->fileloc == NULL)
426 ui_helpline__puts("No source file location.");
427 else {
428 char help_line[SYM_TITLE_MAX_SIZE];
429 sprintf (help_line, "Source file location: %s", al->fileloc);
430 ui_helpline__puts(help_line);
431 }
432}
433
434static void ui_browser__init_asm_mode(struct ui_browser *browser)
435{
436 struct annotation *notes = browser__annotation(browser);
437 ui_browser__reset_index(browser);
438 browser->nr_entries = notes->nr_asm_entries;
439}
440
441static int sym_title(struct symbol *sym, struct map *map, char *title,
442 size_t sz, int percent_type)
443{
444 return snprintf(title, sz, "%s %s [Percent: %s]", sym->name, map->dso->long_name,
445 percent_type_str(percent_type));
446}
447
448/*
449 * This can be called from external jumps, i.e. jumps from one function
450 * to another, like from the kernel's entry_SYSCALL_64 function to the
451 * swapgs_restore_regs_and_return_to_usermode() function.
452 *
453 * So all we check here is that dl->ops.target.sym is set, if it is, just
454 * go to that function and when exiting from its disassembly, come back
455 * to the calling function.
456 */
457static bool annotate_browser__callq(struct annotate_browser *browser,
458 struct evsel *evsel,
459 struct hist_browser_timer *hbt)
460{
461 struct map_symbol *ms = browser->b.priv, target_ms;
462 struct disasm_line *dl = disasm_line(browser->selection);
463 struct annotation *notes;
464 char title[SYM_TITLE_MAX_SIZE];
465
466 if (!dl->ops.target.sym) {
467 ui_helpline__puts("The called function was not found.");
468 return true;
469 }
470
471 notes = symbol__annotation(dl->ops.target.sym);
472 mutex_lock(¬es->lock);
473
474 if (!symbol__hists(dl->ops.target.sym, evsel->evlist->core.nr_entries)) {
475 mutex_unlock(¬es->lock);
476 ui__warning("Not enough memory for annotating '%s' symbol!\n",
477 dl->ops.target.sym->name);
478 return true;
479 }
480
481 target_ms.maps = ms->maps;
482 target_ms.map = ms->map;
483 target_ms.sym = dl->ops.target.sym;
484 mutex_unlock(¬es->lock);
485 symbol__tui_annotate(&target_ms, evsel, hbt, browser->opts);
486 sym_title(ms->sym, ms->map, title, sizeof(title), browser->opts->percent_type);
487 ui_browser__show_title(&browser->b, title);
488 return true;
489}
490
491static
492struct disasm_line *annotate_browser__find_offset(struct annotate_browser *browser,
493 s64 offset, s64 *idx)
494{
495 struct annotation *notes = browser__annotation(&browser->b);
496 struct disasm_line *pos;
497
498 *idx = 0;
499 list_for_each_entry(pos, ¬es->src->source, al.node) {
500 if (pos->al.offset == offset)
501 return pos;
502 if (!annotation_line__filter(&pos->al, notes))
503 ++*idx;
504 }
505
506 return NULL;
507}
508
509static bool annotate_browser__jump(struct annotate_browser *browser,
510 struct evsel *evsel,
511 struct hist_browser_timer *hbt)
512{
513 struct disasm_line *dl = disasm_line(browser->selection);
514 u64 offset;
515 s64 idx;
516
517 if (!ins__is_jump(&dl->ins))
518 return false;
519
520 if (dl->ops.target.outside) {
521 annotate_browser__callq(browser, evsel, hbt);
522 return true;
523 }
524
525 offset = dl->ops.target.offset;
526 dl = annotate_browser__find_offset(browser, offset, &idx);
527 if (dl == NULL) {
528 ui_helpline__printf("Invalid jump offset: %" PRIx64, offset);
529 return true;
530 }
531
532 annotate_browser__set_top(browser, &dl->al, idx);
533
534 return true;
535}
536
537static
538struct annotation_line *annotate_browser__find_string(struct annotate_browser *browser,
539 char *s, s64 *idx)
540{
541 struct annotation *notes = browser__annotation(&browser->b);
542 struct annotation_line *al = browser->selection;
543
544 *idx = browser->b.index;
545 list_for_each_entry_continue(al, ¬es->src->source, node) {
546 if (annotation_line__filter(al, notes))
547 continue;
548
549 ++*idx;
550
551 if (al->line && strstr(al->line, s) != NULL)
552 return al;
553 }
554
555 return NULL;
556}
557
558static bool __annotate_browser__search(struct annotate_browser *browser)
559{
560 struct annotation_line *al;
561 s64 idx;
562
563 al = annotate_browser__find_string(browser, browser->search_bf, &idx);
564 if (al == NULL) {
565 ui_helpline__puts("String not found!");
566 return false;
567 }
568
569 annotate_browser__set_top(browser, al, idx);
570 browser->searching_backwards = false;
571 return true;
572}
573
574static
575struct annotation_line *annotate_browser__find_string_reverse(struct annotate_browser *browser,
576 char *s, s64 *idx)
577{
578 struct annotation *notes = browser__annotation(&browser->b);
579 struct annotation_line *al = browser->selection;
580
581 *idx = browser->b.index;
582 list_for_each_entry_continue_reverse(al, ¬es->src->source, node) {
583 if (annotation_line__filter(al, notes))
584 continue;
585
586 --*idx;
587
588 if (al->line && strstr(al->line, s) != NULL)
589 return al;
590 }
591
592 return NULL;
593}
594
595static bool __annotate_browser__search_reverse(struct annotate_browser *browser)
596{
597 struct annotation_line *al;
598 s64 idx;
599
600 al = annotate_browser__find_string_reverse(browser, browser->search_bf, &idx);
601 if (al == NULL) {
602 ui_helpline__puts("String not found!");
603 return false;
604 }
605
606 annotate_browser__set_top(browser, al, idx);
607 browser->searching_backwards = true;
608 return true;
609}
610
611static bool annotate_browser__search_window(struct annotate_browser *browser,
612 int delay_secs)
613{
614 if (ui_browser__input_window("Search", "String: ", browser->search_bf,
615 "ENTER: OK, ESC: Cancel",
616 delay_secs * 2) != K_ENTER ||
617 !*browser->search_bf)
618 return false;
619
620 return true;
621}
622
623static bool annotate_browser__search(struct annotate_browser *browser, int delay_secs)
624{
625 if (annotate_browser__search_window(browser, delay_secs))
626 return __annotate_browser__search(browser);
627
628 return false;
629}
630
631static bool annotate_browser__continue_search(struct annotate_browser *browser,
632 int delay_secs)
633{
634 if (!*browser->search_bf)
635 return annotate_browser__search(browser, delay_secs);
636
637 return __annotate_browser__search(browser);
638}
639
640static bool annotate_browser__search_reverse(struct annotate_browser *browser,
641 int delay_secs)
642{
643 if (annotate_browser__search_window(browser, delay_secs))
644 return __annotate_browser__search_reverse(browser);
645
646 return false;
647}
648
649static
650bool annotate_browser__continue_search_reverse(struct annotate_browser *browser,
651 int delay_secs)
652{
653 if (!*browser->search_bf)
654 return annotate_browser__search_reverse(browser, delay_secs);
655
656 return __annotate_browser__search_reverse(browser);
657}
658
659static int annotate_browser__show(struct ui_browser *browser, char *title, const char *help)
660{
661 struct annotate_browser *ab = container_of(browser, struct annotate_browser, b);
662 struct map_symbol *ms = browser->priv;
663 struct symbol *sym = ms->sym;
664 char symbol_dso[SYM_TITLE_MAX_SIZE];
665
666 if (ui_browser__show(browser, title, help) < 0)
667 return -1;
668
669 sym_title(sym, ms->map, symbol_dso, sizeof(symbol_dso), ab->opts->percent_type);
670
671 ui_browser__gotorc_title(browser, 0, 0);
672 ui_browser__set_color(browser, HE_COLORSET_ROOT);
673 ui_browser__write_nstring(browser, symbol_dso, browser->width + 1);
674 return 0;
675}
676
677static void
678switch_percent_type(struct annotation_options *opts, bool base)
679{
680 switch (opts->percent_type) {
681 case PERCENT_HITS_LOCAL:
682 if (base)
683 opts->percent_type = PERCENT_PERIOD_LOCAL;
684 else
685 opts->percent_type = PERCENT_HITS_GLOBAL;
686 break;
687 case PERCENT_HITS_GLOBAL:
688 if (base)
689 opts->percent_type = PERCENT_PERIOD_GLOBAL;
690 else
691 opts->percent_type = PERCENT_HITS_LOCAL;
692 break;
693 case PERCENT_PERIOD_LOCAL:
694 if (base)
695 opts->percent_type = PERCENT_HITS_LOCAL;
696 else
697 opts->percent_type = PERCENT_PERIOD_GLOBAL;
698 break;
699 case PERCENT_PERIOD_GLOBAL:
700 if (base)
701 opts->percent_type = PERCENT_HITS_GLOBAL;
702 else
703 opts->percent_type = PERCENT_PERIOD_LOCAL;
704 break;
705 default:
706 WARN_ON(1);
707 }
708}
709
710static int annotate_browser__run(struct annotate_browser *browser,
711 struct evsel *evsel,
712 struct hist_browser_timer *hbt)
713{
714 struct rb_node *nd = NULL;
715 struct hists *hists = evsel__hists(evsel);
716 struct map_symbol *ms = browser->b.priv;
717 struct symbol *sym = ms->sym;
718 struct annotation *notes = symbol__annotation(ms->sym);
719 const char *help = "Press 'h' for help on key bindings";
720 int delay_secs = hbt ? hbt->refresh : 0;
721 char title[256];
722 int key;
723
724 hists__scnprintf_title(hists, title, sizeof(title));
725 if (annotate_browser__show(&browser->b, title, help) < 0)
726 return -1;
727
728 annotate_browser__calc_percent(browser, evsel);
729
730 if (browser->curr_hot) {
731 annotate_browser__set_rb_top(browser, browser->curr_hot);
732 browser->b.navkeypressed = false;
733 }
734
735 nd = browser->curr_hot;
736
737 while (1) {
738 key = ui_browser__run(&browser->b, delay_secs);
739
740 if (delay_secs != 0) {
741 annotate_browser__calc_percent(browser, evsel);
742 /*
743 * Current line focus got out of the list of most active
744 * lines, NULL it so that if TAB|UNTAB is pressed, we
745 * move to curr_hot (current hottest line).
746 */
747 if (nd != NULL && RB_EMPTY_NODE(nd))
748 nd = NULL;
749 }
750
751 switch (key) {
752 case K_TIMER:
753 if (hbt)
754 hbt->timer(hbt->arg);
755
756 if (delay_secs != 0) {
757 symbol__annotate_decay_histogram(sym, evsel->core.idx);
758 hists__scnprintf_title(hists, title, sizeof(title));
759 annotate_browser__show(&browser->b, title, help);
760 }
761 continue;
762 case K_TAB:
763 if (nd != NULL) {
764 nd = rb_prev(nd);
765 if (nd == NULL)
766 nd = rb_last(&browser->entries);
767 } else
768 nd = browser->curr_hot;
769 break;
770 case K_UNTAB:
771 if (nd != NULL) {
772 nd = rb_next(nd);
773 if (nd == NULL)
774 nd = rb_first(&browser->entries);
775 } else
776 nd = browser->curr_hot;
777 break;
778 case K_F1:
779 case 'h':
780 ui_browser__help_window(&browser->b,
781 "UP/DOWN/PGUP\n"
782 "PGDN/SPACE Navigate\n"
783 "q/ESC/CTRL+C Exit\n\n"
784 "ENTER Go to target\n"
785 "ESC Exit\n"
786 "H Go to hottest instruction\n"
787 "TAB/shift+TAB Cycle thru hottest instructions\n"
788 "j Toggle showing jump to target arrows\n"
789 "J Toggle showing number of jump sources on targets\n"
790 "n Search next string\n"
791 "o Toggle disassembler output/simplified view\n"
792 "O Bump offset level (jump targets -> +call -> all -> cycle thru)\n"
793 "s Toggle source code view\n"
794 "t Circulate percent, total period, samples view\n"
795 "c Show min/max cycle\n"
796 "/ Search string\n"
797 "k Toggle line numbers\n"
798 "l Show full source file location\n"
799 "P Print to [symbol_name].annotation file.\n"
800 "r Run available scripts\n"
801 "p Toggle percent type [local/global]\n"
802 "b Toggle percent base [period/hits]\n"
803 "? Search string backwards\n"
804 "f Toggle showing offsets to full address\n");
805 continue;
806 case 'r':
807 script_browse(NULL, NULL);
808 annotate_browser__show(&browser->b, title, help);
809 continue;
810 case 'k':
811 notes->options->show_linenr = !notes->options->show_linenr;
812 continue;
813 case 'l':
814 annotate_browser__show_full_location (&browser->b);
815 continue;
816 case 'H':
817 nd = browser->curr_hot;
818 break;
819 case 's':
820 if (annotate_browser__toggle_source(browser))
821 ui_helpline__puts(help);
822 continue;
823 case 'o':
824 notes->options->use_offset = !notes->options->use_offset;
825 annotation__update_column_widths(notes);
826 continue;
827 case 'O':
828 if (++notes->options->offset_level > ANNOTATION__MAX_OFFSET_LEVEL)
829 notes->options->offset_level = ANNOTATION__MIN_OFFSET_LEVEL;
830 continue;
831 case 'j':
832 notes->options->jump_arrows = !notes->options->jump_arrows;
833 continue;
834 case 'J':
835 notes->options->show_nr_jumps = !notes->options->show_nr_jumps;
836 annotation__update_column_widths(notes);
837 continue;
838 case '/':
839 if (annotate_browser__search(browser, delay_secs)) {
840show_help:
841 ui_helpline__puts(help);
842 }
843 continue;
844 case 'n':
845 if (browser->searching_backwards ?
846 annotate_browser__continue_search_reverse(browser, delay_secs) :
847 annotate_browser__continue_search(browser, delay_secs))
848 goto show_help;
849 continue;
850 case '?':
851 if (annotate_browser__search_reverse(browser, delay_secs))
852 goto show_help;
853 continue;
854 case 'D': {
855 static int seq;
856 ui_helpline__pop();
857 ui_helpline__fpush("%d: nr_ent=%d, height=%d, idx=%d, top_idx=%d, nr_asm_entries=%d",
858 seq++, browser->b.nr_entries,
859 browser->b.height,
860 browser->b.index,
861 browser->b.top_idx,
862 notes->nr_asm_entries);
863 }
864 continue;
865 case K_ENTER:
866 case K_RIGHT:
867 {
868 struct disasm_line *dl = disasm_line(browser->selection);
869
870 if (browser->selection == NULL)
871 ui_helpline__puts("Huh? No selection. Report to linux-kernel@vger.kernel.org");
872 else if (browser->selection->offset == -1)
873 ui_helpline__puts("Actions are only available for assembly lines.");
874 else if (!dl->ins.ops)
875 goto show_sup_ins;
876 else if (ins__is_ret(&dl->ins))
877 goto out;
878 else if (!(annotate_browser__jump(browser, evsel, hbt) ||
879 annotate_browser__callq(browser, evsel, hbt))) {
880show_sup_ins:
881 ui_helpline__puts("Actions are only available for function call/return & jump/branch instructions.");
882 }
883 continue;
884 }
885 case 'P':
886 map_symbol__annotation_dump(ms, evsel, browser->opts);
887 continue;
888 case 't':
889 if (symbol_conf.show_total_period) {
890 symbol_conf.show_total_period = false;
891 symbol_conf.show_nr_samples = true;
892 } else if (symbol_conf.show_nr_samples)
893 symbol_conf.show_nr_samples = false;
894 else
895 symbol_conf.show_total_period = true;
896 annotation__update_column_widths(notes);
897 continue;
898 case 'c':
899 if (notes->options->show_minmax_cycle)
900 notes->options->show_minmax_cycle = false;
901 else
902 notes->options->show_minmax_cycle = true;
903 annotation__update_column_widths(notes);
904 continue;
905 case 'p':
906 case 'b':
907 switch_percent_type(browser->opts, key == 'b');
908 hists__scnprintf_title(hists, title, sizeof(title));
909 annotate_browser__show(&browser->b, title, help);
910 continue;
911 case 'f':
912 annotation__toggle_full_addr(notes, ms);
913 continue;
914 case K_LEFT:
915 case K_ESC:
916 case 'q':
917 case CTRL('c'):
918 goto out;
919 default:
920 continue;
921 }
922
923 if (nd != NULL)
924 annotate_browser__set_rb_top(browser, nd);
925 }
926out:
927 ui_browser__hide(&browser->b);
928 return key;
929}
930
931int map_symbol__tui_annotate(struct map_symbol *ms, struct evsel *evsel,
932 struct hist_browser_timer *hbt,
933 struct annotation_options *opts)
934{
935 return symbol__tui_annotate(ms, evsel, hbt, opts);
936}
937
938int hist_entry__tui_annotate(struct hist_entry *he, struct evsel *evsel,
939 struct hist_browser_timer *hbt,
940 struct annotation_options *opts)
941{
942 /* reset abort key so that it can get Ctrl-C as a key */
943 SLang_reset_tty();
944 SLang_init_tty(0, 0, 0);
945
946 return map_symbol__tui_annotate(&he->ms, evsel, hbt, opts);
947}
948
949int symbol__tui_annotate(struct map_symbol *ms, struct evsel *evsel,
950 struct hist_browser_timer *hbt,
951 struct annotation_options *opts)
952{
953 struct symbol *sym = ms->sym;
954 struct annotation *notes = symbol__annotation(sym);
955 struct annotate_browser browser = {
956 .b = {
957 .refresh = annotate_browser__refresh,
958 .seek = ui_browser__list_head_seek,
959 .write = annotate_browser__write,
960 .filter = disasm_line__filter,
961 .extra_title_lines = 1, /* for hists__scnprintf_title() */
962 .priv = ms,
963 .use_navkeypressed = true,
964 },
965 .opts = opts,
966 };
967 int ret = -1, err;
968 int not_annotated = list_empty(¬es->src->source);
969
970 if (sym == NULL)
971 return -1;
972
973 if (ms->map->dso->annotate_warned)
974 return -1;
975
976 if (not_annotated) {
977 err = symbol__annotate2(ms, evsel, opts, &browser.arch);
978 if (err) {
979 char msg[BUFSIZ];
980 ms->map->dso->annotate_warned = true;
981 symbol__strerror_disassemble(ms, err, msg, sizeof(msg));
982 ui__error("Couldn't annotate %s:\n%s", sym->name, msg);
983 goto out_free_offsets;
984 }
985 }
986
987 ui_helpline__push("Press ESC to exit");
988
989 browser.b.width = notes->max_line_len;
990 browser.b.nr_entries = notes->nr_entries;
991 browser.b.entries = ¬es->src->source,
992 browser.b.width += 18; /* Percentage */
993
994 if (notes->options->hide_src_code)
995 ui_browser__init_asm_mode(&browser.b);
996
997 ret = annotate_browser__run(&browser, evsel, hbt);
998
999 if(not_annotated)
1000 annotated_source__purge(notes->src);
1001
1002out_free_offsets:
1003 if(not_annotated)
1004 zfree(¬es->offsets);
1005 return ret;
1006}