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#include "../../util/util.h"
2#include "../browser.h"
3#include "../helpline.h"
4#include "../libslang.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 <pthread.h>
12#include <newt.h>
13
14struct browser_disasm_line {
15 struct rb_node rb_node;
16 double percent;
17 u32 idx;
18 int idx_asm;
19 int jump_sources;
20};
21
22static struct annotate_browser_opt {
23 bool hide_src_code,
24 use_offset,
25 jump_arrows,
26 show_nr_jumps;
27} annotate_browser__opts = {
28 .use_offset = true,
29 .jump_arrows = true,
30};
31
32struct annotate_browser {
33 struct ui_browser b;
34 struct rb_root entries;
35 struct rb_node *curr_hot;
36 struct disasm_line *selection;
37 struct disasm_line **offsets;
38 u64 start;
39 int nr_asm_entries;
40 int nr_entries;
41 int max_jump_sources;
42 int nr_jumps;
43 bool searching_backwards;
44 u8 addr_width;
45 u8 jumps_width;
46 u8 target_width;
47 u8 min_addr_width;
48 u8 max_addr_width;
49 char search_bf[128];
50};
51
52static inline struct browser_disasm_line *disasm_line__browser(struct disasm_line *dl)
53{
54 return (struct browser_disasm_line *)(dl + 1);
55}
56
57static bool disasm_line__filter(struct ui_browser *browser __used, void *entry)
58{
59 if (annotate_browser__opts.hide_src_code) {
60 struct disasm_line *dl = list_entry(entry, struct disasm_line, node);
61 return dl->offset == -1;
62 }
63
64 return false;
65}
66
67static int annotate_browser__jumps_percent_color(struct annotate_browser *browser,
68 int nr, bool current)
69{
70 if (current && (!browser->b.use_navkeypressed || browser->b.navkeypressed))
71 return HE_COLORSET_SELECTED;
72 if (nr == browser->max_jump_sources)
73 return HE_COLORSET_TOP;
74 if (nr > 1)
75 return HE_COLORSET_MEDIUM;
76 return HE_COLORSET_NORMAL;
77}
78
79static int annotate_browser__set_jumps_percent_color(struct annotate_browser *browser,
80 int nr, bool current)
81{
82 int color = annotate_browser__jumps_percent_color(browser, nr, current);
83 return ui_browser__set_color(&browser->b, color);
84}
85
86static void annotate_browser__write(struct ui_browser *browser, void *entry, int row)
87{
88 struct annotate_browser *ab = container_of(browser, struct annotate_browser, b);
89 struct disasm_line *dl = list_entry(entry, struct disasm_line, node);
90 struct browser_disasm_line *bdl = disasm_line__browser(dl);
91 bool current_entry = ui_browser__is_current_entry(browser, row);
92 bool change_color = (!annotate_browser__opts.hide_src_code &&
93 (!current_entry || (browser->use_navkeypressed &&
94 !browser->navkeypressed)));
95 int width = browser->width, printed;
96 char bf[256];
97
98 if (dl->offset != -1 && bdl->percent != 0.0) {
99 ui_browser__set_percent_color(browser, bdl->percent, current_entry);
100 slsmg_printf("%6.2f ", bdl->percent);
101 } else {
102 ui_browser__set_percent_color(browser, 0, current_entry);
103 slsmg_write_nstring(" ", 7);
104 }
105
106 SLsmg_write_char(' ');
107
108 /* The scroll bar isn't being used */
109 if (!browser->navkeypressed)
110 width += 1;
111
112 if (!*dl->line)
113 slsmg_write_nstring(" ", width - 7);
114 else if (dl->offset == -1) {
115 printed = scnprintf(bf, sizeof(bf), "%*s ",
116 ab->addr_width, " ");
117 slsmg_write_nstring(bf, printed);
118 slsmg_write_nstring(dl->line, width - printed - 6);
119 } else {
120 u64 addr = dl->offset;
121 int color = -1;
122
123 if (!annotate_browser__opts.use_offset)
124 addr += ab->start;
125
126 if (!annotate_browser__opts.use_offset) {
127 printed = scnprintf(bf, sizeof(bf), "%" PRIx64 ": ", addr);
128 } else {
129 if (bdl->jump_sources) {
130 if (annotate_browser__opts.show_nr_jumps) {
131 int prev;
132 printed = scnprintf(bf, sizeof(bf), "%*d ",
133 ab->jumps_width,
134 bdl->jump_sources);
135 prev = annotate_browser__set_jumps_percent_color(ab, bdl->jump_sources,
136 current_entry);
137 slsmg_write_nstring(bf, printed);
138 ui_browser__set_color(browser, prev);
139 }
140
141 printed = scnprintf(bf, sizeof(bf), "%*" PRIx64 ": ",
142 ab->target_width, addr);
143 } else {
144 printed = scnprintf(bf, sizeof(bf), "%*s ",
145 ab->addr_width, " ");
146 }
147 }
148
149 if (change_color)
150 color = ui_browser__set_color(browser, HE_COLORSET_ADDR);
151 slsmg_write_nstring(bf, printed);
152 if (change_color)
153 ui_browser__set_color(browser, color);
154 if (dl->ins && dl->ins->ops->scnprintf) {
155 if (ins__is_jump(dl->ins)) {
156 bool fwd = dl->ops.target.offset > (u64)dl->offset;
157
158 ui_browser__write_graph(browser, fwd ? SLSMG_DARROW_CHAR :
159 SLSMG_UARROW_CHAR);
160 SLsmg_write_char(' ');
161 } else if (ins__is_call(dl->ins)) {
162 ui_browser__write_graph(browser, SLSMG_RARROW_CHAR);
163 SLsmg_write_char(' ');
164 } else {
165 slsmg_write_nstring(" ", 2);
166 }
167 } else {
168 if (strcmp(dl->name, "retq")) {
169 slsmg_write_nstring(" ", 2);
170 } else {
171 ui_browser__write_graph(browser, SLSMG_LARROW_CHAR);
172 SLsmg_write_char(' ');
173 }
174 }
175
176 disasm_line__scnprintf(dl, bf, sizeof(bf), !annotate_browser__opts.use_offset);
177 slsmg_write_nstring(bf, width - 10 - printed);
178 }
179
180 if (current_entry)
181 ab->selection = dl;
182}
183
184static void annotate_browser__draw_current_jump(struct ui_browser *browser)
185{
186 struct annotate_browser *ab = container_of(browser, struct annotate_browser, b);
187 struct disasm_line *cursor = ab->selection, *target;
188 struct browser_disasm_line *btarget, *bcursor;
189 unsigned int from, to;
190
191 if (!cursor || !cursor->ins || !ins__is_jump(cursor->ins) ||
192 !disasm_line__has_offset(cursor))
193 return;
194
195 target = ab->offsets[cursor->ops.target.offset];
196 if (!target)
197 return;
198
199 bcursor = disasm_line__browser(cursor);
200 btarget = disasm_line__browser(target);
201
202 if (annotate_browser__opts.hide_src_code) {
203 from = bcursor->idx_asm;
204 to = btarget->idx_asm;
205 } else {
206 from = (u64)bcursor->idx;
207 to = (u64)btarget->idx;
208 }
209
210 ui_browser__set_color(browser, HE_COLORSET_CODE);
211 __ui_browser__line_arrow(browser, 9 + ab->addr_width, from, to);
212}
213
214static unsigned int annotate_browser__refresh(struct ui_browser *browser)
215{
216 int ret = ui_browser__list_head_refresh(browser);
217
218 if (annotate_browser__opts.jump_arrows)
219 annotate_browser__draw_current_jump(browser);
220
221 ui_browser__set_color(browser, HE_COLORSET_NORMAL);
222 __ui_browser__vline(browser, 7, 0, browser->height - 1);
223 return ret;
224}
225
226static double disasm_line__calc_percent(struct disasm_line *dl, struct symbol *sym, int evidx)
227{
228 double percent = 0.0;
229
230 if (dl->offset != -1) {
231 int len = sym->end - sym->start;
232 unsigned int hits = 0;
233 struct annotation *notes = symbol__annotation(sym);
234 struct source_line *src_line = notes->src->lines;
235 struct sym_hist *h = annotation__histogram(notes, evidx);
236 s64 offset = dl->offset;
237 struct disasm_line *next;
238
239 next = disasm__get_next_ip_line(¬es->src->source, dl);
240 while (offset < (s64)len &&
241 (next == NULL || offset < next->offset)) {
242 if (src_line) {
243 percent += src_line[offset].percent;
244 } else
245 hits += h->addr[offset];
246
247 ++offset;
248 }
249 /*
250 * If the percentage wasn't already calculated in
251 * symbol__get_source_line, do it now:
252 */
253 if (src_line == NULL && h->sum)
254 percent = 100.0 * hits / h->sum;
255 }
256
257 return percent;
258}
259
260static void disasm_rb_tree__insert(struct rb_root *root, struct browser_disasm_line *bdl)
261{
262 struct rb_node **p = &root->rb_node;
263 struct rb_node *parent = NULL;
264 struct browser_disasm_line *l;
265
266 while (*p != NULL) {
267 parent = *p;
268 l = rb_entry(parent, struct browser_disasm_line, rb_node);
269 if (bdl->percent < l->percent)
270 p = &(*p)->rb_left;
271 else
272 p = &(*p)->rb_right;
273 }
274 rb_link_node(&bdl->rb_node, parent, p);
275 rb_insert_color(&bdl->rb_node, root);
276}
277
278static void annotate_browser__set_top(struct annotate_browser *browser,
279 struct disasm_line *pos, u32 idx)
280{
281 unsigned back;
282
283 ui_browser__refresh_dimensions(&browser->b);
284 back = browser->b.height / 2;
285 browser->b.top_idx = browser->b.index = idx;
286
287 while (browser->b.top_idx != 0 && back != 0) {
288 pos = list_entry(pos->node.prev, struct disasm_line, node);
289
290 if (disasm_line__filter(&browser->b, &pos->node))
291 continue;
292
293 --browser->b.top_idx;
294 --back;
295 }
296
297 browser->b.top = pos;
298 browser->b.navkeypressed = true;
299}
300
301static void annotate_browser__set_rb_top(struct annotate_browser *browser,
302 struct rb_node *nd)
303{
304 struct browser_disasm_line *bpos;
305 struct disasm_line *pos;
306 u32 idx;
307
308 bpos = rb_entry(nd, struct browser_disasm_line, rb_node);
309 pos = ((struct disasm_line *)bpos) - 1;
310 idx = bpos->idx;
311 if (annotate_browser__opts.hide_src_code)
312 idx = bpos->idx_asm;
313 annotate_browser__set_top(browser, pos, idx);
314 browser->curr_hot = nd;
315}
316
317static void annotate_browser__calc_percent(struct annotate_browser *browser,
318 int evidx)
319{
320 struct map_symbol *ms = browser->b.priv;
321 struct symbol *sym = ms->sym;
322 struct annotation *notes = symbol__annotation(sym);
323 struct disasm_line *pos;
324
325 browser->entries = RB_ROOT;
326
327 pthread_mutex_lock(¬es->lock);
328
329 list_for_each_entry(pos, ¬es->src->source, node) {
330 struct browser_disasm_line *bpos = disasm_line__browser(pos);
331 bpos->percent = disasm_line__calc_percent(pos, sym, evidx);
332 if (bpos->percent < 0.01) {
333 RB_CLEAR_NODE(&bpos->rb_node);
334 continue;
335 }
336 disasm_rb_tree__insert(&browser->entries, bpos);
337 }
338 pthread_mutex_unlock(¬es->lock);
339
340 browser->curr_hot = rb_last(&browser->entries);
341}
342
343static bool annotate_browser__toggle_source(struct annotate_browser *browser)
344{
345 struct disasm_line *dl;
346 struct browser_disasm_line *bdl;
347 off_t offset = browser->b.index - browser->b.top_idx;
348
349 browser->b.seek(&browser->b, offset, SEEK_CUR);
350 dl = list_entry(browser->b.top, struct disasm_line, node);
351 bdl = disasm_line__browser(dl);
352
353 if (annotate_browser__opts.hide_src_code) {
354 if (bdl->idx_asm < offset)
355 offset = bdl->idx;
356
357 browser->b.nr_entries = browser->nr_entries;
358 annotate_browser__opts.hide_src_code = false;
359 browser->b.seek(&browser->b, -offset, SEEK_CUR);
360 browser->b.top_idx = bdl->idx - offset;
361 browser->b.index = bdl->idx;
362 } else {
363 if (bdl->idx_asm < 0) {
364 ui_helpline__puts("Only available for assembly lines.");
365 browser->b.seek(&browser->b, -offset, SEEK_CUR);
366 return false;
367 }
368
369 if (bdl->idx_asm < offset)
370 offset = bdl->idx_asm;
371
372 browser->b.nr_entries = browser->nr_asm_entries;
373 annotate_browser__opts.hide_src_code = true;
374 browser->b.seek(&browser->b, -offset, SEEK_CUR);
375 browser->b.top_idx = bdl->idx_asm - offset;
376 browser->b.index = bdl->idx_asm;
377 }
378
379 return true;
380}
381
382static void annotate_browser__init_asm_mode(struct annotate_browser *browser)
383{
384 ui_browser__reset_index(&browser->b);
385 browser->b.nr_entries = browser->nr_asm_entries;
386}
387
388static bool annotate_browser__callq(struct annotate_browser *browser,
389 int evidx, void (*timer)(void *arg),
390 void *arg, int delay_secs)
391{
392 struct map_symbol *ms = browser->b.priv;
393 struct disasm_line *dl = browser->selection;
394 struct symbol *sym = ms->sym;
395 struct annotation *notes;
396 struct symbol *target;
397 u64 ip;
398
399 if (!ins__is_call(dl->ins))
400 return false;
401
402 ip = ms->map->map_ip(ms->map, dl->ops.target.addr);
403 target = map__find_symbol(ms->map, ip, NULL);
404 if (target == NULL) {
405 ui_helpline__puts("The called function was not found.");
406 return true;
407 }
408
409 notes = symbol__annotation(target);
410 pthread_mutex_lock(¬es->lock);
411
412 if (notes->src == NULL && symbol__alloc_hist(target) < 0) {
413 pthread_mutex_unlock(¬es->lock);
414 ui__warning("Not enough memory for annotating '%s' symbol!\n",
415 target->name);
416 return true;
417 }
418
419 pthread_mutex_unlock(¬es->lock);
420 symbol__tui_annotate(target, ms->map, evidx, timer, arg, delay_secs);
421 ui_browser__show_title(&browser->b, sym->name);
422 return true;
423}
424
425static
426struct disasm_line *annotate_browser__find_offset(struct annotate_browser *browser,
427 s64 offset, s64 *idx)
428{
429 struct map_symbol *ms = browser->b.priv;
430 struct symbol *sym = ms->sym;
431 struct annotation *notes = symbol__annotation(sym);
432 struct disasm_line *pos;
433
434 *idx = 0;
435 list_for_each_entry(pos, ¬es->src->source, node) {
436 if (pos->offset == offset)
437 return pos;
438 if (!disasm_line__filter(&browser->b, &pos->node))
439 ++*idx;
440 }
441
442 return NULL;
443}
444
445static bool annotate_browser__jump(struct annotate_browser *browser)
446{
447 struct disasm_line *dl = browser->selection;
448 s64 idx;
449
450 if (!ins__is_jump(dl->ins))
451 return false;
452
453 dl = annotate_browser__find_offset(browser, dl->ops.target.offset, &idx);
454 if (dl == NULL) {
455 ui_helpline__puts("Invallid jump offset");
456 return true;
457 }
458
459 annotate_browser__set_top(browser, dl, idx);
460
461 return true;
462}
463
464static
465struct disasm_line *annotate_browser__find_string(struct annotate_browser *browser,
466 char *s, s64 *idx)
467{
468 struct map_symbol *ms = browser->b.priv;
469 struct symbol *sym = ms->sym;
470 struct annotation *notes = symbol__annotation(sym);
471 struct disasm_line *pos = browser->selection;
472
473 *idx = browser->b.index;
474 list_for_each_entry_continue(pos, ¬es->src->source, node) {
475 if (disasm_line__filter(&browser->b, &pos->node))
476 continue;
477
478 ++*idx;
479
480 if (pos->line && strstr(pos->line, s) != NULL)
481 return pos;
482 }
483
484 return NULL;
485}
486
487static bool __annotate_browser__search(struct annotate_browser *browser)
488{
489 struct disasm_line *dl;
490 s64 idx;
491
492 dl = annotate_browser__find_string(browser, browser->search_bf, &idx);
493 if (dl == NULL) {
494 ui_helpline__puts("String not found!");
495 return false;
496 }
497
498 annotate_browser__set_top(browser, dl, idx);
499 browser->searching_backwards = false;
500 return true;
501}
502
503static
504struct disasm_line *annotate_browser__find_string_reverse(struct annotate_browser *browser,
505 char *s, s64 *idx)
506{
507 struct map_symbol *ms = browser->b.priv;
508 struct symbol *sym = ms->sym;
509 struct annotation *notes = symbol__annotation(sym);
510 struct disasm_line *pos = browser->selection;
511
512 *idx = browser->b.index;
513 list_for_each_entry_continue_reverse(pos, ¬es->src->source, node) {
514 if (disasm_line__filter(&browser->b, &pos->node))
515 continue;
516
517 --*idx;
518
519 if (pos->line && strstr(pos->line, s) != NULL)
520 return pos;
521 }
522
523 return NULL;
524}
525
526static bool __annotate_browser__search_reverse(struct annotate_browser *browser)
527{
528 struct disasm_line *dl;
529 s64 idx;
530
531 dl = annotate_browser__find_string_reverse(browser, browser->search_bf, &idx);
532 if (dl == NULL) {
533 ui_helpline__puts("String not found!");
534 return false;
535 }
536
537 annotate_browser__set_top(browser, dl, idx);
538 browser->searching_backwards = true;
539 return true;
540}
541
542static bool annotate_browser__search_window(struct annotate_browser *browser,
543 int delay_secs)
544{
545 if (ui_browser__input_window("Search", "String: ", browser->search_bf,
546 "ENTER: OK, ESC: Cancel",
547 delay_secs * 2) != K_ENTER ||
548 !*browser->search_bf)
549 return false;
550
551 return true;
552}
553
554static bool annotate_browser__search(struct annotate_browser *browser, int delay_secs)
555{
556 if (annotate_browser__search_window(browser, delay_secs))
557 return __annotate_browser__search(browser);
558
559 return false;
560}
561
562static bool annotate_browser__continue_search(struct annotate_browser *browser,
563 int delay_secs)
564{
565 if (!*browser->search_bf)
566 return annotate_browser__search(browser, delay_secs);
567
568 return __annotate_browser__search(browser);
569}
570
571static bool annotate_browser__search_reverse(struct annotate_browser *browser,
572 int delay_secs)
573{
574 if (annotate_browser__search_window(browser, delay_secs))
575 return __annotate_browser__search_reverse(browser);
576
577 return false;
578}
579
580static
581bool annotate_browser__continue_search_reverse(struct annotate_browser *browser,
582 int delay_secs)
583{
584 if (!*browser->search_bf)
585 return annotate_browser__search_reverse(browser, delay_secs);
586
587 return __annotate_browser__search_reverse(browser);
588}
589
590static void annotate_browser__update_addr_width(struct annotate_browser *browser)
591{
592 if (annotate_browser__opts.use_offset)
593 browser->target_width = browser->min_addr_width;
594 else
595 browser->target_width = browser->max_addr_width;
596
597 browser->addr_width = browser->target_width;
598
599 if (annotate_browser__opts.show_nr_jumps)
600 browser->addr_width += browser->jumps_width + 1;
601}
602
603static int annotate_browser__run(struct annotate_browser *browser, int evidx,
604 void(*timer)(void *arg),
605 void *arg, int delay_secs)
606{
607 struct rb_node *nd = NULL;
608 struct map_symbol *ms = browser->b.priv;
609 struct symbol *sym = ms->sym;
610 const char *help = "Press 'h' for help on key bindings";
611 int key;
612
613 if (ui_browser__show(&browser->b, sym->name, help) < 0)
614 return -1;
615
616 annotate_browser__calc_percent(browser, evidx);
617
618 if (browser->curr_hot) {
619 annotate_browser__set_rb_top(browser, browser->curr_hot);
620 browser->b.navkeypressed = false;
621 }
622
623 nd = browser->curr_hot;
624
625 while (1) {
626 key = ui_browser__run(&browser->b, delay_secs);
627
628 if (delay_secs != 0) {
629 annotate_browser__calc_percent(browser, evidx);
630 /*
631 * Current line focus got out of the list of most active
632 * lines, NULL it so that if TAB|UNTAB is pressed, we
633 * move to curr_hot (current hottest line).
634 */
635 if (nd != NULL && RB_EMPTY_NODE(nd))
636 nd = NULL;
637 }
638
639 switch (key) {
640 case K_TIMER:
641 if (timer != NULL)
642 timer(arg);
643
644 if (delay_secs != 0)
645 symbol__annotate_decay_histogram(sym, evidx);
646 continue;
647 case K_TAB:
648 if (nd != NULL) {
649 nd = rb_prev(nd);
650 if (nd == NULL)
651 nd = rb_last(&browser->entries);
652 } else
653 nd = browser->curr_hot;
654 break;
655 case K_UNTAB:
656 if (nd != NULL)
657 nd = rb_next(nd);
658 if (nd == NULL)
659 nd = rb_first(&browser->entries);
660 else
661 nd = browser->curr_hot;
662 break;
663 case K_F1:
664 case 'h':
665 ui_browser__help_window(&browser->b,
666 "UP/DOWN/PGUP\n"
667 "PGDN/SPACE Navigate\n"
668 "q/ESC/CTRL+C Exit\n\n"
669 "-> Go to target\n"
670 "<- Exit\n"
671 "H Cycle thru hottest instructions\n"
672 "j Toggle showing jump to target arrows\n"
673 "J Toggle showing number of jump sources on targets\n"
674 "n Search next string\n"
675 "o Toggle disassembler output/simplified view\n"
676 "s Toggle source code view\n"
677 "/ Search string\n"
678 "? Search previous string\n");
679 continue;
680 case 'H':
681 nd = browser->curr_hot;
682 break;
683 case 's':
684 if (annotate_browser__toggle_source(browser))
685 ui_helpline__puts(help);
686 continue;
687 case 'o':
688 annotate_browser__opts.use_offset = !annotate_browser__opts.use_offset;
689 annotate_browser__update_addr_width(browser);
690 continue;
691 case 'j':
692 annotate_browser__opts.jump_arrows = !annotate_browser__opts.jump_arrows;
693 continue;
694 case 'J':
695 annotate_browser__opts.show_nr_jumps = !annotate_browser__opts.show_nr_jumps;
696 annotate_browser__update_addr_width(browser);
697 continue;
698 case '/':
699 if (annotate_browser__search(browser, delay_secs)) {
700show_help:
701 ui_helpline__puts(help);
702 }
703 continue;
704 case 'n':
705 if (browser->searching_backwards ?
706 annotate_browser__continue_search_reverse(browser, delay_secs) :
707 annotate_browser__continue_search(browser, delay_secs))
708 goto show_help;
709 continue;
710 case '?':
711 if (annotate_browser__search_reverse(browser, delay_secs))
712 goto show_help;
713 continue;
714 case 'D': {
715 static int seq;
716 ui_helpline__pop();
717 ui_helpline__fpush("%d: nr_ent=%d, height=%d, idx=%d, top_idx=%d, nr_asm_entries=%d",
718 seq++, browser->b.nr_entries,
719 browser->b.height,
720 browser->b.index,
721 browser->b.top_idx,
722 browser->nr_asm_entries);
723 }
724 continue;
725 case K_ENTER:
726 case K_RIGHT:
727 if (browser->selection == NULL)
728 ui_helpline__puts("Huh? No selection. Report to linux-kernel@vger.kernel.org");
729 else if (browser->selection->offset == -1)
730 ui_helpline__puts("Actions are only available for assembly lines.");
731 else if (!browser->selection->ins) {
732 if (strcmp(browser->selection->name, "retq"))
733 goto show_sup_ins;
734 goto out;
735 } else if (!(annotate_browser__jump(browser) ||
736 annotate_browser__callq(browser, evidx, timer, arg, delay_secs))) {
737show_sup_ins:
738 ui_helpline__puts("Actions are only available for 'callq', 'retq' & jump instructions.");
739 }
740 continue;
741 case K_LEFT:
742 case K_ESC:
743 case 'q':
744 case CTRL('c'):
745 goto out;
746 default:
747 continue;
748 }
749
750 if (nd != NULL)
751 annotate_browser__set_rb_top(browser, nd);
752 }
753out:
754 ui_browser__hide(&browser->b);
755 return key;
756}
757
758int hist_entry__tui_annotate(struct hist_entry *he, int evidx,
759 void(*timer)(void *arg), void *arg, int delay_secs)
760{
761 return symbol__tui_annotate(he->ms.sym, he->ms.map, evidx,
762 timer, arg, delay_secs);
763}
764
765static void annotate_browser__mark_jump_targets(struct annotate_browser *browser,
766 size_t size)
767{
768 u64 offset;
769
770 for (offset = 0; offset < size; ++offset) {
771 struct disasm_line *dl = browser->offsets[offset], *dlt;
772 struct browser_disasm_line *bdlt;
773
774 if (!dl || !dl->ins || !ins__is_jump(dl->ins) ||
775 !disasm_line__has_offset(dl))
776 continue;
777
778 if (dl->ops.target.offset >= size) {
779 ui__error("jump to after symbol!\n"
780 "size: %zx, jump target: %" PRIx64,
781 size, dl->ops.target.offset);
782 continue;
783 }
784
785 dlt = browser->offsets[dl->ops.target.offset];
786 /*
787 * FIXME: Oops, no jump target? Buggy disassembler? Or do we
788 * have to adjust to the previous offset?
789 */
790 if (dlt == NULL)
791 continue;
792
793 bdlt = disasm_line__browser(dlt);
794 if (++bdlt->jump_sources > browser->max_jump_sources)
795 browser->max_jump_sources = bdlt->jump_sources;
796
797 ++browser->nr_jumps;
798 }
799
800}
801
802static inline int width_jumps(int n)
803{
804 if (n >= 100)
805 return 5;
806 if (n / 10)
807 return 2;
808 return 1;
809}
810
811int symbol__tui_annotate(struct symbol *sym, struct map *map, int evidx,
812 void(*timer)(void *arg), void *arg,
813 int delay_secs)
814{
815 struct disasm_line *pos, *n;
816 struct annotation *notes;
817 const size_t size = symbol__size(sym);
818 struct map_symbol ms = {
819 .map = map,
820 .sym = sym,
821 };
822 struct annotate_browser browser = {
823 .b = {
824 .refresh = annotate_browser__refresh,
825 .seek = ui_browser__list_head_seek,
826 .write = annotate_browser__write,
827 .filter = disasm_line__filter,
828 .priv = &ms,
829 .use_navkeypressed = true,
830 },
831 };
832 int ret = -1;
833
834 if (sym == NULL)
835 return -1;
836
837 if (map->dso->annotate_warned)
838 return -1;
839
840 browser.offsets = zalloc(size * sizeof(struct disasm_line *));
841 if (browser.offsets == NULL) {
842 ui__error("Not enough memory!");
843 return -1;
844 }
845
846 if (symbol__annotate(sym, map, sizeof(struct browser_disasm_line)) < 0) {
847 ui__error("%s", ui_helpline__last_msg);
848 goto out_free_offsets;
849 }
850
851 ui_helpline__push("Press <- or ESC to exit");
852
853 notes = symbol__annotation(sym);
854 browser.start = map__rip_2objdump(map, sym->start);
855
856 list_for_each_entry(pos, ¬es->src->source, node) {
857 struct browser_disasm_line *bpos;
858 size_t line_len = strlen(pos->line);
859
860 if (browser.b.width < line_len)
861 browser.b.width = line_len;
862 bpos = disasm_line__browser(pos);
863 bpos->idx = browser.nr_entries++;
864 if (pos->offset != -1) {
865 bpos->idx_asm = browser.nr_asm_entries++;
866 /*
867 * FIXME: short term bandaid to cope with assembly
868 * routines that comes with labels in the same column
869 * as the address in objdump, sigh.
870 *
871 * E.g. copy_user_generic_unrolled
872 */
873 if (pos->offset < (s64)size)
874 browser.offsets[pos->offset] = pos;
875 } else
876 bpos->idx_asm = -1;
877 }
878
879 annotate_browser__mark_jump_targets(&browser, size);
880
881 browser.addr_width = browser.target_width = browser.min_addr_width = hex_width(size);
882 browser.max_addr_width = hex_width(sym->end);
883 browser.jumps_width = width_jumps(browser.max_jump_sources);
884 browser.b.nr_entries = browser.nr_entries;
885 browser.b.entries = ¬es->src->source,
886 browser.b.width += 18; /* Percentage */
887
888 if (annotate_browser__opts.hide_src_code)
889 annotate_browser__init_asm_mode(&browser);
890
891 annotate_browser__update_addr_width(&browser);
892
893 ret = annotate_browser__run(&browser, evidx, timer, arg, delay_secs);
894 list_for_each_entry_safe(pos, n, ¬es->src->source, node) {
895 list_del(&pos->node);
896 disasm_line__free(pos);
897 }
898
899out_free_offsets:
900 free(browser.offsets);
901 return ret;
902}
903
904#define ANNOTATE_CFG(n) \
905 { .name = #n, .value = &annotate_browser__opts.n, }
906
907/*
908 * Keep the entries sorted, they are bsearch'ed
909 */
910static struct annotate__config {
911 const char *name;
912 bool *value;
913} annotate__configs[] = {
914 ANNOTATE_CFG(hide_src_code),
915 ANNOTATE_CFG(jump_arrows),
916 ANNOTATE_CFG(show_nr_jumps),
917 ANNOTATE_CFG(use_offset),
918};
919
920#undef ANNOTATE_CFG
921
922static int annotate_config__cmp(const void *name, const void *cfgp)
923{
924 const struct annotate__config *cfg = cfgp;
925
926 return strcmp(name, cfg->name);
927}
928
929static int annotate__config(const char *var, const char *value, void *data __used)
930{
931 struct annotate__config *cfg;
932 const char *name;
933
934 if (prefixcmp(var, "annotate.") != 0)
935 return 0;
936
937 name = var + 9;
938 cfg = bsearch(name, annotate__configs, ARRAY_SIZE(annotate__configs),
939 sizeof(struct annotate__config), annotate_config__cmp);
940
941 if (cfg == NULL)
942 return -1;
943
944 *cfg->value = perf_config_bool(name, value);
945 return 0;
946}
947
948void annotate_browser__init(void)
949{
950 perf_config(annotate__config, NULL);
951}