?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge branch 'perf-urgent-for-linus' of git://git.kernel.org/pub/scm/linux/kernel...
[cris-mirror.git] / tools / perf / ui / browsers / annotate.c
blob2e2d10022355ba0303f4462a21758eec773986d0
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
14 struct disasm_line_samples {
15 double percent;
16 u64 nr;
17 };
18
19 #define IPC_WIDTH 6
20 #define CYCLES_WIDTH 6
21
22 struct 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
34 static 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
46 struct 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
68 static inline struct browser_disasm_line *disasm_line__browser(struct disasm_line *dl)
69 {
70 return (struct browser_disasm_line *)(dl + 1);
71 }
72
73 static 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
84 static 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
96 static 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
103 static 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
112 static 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 && dl->ins->ops->scnprintf) {
217 if (ins__is_jump(dl->ins)) {
218 bool fwd = dl->ops.target.offset > (u64)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
244 static bool disasm_line__is_valid_jump(struct disasm_line *dl, struct symbol *sym)
245 {
246 if (!dl || !dl->ins || !ins__is_jump(dl->ins)
247 || !disasm_line__has_offset(dl)
248 || dl->ops.target.offset >= symbol__size(sym))
249 return false;
250
251 return true;
252 }
253
254 static void annotate_browser__draw_current_jump(struct ui_browser *browser)
255 {
256 struct annotate_browser *ab = container_of(browser, struct annotate_browser, b);
257 struct disasm_line *cursor = ab->selection, *target;
258 struct browser_disasm_line *btarget, *bcursor;
259 unsigned int from, to;
260 struct map_symbol *ms = ab->b.priv;
261 struct symbol *sym = ms->sym;
262 u8 pcnt_width = annotate_browser__pcnt_width(ab);
263
264 /* PLT symbols contain external offsets */
265 if (strstr(sym->name, "@plt"))
266 return;
267
268 if (!disasm_line__is_valid_jump(cursor, sym))
269 return;
270
271 target = ab->offsets[cursor->ops.target.offset];
272 if (!target)
273 return;
274
275 bcursor = disasm_line__browser(cursor);
276 btarget = disasm_line__browser(target);
277
278 if (annotate_browser__opts.hide_src_code) {
279 from = bcursor->idx_asm;
280 to = btarget->idx_asm;
281 } else {
282 from = (u64)bcursor->idx;
283 to = (u64)btarget->idx;
284 }
285
286 ui_browser__set_color(browser, HE_COLORSET_JUMP_ARROWS);
287 __ui_browser__line_arrow(browser, pcnt_width + 2 + ab->addr_width,
288 from, to);
289 }
290
291 static unsigned int annotate_browser__refresh(struct ui_browser *browser)
292 {
293 struct annotate_browser *ab = container_of(browser, struct annotate_browser, b);
294 int ret = ui_browser__list_head_refresh(browser);
295 int pcnt_width = annotate_browser__pcnt_width(ab);
296
297 if (annotate_browser__opts.jump_arrows)
298 annotate_browser__draw_current_jump(browser);
299
300 ui_browser__set_color(browser, HE_COLORSET_NORMAL);
301 __ui_browser__vline(browser, pcnt_width, 0, browser->height - 1);
302 return ret;
303 }
304
305 static int disasm__cmp(struct browser_disasm_line *a,
306 struct browser_disasm_line *b, int nr_pcnt)
307 {
308 int i;
309
310 for (i = 0; i < nr_pcnt; i++) {
311 if (a->samples[i].percent == b->samples[i].percent)
312 continue;
313 return a->samples[i].percent < b->samples[i].percent;
314 }
315 return 0;
316 }
317
318 static void disasm_rb_tree__insert(struct rb_root *root, struct browser_disasm_line *bdl,
319 int nr_events)
320 {
321 struct rb_node **p = &root->rb_node;
322 struct rb_node *parent = NULL;
323 struct browser_disasm_line *l;
324
325 while (*p != NULL) {
326 parent = *p;
327 l = rb_entry(parent, struct browser_disasm_line, rb_node);
328
329 if (disasm__cmp(bdl, l, nr_events))
330 p = &(*p)->rb_left;
331 else
332 p = &(*p)->rb_right;
333 }
334 rb_link_node(&bdl->rb_node, parent, p);
335 rb_insert_color(&bdl->rb_node, root);
336 }
337
338 static void annotate_browser__set_top(struct annotate_browser *browser,
339 struct disasm_line *pos, u32 idx)
340 {
341 unsigned back;
342
343 ui_browser__refresh_dimensions(&browser->b);
344 back = browser->b.height / 2;
345 browser->b.top_idx = browser->b.index = idx;
346
347 while (browser->b.top_idx != 0 && back != 0) {
348 pos = list_entry(pos->node.prev, struct disasm_line, node);
349
350 if (disasm_line__filter(&browser->b, &pos->node))
351 continue;
352
353 --browser->b.top_idx;
354 --back;
355 }
356
357 browser->b.top = pos;
358 browser->b.navkeypressed = true;
359 }
360
361 static void annotate_browser__set_rb_top(struct annotate_browser *browser,
362 struct rb_node *nd)
363 {
364 struct browser_disasm_line *bpos;
365 struct disasm_line *pos;
366 u32 idx;
367
368 bpos = rb_entry(nd, struct browser_disasm_line, rb_node);
369 pos = ((struct disasm_line *)bpos) - 1;
370 idx = bpos->idx;
371 if (annotate_browser__opts.hide_src_code)
372 idx = bpos->idx_asm;
373 annotate_browser__set_top(browser, pos, idx);
374 browser->curr_hot = nd;
375 }
376
377 static void annotate_browser__calc_percent(struct annotate_browser *browser,
378 struct perf_evsel *evsel)
379 {
380 struct map_symbol *ms = browser->b.priv;
381 struct symbol *sym = ms->sym;
382 struct annotation *notes = symbol__annotation(sym);
383 struct disasm_line *pos, *next;
384 s64 len = symbol__size(sym);
385
386 browser->entries = RB_ROOT;
387
388 pthread_mutex_lock(&notes->lock);
389
390 list_for_each_entry(pos, &notes->src->source, node) {
391 struct browser_disasm_line *bpos = disasm_line__browser(pos);
392 const char *path = NULL;
393 double max_percent = 0.0;
394 int i;
395
396 if (pos->offset == -1) {
397 RB_CLEAR_NODE(&bpos->rb_node);
398 continue;
399 }
400
401 next = disasm__get_next_ip_line(&notes->src->source, pos);
402
403 for (i = 0; i < browser->nr_events; i++) {
404 u64 nr_samples;
405
406 bpos->samples[i].percent = disasm__calc_percent(notes,
407 evsel->idx + i,
408 pos->offset,
409 next ? next->offset : len,
410 &path, &nr_samples);
411 bpos->samples[i].nr = nr_samples;
412
413 if (max_percent < bpos->samples[i].percent)
414 max_percent = bpos->samples[i].percent;
415 }
416
417 if (max_percent < 0.01 && pos->ipc == 0) {
418 RB_CLEAR_NODE(&bpos->rb_node);
419 continue;
420 }
421 disasm_rb_tree__insert(&browser->entries, bpos,
422 browser->nr_events);
423 }
424 pthread_mutex_unlock(&notes->lock);
425
426 browser->curr_hot = rb_last(&browser->entries);
427 }
428
429 static bool annotate_browser__toggle_source(struct annotate_browser *browser)
430 {
431 struct disasm_line *dl;
432 struct browser_disasm_line *bdl;
433 off_t offset = browser->b.index - browser->b.top_idx;
434
435 browser->b.seek(&browser->b, offset, SEEK_CUR);
436 dl = list_entry(browser->b.top, struct disasm_line, node);
437 bdl = disasm_line__browser(dl);
438
439 if (annotate_browser__opts.hide_src_code) {
440 if (bdl->idx_asm < offset)
441 offset = bdl->idx;
442
443 browser->b.nr_entries = browser->nr_entries;
444 annotate_browser__opts.hide_src_code = false;
445 browser->b.seek(&browser->b, -offset, SEEK_CUR);
446 browser->b.top_idx = bdl->idx - offset;
447 browser->b.index = bdl->idx;
448 } else {
449 if (bdl->idx_asm < 0) {
450 ui_helpline__puts("Only available for assembly lines.");
451 browser->b.seek(&browser->b, -offset, SEEK_CUR);
452 return false;
453 }
454
455 if (bdl->idx_asm < offset)
456 offset = bdl->idx_asm;
457
458 browser->b.nr_entries = browser->nr_asm_entries;
459 annotate_browser__opts.hide_src_code = true;
460 browser->b.seek(&browser->b, -offset, SEEK_CUR);
461 browser->b.top_idx = bdl->idx_asm - offset;
462 browser->b.index = bdl->idx_asm;
463 }
464
465 return true;
466 }
467
468 static void annotate_browser__init_asm_mode(struct annotate_browser *browser)
469 {
470 ui_browser__reset_index(&browser->b);
471 browser->b.nr_entries = browser->nr_asm_entries;
472 }
473
474 #define SYM_TITLE_MAX_SIZE (PATH_MAX + 64)
475
476 static int sym_title(struct symbol *sym, struct map *map, char *title,
477 size_t sz)
478 {
479 return snprintf(title, sz, "%s %s", sym->name, map->dso->long_name);
480 }
481
482 static bool annotate_browser__callq(struct annotate_browser *browser,
483 struct perf_evsel *evsel,
484 struct hist_browser_timer *hbt)
485 {
486 struct map_symbol *ms = browser->b.priv;
487 struct disasm_line *dl = browser->selection;
488 struct annotation *notes;
489 struct addr_map_symbol target = {
490 .map = ms->map,
491 .addr = map__objdump_2mem(ms->map, dl->ops.target.addr),
492 };
493 char title[SYM_TITLE_MAX_SIZE];
494
495 if (!ins__is_call(dl->ins))
496 return false;
497
498 if (map_groups__find_ams(&target, NULL) ||
499 map__rip_2objdump(target.map, target.map->map_ip(target.map,
500 target.addr)) !=
501 dl->ops.target.addr) {
502 ui_helpline__puts("The called function was not found.");
503 return true;
504 }
505
506 notes = symbol__annotation(target.sym);
507 pthread_mutex_lock(&notes->lock);
508
509 if (notes->src == NULL && symbol__alloc_hist(target.sym) < 0) {
510 pthread_mutex_unlock(&notes->lock);
511 ui__warning("Not enough memory for annotating '%s' symbol!\n",
512 target.sym->name);
513 return true;
514 }
515
516 pthread_mutex_unlock(&notes->lock);
517 symbol__tui_annotate(target.sym, target.map, evsel, hbt);
518 sym_title(ms->sym, ms->map, title, sizeof(title));
519 ui_browser__show_title(&browser->b, title);
520 return true;
521 }
522
523 static
524 struct disasm_line *annotate_browser__find_offset(struct annotate_browser *browser,
525 s64 offset, s64 *idx)
526 {
527 struct map_symbol *ms = browser->b.priv;
528 struct symbol *sym = ms->sym;
529 struct annotation *notes = symbol__annotation(sym);
530 struct disasm_line *pos;
531
532 *idx = 0;
533 list_for_each_entry(pos, &notes->src->source, node) {
534 if (pos->offset == offset)
535 return pos;
536 if (!disasm_line__filter(&browser->b, &pos->node))
537 ++*idx;
538 }
539
540 return NULL;
541 }
542
543 static bool annotate_browser__jump(struct annotate_browser *browser)
544 {
545 struct disasm_line *dl = browser->selection;
546 s64 idx;
547
548 if (!ins__is_jump(dl->ins))
549 return false;
550
551 dl = annotate_browser__find_offset(browser, dl->ops.target.offset, &idx);
552 if (dl == NULL) {
553 ui_helpline__puts("Invalid jump offset");
554 return true;
555 }
556
557 annotate_browser__set_top(browser, dl, idx);
558
559 return true;
560 }
561
562 static
563 struct disasm_line *annotate_browser__find_string(struct annotate_browser *browser,
564 char *s, s64 *idx)
565 {
566 struct map_symbol *ms = browser->b.priv;
567 struct symbol *sym = ms->sym;
568 struct annotation *notes = symbol__annotation(sym);
569 struct disasm_line *pos = browser->selection;
570
571 *idx = browser->b.index;
572 list_for_each_entry_continue(pos, &notes->src->source, node) {
573 if (disasm_line__filter(&browser->b, &pos->node))
574 continue;
575
576 ++*idx;
577
578 if (pos->line && strstr(pos->line, s) != NULL)
579 return pos;
580 }
581
582 return NULL;
583 }
584
585 static bool __annotate_browser__search(struct annotate_browser *browser)
586 {
587 struct disasm_line *dl;
588 s64 idx;
589
590 dl = annotate_browser__find_string(browser, browser->search_bf, &idx);
591 if (dl == NULL) {
592 ui_helpline__puts("String not found!");
593 return false;
594 }
595
596 annotate_browser__set_top(browser, dl, idx);
597 browser->searching_backwards = false;
598 return true;
599 }
600
601 static
602 struct disasm_line *annotate_browser__find_string_reverse(struct annotate_browser *browser,
603 char *s, s64 *idx)
604 {
605 struct map_symbol *ms = browser->b.priv;
606 struct symbol *sym = ms->sym;
607 struct annotation *notes = symbol__annotation(sym);
608 struct disasm_line *pos = browser->selection;
609
610 *idx = browser->b.index;
611 list_for_each_entry_continue_reverse(pos, &notes->src->source, node) {
612 if (disasm_line__filter(&browser->b, &pos->node))
613 continue;
614
615 --*idx;
616
617 if (pos->line && strstr(pos->line, s) != NULL)
618 return pos;
619 }
620
621 return NULL;
622 }
623
624 static bool __annotate_browser__search_reverse(struct annotate_browser *browser)
625 {
626 struct disasm_line *dl;
627 s64 idx;
628
629 dl = annotate_browser__find_string_reverse(browser, browser->search_bf, &idx);
630 if (dl == NULL) {
631 ui_helpline__puts("String not found!");
632 return false;
633 }
634
635 annotate_browser__set_top(browser, dl, idx);
636 browser->searching_backwards = true;
637 return true;
638 }
639
640 static bool annotate_browser__search_window(struct annotate_browser *browser,
641 int delay_secs)
642 {
643 if (ui_browser__input_window("Search", "String: ", browser->search_bf,
644 "ENTER: OK, ESC: Cancel",
645 delay_secs * 2) != K_ENTER ||
646 !*browser->search_bf)
647 return false;
648
649 return true;
650 }
651
652 static bool annotate_browser__search(struct annotate_browser *browser, int delay_secs)
653 {
654 if (annotate_browser__search_window(browser, delay_secs))
655 return __annotate_browser__search(browser);
656
657 return false;
658 }
659
660 static bool annotate_browser__continue_search(struct annotate_browser *browser,
661 int delay_secs)
662 {
663 if (!*browser->search_bf)
664 return annotate_browser__search(browser, delay_secs);
665
666 return __annotate_browser__search(browser);
667 }
668
669 static bool annotate_browser__search_reverse(struct annotate_browser *browser,
670 int delay_secs)
671 {
672 if (annotate_browser__search_window(browser, delay_secs))
673 return __annotate_browser__search_reverse(browser);
674
675 return false;
676 }
677
678 static
679 bool annotate_browser__continue_search_reverse(struct annotate_browser *browser,
680 int delay_secs)
681 {
682 if (!*browser->search_bf)
683 return annotate_browser__search_reverse(browser, delay_secs);
684
685 return __annotate_browser__search_reverse(browser);
686 }
687
688 static void annotate_browser__update_addr_width(struct annotate_browser *browser)
689 {
690 if (annotate_browser__opts.use_offset)
691 browser->target_width = browser->min_addr_width;
692 else
693 browser->target_width = browser->max_addr_width;
694
695 browser->addr_width = browser->target_width;
696
697 if (annotate_browser__opts.show_nr_jumps)
698 browser->addr_width += browser->jumps_width + 1;
699 }
700
701 static int annotate_browser__run(struct annotate_browser *browser,
702 struct perf_evsel *evsel,
703 struct hist_browser_timer *hbt)
704 {
705 struct rb_node *nd = NULL;
706 struct map_symbol *ms = browser->b.priv;
707 struct symbol *sym = ms->sym;
708 const char *help = "Press 'h' for help on key bindings";
709 int delay_secs = hbt ? hbt->refresh : 0;
710 int key;
711 char title[SYM_TITLE_MAX_SIZE];
712
713 sym_title(sym, ms->map, title, sizeof(title));
714 if (ui_browser__show(&browser->b, title, help) < 0)
715 return -1;
716
717 annotate_browser__calc_percent(browser, evsel);
718
719 if (browser->curr_hot) {
720 annotate_browser__set_rb_top(browser, browser->curr_hot);
721 browser->b.navkeypressed = false;
722 }
723
724 nd = browser->curr_hot;
725
726 while (1) {
727 key = ui_browser__run(&browser->b, delay_secs);
728
729 if (delay_secs != 0) {
730 annotate_browser__calc_percent(browser, evsel);
731 /*
732 * Current line focus got out of the list of most active
733 * lines, NULL it so that if TAB|UNTAB is pressed, we
734 * move to curr_hot (current hottest line).
735 */
736 if (nd != NULL && RB_EMPTY_NODE(nd))
737 nd = NULL;
738 }
739
740 switch (key) {
741 case K_TIMER:
742 if (hbt)
743 hbt->timer(hbt->arg);
744
745 if (delay_secs != 0)
746 symbol__annotate_decay_histogram(sym, evsel->idx);
747 continue;
748 case K_TAB:
749 if (nd != NULL) {
750 nd = rb_prev(nd);
751 if (nd == NULL)
752 nd = rb_last(&browser->entries);
753 } else
754 nd = browser->curr_hot;
755 break;
756 case K_UNTAB:
757 if (nd != NULL) {
758 nd = rb_next(nd);
759 if (nd == NULL)
760 nd = rb_first(&browser->entries);
761 } else
762 nd = browser->curr_hot;
763 break;
764 case K_F1:
765 case 'h':
766 ui_browser__help_window(&browser->b,
767 "UP/DOWN/PGUP\n"
768 "PGDN/SPACE Navigate\n"
769 "q/ESC/CTRL+C Exit\n\n"
770 "ENTER Go to target\n"
771 "ESC Exit\n"
772 "H Cycle thru hottest instructions\n"
773 "j Toggle showing jump to target arrows\n"
774 "J Toggle showing number of jump sources on targets\n"
775 "n Search next string\n"
776 "o Toggle disassembler output/simplified view\n"
777 "s Toggle source code view\n"
778 "t Toggle total period view\n"
779 "/ Search string\n"
780 "k Toggle line numbers\n"
781 "r Run available scripts\n"
782 "? Search string backwards\n");
783 continue;
784 case 'r':
785 {
786 script_browse(NULL);
787 continue;
788 }
789 case 'k':
790 annotate_browser__opts.show_linenr =
791 !annotate_browser__opts.show_linenr;
792 break;
793 case 'H':
794 nd = browser->curr_hot;
795 break;
796 case 's':
797 if (annotate_browser__toggle_source(browser))
798 ui_helpline__puts(help);
799 continue;
800 case 'o':
801 annotate_browser__opts.use_offset = !annotate_browser__opts.use_offset;
802 annotate_browser__update_addr_width(browser);
803 continue;
804 case 'j':
805 annotate_browser__opts.jump_arrows = !annotate_browser__opts.jump_arrows;
806 continue;
807 case 'J':
808 annotate_browser__opts.show_nr_jumps = !annotate_browser__opts.show_nr_jumps;
809 annotate_browser__update_addr_width(browser);
810 continue;
811 case '/':
812 if (annotate_browser__search(browser, delay_secs)) {
813 show_help:
814 ui_helpline__puts(help);
815 }
816 continue;
817 case 'n':
818 if (browser->searching_backwards ?
819 annotate_browser__continue_search_reverse(browser, delay_secs) :
820 annotate_browser__continue_search(browser, delay_secs))
821 goto show_help;
822 continue;
823 case '?':
824 if (annotate_browser__search_reverse(browser, delay_secs))
825 goto show_help;
826 continue;
827 case 'D': {
828 static int seq;
829 ui_helpline__pop();
830 ui_helpline__fpush("%d: nr_ent=%d, height=%d, idx=%d, top_idx=%d, nr_asm_entries=%d",
831 seq++, browser->b.nr_entries,
832 browser->b.height,
833 browser->b.index,
834 browser->b.top_idx,
835 browser->nr_asm_entries);
836 }
837 continue;
838 case K_ENTER:
839 case K_RIGHT:
840 if (browser->selection == NULL)
841 ui_helpline__puts("Huh? No selection. Report to linux-kernel@vger.kernel.org");
842 else if (browser->selection->offset == -1)
843 ui_helpline__puts("Actions are only available for assembly lines.");
844 else if (!browser->selection->ins)
845 goto show_sup_ins;
846 else if (ins__is_ret(browser->selection->ins))
847 goto out;
848 else if (!(annotate_browser__jump(browser) ||
849 annotate_browser__callq(browser, evsel, hbt))) {
850 show_sup_ins:
851 ui_helpline__puts("Actions are only available for function call/return & jump/branch instructions.");
852 }
853 continue;
854 case 't':
855 annotate_browser__opts.show_total_period =
856 !annotate_browser__opts.show_total_period;
857 annotate_browser__update_addr_width(browser);
858 continue;
859 case K_LEFT:
860 case K_ESC:
861 case 'q':
862 case CTRL('c'):
863 goto out;
864 default:
865 continue;
866 }
867
868 if (nd != NULL)
869 annotate_browser__set_rb_top(browser, nd);
870 }
871 out:
872 ui_browser__hide(&browser->b);
873 return key;
874 }
875
876 int map_symbol__tui_annotate(struct map_symbol *ms, struct perf_evsel *evsel,
877 struct hist_browser_timer *hbt)
878 {
879 /* Set default value for show_total_period. */
880 annotate_browser__opts.show_total_period =
881 symbol_conf.show_total_period;
882
883 return symbol__tui_annotate(ms->sym, ms->map, evsel, hbt);
884 }
885
886 int hist_entry__tui_annotate(struct hist_entry *he, struct perf_evsel *evsel,
887 struct hist_browser_timer *hbt)
888 {
889 /* reset abort key so that it can get Ctrl-C as a key */
890 SLang_reset_tty();
891 SLang_init_tty(0, 0, 0);
892
893 return map_symbol__tui_annotate(&he->ms, evsel, hbt);
894 }
895
896
897 static unsigned count_insn(struct annotate_browser *browser, u64 start, u64 end)
898 {
899 unsigned n_insn = 0;
900 u64 offset;
901
902 for (offset = start; offset <= end; offset++) {
903 if (browser->offsets[offset])
904 n_insn++;
905 }
906 return n_insn;
907 }
908
909 static void count_and_fill(struct annotate_browser *browser, u64 start, u64 end,
910 struct cyc_hist *ch)
911 {
912 unsigned n_insn;
913 u64 offset;
914
915 n_insn = count_insn(browser, start, end);
916 if (n_insn && ch->num && ch->cycles) {
917 float ipc = n_insn / ((double)ch->cycles / (double)ch->num);
918
919 /* Hide data when there are too many overlaps. */
920 if (ch->reset >= 0x7fff || ch->reset >= ch->num / 2)
921 return;
922
923 for (offset = start; offset <= end; offset++) {
924 struct disasm_line *dl = browser->offsets[offset];
925
926 if (dl)
927 dl->ipc = ipc;
928 }
929 }
930 }
931
932 /*
933 * This should probably be in util/annotate.c to share with the tty
934 * annotate, but right now we need the per byte offsets arrays,
935 * which are only here.
936 */
937 static void annotate__compute_ipc(struct annotate_browser *browser, size_t size,
938 struct symbol *sym)
939 {
940 u64 offset;
941 struct annotation *notes = symbol__annotation(sym);
942
943 if (!notes->src || !notes->src->cycles_hist)
944 return;
945
946 pthread_mutex_lock(&notes->lock);
947 for (offset = 0; offset < size; ++offset) {
948 struct cyc_hist *ch;
949
950 ch = &notes->src->cycles_hist[offset];
951 if (ch && ch->cycles) {
952 struct disasm_line *dl;
953
954 if (ch->have_start)
955 count_and_fill(browser, ch->start, offset, ch);
956 dl = browser->offsets[offset];
957 if (dl && ch->num_aggr)
958 dl->cycles = ch->cycles_aggr / ch->num_aggr;
959 browser->have_cycles = true;
960 }
961 }
962 pthread_mutex_unlock(&notes->lock);
963 }
964
965 static void annotate_browser__mark_jump_targets(struct annotate_browser *browser,
966 size_t size)
967 {
968 u64 offset;
969 struct map_symbol *ms = browser->b.priv;
970 struct symbol *sym = ms->sym;
971
972 /* PLT symbols contain external offsets */
973 if (strstr(sym->name, "@plt"))
974 return;
975
976 for (offset = 0; offset < size; ++offset) {
977 struct disasm_line *dl = browser->offsets[offset], *dlt;
978 struct browser_disasm_line *bdlt;
979
980 if (!disasm_line__is_valid_jump(dl, sym))
981 continue;
982
983 dlt = browser->offsets[dl->ops.target.offset];
984 /*
985 * FIXME: Oops, no jump target? Buggy disassembler? Or do we
986 * have to adjust to the previous offset?
987 */
988 if (dlt == NULL)
989 continue;
990
991 bdlt = disasm_line__browser(dlt);
992 if (++bdlt->jump_sources > browser->max_jump_sources)
993 browser->max_jump_sources = bdlt->jump_sources;
994
995 ++browser->nr_jumps;
996 }
997 }
998
999 static inline int width_jumps(int n)
1000 {
1001 if (n >= 100)
1002 return 5;
1003 if (n / 10)
1004 return 2;
1005 return 1;
1006 }
1007
1008 int symbol__tui_annotate(struct symbol *sym, struct map *map,
1009 struct perf_evsel *evsel,
1010 struct hist_browser_timer *hbt)
1011 {
1012 struct disasm_line *pos, *n;
1013 struct annotation *notes;
1014 size_t size;
1015 struct map_symbol ms = {
1016 .map = map,
1017 .sym = sym,
1018 };
1019 struct annotate_browser browser = {
1020 .b = {
1021 .refresh = annotate_browser__refresh,
1022 .seek = ui_browser__list_head_seek,
1023 .write = annotate_browser__write,
1024 .filter = disasm_line__filter,
1025 .priv = &ms,
1026 .use_navkeypressed = true,
1027 },
1028 };
1029 int ret = -1, err;
1030 int nr_pcnt = 1;
1031 size_t sizeof_bdl = sizeof(struct browser_disasm_line);
1032
1033 if (sym == NULL)
1034 return -1;
1035
1036 size = symbol__size(sym);
1037
1038 if (map->dso->annotate_warned)
1039 return -1;
1040
1041 browser.offsets = zalloc(size * sizeof(struct disasm_line *));
1042 if (browser.offsets == NULL) {
1043 ui__error("Not enough memory!");
1044 return -1;
1045 }
1046
1047 if (perf_evsel__is_group_event(evsel)) {
1048 nr_pcnt = evsel->nr_members;
1049 sizeof_bdl += sizeof(struct disasm_line_samples) *
1050 (nr_pcnt - 1);
1051 }
1052
1053 err = symbol__disassemble(sym, map, sizeof_bdl);
1054 if (err) {
1055 char msg[BUFSIZ];
1056 symbol__strerror_disassemble(sym, map, err, msg, sizeof(msg));
1057 ui__error("Couldn't annotate %s:\n%s", sym->name, msg);
1058 goto out_free_offsets;
1059 }
1060
1061 ui_helpline__push("Press ESC to exit");
1062
1063 notes = symbol__annotation(sym);
1064 browser.start = map__rip_2objdump(map, sym->start);
1065
1066 list_for_each_entry(pos, &notes->src->source, node) {
1067 struct browser_disasm_line *bpos;
1068 size_t line_len = strlen(pos->line);
1069
1070 if (browser.b.width < line_len)
1071 browser.b.width = line_len;
1072 bpos = disasm_line__browser(pos);
1073 bpos->idx = browser.nr_entries++;
1074 if (pos->offset != -1) {
1075 bpos->idx_asm = browser.nr_asm_entries++;
1076 /*
1077 * FIXME: short term bandaid to cope with assembly
1078 * routines that comes with labels in the same column
1079 * as the address in objdump, sigh.
1080 *
1081 * E.g. copy_user_generic_unrolled
1082 */
1083 if (pos->offset < (s64)size)
1084 browser.offsets[pos->offset] = pos;
1085 } else
1086 bpos->idx_asm = -1;
1087 }
1088
1089 annotate_browser__mark_jump_targets(&browser, size);
1090 annotate__compute_ipc(&browser, size, sym);
1091
1092 browser.addr_width = browser.target_width = browser.min_addr_width = hex_width(size);
1093 browser.max_addr_width = hex_width(sym->end);
1094 browser.jumps_width = width_jumps(browser.max_jump_sources);
1095 browser.nr_events = nr_pcnt;
1096 browser.b.nr_entries = browser.nr_entries;
1097 browser.b.entries = &notes->src->source,
1098 browser.b.width += 18; /* Percentage */
1099
1100 if (annotate_browser__opts.hide_src_code)
1101 annotate_browser__init_asm_mode(&browser);
1102
1103 annotate_browser__update_addr_width(&browser);
1104
1105 ret = annotate_browser__run(&browser, evsel, hbt);
1106 list_for_each_entry_safe(pos, n, &notes->src->source, node) {
1107 list_del(&pos->node);
1108 disasm_line__free(pos);
1109 }
1110
1111 out_free_offsets:
1112 free(browser.offsets);
1113 return ret;
1114 }
1115
1116 #define ANNOTATE_CFG(n) \
1117 { .name = #n, .value = &annotate_browser__opts.n, }
1118
1119 /*
1120 * Keep the entries sorted, they are bsearch'ed
1121 */
1122 static struct annotate_config {
1123 const char *name;
1124 bool *value;
1125 } annotate__configs[] = {
1126 ANNOTATE_CFG(hide_src_code),
1127 ANNOTATE_CFG(jump_arrows),
1128 ANNOTATE_CFG(show_linenr),
1129 ANNOTATE_CFG(show_nr_jumps),
1130 ANNOTATE_CFG(show_total_period),
1131 ANNOTATE_CFG(use_offset),
1132 };
1133
1134 #undef ANNOTATE_CFG
1135
1136 static int annotate_config__cmp(const void *name, const void *cfgp)
1137 {
1138 const struct annotate_config *cfg = cfgp;
1139
1140 return strcmp(name, cfg->name);
1141 }
1142
1143 static int annotate__config(const char *var, const char *value,
1144 void *data __maybe_unused)
1145 {
1146 struct annotate_config *cfg;
1147 const char *name;
1148
1149 if (prefixcmp(var, "annotate.") != 0)
1150 return 0;
1151
1152 name = var + 9;
1153 cfg = bsearch(name, annotate__configs, ARRAY_SIZE(annotate__configs),
1154 sizeof(struct annotate_config), annotate_config__cmp);
1155
1156 if (cfg == NULL)
1157 ui__warning("%s variable unknown, ignoring...", var);
1158 else
1159 *cfg->value = perf_config_bool(name, value);
1160 return 0;
1161 }
1162
1163 void annotate_browser__init(void)
1164 {
1165 perf_config(annotate__config, NULL);
1166 }
CRIS linux kernel tree