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