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(¬es->lock); 349 350 list_for_each_entry(pos, ¬es->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(¬es->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(¬es->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 #define SYM_TITLE_MAX_SIZE (PATH_MAX + 64) 432 433 static int sym_title(struct symbol *sym, struct map *map, char *title, 434 size_t sz) 435 { 436 return snprintf(title, sz, "%s %s", sym->name, map->dso->long_name); 437 } 438 439 static bool annotate_browser__callq(struct annotate_browser *browser, 440 struct perf_evsel *evsel, 441 struct hist_browser_timer *hbt) 442 { 443 struct map_symbol *ms = browser->b.priv; 444 struct disasm_line *dl = browser->selection; 445 struct symbol *sym = ms->sym; 446 struct annotation *notes; 447 struct symbol *target; 448 u64 ip; 449 char title[SYM_TITLE_MAX_SIZE]; 450 451 if (!ins__is_call(dl->ins)) 452 return false; 453 454 ip = ms->map->map_ip(ms->map, dl->ops.target.addr); 455 target = map__find_symbol(ms->map, ip, NULL); 456 if (target == NULL) { 457 ui_helpline__puts("The called function was not found."); 458 return true; 459 } 460 461 notes = symbol__annotation(target); 462 pthread_mutex_lock(¬es->lock); 463 464 if (notes->src == NULL && symbol__alloc_hist(target) < 0) { 465 pthread_mutex_unlock(¬es->lock); 466 ui__warning("Not enough memory for annotating '%s' symbol!\n", 467 target->name); 468 return true; 469 } 470 471 pthread_mutex_unlock(¬es->lock); 472 symbol__tui_annotate(target, ms->map, evsel, hbt); 473 sym_title(sym, ms->map, title, sizeof(title)); 474 ui_browser__show_title(&browser->b, title); 475 return true; 476 } 477 478 static 479 struct disasm_line *annotate_browser__find_offset(struct annotate_browser *browser, 480 s64 offset, s64 *idx) 481 { 482 struct map_symbol *ms = browser->b.priv; 483 struct symbol *sym = ms->sym; 484 struct annotation *notes = symbol__annotation(sym); 485 struct disasm_line *pos; 486 487 *idx = 0; 488 list_for_each_entry(pos, ¬es->src->source, node) { 489 if (pos->offset == offset) 490 return pos; 491 if (!disasm_line__filter(&browser->b, &pos->node)) 492 ++*idx; 493 } 494 495 return NULL; 496 } 497 498 static bool annotate_browser__jump(struct annotate_browser *browser) 499 { 500 struct disasm_line *dl = browser->selection; 501 s64 idx; 502 503 if (!ins__is_jump(dl->ins)) 504 return false; 505 506 dl = annotate_browser__find_offset(browser, dl->ops.target.offset, &idx); 507 if (dl == NULL) { 508 ui_helpline__puts("Invalid jump offset"); 509 return true; 510 } 511 512 annotate_browser__set_top(browser, dl, idx); 513 514 return true; 515 } 516 517 static 518 struct disasm_line *annotate_browser__find_string(struct annotate_browser *browser, 519 char *s, s64 *idx) 520 { 521 struct map_symbol *ms = browser->b.priv; 522 struct symbol *sym = ms->sym; 523 struct annotation *notes = symbol__annotation(sym); 524 struct disasm_line *pos = browser->selection; 525 526 *idx = browser->b.index; 527 list_for_each_entry_continue(pos, ¬es->src->source, node) { 528 if (disasm_line__filter(&browser->b, &pos->node)) 529 continue; 530 531 ++*idx; 532 533 if (pos->line && strstr(pos->line, s) != NULL) 534 return pos; 535 } 536 537 return NULL; 538 } 539 540 static bool __annotate_browser__search(struct annotate_browser *browser) 541 { 542 struct disasm_line *dl; 543 s64 idx; 544 545 dl = annotate_browser__find_string(browser, browser->search_bf, &idx); 546 if (dl == NULL) { 547 ui_helpline__puts("String not found!"); 548 return false; 549 } 550 551 annotate_browser__set_top(browser, dl, idx); 552 browser->searching_backwards = false; 553 return true; 554 } 555 556 static 557 struct disasm_line *annotate_browser__find_string_reverse(struct annotate_browser *browser, 558 char *s, s64 *idx) 559 { 560 struct map_symbol *ms = browser->b.priv; 561 struct symbol *sym = ms->sym; 562 struct annotation *notes = symbol__annotation(sym); 563 struct disasm_line *pos = browser->selection; 564 565 *idx = browser->b.index; 566 list_for_each_entry_continue_reverse(pos, ¬es->src->source, node) { 567 if (disasm_line__filter(&browser->b, &pos->node)) 568 continue; 569 570 --*idx; 571 572 if (pos->line && strstr(pos->line, s) != NULL) 573 return pos; 574 } 575 576 return NULL; 577 } 578 579 static bool __annotate_browser__search_reverse(struct annotate_browser *browser) 580 { 581 struct disasm_line *dl; 582 s64 idx; 583 584 dl = annotate_browser__find_string_reverse(browser, browser->search_bf, &idx); 585 if (dl == NULL) { 586 ui_helpline__puts("String not found!"); 587 return false; 588 } 589 590 annotate_browser__set_top(browser, dl, idx); 591 browser->searching_backwards = true; 592 return true; 593 } 594 595 static bool annotate_browser__search_window(struct annotate_browser *browser, 596 int delay_secs) 597 { 598 if (ui_browser__input_window("Search", "String: ", browser->search_bf, 599 "ENTER: OK, ESC: Cancel", 600 delay_secs * 2) != K_ENTER || 601 !*browser->search_bf) 602 return false; 603 604 return true; 605 } 606 607 static bool annotate_browser__search(struct annotate_browser *browser, int delay_secs) 608 { 609 if (annotate_browser__search_window(browser, delay_secs)) 610 return __annotate_browser__search(browser); 611 612 return false; 613 } 614 615 static bool annotate_browser__continue_search(struct annotate_browser *browser, 616 int delay_secs) 617 { 618 if (!*browser->search_bf) 619 return annotate_browser__search(browser, delay_secs); 620 621 return __annotate_browser__search(browser); 622 } 623 624 static bool annotate_browser__search_reverse(struct annotate_browser *browser, 625 int delay_secs) 626 { 627 if (annotate_browser__search_window(browser, delay_secs)) 628 return __annotate_browser__search_reverse(browser); 629 630 return false; 631 } 632 633 static 634 bool annotate_browser__continue_search_reverse(struct annotate_browser *browser, 635 int delay_secs) 636 { 637 if (!*browser->search_bf) 638 return annotate_browser__search_reverse(browser, delay_secs); 639 640 return __annotate_browser__search_reverse(browser); 641 } 642 643 static void annotate_browser__update_addr_width(struct annotate_browser *browser) 644 { 645 if (annotate_browser__opts.use_offset) 646 browser->target_width = browser->min_addr_width; 647 else 648 browser->target_width = browser->max_addr_width; 649 650 browser->addr_width = browser->target_width; 651 652 if (annotate_browser__opts.show_nr_jumps) 653 browser->addr_width += browser->jumps_width + 1; 654 } 655 656 static int annotate_browser__run(struct annotate_browser *browser, 657 struct perf_evsel *evsel, 658 struct hist_browser_timer *hbt) 659 { 660 struct rb_node *nd = NULL; 661 struct map_symbol *ms = browser->b.priv; 662 struct symbol *sym = ms->sym; 663 const char *help = "Press 'h' for help on key bindings"; 664 int delay_secs = hbt ? hbt->refresh : 0; 665 int key; 666 char title[SYM_TITLE_MAX_SIZE]; 667 668 sym_title(sym, ms->map, title, sizeof(title)); 669 if (ui_browser__show(&browser->b, title, help) < 0) 670 return -1; 671 672 annotate_browser__calc_percent(browser, evsel); 673 674 if (browser->curr_hot) { 675 annotate_browser__set_rb_top(browser, browser->curr_hot); 676 browser->b.navkeypressed = false; 677 } 678 679 nd = browser->curr_hot; 680 681 while (1) { 682 key = ui_browser__run(&browser->b, delay_secs); 683 684 if (delay_secs != 0) { 685 annotate_browser__calc_percent(browser, evsel); 686 /* 687 * Current line focus got out of the list of most active 688 * lines, NULL it so that if TAB|UNTAB is pressed, we 689 * move to curr_hot (current hottest line). 690 */ 691 if (nd != NULL && RB_EMPTY_NODE(nd)) 692 nd = NULL; 693 } 694 695 switch (key) { 696 case K_TIMER: 697 if (hbt) 698 hbt->timer(hbt->arg); 699 700 if (delay_secs != 0) 701 symbol__annotate_decay_histogram(sym, evsel->idx); 702 continue; 703 case K_TAB: 704 if (nd != NULL) { 705 nd = rb_prev(nd); 706 if (nd == NULL) 707 nd = rb_last(&browser->entries); 708 } else 709 nd = browser->curr_hot; 710 break; 711 case K_UNTAB: 712 if (nd != NULL) 713 nd = rb_next(nd); 714 if (nd == NULL) 715 nd = rb_first(&browser->entries); 716 else 717 nd = browser->curr_hot; 718 break; 719 case K_F1: 720 case 'h': 721 ui_browser__help_window(&browser->b, 722 "UP/DOWN/PGUP\n" 723 "PGDN/SPACE Navigate\n" 724 "q/ESC/CTRL+C Exit\n\n" 725 "-> Go to target\n" 726 "<- Exit\n" 727 "H Cycle thru hottest instructions\n" 728 "j Toggle showing jump to target arrows\n" 729 "J Toggle showing number of jump sources on targets\n" 730 "n Search next string\n" 731 "o Toggle disassembler output/simplified view\n" 732 "s Toggle source code view\n" 733 "/ Search string\n" 734 "r Run available scripts\n" 735 "? Search string backwards\n"); 736 continue; 737 case 'r': 738 { 739 script_browse(NULL); 740 continue; 741 } 742 case 'H': 743 nd = browser->curr_hot; 744 break; 745 case 's': 746 if (annotate_browser__toggle_source(browser)) 747 ui_helpline__puts(help); 748 continue; 749 case 'o': 750 annotate_browser__opts.use_offset = !annotate_browser__opts.use_offset; 751 annotate_browser__update_addr_width(browser); 752 continue; 753 case 'j': 754 annotate_browser__opts.jump_arrows = !annotate_browser__opts.jump_arrows; 755 continue; 756 case 'J': 757 annotate_browser__opts.show_nr_jumps = !annotate_browser__opts.show_nr_jumps; 758 annotate_browser__update_addr_width(browser); 759 continue; 760 case '/': 761 if (annotate_browser__search(browser, delay_secs)) { 762 show_help: 763 ui_helpline__puts(help); 764 } 765 continue; 766 case 'n': 767 if (browser->searching_backwards ? 768 annotate_browser__continue_search_reverse(browser, delay_secs) : 769 annotate_browser__continue_search(browser, delay_secs)) 770 goto show_help; 771 continue; 772 case '?': 773 if (annotate_browser__search_reverse(browser, delay_secs)) 774 goto show_help; 775 continue; 776 case 'D': { 777 static int seq; 778 ui_helpline__pop(); 779 ui_helpline__fpush("%d: nr_ent=%d, height=%d, idx=%d, top_idx=%d, nr_asm_entries=%d", 780 seq++, browser->b.nr_entries, 781 browser->b.height, 782 browser->b.index, 783 browser->b.top_idx, 784 browser->nr_asm_entries); 785 } 786 continue; 787 case K_ENTER: 788 case K_RIGHT: 789 if (browser->selection == NULL) 790 ui_helpline__puts("Huh? No selection. Report to linux-kernel@vger.kernel.org"); 791 else if (browser->selection->offset == -1) 792 ui_helpline__puts("Actions are only available for assembly lines."); 793 else if (!browser->selection->ins) { 794 if (strcmp(browser->selection->name, "retq")) 795 goto show_sup_ins; 796 goto out; 797 } else if (!(annotate_browser__jump(browser) || 798 annotate_browser__callq(browser, evsel, hbt))) { 799 show_sup_ins: 800 ui_helpline__puts("Actions are only available for 'callq', 'retq' & jump instructions."); 801 } 802 continue; 803 case K_LEFT: 804 case K_ESC: 805 case 'q': 806 case CTRL('c'): 807 goto out; 808 default: 809 continue; 810 } 811 812 if (nd != NULL) 813 annotate_browser__set_rb_top(browser, nd); 814 } 815 out: 816 ui_browser__hide(&browser->b); 817 return key; 818 } 819 820 int hist_entry__tui_annotate(struct hist_entry *he, struct perf_evsel *evsel, 821 struct hist_browser_timer *hbt) 822 { 823 return symbol__tui_annotate(he->ms.sym, he->ms.map, evsel, hbt); 824 } 825 826 static void annotate_browser__mark_jump_targets(struct annotate_browser *browser, 827 size_t size) 828 { 829 u64 offset; 830 struct map_symbol *ms = browser->b.priv; 831 struct symbol *sym = ms->sym; 832 833 /* PLT symbols contain external offsets */ 834 if (strstr(sym->name, "@plt")) 835 return; 836 837 for (offset = 0; offset < size; ++offset) { 838 struct disasm_line *dl = browser->offsets[offset], *dlt; 839 struct browser_disasm_line *bdlt; 840 841 if (!disasm_line__is_valid_jump(dl, sym)) 842 continue; 843 844 dlt = browser->offsets[dl->ops.target.offset]; 845 /* 846 * FIXME: Oops, no jump target? Buggy disassembler? Or do we 847 * have to adjust to the previous offset? 848 */ 849 if (dlt == NULL) 850 continue; 851 852 bdlt = disasm_line__browser(dlt); 853 if (++bdlt->jump_sources > browser->max_jump_sources) 854 browser->max_jump_sources = bdlt->jump_sources; 855 856 ++browser->nr_jumps; 857 } 858 859 } 860 861 static inline int width_jumps(int n) 862 { 863 if (n >= 100) 864 return 5; 865 if (n / 10) 866 return 2; 867 return 1; 868 } 869 870 int symbol__tui_annotate(struct symbol *sym, struct map *map, 871 struct perf_evsel *evsel, 872 struct hist_browser_timer *hbt) 873 { 874 struct disasm_line *pos, *n; 875 struct annotation *notes; 876 size_t size; 877 struct map_symbol ms = { 878 .map = map, 879 .sym = sym, 880 }; 881 struct annotate_browser browser = { 882 .b = { 883 .refresh = annotate_browser__refresh, 884 .seek = ui_browser__list_head_seek, 885 .write = annotate_browser__write, 886 .filter = disasm_line__filter, 887 .priv = &ms, 888 .use_navkeypressed = true, 889 }, 890 }; 891 int ret = -1; 892 int nr_pcnt = 1; 893 size_t sizeof_bdl = sizeof(struct browser_disasm_line); 894 895 if (sym == NULL) 896 return -1; 897 898 size = symbol__size(sym); 899 900 if (map->dso->annotate_warned) 901 return -1; 902 903 browser.offsets = zalloc(size * sizeof(struct disasm_line *)); 904 if (browser.offsets == NULL) { 905 ui__error("Not enough memory!"); 906 return -1; 907 } 908 909 if (perf_evsel__is_group_event(evsel)) { 910 nr_pcnt = evsel->nr_members; 911 sizeof_bdl += sizeof(double) * (nr_pcnt - 1); 912 } 913 914 if (symbol__annotate(sym, map, sizeof_bdl) < 0) { 915 ui__error("%s", ui_helpline__last_msg); 916 goto out_free_offsets; 917 } 918 919 ui_helpline__push("Press <- or ESC to exit"); 920 921 notes = symbol__annotation(sym); 922 browser.start = map__rip_2objdump(map, sym->start); 923 924 list_for_each_entry(pos, ¬es->src->source, node) { 925 struct browser_disasm_line *bpos; 926 size_t line_len = strlen(pos->line); 927 928 if (browser.b.width < line_len) 929 browser.b.width = line_len; 930 bpos = disasm_line__browser(pos); 931 bpos->idx = browser.nr_entries++; 932 if (pos->offset != -1) { 933 bpos->idx_asm = browser.nr_asm_entries++; 934 /* 935 * FIXME: short term bandaid to cope with assembly 936 * routines that comes with labels in the same column 937 * as the address in objdump, sigh. 938 * 939 * E.g. copy_user_generic_unrolled 940 */ 941 if (pos->offset < (s64)size) 942 browser.offsets[pos->offset] = pos; 943 } else 944 bpos->idx_asm = -1; 945 } 946 947 annotate_browser__mark_jump_targets(&browser, size); 948 949 browser.addr_width = browser.target_width = browser.min_addr_width = hex_width(size); 950 browser.max_addr_width = hex_width(sym->end); 951 browser.jumps_width = width_jumps(browser.max_jump_sources); 952 browser.nr_events = nr_pcnt; 953 browser.b.nr_entries = browser.nr_entries; 954 browser.b.entries = ¬es->src->source, 955 browser.b.width += 18; /* Percentage */ 956 957 if (annotate_browser__opts.hide_src_code) 958 annotate_browser__init_asm_mode(&browser); 959 960 annotate_browser__update_addr_width(&browser); 961 962 ret = annotate_browser__run(&browser, evsel, hbt); 963 list_for_each_entry_safe(pos, n, ¬es->src->source, node) { 964 list_del(&pos->node); 965 disasm_line__free(pos); 966 } 967 968 out_free_offsets: 969 free(browser.offsets); 970 return ret; 971 } 972 973 #define ANNOTATE_CFG(n) \ 974 { .name = #n, .value = &annotate_browser__opts.n, } 975 976 /* 977 * Keep the entries sorted, they are bsearch'ed 978 */ 979 static struct annotate_config { 980 const char *name; 981 bool *value; 982 } annotate__configs[] = { 983 ANNOTATE_CFG(hide_src_code), 984 ANNOTATE_CFG(jump_arrows), 985 ANNOTATE_CFG(show_nr_jumps), 986 ANNOTATE_CFG(use_offset), 987 }; 988 989 #undef ANNOTATE_CFG 990 991 static int annotate_config__cmp(const void *name, const void *cfgp) 992 { 993 const struct annotate_config *cfg = cfgp; 994 995 return strcmp(name, cfg->name); 996 } 997 998 static int annotate__config(const char *var, const char *value, 999 void *data __maybe_unused) 1000 { 1001 struct annotate_config *cfg; 1002 const char *name; 1003 1004 if (prefixcmp(var, "annotate.") != 0) 1005 return 0; 1006 1007 name = var + 9; 1008 cfg = bsearch(name, annotate__configs, ARRAY_SIZE(annotate__configs), 1009 sizeof(struct annotate_config), annotate_config__cmp); 1010 1011 if (cfg == NULL) 1012 return -1; 1013 1014 *cfg->value = perf_config_bool(name, value); 1015 return 0; 1016 } 1017 1018 void annotate_browser__init(void) 1019 { 1020 perf_config(annotate__config, NULL); 1021 } 1022