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