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