1 /* 2 * Copyright (C) 2011, Red Hat Inc, Arnaldo Carvalho de Melo <acme@redhat.com> 3 * 4 * Parts came from builtin-annotate.c, see those files for further 5 * copyright notes. 6 * 7 * Released under the GPL v2. (and only v2, not any later version) 8 */ 9 10 #include <errno.h> 11 #include <inttypes.h> 12 #include "util.h" 13 #include "ui/ui.h" 14 #include "sort.h" 15 #include "build-id.h" 16 #include "color.h" 17 #include "config.h" 18 #include "cache.h" 19 #include "symbol.h" 20 #include "units.h" 21 #include "debug.h" 22 #include "annotate.h" 23 #include "evsel.h" 24 #include "block-range.h" 25 #include "string2.h" 26 #include "arch/common.h" 27 #include <regex.h> 28 #include <pthread.h> 29 #include <linux/bitops.h> 30 #include <linux/kernel.h> 31 32 /* FIXME: For the HE_COLORSET */ 33 #include "ui/browser.h" 34 35 /* 36 * FIXME: Using the same values as slang.h, 37 * but that header may not be available everywhere 38 */ 39 #define LARROW_CHAR ((unsigned char)',') 40 #define RARROW_CHAR ((unsigned char)'+') 41 #define DARROW_CHAR ((unsigned char)'.') 42 #define UARROW_CHAR ((unsigned char)'-') 43 44 #include "sane_ctype.h" 45 46 struct annotation_options annotation__default_options = { 47 .use_offset = true, 48 .jump_arrows = true, 49 .offset_level = ANNOTATION__OFFSET_JUMP_TARGETS, 50 }; 51 52 const char *disassembler_style; 53 const char *objdump_path; 54 static regex_t file_lineno; 55 56 static struct ins_ops *ins__find(struct arch *arch, const char *name); 57 static void ins__sort(struct arch *arch); 58 static int disasm_line__parse(char *line, const char **namep, char **rawp); 59 60 struct arch { 61 const char *name; 62 struct ins *instructions; 63 size_t nr_instructions; 64 size_t nr_instructions_allocated; 65 struct ins_ops *(*associate_instruction_ops)(struct arch *arch, const char *name); 66 bool sorted_instructions; 67 bool initialized; 68 void *priv; 69 unsigned int model; 70 unsigned int family; 71 int (*init)(struct arch *arch, char *cpuid); 72 bool (*ins_is_fused)(struct arch *arch, const char *ins1, 73 const char *ins2); 74 struct { 75 char comment_char; 76 char skip_functions_char; 77 } objdump; 78 }; 79 80 static struct ins_ops call_ops; 81 static struct ins_ops dec_ops; 82 static struct ins_ops jump_ops; 83 static struct ins_ops mov_ops; 84 static struct ins_ops nop_ops; 85 static struct ins_ops lock_ops; 86 static struct ins_ops ret_ops; 87 88 static int arch__grow_instructions(struct arch *arch) 89 { 90 struct ins *new_instructions; 91 size_t new_nr_allocated; 92 93 if (arch->nr_instructions_allocated == 0 && arch->instructions) 94 goto grow_from_non_allocated_table; 95 96 new_nr_allocated = arch->nr_instructions_allocated + 128; 97 new_instructions = realloc(arch->instructions, new_nr_allocated * sizeof(struct ins)); 98 if (new_instructions == NULL) 99 return -1; 100 101 out_update_instructions: 102 arch->instructions = new_instructions; 103 arch->nr_instructions_allocated = new_nr_allocated; 104 return 0; 105 106 grow_from_non_allocated_table: 107 new_nr_allocated = arch->nr_instructions + 128; 108 new_instructions = calloc(new_nr_allocated, sizeof(struct ins)); 109 if (new_instructions == NULL) 110 return -1; 111 112 memcpy(new_instructions, arch->instructions, arch->nr_instructions); 113 goto out_update_instructions; 114 } 115 116 static int arch__associate_ins_ops(struct arch* arch, const char *name, struct ins_ops *ops) 117 { 118 struct ins *ins; 119 120 if (arch->nr_instructions == arch->nr_instructions_allocated && 121 arch__grow_instructions(arch)) 122 return -1; 123 124 ins = &arch->instructions[arch->nr_instructions]; 125 ins->name = strdup(name); 126 if (!ins->name) 127 return -1; 128 129 ins->ops = ops; 130 arch->nr_instructions++; 131 132 ins__sort(arch); 133 return 0; 134 } 135 136 #include "arch/arm/annotate/instructions.c" 137 #include "arch/arm64/annotate/instructions.c" 138 #include "arch/x86/annotate/instructions.c" 139 #include "arch/powerpc/annotate/instructions.c" 140 #include "arch/s390/annotate/instructions.c" 141 142 static struct arch architectures[] = { 143 { 144 .name = "arm", 145 .init = arm__annotate_init, 146 }, 147 { 148 .name = "arm64", 149 .init = arm64__annotate_init, 150 }, 151 { 152 .name = "x86", 153 .init = x86__annotate_init, 154 .instructions = x86__instructions, 155 .nr_instructions = ARRAY_SIZE(x86__instructions), 156 .ins_is_fused = x86__ins_is_fused, 157 .objdump = { 158 .comment_char = '#', 159 }, 160 }, 161 { 162 .name = "powerpc", 163 .init = powerpc__annotate_init, 164 }, 165 { 166 .name = "s390", 167 .init = s390__annotate_init, 168 .objdump = { 169 .comment_char = '#', 170 }, 171 }, 172 }; 173 174 static void ins__delete(struct ins_operands *ops) 175 { 176 if (ops == NULL) 177 return; 178 zfree(&ops->source.raw); 179 zfree(&ops->source.name); 180 zfree(&ops->target.raw); 181 zfree(&ops->target.name); 182 } 183 184 static int ins__raw_scnprintf(struct ins *ins, char *bf, size_t size, 185 struct ins_operands *ops) 186 { 187 return scnprintf(bf, size, "%-6s %s", ins->name, ops->raw); 188 } 189 190 int ins__scnprintf(struct ins *ins, char *bf, size_t size, 191 struct ins_operands *ops) 192 { 193 if (ins->ops->scnprintf) 194 return ins->ops->scnprintf(ins, bf, size, ops); 195 196 return ins__raw_scnprintf(ins, bf, size, ops); 197 } 198 199 bool ins__is_fused(struct arch *arch, const char *ins1, const char *ins2) 200 { 201 if (!arch || !arch->ins_is_fused) 202 return false; 203 204 return arch->ins_is_fused(arch, ins1, ins2); 205 } 206 207 static int call__parse(struct arch *arch, struct ins_operands *ops, struct map_symbol *ms) 208 { 209 char *endptr, *tok, *name; 210 struct map *map = ms->map; 211 struct addr_map_symbol target = { 212 .map = map, 213 }; 214 215 ops->target.addr = strtoull(ops->raw, &endptr, 16); 216 217 name = strchr(endptr, '<'); 218 if (name == NULL) 219 goto indirect_call; 220 221 name++; 222 223 if (arch->objdump.skip_functions_char && 224 strchr(name, arch->objdump.skip_functions_char)) 225 return -1; 226 227 tok = strchr(name, '>'); 228 if (tok == NULL) 229 return -1; 230 231 *tok = '\0'; 232 ops->target.name = strdup(name); 233 *tok = '>'; 234 235 if (ops->target.name == NULL) 236 return -1; 237 find_target: 238 target.addr = map__objdump_2mem(map, ops->target.addr); 239 240 if (map_groups__find_ams(&target) == 0 && 241 map__rip_2objdump(target.map, map->map_ip(target.map, target.addr)) == ops->target.addr) 242 ops->target.sym = target.sym; 243 244 return 0; 245 246 indirect_call: 247 tok = strchr(endptr, '*'); 248 if (tok != NULL) 249 ops->target.addr = strtoull(tok + 1, NULL, 16); 250 goto find_target; 251 } 252 253 static int call__scnprintf(struct ins *ins, char *bf, size_t size, 254 struct ins_operands *ops) 255 { 256 if (ops->target.sym) 257 return scnprintf(bf, size, "%-6s %s", ins->name, ops->target.sym->name); 258 259 if (ops->target.addr == 0) 260 return ins__raw_scnprintf(ins, bf, size, ops); 261 262 if (ops->target.name) 263 return scnprintf(bf, size, "%-6s %s", ins->name, ops->target.name); 264 265 return scnprintf(bf, size, "%-6s *%" PRIx64, ins->name, ops->target.addr); 266 } 267 268 static struct ins_ops call_ops = { 269 .parse = call__parse, 270 .scnprintf = call__scnprintf, 271 }; 272 273 bool ins__is_call(const struct ins *ins) 274 { 275 return ins->ops == &call_ops || ins->ops == &s390_call_ops; 276 } 277 278 static int jump__parse(struct arch *arch __maybe_unused, struct ins_operands *ops, struct map_symbol *ms) 279 { 280 struct map *map = ms->map; 281 struct symbol *sym = ms->sym; 282 struct addr_map_symbol target = { 283 .map = map, 284 }; 285 const char *c = strchr(ops->raw, ','); 286 u64 start, end; 287 /* 288 * Examples of lines to parse for the _cpp_lex_token@@Base 289 * function: 290 * 291 * 1159e6c: jne 115aa32 <_cpp_lex_token@@Base+0xf92> 292 * 1159e8b: jne c469be <cpp_named_operator2name@@Base+0xa72> 293 * 294 * The first is a jump to an offset inside the same function, 295 * the second is to another function, i.e. that 0xa72 is an 296 * offset in the cpp_named_operator2name@@base function. 297 */ 298 /* 299 * skip over possible up to 2 operands to get to address, e.g.: 300 * tbnz w0, #26, ffff0000083cd190 <security_file_permission+0xd0> 301 */ 302 if (c++ != NULL) { 303 ops->target.addr = strtoull(c, NULL, 16); 304 if (!ops->target.addr) { 305 c = strchr(c, ','); 306 if (c++ != NULL) 307 ops->target.addr = strtoull(c, NULL, 16); 308 } 309 } else { 310 ops->target.addr = strtoull(ops->raw, NULL, 16); 311 } 312 313 target.addr = map__objdump_2mem(map, ops->target.addr); 314 start = map->unmap_ip(map, sym->start), 315 end = map->unmap_ip(map, sym->end); 316 317 ops->target.outside = target.addr < start || target.addr > end; 318 319 /* 320 * FIXME: things like this in _cpp_lex_token (gcc's cc1 program): 321 322 cpp_named_operator2name@@Base+0xa72 323 324 * Point to a place that is after the cpp_named_operator2name 325 * boundaries, i.e. in the ELF symbol table for cc1 326 * cpp_named_operator2name is marked as being 32-bytes long, but it in 327 * fact is much larger than that, so we seem to need a symbols__find() 328 * routine that looks for >= current->start and < next_symbol->start, 329 * possibly just for C++ objects? 330 * 331 * For now lets just make some progress by marking jumps to outside the 332 * current function as call like. 333 * 334 * Actual navigation will come next, with further understanding of how 335 * the symbol searching and disassembly should be done. 336 */ 337 if (map_groups__find_ams(&target) == 0 && 338 map__rip_2objdump(target.map, map->map_ip(target.map, target.addr)) == ops->target.addr) 339 ops->target.sym = target.sym; 340 341 if (!ops->target.outside) { 342 ops->target.offset = target.addr - start; 343 ops->target.offset_avail = true; 344 } else { 345 ops->target.offset_avail = false; 346 } 347 348 return 0; 349 } 350 351 static int jump__scnprintf(struct ins *ins, char *bf, size_t size, 352 struct ins_operands *ops) 353 { 354 const char *c; 355 356 if (!ops->target.addr || ops->target.offset < 0) 357 return ins__raw_scnprintf(ins, bf, size, ops); 358 359 if (ops->target.outside && ops->target.sym != NULL) 360 return scnprintf(bf, size, "%-6s %s", ins->name, ops->target.sym->name); 361 362 c = strchr(ops->raw, ','); 363 if (c != NULL) { 364 const char *c2 = strchr(c + 1, ','); 365 366 /* check for 3-op insn */ 367 if (c2 != NULL) 368 c = c2; 369 c++; 370 371 /* mirror arch objdump's space-after-comma style */ 372 if (*c == ' ') 373 c++; 374 } 375 376 return scnprintf(bf, size, "%-6s %.*s%" PRIx64, 377 ins->name, c ? c - ops->raw : 0, ops->raw, 378 ops->target.offset); 379 } 380 381 static struct ins_ops jump_ops = { 382 .parse = jump__parse, 383 .scnprintf = jump__scnprintf, 384 }; 385 386 bool ins__is_jump(const struct ins *ins) 387 { 388 return ins->ops == &jump_ops; 389 } 390 391 static int comment__symbol(char *raw, char *comment, u64 *addrp, char **namep) 392 { 393 char *endptr, *name, *t; 394 395 if (strstr(raw, "(%rip)") == NULL) 396 return 0; 397 398 *addrp = strtoull(comment, &endptr, 16); 399 if (endptr == comment) 400 return 0; 401 name = strchr(endptr, '<'); 402 if (name == NULL) 403 return -1; 404 405 name++; 406 407 t = strchr(name, '>'); 408 if (t == NULL) 409 return 0; 410 411 *t = '\0'; 412 *namep = strdup(name); 413 *t = '>'; 414 415 return 0; 416 } 417 418 static int lock__parse(struct arch *arch, struct ins_operands *ops, struct map_symbol *ms) 419 { 420 ops->locked.ops = zalloc(sizeof(*ops->locked.ops)); 421 if (ops->locked.ops == NULL) 422 return 0; 423 424 if (disasm_line__parse(ops->raw, &ops->locked.ins.name, &ops->locked.ops->raw) < 0) 425 goto out_free_ops; 426 427 ops->locked.ins.ops = ins__find(arch, ops->locked.ins.name); 428 429 if (ops->locked.ins.ops == NULL) 430 goto out_free_ops; 431 432 if (ops->locked.ins.ops->parse && 433 ops->locked.ins.ops->parse(arch, ops->locked.ops, ms) < 0) 434 goto out_free_ops; 435 436 return 0; 437 438 out_free_ops: 439 zfree(&ops->locked.ops); 440 return 0; 441 } 442 443 static int lock__scnprintf(struct ins *ins, char *bf, size_t size, 444 struct ins_operands *ops) 445 { 446 int printed; 447 448 if (ops->locked.ins.ops == NULL) 449 return ins__raw_scnprintf(ins, bf, size, ops); 450 451 printed = scnprintf(bf, size, "%-6s ", ins->name); 452 return printed + ins__scnprintf(&ops->locked.ins, bf + printed, 453 size - printed, ops->locked.ops); 454 } 455 456 static void lock__delete(struct ins_operands *ops) 457 { 458 struct ins *ins = &ops->locked.ins; 459 460 if (ins->ops && ins->ops->free) 461 ins->ops->free(ops->locked.ops); 462 else 463 ins__delete(ops->locked.ops); 464 465 zfree(&ops->locked.ops); 466 zfree(&ops->target.raw); 467 zfree(&ops->target.name); 468 } 469 470 static struct ins_ops lock_ops = { 471 .free = lock__delete, 472 .parse = lock__parse, 473 .scnprintf = lock__scnprintf, 474 }; 475 476 static int mov__parse(struct arch *arch, struct ins_operands *ops, struct map_symbol *ms __maybe_unused) 477 { 478 char *s = strchr(ops->raw, ','), *target, *comment, prev; 479 480 if (s == NULL) 481 return -1; 482 483 *s = '\0'; 484 ops->source.raw = strdup(ops->raw); 485 *s = ','; 486 487 if (ops->source.raw == NULL) 488 return -1; 489 490 target = ++s; 491 comment = strchr(s, arch->objdump.comment_char); 492 493 if (comment != NULL) 494 s = comment - 1; 495 else 496 s = strchr(s, '\0') - 1; 497 498 while (s > target && isspace(s[0])) 499 --s; 500 s++; 501 prev = *s; 502 *s = '\0'; 503 504 ops->target.raw = strdup(target); 505 *s = prev; 506 507 if (ops->target.raw == NULL) 508 goto out_free_source; 509 510 if (comment == NULL) 511 return 0; 512 513 comment = ltrim(comment); 514 comment__symbol(ops->source.raw, comment + 1, &ops->source.addr, &ops->source.name); 515 comment__symbol(ops->target.raw, comment + 1, &ops->target.addr, &ops->target.name); 516 517 return 0; 518 519 out_free_source: 520 zfree(&ops->source.raw); 521 return -1; 522 } 523 524 static int mov__scnprintf(struct ins *ins, char *bf, size_t size, 525 struct ins_operands *ops) 526 { 527 return scnprintf(bf, size, "%-6s %s,%s", ins->name, 528 ops->source.name ?: ops->source.raw, 529 ops->target.name ?: ops->target.raw); 530 } 531 532 static struct ins_ops mov_ops = { 533 .parse = mov__parse, 534 .scnprintf = mov__scnprintf, 535 }; 536 537 static int dec__parse(struct arch *arch __maybe_unused, struct ins_operands *ops, struct map_symbol *ms __maybe_unused) 538 { 539 char *target, *comment, *s, prev; 540 541 target = s = ops->raw; 542 543 while (s[0] != '\0' && !isspace(s[0])) 544 ++s; 545 prev = *s; 546 *s = '\0'; 547 548 ops->target.raw = strdup(target); 549 *s = prev; 550 551 if (ops->target.raw == NULL) 552 return -1; 553 554 comment = strchr(s, arch->objdump.comment_char); 555 if (comment == NULL) 556 return 0; 557 558 comment = ltrim(comment); 559 comment__symbol(ops->target.raw, comment + 1, &ops->target.addr, &ops->target.name); 560 561 return 0; 562 } 563 564 static int dec__scnprintf(struct ins *ins, char *bf, size_t size, 565 struct ins_operands *ops) 566 { 567 return scnprintf(bf, size, "%-6s %s", ins->name, 568 ops->target.name ?: ops->target.raw); 569 } 570 571 static struct ins_ops dec_ops = { 572 .parse = dec__parse, 573 .scnprintf = dec__scnprintf, 574 }; 575 576 static int nop__scnprintf(struct ins *ins __maybe_unused, char *bf, size_t size, 577 struct ins_operands *ops __maybe_unused) 578 { 579 return scnprintf(bf, size, "%-6s", "nop"); 580 } 581 582 static struct ins_ops nop_ops = { 583 .scnprintf = nop__scnprintf, 584 }; 585 586 static struct ins_ops ret_ops = { 587 .scnprintf = ins__raw_scnprintf, 588 }; 589 590 bool ins__is_ret(const struct ins *ins) 591 { 592 return ins->ops == &ret_ops; 593 } 594 595 bool ins__is_lock(const struct ins *ins) 596 { 597 return ins->ops == &lock_ops; 598 } 599 600 static int ins__key_cmp(const void *name, const void *insp) 601 { 602 const struct ins *ins = insp; 603 604 return strcmp(name, ins->name); 605 } 606 607 static int ins__cmp(const void *a, const void *b) 608 { 609 const struct ins *ia = a; 610 const struct ins *ib = b; 611 612 return strcmp(ia->name, ib->name); 613 } 614 615 static void ins__sort(struct arch *arch) 616 { 617 const int nmemb = arch->nr_instructions; 618 619 qsort(arch->instructions, nmemb, sizeof(struct ins), ins__cmp); 620 } 621 622 static struct ins_ops *__ins__find(struct arch *arch, const char *name) 623 { 624 struct ins *ins; 625 const int nmemb = arch->nr_instructions; 626 627 if (!arch->sorted_instructions) { 628 ins__sort(arch); 629 arch->sorted_instructions = true; 630 } 631 632 ins = bsearch(name, arch->instructions, nmemb, sizeof(struct ins), ins__key_cmp); 633 return ins ? ins->ops : NULL; 634 } 635 636 static struct ins_ops *ins__find(struct arch *arch, const char *name) 637 { 638 struct ins_ops *ops = __ins__find(arch, name); 639 640 if (!ops && arch->associate_instruction_ops) 641 ops = arch->associate_instruction_ops(arch, name); 642 643 return ops; 644 } 645 646 static int arch__key_cmp(const void *name, const void *archp) 647 { 648 const struct arch *arch = archp; 649 650 return strcmp(name, arch->name); 651 } 652 653 static int arch__cmp(const void *a, const void *b) 654 { 655 const struct arch *aa = a; 656 const struct arch *ab = b; 657 658 return strcmp(aa->name, ab->name); 659 } 660 661 static void arch__sort(void) 662 { 663 const int nmemb = ARRAY_SIZE(architectures); 664 665 qsort(architectures, nmemb, sizeof(struct arch), arch__cmp); 666 } 667 668 static struct arch *arch__find(const char *name) 669 { 670 const int nmemb = ARRAY_SIZE(architectures); 671 static bool sorted; 672 673 if (!sorted) { 674 arch__sort(); 675 sorted = true; 676 } 677 678 return bsearch(name, architectures, nmemb, sizeof(struct arch), arch__key_cmp); 679 } 680 681 int symbol__alloc_hist(struct symbol *sym) 682 { 683 struct annotation *notes = symbol__annotation(sym); 684 size_t size = symbol__size(sym); 685 size_t sizeof_sym_hist; 686 687 /* 688 * Add buffer of one element for zero length symbol. 689 * When sample is taken from first instruction of 690 * zero length symbol, perf still resolves it and 691 * shows symbol name in perf report and allows to 692 * annotate it. 693 */ 694 if (size == 0) 695 size = 1; 696 697 /* Check for overflow when calculating sizeof_sym_hist */ 698 if (size > (SIZE_MAX - sizeof(struct sym_hist)) / sizeof(struct sym_hist_entry)) 699 return -1; 700 701 sizeof_sym_hist = (sizeof(struct sym_hist) + size * sizeof(struct sym_hist_entry)); 702 703 /* Check for overflow in zalloc argument */ 704 if (sizeof_sym_hist > (SIZE_MAX - sizeof(*notes->src)) 705 / symbol_conf.nr_events) 706 return -1; 707 708 notes->src = zalloc(sizeof(*notes->src) + symbol_conf.nr_events * sizeof_sym_hist); 709 if (notes->src == NULL) 710 return -1; 711 notes->src->sizeof_sym_hist = sizeof_sym_hist; 712 notes->src->nr_histograms = symbol_conf.nr_events; 713 INIT_LIST_HEAD(¬es->src->source); 714 return 0; 715 } 716 717 /* The cycles histogram is lazily allocated. */ 718 static int symbol__alloc_hist_cycles(struct symbol *sym) 719 { 720 struct annotation *notes = symbol__annotation(sym); 721 const size_t size = symbol__size(sym); 722 723 notes->src->cycles_hist = calloc(size, sizeof(struct cyc_hist)); 724 if (notes->src->cycles_hist == NULL) 725 return -1; 726 return 0; 727 } 728 729 void symbol__annotate_zero_histograms(struct symbol *sym) 730 { 731 struct annotation *notes = symbol__annotation(sym); 732 733 pthread_mutex_lock(¬es->lock); 734 if (notes->src != NULL) { 735 memset(notes->src->histograms, 0, 736 notes->src->nr_histograms * notes->src->sizeof_sym_hist); 737 if (notes->src->cycles_hist) 738 memset(notes->src->cycles_hist, 0, 739 symbol__size(sym) * sizeof(struct cyc_hist)); 740 } 741 pthread_mutex_unlock(¬es->lock); 742 } 743 744 static int __symbol__account_cycles(struct annotation *notes, 745 u64 start, 746 unsigned offset, unsigned cycles, 747 unsigned have_start) 748 { 749 struct cyc_hist *ch; 750 751 ch = notes->src->cycles_hist; 752 /* 753 * For now we can only account one basic block per 754 * final jump. But multiple could be overlapping. 755 * Always account the longest one. So when 756 * a shorter one has been already seen throw it away. 757 * 758 * We separately always account the full cycles. 759 */ 760 ch[offset].num_aggr++; 761 ch[offset].cycles_aggr += cycles; 762 763 if (!have_start && ch[offset].have_start) 764 return 0; 765 if (ch[offset].num) { 766 if (have_start && (!ch[offset].have_start || 767 ch[offset].start > start)) { 768 ch[offset].have_start = 0; 769 ch[offset].cycles = 0; 770 ch[offset].num = 0; 771 if (ch[offset].reset < 0xffff) 772 ch[offset].reset++; 773 } else if (have_start && 774 ch[offset].start < start) 775 return 0; 776 } 777 ch[offset].have_start = have_start; 778 ch[offset].start = start; 779 ch[offset].cycles += cycles; 780 ch[offset].num++; 781 return 0; 782 } 783 784 static int __symbol__inc_addr_samples(struct symbol *sym, struct map *map, 785 struct annotation *notes, int evidx, u64 addr, 786 struct perf_sample *sample) 787 { 788 unsigned offset; 789 struct sym_hist *h; 790 791 pr_debug3("%s: addr=%#" PRIx64 "\n", __func__, map->unmap_ip(map, addr)); 792 793 if ((addr < sym->start || addr >= sym->end) && 794 (addr != sym->end || sym->start != sym->end)) { 795 pr_debug("%s(%d): ERANGE! sym->name=%s, start=%#" PRIx64 ", addr=%#" PRIx64 ", end=%#" PRIx64 "\n", 796 __func__, __LINE__, sym->name, sym->start, addr, sym->end); 797 return -ERANGE; 798 } 799 800 offset = addr - sym->start; 801 h = annotation__histogram(notes, evidx); 802 h->nr_samples++; 803 h->addr[offset].nr_samples++; 804 h->period += sample->period; 805 h->addr[offset].period += sample->period; 806 807 pr_debug3("%#" PRIx64 " %s: period++ [addr: %#" PRIx64 ", %#" PRIx64 808 ", evidx=%d] => nr_samples: %" PRIu64 ", period: %" PRIu64 "\n", 809 sym->start, sym->name, addr, addr - sym->start, evidx, 810 h->addr[offset].nr_samples, h->addr[offset].period); 811 return 0; 812 } 813 814 static struct annotation *symbol__get_annotation(struct symbol *sym, bool cycles) 815 { 816 struct annotation *notes = symbol__annotation(sym); 817 818 if (notes->src == NULL) { 819 if (symbol__alloc_hist(sym) < 0) 820 return NULL; 821 } 822 if (!notes->src->cycles_hist && cycles) { 823 if (symbol__alloc_hist_cycles(sym) < 0) 824 return NULL; 825 } 826 return notes; 827 } 828 829 static int symbol__inc_addr_samples(struct symbol *sym, struct map *map, 830 int evidx, u64 addr, 831 struct perf_sample *sample) 832 { 833 struct annotation *notes; 834 835 if (sym == NULL) 836 return 0; 837 notes = symbol__get_annotation(sym, false); 838 if (notes == NULL) 839 return -ENOMEM; 840 return __symbol__inc_addr_samples(sym, map, notes, evidx, addr, sample); 841 } 842 843 static int symbol__account_cycles(u64 addr, u64 start, 844 struct symbol *sym, unsigned cycles) 845 { 846 struct annotation *notes; 847 unsigned offset; 848 849 if (sym == NULL) 850 return 0; 851 notes = symbol__get_annotation(sym, true); 852 if (notes == NULL) 853 return -ENOMEM; 854 if (addr < sym->start || addr >= sym->end) 855 return -ERANGE; 856 857 if (start) { 858 if (start < sym->start || start >= sym->end) 859 return -ERANGE; 860 if (start >= addr) 861 start = 0; 862 } 863 offset = addr - sym->start; 864 return __symbol__account_cycles(notes, 865 start ? start - sym->start : 0, 866 offset, cycles, 867 !!start); 868 } 869 870 int addr_map_symbol__account_cycles(struct addr_map_symbol *ams, 871 struct addr_map_symbol *start, 872 unsigned cycles) 873 { 874 u64 saddr = 0; 875 int err; 876 877 if (!cycles) 878 return 0; 879 880 /* 881 * Only set start when IPC can be computed. We can only 882 * compute it when the basic block is completely in a single 883 * function. 884 * Special case the case when the jump is elsewhere, but 885 * it starts on the function start. 886 */ 887 if (start && 888 (start->sym == ams->sym || 889 (ams->sym && 890 start->addr == ams->sym->start + ams->map->start))) 891 saddr = start->al_addr; 892 if (saddr == 0) 893 pr_debug2("BB with bad start: addr %"PRIx64" start %"PRIx64" sym %"PRIx64" saddr %"PRIx64"\n", 894 ams->addr, 895 start ? start->addr : 0, 896 ams->sym ? ams->sym->start + ams->map->start : 0, 897 saddr); 898 err = symbol__account_cycles(ams->al_addr, saddr, ams->sym, cycles); 899 if (err) 900 pr_debug2("account_cycles failed %d\n", err); 901 return err; 902 } 903 904 static unsigned annotation__count_insn(struct annotation *notes, u64 start, u64 end) 905 { 906 unsigned n_insn = 0; 907 u64 offset; 908 909 for (offset = start; offset <= end; offset++) { 910 if (notes->offsets[offset]) 911 n_insn++; 912 } 913 return n_insn; 914 } 915 916 static void annotation__count_and_fill(struct annotation *notes, u64 start, u64 end, struct cyc_hist *ch) 917 { 918 unsigned n_insn; 919 u64 offset; 920 921 n_insn = annotation__count_insn(notes, start, end); 922 if (n_insn && ch->num && ch->cycles) { 923 float ipc = n_insn / ((double)ch->cycles / (double)ch->num); 924 925 /* Hide data when there are too many overlaps. */ 926 if (ch->reset >= 0x7fff || ch->reset >= ch->num / 2) 927 return; 928 929 for (offset = start; offset <= end; offset++) { 930 struct annotation_line *al = notes->offsets[offset]; 931 932 if (al) 933 al->ipc = ipc; 934 } 935 } 936 } 937 938 void annotation__compute_ipc(struct annotation *notes, size_t size) 939 { 940 u64 offset; 941 942 if (!notes->src || !notes->src->cycles_hist) 943 return; 944 945 pthread_mutex_lock(¬es->lock); 946 for (offset = 0; offset < size; ++offset) { 947 struct cyc_hist *ch; 948 949 ch = ¬es->src->cycles_hist[offset]; 950 if (ch && ch->cycles) { 951 struct annotation_line *al; 952 953 if (ch->have_start) 954 annotation__count_and_fill(notes, ch->start, offset, ch); 955 al = notes->offsets[offset]; 956 if (al && ch->num_aggr) 957 al->cycles = ch->cycles_aggr / ch->num_aggr; 958 notes->have_cycles = true; 959 } 960 } 961 pthread_mutex_unlock(¬es->lock); 962 } 963 964 int addr_map_symbol__inc_samples(struct addr_map_symbol *ams, struct perf_sample *sample, 965 int evidx) 966 { 967 return symbol__inc_addr_samples(ams->sym, ams->map, evidx, ams->al_addr, sample); 968 } 969 970 int hist_entry__inc_addr_samples(struct hist_entry *he, struct perf_sample *sample, 971 int evidx, u64 ip) 972 { 973 return symbol__inc_addr_samples(he->ms.sym, he->ms.map, evidx, ip, sample); 974 } 975 976 static void disasm_line__init_ins(struct disasm_line *dl, struct arch *arch, struct map_symbol *ms) 977 { 978 dl->ins.ops = ins__find(arch, dl->ins.name); 979 980 if (!dl->ins.ops) 981 return; 982 983 if (dl->ins.ops->parse && dl->ins.ops->parse(arch, &dl->ops, ms) < 0) 984 dl->ins.ops = NULL; 985 } 986 987 static int disasm_line__parse(char *line, const char **namep, char **rawp) 988 { 989 char tmp, *name = ltrim(line); 990 991 if (name[0] == '\0') 992 return -1; 993 994 *rawp = name + 1; 995 996 while ((*rawp)[0] != '\0' && !isspace((*rawp)[0])) 997 ++*rawp; 998 999 tmp = (*rawp)[0]; 1000 (*rawp)[0] = '\0'; 1001 *namep = strdup(name); 1002 1003 if (*namep == NULL) 1004 goto out_free_name; 1005 1006 (*rawp)[0] = tmp; 1007 *rawp = ltrim(*rawp); 1008 1009 return 0; 1010 1011 out_free_name: 1012 free((void *)namep); 1013 *namep = NULL; 1014 return -1; 1015 } 1016 1017 struct annotate_args { 1018 size_t privsize; 1019 struct arch *arch; 1020 struct map_symbol ms; 1021 struct perf_evsel *evsel; 1022 s64 offset; 1023 char *line; 1024 int line_nr; 1025 }; 1026 1027 static void annotation_line__delete(struct annotation_line *al) 1028 { 1029 void *ptr = (void *) al - al->privsize; 1030 1031 free_srcline(al->path); 1032 zfree(&al->line); 1033 free(ptr); 1034 } 1035 1036 /* 1037 * Allocating the annotation line data with following 1038 * structure: 1039 * 1040 * -------------------------------------- 1041 * private space | struct annotation_line 1042 * -------------------------------------- 1043 * 1044 * Size of the private space is stored in 'struct annotation_line'. 1045 * 1046 */ 1047 static struct annotation_line * 1048 annotation_line__new(struct annotate_args *args, size_t privsize) 1049 { 1050 struct annotation_line *al; 1051 struct perf_evsel *evsel = args->evsel; 1052 size_t size = privsize + sizeof(*al); 1053 int nr = 1; 1054 1055 if (perf_evsel__is_group_event(evsel)) 1056 nr = evsel->nr_members; 1057 1058 size += sizeof(al->samples[0]) * nr; 1059 1060 al = zalloc(size); 1061 if (al) { 1062 al = (void *) al + privsize; 1063 al->privsize = privsize; 1064 al->offset = args->offset; 1065 al->line = strdup(args->line); 1066 al->line_nr = args->line_nr; 1067 al->samples_nr = nr; 1068 } 1069 1070 return al; 1071 } 1072 1073 /* 1074 * Allocating the disasm annotation line data with 1075 * following structure: 1076 * 1077 * ------------------------------------------------------------ 1078 * privsize space | struct disasm_line | struct annotation_line 1079 * ------------------------------------------------------------ 1080 * 1081 * We have 'struct annotation_line' member as last member 1082 * of 'struct disasm_line' to have an easy access. 1083 * 1084 */ 1085 static struct disasm_line *disasm_line__new(struct annotate_args *args) 1086 { 1087 struct disasm_line *dl = NULL; 1088 struct annotation_line *al; 1089 size_t privsize = args->privsize + offsetof(struct disasm_line, al); 1090 1091 al = annotation_line__new(args, privsize); 1092 if (al != NULL) { 1093 dl = disasm_line(al); 1094 1095 if (dl->al.line == NULL) 1096 goto out_delete; 1097 1098 if (args->offset != -1) { 1099 if (disasm_line__parse(dl->al.line, &dl->ins.name, &dl->ops.raw) < 0) 1100 goto out_free_line; 1101 1102 disasm_line__init_ins(dl, args->arch, &args->ms); 1103 } 1104 } 1105 1106 return dl; 1107 1108 out_free_line: 1109 zfree(&dl->al.line); 1110 out_delete: 1111 free(dl); 1112 return NULL; 1113 } 1114 1115 void disasm_line__free(struct disasm_line *dl) 1116 { 1117 if (dl->ins.ops && dl->ins.ops->free) 1118 dl->ins.ops->free(&dl->ops); 1119 else 1120 ins__delete(&dl->ops); 1121 free((void *)dl->ins.name); 1122 dl->ins.name = NULL; 1123 annotation_line__delete(&dl->al); 1124 } 1125 1126 int disasm_line__scnprintf(struct disasm_line *dl, char *bf, size_t size, bool raw) 1127 { 1128 if (raw || !dl->ins.ops) 1129 return scnprintf(bf, size, "%-6s %s", dl->ins.name, dl->ops.raw); 1130 1131 return ins__scnprintf(&dl->ins, bf, size, &dl->ops); 1132 } 1133 1134 static void annotation_line__add(struct annotation_line *al, struct list_head *head) 1135 { 1136 list_add_tail(&al->node, head); 1137 } 1138 1139 struct annotation_line * 1140 annotation_line__next(struct annotation_line *pos, struct list_head *head) 1141 { 1142 list_for_each_entry_continue(pos, head, node) 1143 if (pos->offset >= 0) 1144 return pos; 1145 1146 return NULL; 1147 } 1148 1149 static const char *annotate__address_color(struct block_range *br) 1150 { 1151 double cov = block_range__coverage(br); 1152 1153 if (cov >= 0) { 1154 /* mark red for >75% coverage */ 1155 if (cov > 0.75) 1156 return PERF_COLOR_RED; 1157 1158 /* mark dull for <1% coverage */ 1159 if (cov < 0.01) 1160 return PERF_COLOR_NORMAL; 1161 } 1162 1163 return PERF_COLOR_MAGENTA; 1164 } 1165 1166 static const char *annotate__asm_color(struct block_range *br) 1167 { 1168 double cov = block_range__coverage(br); 1169 1170 if (cov >= 0) { 1171 /* mark dull for <1% coverage */ 1172 if (cov < 0.01) 1173 return PERF_COLOR_NORMAL; 1174 } 1175 1176 return PERF_COLOR_BLUE; 1177 } 1178 1179 static void annotate__branch_printf(struct block_range *br, u64 addr) 1180 { 1181 bool emit_comment = true; 1182 1183 if (!br) 1184 return; 1185 1186 #if 1 1187 if (br->is_target && br->start == addr) { 1188 struct block_range *branch = br; 1189 double p; 1190 1191 /* 1192 * Find matching branch to our target. 1193 */ 1194 while (!branch->is_branch) 1195 branch = block_range__next(branch); 1196 1197 p = 100 *(double)br->entry / branch->coverage; 1198 1199 if (p > 0.1) { 1200 if (emit_comment) { 1201 emit_comment = false; 1202 printf("\t#"); 1203 } 1204 1205 /* 1206 * The percentage of coverage joined at this target in relation 1207 * to the next branch. 1208 */ 1209 printf(" +%.2f%%", p); 1210 } 1211 } 1212 #endif 1213 if (br->is_branch && br->end == addr) { 1214 double p = 100*(double)br->taken / br->coverage; 1215 1216 if (p > 0.1) { 1217 if (emit_comment) { 1218 emit_comment = false; 1219 printf("\t#"); 1220 } 1221 1222 /* 1223 * The percentage of coverage leaving at this branch, and 1224 * its prediction ratio. 1225 */ 1226 printf(" -%.2f%% (p:%.2f%%)", p, 100*(double)br->pred / br->taken); 1227 } 1228 } 1229 } 1230 1231 static int disasm_line__print(struct disasm_line *dl, u64 start, int addr_fmt_width) 1232 { 1233 s64 offset = dl->al.offset; 1234 const u64 addr = start + offset; 1235 struct block_range *br; 1236 1237 br = block_range__find(addr); 1238 color_fprintf(stdout, annotate__address_color(br), " %*" PRIx64 ":", addr_fmt_width, addr); 1239 color_fprintf(stdout, annotate__asm_color(br), "%s", dl->al.line); 1240 annotate__branch_printf(br, addr); 1241 return 0; 1242 } 1243 1244 static int 1245 annotation_line__print(struct annotation_line *al, struct symbol *sym, u64 start, 1246 struct perf_evsel *evsel, u64 len, int min_pcnt, int printed, 1247 int max_lines, struct annotation_line *queue, int addr_fmt_width) 1248 { 1249 struct disasm_line *dl = container_of(al, struct disasm_line, al); 1250 static const char *prev_line; 1251 static const char *prev_color; 1252 1253 if (al->offset != -1) { 1254 double max_percent = 0.0; 1255 int i, nr_percent = 1; 1256 const char *color; 1257 struct annotation *notes = symbol__annotation(sym); 1258 1259 for (i = 0; i < al->samples_nr; i++) { 1260 struct annotation_data *sample = &al->samples[i]; 1261 1262 if (sample->percent > max_percent) 1263 max_percent = sample->percent; 1264 } 1265 1266 if (max_percent < min_pcnt) 1267 return -1; 1268 1269 if (max_lines && printed >= max_lines) 1270 return 1; 1271 1272 if (queue != NULL) { 1273 list_for_each_entry_from(queue, ¬es->src->source, node) { 1274 if (queue == al) 1275 break; 1276 annotation_line__print(queue, sym, start, evsel, len, 1277 0, 0, 1, NULL, addr_fmt_width); 1278 } 1279 } 1280 1281 color = get_percent_color(max_percent); 1282 1283 /* 1284 * Also color the filename and line if needed, with 1285 * the same color than the percentage. Don't print it 1286 * twice for close colored addr with the same filename:line 1287 */ 1288 if (al->path) { 1289 if (!prev_line || strcmp(prev_line, al->path) 1290 || color != prev_color) { 1291 color_fprintf(stdout, color, " %s", al->path); 1292 prev_line = al->path; 1293 prev_color = color; 1294 } 1295 } 1296 1297 for (i = 0; i < nr_percent; i++) { 1298 struct annotation_data *sample = &al->samples[i]; 1299 1300 color = get_percent_color(sample->percent); 1301 1302 if (symbol_conf.show_total_period) 1303 color_fprintf(stdout, color, " %11" PRIu64, 1304 sample->he.period); 1305 else if (symbol_conf.show_nr_samples) 1306 color_fprintf(stdout, color, " %7" PRIu64, 1307 sample->he.nr_samples); 1308 else 1309 color_fprintf(stdout, color, " %7.2f", sample->percent); 1310 } 1311 1312 printf(" : "); 1313 1314 disasm_line__print(dl, start, addr_fmt_width); 1315 printf("\n"); 1316 } else if (max_lines && printed >= max_lines) 1317 return 1; 1318 else { 1319 int width = symbol_conf.show_total_period ? 12 : 8; 1320 1321 if (queue) 1322 return -1; 1323 1324 if (perf_evsel__is_group_event(evsel)) 1325 width *= evsel->nr_members; 1326 1327 if (!*al->line) 1328 printf(" %*s:\n", width, " "); 1329 else 1330 printf(" %*s: %*s %s\n", width, " ", addr_fmt_width, " ", al->line); 1331 } 1332 1333 return 0; 1334 } 1335 1336 /* 1337 * symbol__parse_objdump_line() parses objdump output (with -d --no-show-raw) 1338 * which looks like following 1339 * 1340 * 0000000000415500 <_init>: 1341 * 415500: sub $0x8,%rsp 1342 * 415504: mov 0x2f5ad5(%rip),%rax # 70afe0 <_DYNAMIC+0x2f8> 1343 * 41550b: test %rax,%rax 1344 * 41550e: je 415515 <_init+0x15> 1345 * 415510: callq 416e70 <__gmon_start__@plt> 1346 * 415515: add $0x8,%rsp 1347 * 415519: retq 1348 * 1349 * it will be parsed and saved into struct disasm_line as 1350 * <offset> <name> <ops.raw> 1351 * 1352 * The offset will be a relative offset from the start of the symbol and -1 1353 * means that it's not a disassembly line so should be treated differently. 1354 * The ops.raw part will be parsed further according to type of the instruction. 1355 */ 1356 static int symbol__parse_objdump_line(struct symbol *sym, FILE *file, 1357 struct annotate_args *args, 1358 int *line_nr) 1359 { 1360 struct map *map = args->ms.map; 1361 struct annotation *notes = symbol__annotation(sym); 1362 struct disasm_line *dl; 1363 char *line = NULL, *parsed_line, *tmp, *tmp2; 1364 size_t line_len; 1365 s64 line_ip, offset = -1; 1366 regmatch_t match[2]; 1367 1368 if (getline(&line, &line_len, file) < 0) 1369 return -1; 1370 1371 if (!line) 1372 return -1; 1373 1374 line_ip = -1; 1375 parsed_line = rtrim(line); 1376 1377 /* /filename:linenr ? Save line number and ignore. */ 1378 if (regexec(&file_lineno, parsed_line, 2, match, 0) == 0) { 1379 *line_nr = atoi(parsed_line + match[1].rm_so); 1380 return 0; 1381 } 1382 1383 tmp = ltrim(parsed_line); 1384 if (*tmp) { 1385 /* 1386 * Parse hexa addresses followed by ':' 1387 */ 1388 line_ip = strtoull(tmp, &tmp2, 16); 1389 if (*tmp2 != ':' || tmp == tmp2 || tmp2[1] == '\0') 1390 line_ip = -1; 1391 } 1392 1393 if (line_ip != -1) { 1394 u64 start = map__rip_2objdump(map, sym->start), 1395 end = map__rip_2objdump(map, sym->end); 1396 1397 offset = line_ip - start; 1398 if ((u64)line_ip < start || (u64)line_ip >= end) 1399 offset = -1; 1400 else 1401 parsed_line = tmp2 + 1; 1402 } 1403 1404 args->offset = offset; 1405 args->line = parsed_line; 1406 args->line_nr = *line_nr; 1407 args->ms.sym = sym; 1408 1409 dl = disasm_line__new(args); 1410 free(line); 1411 (*line_nr)++; 1412 1413 if (dl == NULL) 1414 return -1; 1415 1416 if (!disasm_line__has_local_offset(dl)) { 1417 dl->ops.target.offset = dl->ops.target.addr - 1418 map__rip_2objdump(map, sym->start); 1419 dl->ops.target.offset_avail = true; 1420 } 1421 1422 /* kcore has no symbols, so add the call target symbol */ 1423 if (dl->ins.ops && ins__is_call(&dl->ins) && !dl->ops.target.sym) { 1424 struct addr_map_symbol target = { 1425 .map = map, 1426 .addr = dl->ops.target.addr, 1427 }; 1428 1429 if (!map_groups__find_ams(&target) && 1430 target.sym->start == target.al_addr) 1431 dl->ops.target.sym = target.sym; 1432 } 1433 1434 annotation_line__add(&dl->al, ¬es->src->source); 1435 1436 return 0; 1437 } 1438 1439 static __attribute__((constructor)) void symbol__init_regexpr(void) 1440 { 1441 regcomp(&file_lineno, "^/[^:]+:([0-9]+)", REG_EXTENDED); 1442 } 1443 1444 static void delete_last_nop(struct symbol *sym) 1445 { 1446 struct annotation *notes = symbol__annotation(sym); 1447 struct list_head *list = ¬es->src->source; 1448 struct disasm_line *dl; 1449 1450 while (!list_empty(list)) { 1451 dl = list_entry(list->prev, struct disasm_line, al.node); 1452 1453 if (dl->ins.ops) { 1454 if (dl->ins.ops != &nop_ops) 1455 return; 1456 } else { 1457 if (!strstr(dl->al.line, " nop ") && 1458 !strstr(dl->al.line, " nopl ") && 1459 !strstr(dl->al.line, " nopw ")) 1460 return; 1461 } 1462 1463 list_del(&dl->al.node); 1464 disasm_line__free(dl); 1465 } 1466 } 1467 1468 int symbol__strerror_disassemble(struct symbol *sym __maybe_unused, struct map *map, 1469 int errnum, char *buf, size_t buflen) 1470 { 1471 struct dso *dso = map->dso; 1472 1473 BUG_ON(buflen == 0); 1474 1475 if (errnum >= 0) { 1476 str_error_r(errnum, buf, buflen); 1477 return 0; 1478 } 1479 1480 switch (errnum) { 1481 case SYMBOL_ANNOTATE_ERRNO__NO_VMLINUX: { 1482 char bf[SBUILD_ID_SIZE + 15] = " with build id "; 1483 char *build_id_msg = NULL; 1484 1485 if (dso->has_build_id) { 1486 build_id__sprintf(dso->build_id, 1487 sizeof(dso->build_id), bf + 15); 1488 build_id_msg = bf; 1489 } 1490 scnprintf(buf, buflen, 1491 "No vmlinux file%s\nwas found in the path.\n\n" 1492 "Note that annotation using /proc/kcore requires CAP_SYS_RAWIO capability.\n\n" 1493 "Please use:\n\n" 1494 " perf buildid-cache -vu vmlinux\n\n" 1495 "or:\n\n" 1496 " --vmlinux vmlinux\n", build_id_msg ?: ""); 1497 } 1498 break; 1499 default: 1500 scnprintf(buf, buflen, "Internal error: Invalid %d error code\n", errnum); 1501 break; 1502 } 1503 1504 return 0; 1505 } 1506 1507 static int dso__disassemble_filename(struct dso *dso, char *filename, size_t filename_size) 1508 { 1509 char linkname[PATH_MAX]; 1510 char *build_id_filename; 1511 char *build_id_path = NULL; 1512 char *pos; 1513 1514 if (dso->symtab_type == DSO_BINARY_TYPE__KALLSYMS && 1515 !dso__is_kcore(dso)) 1516 return SYMBOL_ANNOTATE_ERRNO__NO_VMLINUX; 1517 1518 build_id_filename = dso__build_id_filename(dso, NULL, 0, false); 1519 if (build_id_filename) { 1520 __symbol__join_symfs(filename, filename_size, build_id_filename); 1521 free(build_id_filename); 1522 } else { 1523 if (dso->has_build_id) 1524 return ENOMEM; 1525 goto fallback; 1526 } 1527 1528 build_id_path = strdup(filename); 1529 if (!build_id_path) 1530 return -1; 1531 1532 /* 1533 * old style build-id cache has name of XX/XXXXXXX.. while 1534 * new style has XX/XXXXXXX../{elf,kallsyms,vdso}. 1535 * extract the build-id part of dirname in the new style only. 1536 */ 1537 pos = strrchr(build_id_path, '/'); 1538 if (pos && strlen(pos) < SBUILD_ID_SIZE - 2) 1539 dirname(build_id_path); 1540 1541 if (dso__is_kcore(dso) || 1542 readlink(build_id_path, linkname, sizeof(linkname)) < 0 || 1543 strstr(linkname, DSO__NAME_KALLSYMS) || 1544 access(filename, R_OK)) { 1545 fallback: 1546 /* 1547 * If we don't have build-ids or the build-id file isn't in the 1548 * cache, or is just a kallsyms file, well, lets hope that this 1549 * DSO is the same as when 'perf record' ran. 1550 */ 1551 __symbol__join_symfs(filename, filename_size, dso->long_name); 1552 } 1553 1554 free(build_id_path); 1555 return 0; 1556 } 1557 1558 static int symbol__disassemble(struct symbol *sym, struct annotate_args *args) 1559 { 1560 struct map *map = args->ms.map; 1561 struct dso *dso = map->dso; 1562 char *command; 1563 FILE *file; 1564 char symfs_filename[PATH_MAX]; 1565 struct kcore_extract kce; 1566 bool delete_extract = false; 1567 int stdout_fd[2]; 1568 int lineno = 0; 1569 int nline; 1570 pid_t pid; 1571 int err = dso__disassemble_filename(dso, symfs_filename, sizeof(symfs_filename)); 1572 1573 if (err) 1574 return err; 1575 1576 pr_debug("%s: filename=%s, sym=%s, start=%#" PRIx64 ", end=%#" PRIx64 "\n", __func__, 1577 symfs_filename, sym->name, map->unmap_ip(map, sym->start), 1578 map->unmap_ip(map, sym->end)); 1579 1580 pr_debug("annotating [%p] %30s : [%p] %30s\n", 1581 dso, dso->long_name, sym, sym->name); 1582 1583 if (dso__is_kcore(dso)) { 1584 kce.kcore_filename = symfs_filename; 1585 kce.addr = map__rip_2objdump(map, sym->start); 1586 kce.offs = sym->start; 1587 kce.len = sym->end - sym->start; 1588 if (!kcore_extract__create(&kce)) { 1589 delete_extract = true; 1590 strlcpy(symfs_filename, kce.extract_filename, 1591 sizeof(symfs_filename)); 1592 } 1593 } else if (dso__needs_decompress(dso)) { 1594 char tmp[KMOD_DECOMP_LEN]; 1595 1596 if (dso__decompress_kmodule_path(dso, symfs_filename, 1597 tmp, sizeof(tmp)) < 0) 1598 goto out; 1599 1600 strcpy(symfs_filename, tmp); 1601 } 1602 1603 err = asprintf(&command, 1604 "%s %s%s --start-address=0x%016" PRIx64 1605 " --stop-address=0x%016" PRIx64 1606 " -l -d %s %s -C \"%s\" 2>/dev/null|grep -v \"%s:\"|expand", 1607 objdump_path ? objdump_path : "objdump", 1608 disassembler_style ? "-M " : "", 1609 disassembler_style ? disassembler_style : "", 1610 map__rip_2objdump(map, sym->start), 1611 map__rip_2objdump(map, sym->end), 1612 symbol_conf.annotate_asm_raw ? "" : "--no-show-raw", 1613 symbol_conf.annotate_src ? "-S" : "", 1614 symfs_filename, symfs_filename); 1615 1616 if (err < 0) { 1617 pr_err("Failure allocating memory for the command to run\n"); 1618 goto out_remove_tmp; 1619 } 1620 1621 pr_debug("Executing: %s\n", command); 1622 1623 err = -1; 1624 if (pipe(stdout_fd) < 0) { 1625 pr_err("Failure creating the pipe to run %s\n", command); 1626 goto out_free_command; 1627 } 1628 1629 pid = fork(); 1630 if (pid < 0) { 1631 pr_err("Failure forking to run %s\n", command); 1632 goto out_close_stdout; 1633 } 1634 1635 if (pid == 0) { 1636 close(stdout_fd[0]); 1637 dup2(stdout_fd[1], 1); 1638 close(stdout_fd[1]); 1639 execl("/bin/sh", "sh", "-c", command, NULL); 1640 perror(command); 1641 exit(-1); 1642 } 1643 1644 close(stdout_fd[1]); 1645 1646 file = fdopen(stdout_fd[0], "r"); 1647 if (!file) { 1648 pr_err("Failure creating FILE stream for %s\n", command); 1649 /* 1650 * If we were using debug info should retry with 1651 * original binary. 1652 */ 1653 goto out_free_command; 1654 } 1655 1656 nline = 0; 1657 while (!feof(file)) { 1658 /* 1659 * The source code line number (lineno) needs to be kept in 1660 * accross calls to symbol__parse_objdump_line(), so that it 1661 * can associate it with the instructions till the next one. 1662 * See disasm_line__new() and struct disasm_line::line_nr. 1663 */ 1664 if (symbol__parse_objdump_line(sym, file, args, &lineno) < 0) 1665 break; 1666 nline++; 1667 } 1668 1669 if (nline == 0) 1670 pr_err("No output from %s\n", command); 1671 1672 /* 1673 * kallsyms does not have symbol sizes so there may a nop at the end. 1674 * Remove it. 1675 */ 1676 if (dso__is_kcore(dso)) 1677 delete_last_nop(sym); 1678 1679 fclose(file); 1680 err = 0; 1681 out_free_command: 1682 free(command); 1683 out_remove_tmp: 1684 close(stdout_fd[0]); 1685 1686 if (dso__needs_decompress(dso)) 1687 unlink(symfs_filename); 1688 1689 if (delete_extract) 1690 kcore_extract__delete(&kce); 1691 out: 1692 return err; 1693 1694 out_close_stdout: 1695 close(stdout_fd[1]); 1696 goto out_free_command; 1697 } 1698 1699 static void calc_percent(struct sym_hist *hist, 1700 struct annotation_data *sample, 1701 s64 offset, s64 end) 1702 { 1703 unsigned int hits = 0; 1704 u64 period = 0; 1705 1706 while (offset < end) { 1707 hits += hist->addr[offset].nr_samples; 1708 period += hist->addr[offset].period; 1709 ++offset; 1710 } 1711 1712 if (hist->nr_samples) { 1713 sample->he.period = period; 1714 sample->he.nr_samples = hits; 1715 sample->percent = 100.0 * hits / hist->nr_samples; 1716 } 1717 } 1718 1719 static void annotation__calc_percent(struct annotation *notes, 1720 struct perf_evsel *evsel, s64 len) 1721 { 1722 struct annotation_line *al, *next; 1723 1724 list_for_each_entry(al, ¬es->src->source, node) { 1725 s64 end; 1726 int i; 1727 1728 if (al->offset == -1) 1729 continue; 1730 1731 next = annotation_line__next(al, ¬es->src->source); 1732 end = next ? next->offset : len; 1733 1734 for (i = 0; i < al->samples_nr; i++) { 1735 struct annotation_data *sample; 1736 struct sym_hist *hist; 1737 1738 hist = annotation__histogram(notes, evsel->idx + i); 1739 sample = &al->samples[i]; 1740 1741 calc_percent(hist, sample, al->offset, end); 1742 } 1743 } 1744 } 1745 1746 void symbol__calc_percent(struct symbol *sym, struct perf_evsel *evsel) 1747 { 1748 struct annotation *notes = symbol__annotation(sym); 1749 1750 annotation__calc_percent(notes, evsel, symbol__size(sym)); 1751 } 1752 1753 int symbol__annotate(struct symbol *sym, struct map *map, 1754 struct perf_evsel *evsel, size_t privsize, 1755 struct arch **parch) 1756 { 1757 struct annotate_args args = { 1758 .privsize = privsize, 1759 .evsel = evsel, 1760 }; 1761 struct perf_env *env = perf_evsel__env(evsel); 1762 const char *arch_name = perf_env__arch(env); 1763 struct arch *arch; 1764 int err; 1765 1766 if (!arch_name) 1767 return -1; 1768 1769 args.arch = arch = arch__find(arch_name); 1770 if (arch == NULL) 1771 return -ENOTSUP; 1772 1773 if (parch) 1774 *parch = arch; 1775 1776 if (arch->init) { 1777 err = arch->init(arch, env ? env->cpuid : NULL); 1778 if (err) { 1779 pr_err("%s: failed to initialize %s arch priv area\n", __func__, arch->name); 1780 return err; 1781 } 1782 } 1783 1784 args.ms.map = map; 1785 args.ms.sym = sym; 1786 1787 return symbol__disassemble(sym, &args); 1788 } 1789 1790 static void insert_source_line(struct rb_root *root, struct annotation_line *al) 1791 { 1792 struct annotation_line *iter; 1793 struct rb_node **p = &root->rb_node; 1794 struct rb_node *parent = NULL; 1795 int i, ret; 1796 1797 while (*p != NULL) { 1798 parent = *p; 1799 iter = rb_entry(parent, struct annotation_line, rb_node); 1800 1801 ret = strcmp(iter->path, al->path); 1802 if (ret == 0) { 1803 for (i = 0; i < al->samples_nr; i++) 1804 iter->samples[i].percent_sum += al->samples[i].percent; 1805 return; 1806 } 1807 1808 if (ret < 0) 1809 p = &(*p)->rb_left; 1810 else 1811 p = &(*p)->rb_right; 1812 } 1813 1814 for (i = 0; i < al->samples_nr; i++) 1815 al->samples[i].percent_sum = al->samples[i].percent; 1816 1817 rb_link_node(&al->rb_node, parent, p); 1818 rb_insert_color(&al->rb_node, root); 1819 } 1820 1821 static int cmp_source_line(struct annotation_line *a, struct annotation_line *b) 1822 { 1823 int i; 1824 1825 for (i = 0; i < a->samples_nr; i++) { 1826 if (a->samples[i].percent_sum == b->samples[i].percent_sum) 1827 continue; 1828 return a->samples[i].percent_sum > b->samples[i].percent_sum; 1829 } 1830 1831 return 0; 1832 } 1833 1834 static void __resort_source_line(struct rb_root *root, struct annotation_line *al) 1835 { 1836 struct annotation_line *iter; 1837 struct rb_node **p = &root->rb_node; 1838 struct rb_node *parent = NULL; 1839 1840 while (*p != NULL) { 1841 parent = *p; 1842 iter = rb_entry(parent, struct annotation_line, rb_node); 1843 1844 if (cmp_source_line(al, iter)) 1845 p = &(*p)->rb_left; 1846 else 1847 p = &(*p)->rb_right; 1848 } 1849 1850 rb_link_node(&al->rb_node, parent, p); 1851 rb_insert_color(&al->rb_node, root); 1852 } 1853 1854 static void resort_source_line(struct rb_root *dest_root, struct rb_root *src_root) 1855 { 1856 struct annotation_line *al; 1857 struct rb_node *node; 1858 1859 node = rb_first(src_root); 1860 while (node) { 1861 struct rb_node *next; 1862 1863 al = rb_entry(node, struct annotation_line, rb_node); 1864 next = rb_next(node); 1865 rb_erase(node, src_root); 1866 1867 __resort_source_line(dest_root, al); 1868 node = next; 1869 } 1870 } 1871 1872 static void print_summary(struct rb_root *root, const char *filename) 1873 { 1874 struct annotation_line *al; 1875 struct rb_node *node; 1876 1877 printf("\nSorted summary for file %s\n", filename); 1878 printf("----------------------------------------------\n\n"); 1879 1880 if (RB_EMPTY_ROOT(root)) { 1881 printf(" Nothing higher than %1.1f%%\n", MIN_GREEN); 1882 return; 1883 } 1884 1885 node = rb_first(root); 1886 while (node) { 1887 double percent, percent_max = 0.0; 1888 const char *color; 1889 char *path; 1890 int i; 1891 1892 al = rb_entry(node, struct annotation_line, rb_node); 1893 for (i = 0; i < al->samples_nr; i++) { 1894 percent = al->samples[i].percent_sum; 1895 color = get_percent_color(percent); 1896 color_fprintf(stdout, color, " %7.2f", percent); 1897 1898 if (percent > percent_max) 1899 percent_max = percent; 1900 } 1901 1902 path = al->path; 1903 color = get_percent_color(percent_max); 1904 color_fprintf(stdout, color, " %s\n", path); 1905 1906 node = rb_next(node); 1907 } 1908 } 1909 1910 static void symbol__annotate_hits(struct symbol *sym, struct perf_evsel *evsel) 1911 { 1912 struct annotation *notes = symbol__annotation(sym); 1913 struct sym_hist *h = annotation__histogram(notes, evsel->idx); 1914 u64 len = symbol__size(sym), offset; 1915 1916 for (offset = 0; offset < len; ++offset) 1917 if (h->addr[offset].nr_samples != 0) 1918 printf("%*" PRIx64 ": %" PRIu64 "\n", BITS_PER_LONG / 2, 1919 sym->start + offset, h->addr[offset].nr_samples); 1920 printf("%*s: %" PRIu64 "\n", BITS_PER_LONG / 2, "h->nr_samples", h->nr_samples); 1921 } 1922 1923 static int annotated_source__addr_fmt_width(struct list_head *lines, u64 start) 1924 { 1925 char bf[32]; 1926 struct annotation_line *line; 1927 1928 list_for_each_entry_reverse(line, lines, node) { 1929 if (line->offset != -1) 1930 return scnprintf(bf, sizeof(bf), "%" PRIx64, start + line->offset); 1931 } 1932 1933 return 0; 1934 } 1935 1936 int symbol__annotate_printf(struct symbol *sym, struct map *map, 1937 struct perf_evsel *evsel, bool full_paths, 1938 int min_pcnt, int max_lines, int context) 1939 { 1940 struct dso *dso = map->dso; 1941 char *filename; 1942 const char *d_filename; 1943 const char *evsel_name = perf_evsel__name(evsel); 1944 struct annotation *notes = symbol__annotation(sym); 1945 struct sym_hist *h = annotation__histogram(notes, evsel->idx); 1946 struct annotation_line *pos, *queue = NULL; 1947 u64 start = map__rip_2objdump(map, sym->start); 1948 int printed = 2, queue_len = 0, addr_fmt_width; 1949 int more = 0; 1950 u64 len; 1951 int width = symbol_conf.show_total_period ? 12 : 8; 1952 int graph_dotted_len; 1953 1954 filename = strdup(dso->long_name); 1955 if (!filename) 1956 return -ENOMEM; 1957 1958 if (full_paths) 1959 d_filename = filename; 1960 else 1961 d_filename = basename(filename); 1962 1963 len = symbol__size(sym); 1964 1965 if (perf_evsel__is_group_event(evsel)) 1966 width *= evsel->nr_members; 1967 1968 graph_dotted_len = printf(" %-*.*s| Source code & Disassembly of %s for %s (%" PRIu64 " samples)\n", 1969 width, width, symbol_conf.show_total_period ? "Period" : 1970 symbol_conf.show_nr_samples ? "Samples" : "Percent", 1971 d_filename, evsel_name, h->nr_samples); 1972 1973 printf("%-*.*s----\n", 1974 graph_dotted_len, graph_dotted_len, graph_dotted_line); 1975 1976 if (verbose > 0) 1977 symbol__annotate_hits(sym, evsel); 1978 1979 addr_fmt_width = annotated_source__addr_fmt_width(¬es->src->source, start); 1980 1981 list_for_each_entry(pos, ¬es->src->source, node) { 1982 int err; 1983 1984 if (context && queue == NULL) { 1985 queue = pos; 1986 queue_len = 0; 1987 } 1988 1989 err = annotation_line__print(pos, sym, start, evsel, len, 1990 min_pcnt, printed, max_lines, 1991 queue, addr_fmt_width); 1992 1993 switch (err) { 1994 case 0: 1995 ++printed; 1996 if (context) { 1997 printed += queue_len; 1998 queue = NULL; 1999 queue_len = 0; 2000 } 2001 break; 2002 case 1: 2003 /* filtered by max_lines */ 2004 ++more; 2005 break; 2006 case -1: 2007 default: 2008 /* 2009 * Filtered by min_pcnt or non IP lines when 2010 * context != 0 2011 */ 2012 if (!context) 2013 break; 2014 if (queue_len == context) 2015 queue = list_entry(queue->node.next, typeof(*queue), node); 2016 else 2017 ++queue_len; 2018 break; 2019 } 2020 } 2021 2022 free(filename); 2023 2024 return more; 2025 } 2026 2027 static void FILE__set_percent_color(void *fp __maybe_unused, 2028 double percent __maybe_unused, 2029 bool current __maybe_unused) 2030 { 2031 } 2032 2033 static int FILE__set_jumps_percent_color(void *fp __maybe_unused, 2034 int nr __maybe_unused, bool current __maybe_unused) 2035 { 2036 return 0; 2037 } 2038 2039 static int FILE__set_color(void *fp __maybe_unused, int color __maybe_unused) 2040 { 2041 return 0; 2042 } 2043 2044 static void FILE__printf(void *fp, const char *fmt, ...) 2045 { 2046 va_list args; 2047 2048 va_start(args, fmt); 2049 vfprintf(fp, fmt, args); 2050 va_end(args); 2051 } 2052 2053 static void FILE__write_graph(void *fp, int graph) 2054 { 2055 const char *s; 2056 switch (graph) { 2057 2058 case DARROW_CHAR: s = "↓"; break; 2059 case UARROW_CHAR: s = "↑"; break; 2060 case LARROW_CHAR: s = "←"; break; 2061 case RARROW_CHAR: s = "→"; break; 2062 default: s = "?"; break; 2063 } 2064 2065 fputs(s, fp); 2066 } 2067 2068 int symbol__annotate_fprintf2(struct symbol *sym, FILE *fp) 2069 { 2070 struct annotation *notes = symbol__annotation(sym); 2071 struct annotation_write_ops ops = { 2072 .first_line = true, 2073 .obj = fp, 2074 .set_color = FILE__set_color, 2075 .set_percent_color = FILE__set_percent_color, 2076 .set_jumps_percent_color = FILE__set_jumps_percent_color, 2077 .printf = FILE__printf, 2078 .write_graph = FILE__write_graph, 2079 }; 2080 struct annotation_line *al; 2081 2082 list_for_each_entry(al, ¬es->src->source, node) { 2083 if (annotation_line__filter(al, notes)) 2084 continue; 2085 annotation_line__write(al, notes, &ops); 2086 fputc('\n', fp); 2087 ops.first_line = false; 2088 } 2089 2090 return 0; 2091 } 2092 2093 int map_symbol__annotation_dump(struct map_symbol *ms, struct perf_evsel *evsel) 2094 { 2095 const char *ev_name = perf_evsel__name(evsel); 2096 char buf[1024]; 2097 char *filename; 2098 int err = -1; 2099 FILE *fp; 2100 2101 if (asprintf(&filename, "%s.annotation", ms->sym->name) < 0) 2102 return -1; 2103 2104 fp = fopen(filename, "w"); 2105 if (fp == NULL) 2106 goto out_free_filename; 2107 2108 if (perf_evsel__is_group_event(evsel)) { 2109 perf_evsel__group_desc(evsel, buf, sizeof(buf)); 2110 ev_name = buf; 2111 } 2112 2113 fprintf(fp, "%s() %s\nEvent: %s\n\n", 2114 ms->sym->name, ms->map->dso->long_name, ev_name); 2115 symbol__annotate_fprintf2(ms->sym, fp); 2116 2117 fclose(fp); 2118 err = 0; 2119 out_free_filename: 2120 free(filename); 2121 return err; 2122 } 2123 2124 void symbol__annotate_zero_histogram(struct symbol *sym, int evidx) 2125 { 2126 struct annotation *notes = symbol__annotation(sym); 2127 struct sym_hist *h = annotation__histogram(notes, evidx); 2128 2129 memset(h, 0, notes->src->sizeof_sym_hist); 2130 } 2131 2132 void symbol__annotate_decay_histogram(struct symbol *sym, int evidx) 2133 { 2134 struct annotation *notes = symbol__annotation(sym); 2135 struct sym_hist *h = annotation__histogram(notes, evidx); 2136 int len = symbol__size(sym), offset; 2137 2138 h->nr_samples = 0; 2139 for (offset = 0; offset < len; ++offset) { 2140 h->addr[offset].nr_samples = h->addr[offset].nr_samples * 7 / 8; 2141 h->nr_samples += h->addr[offset].nr_samples; 2142 } 2143 } 2144 2145 void annotated_source__purge(struct annotated_source *as) 2146 { 2147 struct annotation_line *al, *n; 2148 2149 list_for_each_entry_safe(al, n, &as->source, node) { 2150 list_del(&al->node); 2151 disasm_line__free(disasm_line(al)); 2152 } 2153 } 2154 2155 static size_t disasm_line__fprintf(struct disasm_line *dl, FILE *fp) 2156 { 2157 size_t printed; 2158 2159 if (dl->al.offset == -1) 2160 return fprintf(fp, "%s\n", dl->al.line); 2161 2162 printed = fprintf(fp, "%#" PRIx64 " %s", dl->al.offset, dl->ins.name); 2163 2164 if (dl->ops.raw[0] != '\0') { 2165 printed += fprintf(fp, "%.*s %s\n", 6 - (int)printed, " ", 2166 dl->ops.raw); 2167 } 2168 2169 return printed + fprintf(fp, "\n"); 2170 } 2171 2172 size_t disasm__fprintf(struct list_head *head, FILE *fp) 2173 { 2174 struct disasm_line *pos; 2175 size_t printed = 0; 2176 2177 list_for_each_entry(pos, head, al.node) 2178 printed += disasm_line__fprintf(pos, fp); 2179 2180 return printed; 2181 } 2182 2183 bool disasm_line__is_valid_local_jump(struct disasm_line *dl, struct symbol *sym) 2184 { 2185 if (!dl || !dl->ins.ops || !ins__is_jump(&dl->ins) || 2186 !disasm_line__has_local_offset(dl) || dl->ops.target.offset < 0 || 2187 dl->ops.target.offset >= (s64)symbol__size(sym)) 2188 return false; 2189 2190 return true; 2191 } 2192 2193 void annotation__mark_jump_targets(struct annotation *notes, struct symbol *sym) 2194 { 2195 u64 offset, size = symbol__size(sym); 2196 2197 /* PLT symbols contain external offsets */ 2198 if (strstr(sym->name, "@plt")) 2199 return; 2200 2201 for (offset = 0; offset < size; ++offset) { 2202 struct annotation_line *al = notes->offsets[offset]; 2203 struct disasm_line *dl; 2204 2205 dl = disasm_line(al); 2206 2207 if (!disasm_line__is_valid_local_jump(dl, sym)) 2208 continue; 2209 2210 al = notes->offsets[dl->ops.target.offset]; 2211 2212 /* 2213 * FIXME: Oops, no jump target? Buggy disassembler? Or do we 2214 * have to adjust to the previous offset? 2215 */ 2216 if (al == NULL) 2217 continue; 2218 2219 if (++al->jump_sources > notes->max_jump_sources) 2220 notes->max_jump_sources = al->jump_sources; 2221 2222 ++notes->nr_jumps; 2223 } 2224 } 2225 2226 void annotation__set_offsets(struct annotation *notes, s64 size) 2227 { 2228 struct annotation_line *al; 2229 2230 notes->max_line_len = 0; 2231 2232 list_for_each_entry(al, ¬es->src->source, node) { 2233 size_t line_len = strlen(al->line); 2234 2235 if (notes->max_line_len < line_len) 2236 notes->max_line_len = line_len; 2237 al->idx = notes->nr_entries++; 2238 if (al->offset != -1) { 2239 al->idx_asm = notes->nr_asm_entries++; 2240 /* 2241 * FIXME: short term bandaid to cope with assembly 2242 * routines that comes with labels in the same column 2243 * as the address in objdump, sigh. 2244 * 2245 * E.g. copy_user_generic_unrolled 2246 */ 2247 if (al->offset < size) 2248 notes->offsets[al->offset] = al; 2249 } else 2250 al->idx_asm = -1; 2251 } 2252 } 2253 2254 static inline int width_jumps(int n) 2255 { 2256 if (n >= 100) 2257 return 5; 2258 if (n / 10) 2259 return 2; 2260 return 1; 2261 } 2262 2263 void annotation__init_column_widths(struct annotation *notes, struct symbol *sym) 2264 { 2265 notes->widths.addr = notes->widths.target = 2266 notes->widths.min_addr = hex_width(symbol__size(sym)); 2267 notes->widths.max_addr = hex_width(sym->end); 2268 notes->widths.jumps = width_jumps(notes->max_jump_sources); 2269 } 2270 2271 void annotation__update_column_widths(struct annotation *notes) 2272 { 2273 if (notes->options->use_offset) 2274 notes->widths.target = notes->widths.min_addr; 2275 else 2276 notes->widths.target = notes->widths.max_addr; 2277 2278 notes->widths.addr = notes->widths.target; 2279 2280 if (notes->options->show_nr_jumps) 2281 notes->widths.addr += notes->widths.jumps + 1; 2282 } 2283 2284 static void annotation__calc_lines(struct annotation *notes, struct map *map, 2285 struct rb_root *root) 2286 { 2287 struct annotation_line *al; 2288 struct rb_root tmp_root = RB_ROOT; 2289 2290 list_for_each_entry(al, ¬es->src->source, node) { 2291 double percent_max = 0.0; 2292 int i; 2293 2294 for (i = 0; i < al->samples_nr; i++) { 2295 struct annotation_data *sample; 2296 2297 sample = &al->samples[i]; 2298 2299 if (sample->percent > percent_max) 2300 percent_max = sample->percent; 2301 } 2302 2303 if (percent_max <= 0.5) 2304 continue; 2305 2306 al->path = get_srcline(map->dso, notes->start + al->offset, NULL, 2307 false, true, notes->start + al->offset); 2308 insert_source_line(&tmp_root, al); 2309 } 2310 2311 resort_source_line(root, &tmp_root); 2312 } 2313 2314 static void symbol__calc_lines(struct symbol *sym, struct map *map, 2315 struct rb_root *root) 2316 { 2317 struct annotation *notes = symbol__annotation(sym); 2318 2319 annotation__calc_lines(notes, map, root); 2320 } 2321 2322 int symbol__tty_annotate2(struct symbol *sym, struct map *map, 2323 struct perf_evsel *evsel, bool print_lines, 2324 bool full_paths) 2325 { 2326 struct dso *dso = map->dso; 2327 struct rb_root source_line = RB_ROOT; 2328 struct annotation_options opts = annotation__default_options; 2329 struct annotation *notes = symbol__annotation(sym); 2330 char buf[1024]; 2331 2332 if (symbol__annotate2(sym, map, evsel, &opts, NULL) < 0) 2333 return -1; 2334 2335 if (print_lines) { 2336 srcline_full_filename = full_paths; 2337 symbol__calc_lines(sym, map, &source_line); 2338 print_summary(&source_line, dso->long_name); 2339 } 2340 2341 annotation__scnprintf_samples_period(notes, buf, sizeof(buf), evsel); 2342 fprintf(stdout, "%s\n%s() %s\n", buf, sym->name, dso->long_name); 2343 symbol__annotate_fprintf2(sym, stdout); 2344 2345 annotated_source__purge(symbol__annotation(sym)->src); 2346 2347 return 0; 2348 } 2349 2350 int symbol__tty_annotate(struct symbol *sym, struct map *map, 2351 struct perf_evsel *evsel, bool print_lines, 2352 bool full_paths, int min_pcnt, int max_lines) 2353 { 2354 struct dso *dso = map->dso; 2355 struct rb_root source_line = RB_ROOT; 2356 2357 if (symbol__annotate(sym, map, evsel, 0, NULL) < 0) 2358 return -1; 2359 2360 symbol__calc_percent(sym, evsel); 2361 2362 if (print_lines) { 2363 srcline_full_filename = full_paths; 2364 symbol__calc_lines(sym, map, &source_line); 2365 print_summary(&source_line, dso->long_name); 2366 } 2367 2368 symbol__annotate_printf(sym, map, evsel, full_paths, 2369 min_pcnt, max_lines, 0); 2370 2371 annotated_source__purge(symbol__annotation(sym)->src); 2372 2373 return 0; 2374 } 2375 2376 bool ui__has_annotation(void) 2377 { 2378 return use_browser == 1 && perf_hpp_list.sym; 2379 } 2380 2381 2382 double annotation_line__max_percent(struct annotation_line *al, struct annotation *notes) 2383 { 2384 double percent_max = 0.0; 2385 int i; 2386 2387 for (i = 0; i < notes->nr_events; i++) { 2388 if (al->samples[i].percent > percent_max) 2389 percent_max = al->samples[i].percent; 2390 } 2391 2392 return percent_max; 2393 } 2394 2395 static void disasm_line__write(struct disasm_line *dl, struct annotation *notes, 2396 void *obj, char *bf, size_t size, 2397 void (*obj__printf)(void *obj, const char *fmt, ...), 2398 void (*obj__write_graph)(void *obj, int graph)) 2399 { 2400 if (dl->ins.ops && dl->ins.ops->scnprintf) { 2401 if (ins__is_jump(&dl->ins)) { 2402 bool fwd; 2403 2404 if (dl->ops.target.outside) 2405 goto call_like; 2406 fwd = dl->ops.target.offset > dl->al.offset; 2407 obj__write_graph(obj, fwd ? DARROW_CHAR : UARROW_CHAR); 2408 obj__printf(obj, " "); 2409 } else if (ins__is_call(&dl->ins)) { 2410 call_like: 2411 obj__write_graph(obj, RARROW_CHAR); 2412 obj__printf(obj, " "); 2413 } else if (ins__is_ret(&dl->ins)) { 2414 obj__write_graph(obj, LARROW_CHAR); 2415 obj__printf(obj, " "); 2416 } else { 2417 obj__printf(obj, " "); 2418 } 2419 } else { 2420 obj__printf(obj, " "); 2421 } 2422 2423 disasm_line__scnprintf(dl, bf, size, !notes->options->use_offset); 2424 } 2425 2426 static void __annotation_line__write(struct annotation_line *al, struct annotation *notes, 2427 bool first_line, bool current_entry, bool change_color, int width, 2428 void *obj, 2429 int (*obj__set_color)(void *obj, int color), 2430 void (*obj__set_percent_color)(void *obj, double percent, bool current), 2431 int (*obj__set_jumps_percent_color)(void *obj, int nr, bool current), 2432 void (*obj__printf)(void *obj, const char *fmt, ...), 2433 void (*obj__write_graph)(void *obj, int graph)) 2434 2435 { 2436 double percent_max = annotation_line__max_percent(al, notes); 2437 int pcnt_width = annotation__pcnt_width(notes), 2438 cycles_width = annotation__cycles_width(notes); 2439 bool show_title = false; 2440 char bf[256]; 2441 int printed; 2442 2443 if (first_line && (al->offset == -1 || percent_max == 0.0)) { 2444 if (notes->have_cycles) { 2445 if (al->ipc == 0.0 && al->cycles == 0) 2446 show_title = true; 2447 } else 2448 show_title = true; 2449 } 2450 2451 if (al->offset != -1 && percent_max != 0.0) { 2452 int i; 2453 2454 for (i = 0; i < notes->nr_events; i++) { 2455 obj__set_percent_color(obj, al->samples[i].percent, current_entry); 2456 if (notes->options->show_total_period) { 2457 obj__printf(obj, "%11" PRIu64 " ", al->samples[i].he.period); 2458 } else if (notes->options->show_nr_samples) { 2459 obj__printf(obj, "%6" PRIu64 " ", 2460 al->samples[i].he.nr_samples); 2461 } else { 2462 obj__printf(obj, "%6.2f ", 2463 al->samples[i].percent); 2464 } 2465 } 2466 } else { 2467 obj__set_percent_color(obj, 0, current_entry); 2468 2469 if (!show_title) 2470 obj__printf(obj, "%-*s", pcnt_width, " "); 2471 else { 2472 obj__printf(obj, "%-*s", pcnt_width, 2473 notes->options->show_total_period ? "Period" : 2474 notes->options->show_nr_samples ? "Samples" : "Percent"); 2475 } 2476 } 2477 2478 if (notes->have_cycles) { 2479 if (al->ipc) 2480 obj__printf(obj, "%*.2f ", ANNOTATION__IPC_WIDTH - 1, al->ipc); 2481 else if (!show_title) 2482 obj__printf(obj, "%*s", ANNOTATION__IPC_WIDTH, " "); 2483 else 2484 obj__printf(obj, "%*s ", ANNOTATION__IPC_WIDTH - 1, "IPC"); 2485 2486 if (al->cycles) 2487 obj__printf(obj, "%*" PRIu64 " ", 2488 ANNOTATION__CYCLES_WIDTH - 1, al->cycles); 2489 else if (!show_title) 2490 obj__printf(obj, "%*s", ANNOTATION__CYCLES_WIDTH, " "); 2491 else 2492 obj__printf(obj, "%*s ", ANNOTATION__CYCLES_WIDTH - 1, "Cycle"); 2493 } 2494 2495 obj__printf(obj, " "); 2496 2497 if (!*al->line) 2498 obj__printf(obj, "%-*s", width - pcnt_width - cycles_width, " "); 2499 else if (al->offset == -1) { 2500 if (al->line_nr && notes->options->show_linenr) 2501 printed = scnprintf(bf, sizeof(bf), "%-*d ", notes->widths.addr + 1, al->line_nr); 2502 else 2503 printed = scnprintf(bf, sizeof(bf), "%-*s ", notes->widths.addr, " "); 2504 obj__printf(obj, bf); 2505 obj__printf(obj, "%-*s", width - printed - pcnt_width - cycles_width + 1, al->line); 2506 } else { 2507 u64 addr = al->offset; 2508 int color = -1; 2509 2510 if (!notes->options->use_offset) 2511 addr += notes->start; 2512 2513 if (!notes->options->use_offset) { 2514 printed = scnprintf(bf, sizeof(bf), "%" PRIx64 ": ", addr); 2515 } else { 2516 if (al->jump_sources && 2517 notes->options->offset_level >= ANNOTATION__OFFSET_JUMP_TARGETS) { 2518 if (notes->options->show_nr_jumps) { 2519 int prev; 2520 printed = scnprintf(bf, sizeof(bf), "%*d ", 2521 notes->widths.jumps, 2522 al->jump_sources); 2523 prev = obj__set_jumps_percent_color(obj, al->jump_sources, 2524 current_entry); 2525 obj__printf(obj, bf); 2526 obj__set_color(obj, prev); 2527 } 2528 print_addr: 2529 printed = scnprintf(bf, sizeof(bf), "%*" PRIx64 ": ", 2530 notes->widths.target, addr); 2531 } else if (ins__is_call(&disasm_line(al)->ins) && 2532 notes->options->offset_level >= ANNOTATION__OFFSET_CALL) { 2533 goto print_addr; 2534 } else if (notes->options->offset_level == ANNOTATION__MAX_OFFSET_LEVEL) { 2535 goto print_addr; 2536 } else { 2537 printed = scnprintf(bf, sizeof(bf), "%-*s ", 2538 notes->widths.addr, " "); 2539 } 2540 } 2541 2542 if (change_color) 2543 color = obj__set_color(obj, HE_COLORSET_ADDR); 2544 obj__printf(obj, bf); 2545 if (change_color) 2546 obj__set_color(obj, color); 2547 2548 disasm_line__write(disasm_line(al), notes, obj, bf, sizeof(bf), obj__printf, obj__write_graph); 2549 2550 obj__printf(obj, "%-*s", width - pcnt_width - cycles_width - 3 - printed, bf); 2551 } 2552 2553 } 2554 2555 void annotation_line__write(struct annotation_line *al, struct annotation *notes, 2556 struct annotation_write_ops *ops) 2557 { 2558 __annotation_line__write(al, notes, ops->first_line, ops->current_entry, 2559 ops->change_color, ops->width, ops->obj, 2560 ops->set_color, ops->set_percent_color, 2561 ops->set_jumps_percent_color, ops->printf, 2562 ops->write_graph); 2563 } 2564 2565 int symbol__annotate2(struct symbol *sym, struct map *map, struct perf_evsel *evsel, 2566 struct annotation_options *options, struct arch **parch) 2567 { 2568 struct annotation *notes = symbol__annotation(sym); 2569 size_t size = symbol__size(sym); 2570 int nr_pcnt = 1, err; 2571 2572 notes->offsets = zalloc(size * sizeof(struct annotation_line *)); 2573 if (notes->offsets == NULL) 2574 return -1; 2575 2576 if (perf_evsel__is_group_event(evsel)) 2577 nr_pcnt = evsel->nr_members; 2578 2579 err = symbol__annotate(sym, map, evsel, 0, parch); 2580 if (err) 2581 goto out_free_offsets; 2582 2583 notes->options = options; 2584 2585 symbol__calc_percent(sym, evsel); 2586 2587 notes->start = map__rip_2objdump(map, sym->start); 2588 2589 annotation__set_offsets(notes, size); 2590 annotation__mark_jump_targets(notes, sym); 2591 annotation__compute_ipc(notes, size); 2592 annotation__init_column_widths(notes, sym); 2593 notes->nr_events = nr_pcnt; 2594 2595 annotation__update_column_widths(notes); 2596 2597 return 0; 2598 2599 out_free_offsets: 2600 zfree(¬es->offsets); 2601 return -1; 2602 } 2603 2604 int __annotation__scnprintf_samples_period(struct annotation *notes, 2605 char *bf, size_t size, 2606 struct perf_evsel *evsel, 2607 bool show_freq) 2608 { 2609 const char *ev_name = perf_evsel__name(evsel); 2610 char buf[1024], ref[30] = " show reference callgraph, "; 2611 char sample_freq_str[64] = ""; 2612 unsigned long nr_samples = 0; 2613 int nr_members = 1; 2614 bool enable_ref = false; 2615 u64 nr_events = 0; 2616 char unit; 2617 int i; 2618 2619 if (perf_evsel__is_group_event(evsel)) { 2620 perf_evsel__group_desc(evsel, buf, sizeof(buf)); 2621 ev_name = buf; 2622 nr_members = evsel->nr_members; 2623 } 2624 2625 for (i = 0; i < nr_members; i++) { 2626 struct sym_hist *ah = annotation__histogram(notes, evsel->idx + i); 2627 2628 nr_samples += ah->nr_samples; 2629 nr_events += ah->period; 2630 } 2631 2632 if (symbol_conf.show_ref_callgraph && strstr(ev_name, "call-graph=no")) 2633 enable_ref = true; 2634 2635 if (show_freq) 2636 scnprintf(sample_freq_str, sizeof(sample_freq_str), " %d Hz,", evsel->attr.sample_freq); 2637 2638 nr_samples = convert_unit(nr_samples, &unit); 2639 return scnprintf(bf, size, "Samples: %lu%c of event%s '%s',%s%sEvent count (approx.): %" PRIu64, 2640 nr_samples, unit, evsel->nr_members > 1 ? "s" : "", 2641 ev_name, sample_freq_str, enable_ref ? ref : " ", nr_events); 2642 } 2643 2644 #define ANNOTATION__CFG(n) \ 2645 { .name = #n, .value = &annotation__default_options.n, } 2646 2647 /* 2648 * Keep the entries sorted, they are bsearch'ed 2649 */ 2650 static struct annotation_config { 2651 const char *name; 2652 void *value; 2653 } annotation__configs[] = { 2654 ANNOTATION__CFG(hide_src_code), 2655 ANNOTATION__CFG(jump_arrows), 2656 ANNOTATION__CFG(offset_level), 2657 ANNOTATION__CFG(show_linenr), 2658 ANNOTATION__CFG(show_nr_jumps), 2659 ANNOTATION__CFG(show_nr_samples), 2660 ANNOTATION__CFG(show_total_period), 2661 ANNOTATION__CFG(use_offset), 2662 }; 2663 2664 #undef ANNOTATION__CFG 2665 2666 static int annotation_config__cmp(const void *name, const void *cfgp) 2667 { 2668 const struct annotation_config *cfg = cfgp; 2669 2670 return strcmp(name, cfg->name); 2671 } 2672 2673 static int annotation__config(const char *var, const char *value, 2674 void *data __maybe_unused) 2675 { 2676 struct annotation_config *cfg; 2677 const char *name; 2678 2679 if (!strstarts(var, "annotate.")) 2680 return 0; 2681 2682 name = var + 9; 2683 cfg = bsearch(name, annotation__configs, ARRAY_SIZE(annotation__configs), 2684 sizeof(struct annotation_config), annotation_config__cmp); 2685 2686 if (cfg == NULL) 2687 pr_debug("%s variable unknown, ignoring...", var); 2688 else if (strcmp(var, "annotate.offset_level") == 0) { 2689 perf_config_int(cfg->value, name, value); 2690 2691 if (*(int *)cfg->value > ANNOTATION__MAX_OFFSET_LEVEL) 2692 *(int *)cfg->value = ANNOTATION__MAX_OFFSET_LEVEL; 2693 else if (*(int *)cfg->value < ANNOTATION__MIN_OFFSET_LEVEL) 2694 *(int *)cfg->value = ANNOTATION__MIN_OFFSET_LEVEL; 2695 } else { 2696 *(bool *)cfg->value = perf_config_bool(name, value); 2697 } 2698 return 0; 2699 } 2700 2701 void annotation_config__init(void) 2702 { 2703 perf_config(annotation__config, NULL); 2704 2705 annotation__default_options.show_total_period = symbol_conf.show_total_period; 2706 annotation__default_options.show_nr_samples = symbol_conf.show_nr_samples; 2707 } 2708