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