~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/tools/perf/ui/browsers/annotate.c

Version: ~ [ linux-5.2-rc4 ] ~ [ linux-5.1.9 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.50 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.125 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.181 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.181 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.68 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp