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