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 "cache.h" 18 #include "symbol.h" 19 #include "debug.h" 20 #include "annotate.h" 21 #include "evsel.h" 22 #include "block-range.h" 23 #include "string2.h" 24 #include "arch/common.h" 25 #include <regex.h> 26 #include <pthread.h> 27 #include <linux/bitops.h> 28 #include <linux/kernel.h> 29 #include <sys/utsname.h> 30 31 #include "sane_ctype.h" 32 33 const char *disassembler_style; 34 const char *objdump_path; 35 static regex_t file_lineno; 36 37 static struct ins_ops *ins__find(struct arch *arch, const char *name); 38 static void ins__sort(struct arch *arch); 39 static int disasm_line__parse(char *line, const char **namep, char **rawp); 40 41 struct arch { 42 const char *name; 43 struct ins *instructions; 44 size_t nr_instructions; 45 size_t nr_instructions_allocated; 46 struct ins_ops *(*associate_instruction_ops)(struct arch *arch, const char *name); 47 bool sorted_instructions; 48 bool initialized; 49 void *priv; 50 unsigned int model; 51 unsigned int family; 52 int (*init)(struct arch *arch, char *cpuid); 53 bool (*ins_is_fused)(struct arch *arch, const char *ins1, 54 const char *ins2); 55 struct { 56 char comment_char; 57 char skip_functions_char; 58 } objdump; 59 }; 60 61 static struct ins_ops call_ops; 62 static struct ins_ops dec_ops; 63 static struct ins_ops jump_ops; 64 static struct ins_ops mov_ops; 65 static struct ins_ops nop_ops; 66 static struct ins_ops lock_ops; 67 static struct ins_ops ret_ops; 68 69 static int arch__grow_instructions(struct arch *arch) 70 { 71 struct ins *new_instructions; 72 size_t new_nr_allocated; 73 74 if (arch->nr_instructions_allocated == 0 && arch->instructions) 75 goto grow_from_non_allocated_table; 76 77 new_nr_allocated = arch->nr_instructions_allocated + 128; 78 new_instructions = realloc(arch->instructions, new_nr_allocated * sizeof(struct ins)); 79 if (new_instructions == NULL) 80 return -1; 81 82 out_update_instructions: 83 arch->instructions = new_instructions; 84 arch->nr_instructions_allocated = new_nr_allocated; 85 return 0; 86 87 grow_from_non_allocated_table: 88 new_nr_allocated = arch->nr_instructions + 128; 89 new_instructions = calloc(new_nr_allocated, sizeof(struct ins)); 90 if (new_instructions == NULL) 91 return -1; 92 93 memcpy(new_instructions, arch->instructions, arch->nr_instructions); 94 goto out_update_instructions; 95 } 96 97 static int arch__associate_ins_ops(struct arch* arch, const char *name, struct ins_ops *ops) 98 { 99 struct ins *ins; 100 101 if (arch->nr_instructions == arch->nr_instructions_allocated && 102 arch__grow_instructions(arch)) 103 return -1; 104 105 ins = &arch->instructions[arch->nr_instructions]; 106 ins->name = strdup(name); 107 if (!ins->name) 108 return -1; 109 110 ins->ops = ops; 111 arch->nr_instructions++; 112 113 ins__sort(arch); 114 return 0; 115 } 116 117 #include "arch/arm/annotate/instructions.c" 118 #include "arch/arm64/annotate/instructions.c" 119 #include "arch/x86/annotate/instructions.c" 120 #include "arch/powerpc/annotate/instructions.c" 121 #include "arch/s390/annotate/instructions.c" 122 123 static struct arch architectures[] = { 124 { 125 .name = "arm", 126 .init = arm__annotate_init, 127 }, 128 { 129 .name = "arm64", 130 .init = arm64__annotate_init, 131 }, 132 { 133 .name = "x86", 134 .init = x86__annotate_init, 135 .instructions = x86__instructions, 136 .nr_instructions = ARRAY_SIZE(x86__instructions), 137 .ins_is_fused = x86__ins_is_fused, 138 .objdump = { 139 .comment_char = '#', 140 }, 141 }, 142 { 143 .name = "powerpc", 144 .init = powerpc__annotate_init, 145 }, 146 { 147 .name = "s390", 148 .init = s390__annotate_init, 149 .objdump = { 150 .comment_char = '#', 151 }, 152 }, 153 }; 154 155 static void ins__delete(struct ins_operands *ops) 156 { 157 if (ops == NULL) 158 return; 159 zfree(&ops->source.raw); 160 zfree(&ops->source.name); 161 zfree(&ops->target.raw); 162 zfree(&ops->target.name); 163 } 164 165 static int ins__raw_scnprintf(struct ins *ins, char *bf, size_t size, 166 struct ins_operands *ops) 167 { 168 return scnprintf(bf, size, "%-6s %s", ins->name, ops->raw); 169 } 170 171 int ins__scnprintf(struct ins *ins, char *bf, size_t size, 172 struct ins_operands *ops) 173 { 174 if (ins->ops->scnprintf) 175 return ins->ops->scnprintf(ins, bf, size, ops); 176 177 return ins__raw_scnprintf(ins, bf, size, ops); 178 } 179 180 bool ins__is_fused(struct arch *arch, const char *ins1, const char *ins2) 181 { 182 if (!arch || !arch->ins_is_fused) 183 return false; 184 185 return arch->ins_is_fused(arch, ins1, ins2); 186 } 187 188 static int call__parse(struct arch *arch, struct ins_operands *ops, struct map *map) 189 { 190 char *endptr, *tok, *name; 191 192 ops->target.addr = strtoull(ops->raw, &endptr, 16); 193 194 name = strchr(endptr, '<'); 195 if (name == NULL) 196 goto indirect_call; 197 198 name++; 199 200 if (arch->objdump.skip_functions_char && 201 strchr(name, arch->objdump.skip_functions_char)) 202 return -1; 203 204 tok = strchr(name, '>'); 205 if (tok == NULL) 206 return -1; 207 208 *tok = '\0'; 209 ops->target.name = strdup(name); 210 *tok = '>'; 211 212 return ops->target.name == NULL ? -1 : 0; 213 214 indirect_call: 215 tok = strchr(endptr, '*'); 216 if (tok == NULL) { 217 struct symbol *sym = map__find_symbol(map, map->map_ip(map, ops->target.addr)); 218 if (sym != NULL) 219 ops->target.name = strdup(sym->name); 220 else 221 ops->target.addr = 0; 222 return 0; 223 } 224 225 ops->target.addr = strtoull(tok + 1, NULL, 16); 226 return 0; 227 } 228 229 static int call__scnprintf(struct ins *ins, char *bf, size_t size, 230 struct ins_operands *ops) 231 { 232 if (ops->target.name) 233 return scnprintf(bf, size, "%-6s %s", ins->name, ops->target.name); 234 235 if (ops->target.addr == 0) 236 return ins__raw_scnprintf(ins, bf, size, ops); 237 238 return scnprintf(bf, size, "%-6s *%" PRIx64, ins->name, ops->target.addr); 239 } 240 241 static struct ins_ops call_ops = { 242 .parse = call__parse, 243 .scnprintf = call__scnprintf, 244 }; 245 246 bool ins__is_call(const struct ins *ins) 247 { 248 return ins->ops == &call_ops; 249 } 250 251 static int jump__parse(struct arch *arch __maybe_unused, struct ins_operands *ops, struct map *map __maybe_unused) 252 { 253 const char *s = strchr(ops->raw, '+'); 254 const char *c = strchr(ops->raw, ','); 255 256 /* 257 * skip over possible up to 2 operands to get to address, e.g.: 258 * tbnz w0, #26, ffff0000083cd190 <security_file_permission+0xd0> 259 */ 260 if (c++ != NULL) { 261 ops->target.addr = strtoull(c, NULL, 16); 262 if (!ops->target.addr) { 263 c = strchr(c, ','); 264 if (c++ != NULL) 265 ops->target.addr = strtoull(c, NULL, 16); 266 } 267 } else { 268 ops->target.addr = strtoull(ops->raw, NULL, 16); 269 } 270 271 if (s++ != NULL) { 272 ops->target.offset = strtoull(s, NULL, 16); 273 ops->target.offset_avail = true; 274 } else { 275 ops->target.offset_avail = false; 276 } 277 278 return 0; 279 } 280 281 static int jump__scnprintf(struct ins *ins, char *bf, size_t size, 282 struct ins_operands *ops) 283 { 284 const char *c = strchr(ops->raw, ','); 285 286 if (!ops->target.addr || ops->target.offset < 0) 287 return ins__raw_scnprintf(ins, bf, size, ops); 288 289 if (c != NULL) { 290 const char *c2 = strchr(c + 1, ','); 291 292 /* check for 3-op insn */ 293 if (c2 != NULL) 294 c = c2; 295 c++; 296 297 /* mirror arch objdump's space-after-comma style */ 298 if (*c == ' ') 299 c++; 300 } 301 302 return scnprintf(bf, size, "%-6s %.*s%" PRIx64, 303 ins->name, c ? c - ops->raw : 0, ops->raw, 304 ops->target.offset); 305 } 306 307 static struct ins_ops jump_ops = { 308 .parse = jump__parse, 309 .scnprintf = jump__scnprintf, 310 }; 311 312 bool ins__is_jump(const struct ins *ins) 313 { 314 return ins->ops == &jump_ops; 315 } 316 317 static int comment__symbol(char *raw, char *comment, u64 *addrp, char **namep) 318 { 319 char *endptr, *name, *t; 320 321 if (strstr(raw, "(%rip)") == NULL) 322 return 0; 323 324 *addrp = strtoull(comment, &endptr, 16); 325 if (endptr == comment) 326 return 0; 327 name = strchr(endptr, '<'); 328 if (name == NULL) 329 return -1; 330 331 name++; 332 333 t = strchr(name, '>'); 334 if (t == NULL) 335 return 0; 336 337 *t = '\0'; 338 *namep = strdup(name); 339 *t = '>'; 340 341 return 0; 342 } 343 344 static int lock__parse(struct arch *arch, struct ins_operands *ops, struct map *map) 345 { 346 ops->locked.ops = zalloc(sizeof(*ops->locked.ops)); 347 if (ops->locked.ops == NULL) 348 return 0; 349 350 if (disasm_line__parse(ops->raw, &ops->locked.ins.name, &ops->locked.ops->raw) < 0) 351 goto out_free_ops; 352 353 ops->locked.ins.ops = ins__find(arch, ops->locked.ins.name); 354 355 if (ops->locked.ins.ops == NULL) 356 goto out_free_ops; 357 358 if (ops->locked.ins.ops->parse && 359 ops->locked.ins.ops->parse(arch, ops->locked.ops, map) < 0) 360 goto out_free_ops; 361 362 return 0; 363 364 out_free_ops: 365 zfree(&ops->locked.ops); 366 return 0; 367 } 368 369 static int lock__scnprintf(struct ins *ins, char *bf, size_t size, 370 struct ins_operands *ops) 371 { 372 int printed; 373 374 if (ops->locked.ins.ops == NULL) 375 return ins__raw_scnprintf(ins, bf, size, ops); 376 377 printed = scnprintf(bf, size, "%-6s ", ins->name); 378 return printed + ins__scnprintf(&ops->locked.ins, bf + printed, 379 size - printed, ops->locked.ops); 380 } 381 382 static void lock__delete(struct ins_operands *ops) 383 { 384 struct ins *ins = &ops->locked.ins; 385 386 if (ins->ops && ins->ops->free) 387 ins->ops->free(ops->locked.ops); 388 else 389 ins__delete(ops->locked.ops); 390 391 zfree(&ops->locked.ops); 392 zfree(&ops->target.raw); 393 zfree(&ops->target.name); 394 } 395 396 static struct ins_ops lock_ops = { 397 .free = lock__delete, 398 .parse = lock__parse, 399 .scnprintf = lock__scnprintf, 400 }; 401 402 static int mov__parse(struct arch *arch, struct ins_operands *ops, struct map *map __maybe_unused) 403 { 404 char *s = strchr(ops->raw, ','), *target, *comment, prev; 405 406 if (s == NULL) 407 return -1; 408 409 *s = '\0'; 410 ops->source.raw = strdup(ops->raw); 411 *s = ','; 412 413 if (ops->source.raw == NULL) 414 return -1; 415 416 target = ++s; 417 comment = strchr(s, arch->objdump.comment_char); 418 419 if (comment != NULL) 420 s = comment - 1; 421 else 422 s = strchr(s, '\0') - 1; 423 424 while (s > target && isspace(s[0])) 425 --s; 426 s++; 427 prev = *s; 428 *s = '\0'; 429 430 ops->target.raw = strdup(target); 431 *s = prev; 432 433 if (ops->target.raw == NULL) 434 goto out_free_source; 435 436 if (comment == NULL) 437 return 0; 438 439 comment = ltrim(comment); 440 comment__symbol(ops->source.raw, comment + 1, &ops->source.addr, &ops->source.name); 441 comment__symbol(ops->target.raw, comment + 1, &ops->target.addr, &ops->target.name); 442 443 return 0; 444 445 out_free_source: 446 zfree(&ops->source.raw); 447 return -1; 448 } 449 450 static int mov__scnprintf(struct ins *ins, char *bf, size_t size, 451 struct ins_operands *ops) 452 { 453 return scnprintf(bf, size, "%-6s %s,%s", ins->name, 454 ops->source.name ?: ops->source.raw, 455 ops->target.name ?: ops->target.raw); 456 } 457 458 static struct ins_ops mov_ops = { 459 .parse = mov__parse, 460 .scnprintf = mov__scnprintf, 461 }; 462 463 static int dec__parse(struct arch *arch __maybe_unused, struct ins_operands *ops, struct map *map __maybe_unused) 464 { 465 char *target, *comment, *s, prev; 466 467 target = s = ops->raw; 468 469 while (s[0] != '\0' && !isspace(s[0])) 470 ++s; 471 prev = *s; 472 *s = '\0'; 473 474 ops->target.raw = strdup(target); 475 *s = prev; 476 477 if (ops->target.raw == NULL) 478 return -1; 479 480 comment = strchr(s, arch->objdump.comment_char); 481 if (comment == NULL) 482 return 0; 483 484 comment = ltrim(comment); 485 comment__symbol(ops->target.raw, comment + 1, &ops->target.addr, &ops->target.name); 486 487 return 0; 488 } 489 490 static int dec__scnprintf(struct ins *ins, char *bf, size_t size, 491 struct ins_operands *ops) 492 { 493 return scnprintf(bf, size, "%-6s %s", ins->name, 494 ops->target.name ?: ops->target.raw); 495 } 496 497 static struct ins_ops dec_ops = { 498 .parse = dec__parse, 499 .scnprintf = dec__scnprintf, 500 }; 501 502 static int nop__scnprintf(struct ins *ins __maybe_unused, char *bf, size_t size, 503 struct ins_operands *ops __maybe_unused) 504 { 505 return scnprintf(bf, size, "%-6s", "nop"); 506 } 507 508 static struct ins_ops nop_ops = { 509 .scnprintf = nop__scnprintf, 510 }; 511 512 static struct ins_ops ret_ops = { 513 .scnprintf = ins__raw_scnprintf, 514 }; 515 516 bool ins__is_ret(const struct ins *ins) 517 { 518 return ins->ops == &ret_ops; 519 } 520 521 bool ins__is_lock(const struct ins *ins) 522 { 523 return ins->ops == &lock_ops; 524 } 525 526 static int ins__key_cmp(const void *name, const void *insp) 527 { 528 const struct ins *ins = insp; 529 530 return strcmp(name, ins->name); 531 } 532 533 static int ins__cmp(const void *a, const void *b) 534 { 535 const struct ins *ia = a; 536 const struct ins *ib = b; 537 538 return strcmp(ia->name, ib->name); 539 } 540 541 static void ins__sort(struct arch *arch) 542 { 543 const int nmemb = arch->nr_instructions; 544 545 qsort(arch->instructions, nmemb, sizeof(struct ins), ins__cmp); 546 } 547 548 static struct ins_ops *__ins__find(struct arch *arch, const char *name) 549 { 550 struct ins *ins; 551 const int nmemb = arch->nr_instructions; 552 553 if (!arch->sorted_instructions) { 554 ins__sort(arch); 555 arch->sorted_instructions = true; 556 } 557 558 ins = bsearch(name, arch->instructions, nmemb, sizeof(struct ins), ins__key_cmp); 559 return ins ? ins->ops : NULL; 560 } 561 562 static struct ins_ops *ins__find(struct arch *arch, const char *name) 563 { 564 struct ins_ops *ops = __ins__find(arch, name); 565 566 if (!ops && arch->associate_instruction_ops) 567 ops = arch->associate_instruction_ops(arch, name); 568 569 return ops; 570 } 571 572 static int arch__key_cmp(const void *name, const void *archp) 573 { 574 const struct arch *arch = archp; 575 576 return strcmp(name, arch->name); 577 } 578 579 static int arch__cmp(const void *a, const void *b) 580 { 581 const struct arch *aa = a; 582 const struct arch *ab = b; 583 584 return strcmp(aa->name, ab->name); 585 } 586 587 static void arch__sort(void) 588 { 589 const int nmemb = ARRAY_SIZE(architectures); 590 591 qsort(architectures, nmemb, sizeof(struct arch), arch__cmp); 592 } 593 594 static struct arch *arch__find(const char *name) 595 { 596 const int nmemb = ARRAY_SIZE(architectures); 597 static bool sorted; 598 599 if (!sorted) { 600 arch__sort(); 601 sorted = true; 602 } 603 604 return bsearch(name, architectures, nmemb, sizeof(struct arch), arch__key_cmp); 605 } 606 607 int symbol__alloc_hist(struct symbol *sym) 608 { 609 struct annotation *notes = symbol__annotation(sym); 610 size_t size = symbol__size(sym); 611 size_t sizeof_sym_hist; 612 613 /* 614 * Add buffer of one element for zero length symbol. 615 * When sample is taken from first instruction of 616 * zero length symbol, perf still resolves it and 617 * shows symbol name in perf report and allows to 618 * annotate it. 619 */ 620 if (size == 0) 621 size = 1; 622 623 /* Check for overflow when calculating sizeof_sym_hist */ 624 if (size > (SIZE_MAX - sizeof(struct sym_hist)) / sizeof(struct sym_hist_entry)) 625 return -1; 626 627 sizeof_sym_hist = (sizeof(struct sym_hist) + size * sizeof(struct sym_hist_entry)); 628 629 /* Check for overflow in zalloc argument */ 630 if (sizeof_sym_hist > (SIZE_MAX - sizeof(*notes->src)) 631 / symbol_conf.nr_events) 632 return -1; 633 634 notes->src = zalloc(sizeof(*notes->src) + symbol_conf.nr_events * sizeof_sym_hist); 635 if (notes->src == NULL) 636 return -1; 637 notes->src->sizeof_sym_hist = sizeof_sym_hist; 638 notes->src->nr_histograms = symbol_conf.nr_events; 639 INIT_LIST_HEAD(¬es->src->source); 640 return 0; 641 } 642 643 /* The cycles histogram is lazily allocated. */ 644 static int symbol__alloc_hist_cycles(struct symbol *sym) 645 { 646 struct annotation *notes = symbol__annotation(sym); 647 const size_t size = symbol__size(sym); 648 649 notes->src->cycles_hist = calloc(size, sizeof(struct cyc_hist)); 650 if (notes->src->cycles_hist == NULL) 651 return -1; 652 return 0; 653 } 654 655 void symbol__annotate_zero_histograms(struct symbol *sym) 656 { 657 struct annotation *notes = symbol__annotation(sym); 658 659 pthread_mutex_lock(¬es->lock); 660 if (notes->src != NULL) { 661 memset(notes->src->histograms, 0, 662 notes->src->nr_histograms * notes->src->sizeof_sym_hist); 663 if (notes->src->cycles_hist) 664 memset(notes->src->cycles_hist, 0, 665 symbol__size(sym) * sizeof(struct cyc_hist)); 666 } 667 pthread_mutex_unlock(¬es->lock); 668 } 669 670 static int __symbol__account_cycles(struct annotation *notes, 671 u64 start, 672 unsigned offset, unsigned cycles, 673 unsigned have_start) 674 { 675 struct cyc_hist *ch; 676 677 ch = notes->src->cycles_hist; 678 /* 679 * For now we can only account one basic block per 680 * final jump. But multiple could be overlapping. 681 * Always account the longest one. So when 682 * a shorter one has been already seen throw it away. 683 * 684 * We separately always account the full cycles. 685 */ 686 ch[offset].num_aggr++; 687 ch[offset].cycles_aggr += cycles; 688 689 if (!have_start && ch[offset].have_start) 690 return 0; 691 if (ch[offset].num) { 692 if (have_start && (!ch[offset].have_start || 693 ch[offset].start > start)) { 694 ch[offset].have_start = 0; 695 ch[offset].cycles = 0; 696 ch[offset].num = 0; 697 if (ch[offset].reset < 0xffff) 698 ch[offset].reset++; 699 } else if (have_start && 700 ch[offset].start < start) 701 return 0; 702 } 703 ch[offset].have_start = have_start; 704 ch[offset].start = start; 705 ch[offset].cycles += cycles; 706 ch[offset].num++; 707 return 0; 708 } 709 710 static int __symbol__inc_addr_samples(struct symbol *sym, struct map *map, 711 struct annotation *notes, int evidx, u64 addr, 712 struct perf_sample *sample) 713 { 714 unsigned offset; 715 struct sym_hist *h; 716 717 pr_debug3("%s: addr=%#" PRIx64 "\n", __func__, map->unmap_ip(map, addr)); 718 719 if ((addr < sym->start || addr >= sym->end) && 720 (addr != sym->end || sym->start != sym->end)) { 721 pr_debug("%s(%d): ERANGE! sym->name=%s, start=%#" PRIx64 ", addr=%#" PRIx64 ", end=%#" PRIx64 "\n", 722 __func__, __LINE__, sym->name, sym->start, addr, sym->end); 723 return -ERANGE; 724 } 725 726 offset = addr - sym->start; 727 h = annotation__histogram(notes, evidx); 728 h->nr_samples++; 729 h->addr[offset].nr_samples++; 730 h->period += sample->period; 731 h->addr[offset].period += sample->period; 732 733 pr_debug3("%#" PRIx64 " %s: period++ [addr: %#" PRIx64 ", %#" PRIx64 734 ", evidx=%d] => nr_samples: %" PRIu64 ", period: %" PRIu64 "\n", 735 sym->start, sym->name, addr, addr - sym->start, evidx, 736 h->addr[offset].nr_samples, h->addr[offset].period); 737 return 0; 738 } 739 740 static struct annotation *symbol__get_annotation(struct symbol *sym, bool cycles) 741 { 742 struct annotation *notes = symbol__annotation(sym); 743 744 if (notes->src == NULL) { 745 if (symbol__alloc_hist(sym) < 0) 746 return NULL; 747 } 748 if (!notes->src->cycles_hist && cycles) { 749 if (symbol__alloc_hist_cycles(sym) < 0) 750 return NULL; 751 } 752 return notes; 753 } 754 755 static int symbol__inc_addr_samples(struct symbol *sym, struct map *map, 756 int evidx, u64 addr, 757 struct perf_sample *sample) 758 { 759 struct annotation *notes; 760 761 if (sym == NULL) 762 return 0; 763 notes = symbol__get_annotation(sym, false); 764 if (notes == NULL) 765 return -ENOMEM; 766 return __symbol__inc_addr_samples(sym, map, notes, evidx, addr, sample); 767 } 768 769 static int symbol__account_cycles(u64 addr, u64 start, 770 struct symbol *sym, unsigned cycles) 771 { 772 struct annotation *notes; 773 unsigned offset; 774 775 if (sym == NULL) 776 return 0; 777 notes = symbol__get_annotation(sym, true); 778 if (notes == NULL) 779 return -ENOMEM; 780 if (addr < sym->start || addr >= sym->end) 781 return -ERANGE; 782 783 if (start) { 784 if (start < sym->start || start >= sym->end) 785 return -ERANGE; 786 if (start >= addr) 787 start = 0; 788 } 789 offset = addr - sym->start; 790 return __symbol__account_cycles(notes, 791 start ? start - sym->start : 0, 792 offset, cycles, 793 !!start); 794 } 795 796 int addr_map_symbol__account_cycles(struct addr_map_symbol *ams, 797 struct addr_map_symbol *start, 798 unsigned cycles) 799 { 800 u64 saddr = 0; 801 int err; 802 803 if (!cycles) 804 return 0; 805 806 /* 807 * Only set start when IPC can be computed. We can only 808 * compute it when the basic block is completely in a single 809 * function. 810 * Special case the case when the jump is elsewhere, but 811 * it starts on the function start. 812 */ 813 if (start && 814 (start->sym == ams->sym || 815 (ams->sym && 816 start->addr == ams->sym->start + ams->map->start))) 817 saddr = start->al_addr; 818 if (saddr == 0) 819 pr_debug2("BB with bad start: addr %"PRIx64" start %"PRIx64" sym %"PRIx64" saddr %"PRIx64"\n", 820 ams->addr, 821 start ? start->addr : 0, 822 ams->sym ? ams->sym->start + ams->map->start : 0, 823 saddr); 824 err = symbol__account_cycles(ams->al_addr, saddr, ams->sym, cycles); 825 if (err) 826 pr_debug2("account_cycles failed %d\n", err); 827 return err; 828 } 829 830 int addr_map_symbol__inc_samples(struct addr_map_symbol *ams, struct perf_sample *sample, 831 int evidx) 832 { 833 return symbol__inc_addr_samples(ams->sym, ams->map, evidx, ams->al_addr, sample); 834 } 835 836 int hist_entry__inc_addr_samples(struct hist_entry *he, struct perf_sample *sample, 837 int evidx, u64 ip) 838 { 839 return symbol__inc_addr_samples(he->ms.sym, he->ms.map, evidx, ip, sample); 840 } 841 842 static void disasm_line__init_ins(struct disasm_line *dl, struct arch *arch, struct map *map) 843 { 844 dl->ins.ops = ins__find(arch, dl->ins.name); 845 846 if (!dl->ins.ops) 847 return; 848 849 if (dl->ins.ops->parse && dl->ins.ops->parse(arch, &dl->ops, map) < 0) 850 dl->ins.ops = NULL; 851 } 852 853 static int disasm_line__parse(char *line, const char **namep, char **rawp) 854 { 855 char tmp, *name = ltrim(line); 856 857 if (name[0] == '\0') 858 return -1; 859 860 *rawp = name + 1; 861 862 while ((*rawp)[0] != '\0' && !isspace((*rawp)[0])) 863 ++*rawp; 864 865 tmp = (*rawp)[0]; 866 (*rawp)[0] = '\0'; 867 *namep = strdup(name); 868 869 if (*namep == NULL) 870 goto out_free_name; 871 872 (*rawp)[0] = tmp; 873 *rawp = ltrim(*rawp); 874 875 return 0; 876 877 out_free_name: 878 free((void *)namep); 879 *namep = NULL; 880 return -1; 881 } 882 883 struct annotate_args { 884 size_t privsize; 885 struct arch *arch; 886 struct map *map; 887 struct perf_evsel *evsel; 888 s64 offset; 889 char *line; 890 int line_nr; 891 }; 892 893 static void annotation_line__delete(struct annotation_line *al) 894 { 895 void *ptr = (void *) al - al->privsize; 896 897 free_srcline(al->path); 898 zfree(&al->line); 899 free(ptr); 900 } 901 902 /* 903 * Allocating the annotation line data with following 904 * structure: 905 * 906 * -------------------------------------- 907 * private space | struct annotation_line 908 * -------------------------------------- 909 * 910 * Size of the private space is stored in 'struct annotation_line'. 911 * 912 */ 913 static struct annotation_line * 914 annotation_line__new(struct annotate_args *args, size_t privsize) 915 { 916 struct annotation_line *al; 917 struct perf_evsel *evsel = args->evsel; 918 size_t size = privsize + sizeof(*al); 919 int nr = 1; 920 921 if (perf_evsel__is_group_event(evsel)) 922 nr = evsel->nr_members; 923 924 size += sizeof(al->samples[0]) * nr; 925 926 al = zalloc(size); 927 if (al) { 928 al = (void *) al + privsize; 929 al->privsize = privsize; 930 al->offset = args->offset; 931 al->line = strdup(args->line); 932 al->line_nr = args->line_nr; 933 al->samples_nr = nr; 934 } 935 936 return al; 937 } 938 939 /* 940 * Allocating the disasm annotation line data with 941 * following structure: 942 * 943 * ------------------------------------------------------------ 944 * privsize space | struct disasm_line | struct annotation_line 945 * ------------------------------------------------------------ 946 * 947 * We have 'struct annotation_line' member as last member 948 * of 'struct disasm_line' to have an easy access. 949 * 950 */ 951 static struct disasm_line *disasm_line__new(struct annotate_args *args) 952 { 953 struct disasm_line *dl = NULL; 954 struct annotation_line *al; 955 size_t privsize = args->privsize + offsetof(struct disasm_line, al); 956 957 al = annotation_line__new(args, privsize); 958 if (al != NULL) { 959 dl = disasm_line(al); 960 961 if (dl->al.line == NULL) 962 goto out_delete; 963 964 if (args->offset != -1) { 965 if (disasm_line__parse(dl->al.line, &dl->ins.name, &dl->ops.raw) < 0) 966 goto out_free_line; 967 968 disasm_line__init_ins(dl, args->arch, args->map); 969 } 970 } 971 972 return dl; 973 974 out_free_line: 975 zfree(&dl->al.line); 976 out_delete: 977 free(dl); 978 return NULL; 979 } 980 981 void disasm_line__free(struct disasm_line *dl) 982 { 983 if (dl->ins.ops && dl->ins.ops->free) 984 dl->ins.ops->free(&dl->ops); 985 else 986 ins__delete(&dl->ops); 987 free((void *)dl->ins.name); 988 dl->ins.name = NULL; 989 annotation_line__delete(&dl->al); 990 } 991 992 int disasm_line__scnprintf(struct disasm_line *dl, char *bf, size_t size, bool raw) 993 { 994 if (raw || !dl->ins.ops) 995 return scnprintf(bf, size, "%-6s %s", dl->ins.name, dl->ops.raw); 996 997 return ins__scnprintf(&dl->ins, bf, size, &dl->ops); 998 } 999 1000 static void annotation_line__add(struct annotation_line *al, struct list_head *head) 1001 { 1002 list_add_tail(&al->node, head); 1003 } 1004 1005 struct annotation_line * 1006 annotation_line__next(struct annotation_line *pos, struct list_head *head) 1007 { 1008 list_for_each_entry_continue(pos, head, node) 1009 if (pos->offset >= 0) 1010 return pos; 1011 1012 return NULL; 1013 } 1014 1015 static const char *annotate__address_color(struct block_range *br) 1016 { 1017 double cov = block_range__coverage(br); 1018 1019 if (cov >= 0) { 1020 /* mark red for >75% coverage */ 1021 if (cov > 0.75) 1022 return PERF_COLOR_RED; 1023 1024 /* mark dull for <1% coverage */ 1025 if (cov < 0.01) 1026 return PERF_COLOR_NORMAL; 1027 } 1028 1029 return PERF_COLOR_MAGENTA; 1030 } 1031 1032 static const char *annotate__asm_color(struct block_range *br) 1033 { 1034 double cov = block_range__coverage(br); 1035 1036 if (cov >= 0) { 1037 /* mark dull for <1% coverage */ 1038 if (cov < 0.01) 1039 return PERF_COLOR_NORMAL; 1040 } 1041 1042 return PERF_COLOR_BLUE; 1043 } 1044 1045 static void annotate__branch_printf(struct block_range *br, u64 addr) 1046 { 1047 bool emit_comment = true; 1048 1049 if (!br) 1050 return; 1051 1052 #if 1 1053 if (br->is_target && br->start == addr) { 1054 struct block_range *branch = br; 1055 double p; 1056 1057 /* 1058 * Find matching branch to our target. 1059 */ 1060 while (!branch->is_branch) 1061 branch = block_range__next(branch); 1062 1063 p = 100 *(double)br->entry / branch->coverage; 1064 1065 if (p > 0.1) { 1066 if (emit_comment) { 1067 emit_comment = false; 1068 printf("\t#"); 1069 } 1070 1071 /* 1072 * The percentage of coverage joined at this target in relation 1073 * to the next branch. 1074 */ 1075 printf(" +%.2f%%", p); 1076 } 1077 } 1078 #endif 1079 if (br->is_branch && br->end == addr) { 1080 double p = 100*(double)br->taken / br->coverage; 1081 1082 if (p > 0.1) { 1083 if (emit_comment) { 1084 emit_comment = false; 1085 printf("\t#"); 1086 } 1087 1088 /* 1089 * The percentage of coverage leaving at this branch, and 1090 * its prediction ratio. 1091 */ 1092 printf(" -%.2f%% (p:%.2f%%)", p, 100*(double)br->pred / br->taken); 1093 } 1094 } 1095 } 1096 1097 static int disasm_line__print(struct disasm_line *dl, u64 start, int addr_fmt_width) 1098 { 1099 s64 offset = dl->al.offset; 1100 const u64 addr = start + offset; 1101 struct block_range *br; 1102 1103 br = block_range__find(addr); 1104 color_fprintf(stdout, annotate__address_color(br), " %*" PRIx64 ":", addr_fmt_width, addr); 1105 color_fprintf(stdout, annotate__asm_color(br), "%s", dl->al.line); 1106 annotate__branch_printf(br, addr); 1107 return 0; 1108 } 1109 1110 static int 1111 annotation_line__print(struct annotation_line *al, struct symbol *sym, u64 start, 1112 struct perf_evsel *evsel, u64 len, int min_pcnt, int printed, 1113 int max_lines, struct annotation_line *queue, int addr_fmt_width) 1114 { 1115 struct disasm_line *dl = container_of(al, struct disasm_line, al); 1116 static const char *prev_line; 1117 static const char *prev_color; 1118 1119 if (al->offset != -1) { 1120 double max_percent = 0.0; 1121 int i, nr_percent = 1; 1122 const char *color; 1123 struct annotation *notes = symbol__annotation(sym); 1124 1125 for (i = 0; i < al->samples_nr; i++) { 1126 struct annotation_data *sample = &al->samples[i]; 1127 1128 if (sample->percent > max_percent) 1129 max_percent = sample->percent; 1130 } 1131 1132 if (max_percent < min_pcnt) 1133 return -1; 1134 1135 if (max_lines && printed >= max_lines) 1136 return 1; 1137 1138 if (queue != NULL) { 1139 list_for_each_entry_from(queue, ¬es->src->source, node) { 1140 if (queue == al) 1141 break; 1142 annotation_line__print(queue, sym, start, evsel, len, 1143 0, 0, 1, NULL, addr_fmt_width); 1144 } 1145 } 1146 1147 color = get_percent_color(max_percent); 1148 1149 /* 1150 * Also color the filename and line if needed, with 1151 * the same color than the percentage. Don't print it 1152 * twice for close colored addr with the same filename:line 1153 */ 1154 if (al->path) { 1155 if (!prev_line || strcmp(prev_line, al->path) 1156 || color != prev_color) { 1157 color_fprintf(stdout, color, " %s", al->path); 1158 prev_line = al->path; 1159 prev_color = color; 1160 } 1161 } 1162 1163 for (i = 0; i < nr_percent; i++) { 1164 struct annotation_data *sample = &al->samples[i]; 1165 1166 color = get_percent_color(sample->percent); 1167 1168 if (symbol_conf.show_total_period) 1169 color_fprintf(stdout, color, " %11" PRIu64, 1170 sample->he.period); 1171 else if (symbol_conf.show_nr_samples) 1172 color_fprintf(stdout, color, " %7" PRIu64, 1173 sample->he.nr_samples); 1174 else 1175 color_fprintf(stdout, color, " %7.2f", sample->percent); 1176 } 1177 1178 printf(" : "); 1179 1180 disasm_line__print(dl, start, addr_fmt_width); 1181 printf("\n"); 1182 } else if (max_lines && printed >= max_lines) 1183 return 1; 1184 else { 1185 int width = symbol_conf.show_total_period ? 12 : 8; 1186 1187 if (queue) 1188 return -1; 1189 1190 if (perf_evsel__is_group_event(evsel)) 1191 width *= evsel->nr_members; 1192 1193 if (!*al->line) 1194 printf(" %*s:\n", width, " "); 1195 else 1196 printf(" %*s: %*s %s\n", width, " ", addr_fmt_width, " ", al->line); 1197 } 1198 1199 return 0; 1200 } 1201 1202 /* 1203 * symbol__parse_objdump_line() parses objdump output (with -d --no-show-raw) 1204 * which looks like following 1205 * 1206 * 0000000000415500 <_init>: 1207 * 415500: sub $0x8,%rsp 1208 * 415504: mov 0x2f5ad5(%rip),%rax # 70afe0 <_DYNAMIC+0x2f8> 1209 * 41550b: test %rax,%rax 1210 * 41550e: je 415515 <_init+0x15> 1211 * 415510: callq 416e70 <__gmon_start__@plt> 1212 * 415515: add $0x8,%rsp 1213 * 415519: retq 1214 * 1215 * it will be parsed and saved into struct disasm_line as 1216 * <offset> <name> <ops.raw> 1217 * 1218 * The offset will be a relative offset from the start of the symbol and -1 1219 * means that it's not a disassembly line so should be treated differently. 1220 * The ops.raw part will be parsed further according to type of the instruction. 1221 */ 1222 static int symbol__parse_objdump_line(struct symbol *sym, FILE *file, 1223 struct annotate_args *args, 1224 int *line_nr) 1225 { 1226 struct map *map = args->map; 1227 struct annotation *notes = symbol__annotation(sym); 1228 struct disasm_line *dl; 1229 char *line = NULL, *parsed_line, *tmp, *tmp2; 1230 size_t line_len; 1231 s64 line_ip, offset = -1; 1232 regmatch_t match[2]; 1233 1234 if (getline(&line, &line_len, file) < 0) 1235 return -1; 1236 1237 if (!line) 1238 return -1; 1239 1240 line_ip = -1; 1241 parsed_line = rtrim(line); 1242 1243 /* /filename:linenr ? Save line number and ignore. */ 1244 if (regexec(&file_lineno, parsed_line, 2, match, 0) == 0) { 1245 *line_nr = atoi(parsed_line + match[1].rm_so); 1246 return 0; 1247 } 1248 1249 tmp = ltrim(parsed_line); 1250 if (*tmp) { 1251 /* 1252 * Parse hexa addresses followed by ':' 1253 */ 1254 line_ip = strtoull(tmp, &tmp2, 16); 1255 if (*tmp2 != ':' || tmp == tmp2 || tmp2[1] == '\0') 1256 line_ip = -1; 1257 } 1258 1259 if (line_ip != -1) { 1260 u64 start = map__rip_2objdump(map, sym->start), 1261 end = map__rip_2objdump(map, sym->end); 1262 1263 offset = line_ip - start; 1264 if ((u64)line_ip < start || (u64)line_ip >= end) 1265 offset = -1; 1266 else 1267 parsed_line = tmp2 + 1; 1268 } 1269 1270 args->offset = offset; 1271 args->line = parsed_line; 1272 args->line_nr = *line_nr; 1273 1274 dl = disasm_line__new(args); 1275 free(line); 1276 (*line_nr)++; 1277 1278 if (dl == NULL) 1279 return -1; 1280 1281 if (!disasm_line__has_offset(dl)) { 1282 dl->ops.target.offset = dl->ops.target.addr - 1283 map__rip_2objdump(map, sym->start); 1284 dl->ops.target.offset_avail = true; 1285 } 1286 1287 /* kcore has no symbols, so add the call target name */ 1288 if (dl->ins.ops && ins__is_call(&dl->ins) && !dl->ops.target.name) { 1289 struct addr_map_symbol target = { 1290 .map = map, 1291 .addr = dl->ops.target.addr, 1292 }; 1293 1294 if (!map_groups__find_ams(&target) && 1295 target.sym->start == target.al_addr) 1296 dl->ops.target.name = strdup(target.sym->name); 1297 } 1298 1299 annotation_line__add(&dl->al, ¬es->src->source); 1300 1301 return 0; 1302 } 1303 1304 static __attribute__((constructor)) void symbol__init_regexpr(void) 1305 { 1306 regcomp(&file_lineno, "^/[^:]+:([0-9]+)", REG_EXTENDED); 1307 } 1308 1309 static void delete_last_nop(struct symbol *sym) 1310 { 1311 struct annotation *notes = symbol__annotation(sym); 1312 struct list_head *list = ¬es->src->source; 1313 struct disasm_line *dl; 1314 1315 while (!list_empty(list)) { 1316 dl = list_entry(list->prev, struct disasm_line, al.node); 1317 1318 if (dl->ins.ops) { 1319 if (dl->ins.ops != &nop_ops) 1320 return; 1321 } else { 1322 if (!strstr(dl->al.line, " nop ") && 1323 !strstr(dl->al.line, " nopl ") && 1324 !strstr(dl->al.line, " nopw ")) 1325 return; 1326 } 1327 1328 list_del(&dl->al.node); 1329 disasm_line__free(dl); 1330 } 1331 } 1332 1333 int symbol__strerror_disassemble(struct symbol *sym __maybe_unused, struct map *map, 1334 int errnum, char *buf, size_t buflen) 1335 { 1336 struct dso *dso = map->dso; 1337 1338 BUG_ON(buflen == 0); 1339 1340 if (errnum >= 0) { 1341 str_error_r(errnum, buf, buflen); 1342 return 0; 1343 } 1344 1345 switch (errnum) { 1346 case SYMBOL_ANNOTATE_ERRNO__NO_VMLINUX: { 1347 char bf[SBUILD_ID_SIZE + 15] = " with build id "; 1348 char *build_id_msg = NULL; 1349 1350 if (dso->has_build_id) { 1351 build_id__sprintf(dso->build_id, 1352 sizeof(dso->build_id), bf + 15); 1353 build_id_msg = bf; 1354 } 1355 scnprintf(buf, buflen, 1356 "No vmlinux file%s\nwas found in the path.\n\n" 1357 "Note that annotation using /proc/kcore requires CAP_SYS_RAWIO capability.\n\n" 1358 "Please use:\n\n" 1359 " perf buildid-cache -vu vmlinux\n\n" 1360 "or:\n\n" 1361 " --vmlinux vmlinux\n", build_id_msg ?: ""); 1362 } 1363 break; 1364 default: 1365 scnprintf(buf, buflen, "Internal error: Invalid %d error code\n", errnum); 1366 break; 1367 } 1368 1369 return 0; 1370 } 1371 1372 static int dso__disassemble_filename(struct dso *dso, char *filename, size_t filename_size) 1373 { 1374 char linkname[PATH_MAX]; 1375 char *build_id_filename; 1376 char *build_id_path = NULL; 1377 char *pos; 1378 1379 if (dso->symtab_type == DSO_BINARY_TYPE__KALLSYMS && 1380 !dso__is_kcore(dso)) 1381 return SYMBOL_ANNOTATE_ERRNO__NO_VMLINUX; 1382 1383 build_id_filename = dso__build_id_filename(dso, NULL, 0, false); 1384 if (build_id_filename) { 1385 __symbol__join_symfs(filename, filename_size, build_id_filename); 1386 free(build_id_filename); 1387 } else { 1388 if (dso->has_build_id) 1389 return ENOMEM; 1390 goto fallback; 1391 } 1392 1393 build_id_path = strdup(filename); 1394 if (!build_id_path) 1395 return -1; 1396 1397 /* 1398 * old style build-id cache has name of XX/XXXXXXX.. while 1399 * new style has XX/XXXXXXX../{elf,kallsyms,vdso}. 1400 * extract the build-id part of dirname in the new style only. 1401 */ 1402 pos = strrchr(build_id_path, '/'); 1403 if (pos && strlen(pos) < SBUILD_ID_SIZE - 2) 1404 dirname(build_id_path); 1405 1406 if (dso__is_kcore(dso) || 1407 readlink(build_id_path, linkname, sizeof(linkname)) < 0 || 1408 strstr(linkname, DSO__NAME_KALLSYMS) || 1409 access(filename, R_OK)) { 1410 fallback: 1411 /* 1412 * If we don't have build-ids or the build-id file isn't in the 1413 * cache, or is just a kallsyms file, well, lets hope that this 1414 * DSO is the same as when 'perf record' ran. 1415 */ 1416 __symbol__join_symfs(filename, filename_size, dso->long_name); 1417 } 1418 1419 free(build_id_path); 1420 return 0; 1421 } 1422 1423 static const char *annotate__norm_arch(const char *arch_name) 1424 { 1425 struct utsname uts; 1426 1427 if (!arch_name) { /* Assume we are annotating locally. */ 1428 if (uname(&uts) < 0) 1429 return NULL; 1430 arch_name = uts.machine; 1431 } 1432 return normalize_arch((char *)arch_name); 1433 } 1434 1435 static int symbol__disassemble(struct symbol *sym, struct annotate_args *args) 1436 { 1437 struct map *map = args->map; 1438 struct dso *dso = map->dso; 1439 char command[PATH_MAX * 2]; 1440 FILE *file; 1441 char symfs_filename[PATH_MAX]; 1442 struct kcore_extract kce; 1443 bool delete_extract = false; 1444 int stdout_fd[2]; 1445 int lineno = 0; 1446 int nline; 1447 pid_t pid; 1448 int err = dso__disassemble_filename(dso, symfs_filename, sizeof(symfs_filename)); 1449 1450 if (err) 1451 return err; 1452 1453 pr_debug("%s: filename=%s, sym=%s, start=%#" PRIx64 ", end=%#" PRIx64 "\n", __func__, 1454 symfs_filename, sym->name, map->unmap_ip(map, sym->start), 1455 map->unmap_ip(map, sym->end)); 1456 1457 pr_debug("annotating [%p] %30s : [%p] %30s\n", 1458 dso, dso->long_name, sym, sym->name); 1459 1460 if (dso__is_kcore(dso)) { 1461 kce.kcore_filename = symfs_filename; 1462 kce.addr = map__rip_2objdump(map, sym->start); 1463 kce.offs = sym->start; 1464 kce.len = sym->end - sym->start; 1465 if (!kcore_extract__create(&kce)) { 1466 delete_extract = true; 1467 strlcpy(symfs_filename, kce.extract_filename, 1468 sizeof(symfs_filename)); 1469 } 1470 } else if (dso__needs_decompress(dso)) { 1471 char tmp[KMOD_DECOMP_LEN]; 1472 1473 if (dso__decompress_kmodule_path(dso, symfs_filename, 1474 tmp, sizeof(tmp)) < 0) 1475 goto out; 1476 1477 strcpy(symfs_filename, tmp); 1478 } 1479 1480 snprintf(command, sizeof(command), 1481 "%s %s%s --start-address=0x%016" PRIx64 1482 " --stop-address=0x%016" PRIx64 1483 " -l -d %s %s -C \"%s\" 2>/dev/null|grep -v \"%s:\"|expand", 1484 objdump_path ? objdump_path : "objdump", 1485 disassembler_style ? "-M " : "", 1486 disassembler_style ? disassembler_style : "", 1487 map__rip_2objdump(map, sym->start), 1488 map__rip_2objdump(map, sym->end), 1489 symbol_conf.annotate_asm_raw ? "" : "--no-show-raw", 1490 symbol_conf.annotate_src ? "-S" : "", 1491 symfs_filename, symfs_filename); 1492 1493 pr_debug("Executing: %s\n", command); 1494 1495 err = -1; 1496 if (pipe(stdout_fd) < 0) { 1497 pr_err("Failure creating the pipe to run %s\n", command); 1498 goto out_remove_tmp; 1499 } 1500 1501 pid = fork(); 1502 if (pid < 0) { 1503 pr_err("Failure forking to run %s\n", command); 1504 goto out_close_stdout; 1505 } 1506 1507 if (pid == 0) { 1508 close(stdout_fd[0]); 1509 dup2(stdout_fd[1], 1); 1510 close(stdout_fd[1]); 1511 execl("/bin/sh", "sh", "-c", command, NULL); 1512 perror(command); 1513 exit(-1); 1514 } 1515 1516 close(stdout_fd[1]); 1517 1518 file = fdopen(stdout_fd[0], "r"); 1519 if (!file) { 1520 pr_err("Failure creating FILE stream for %s\n", command); 1521 /* 1522 * If we were using debug info should retry with 1523 * original binary. 1524 */ 1525 goto out_remove_tmp; 1526 } 1527 1528 nline = 0; 1529 while (!feof(file)) { 1530 /* 1531 * The source code line number (lineno) needs to be kept in 1532 * accross calls to symbol__parse_objdump_line(), so that it 1533 * can associate it with the instructions till the next one. 1534 * See disasm_line__new() and struct disasm_line::line_nr. 1535 */ 1536 if (symbol__parse_objdump_line(sym, file, args, &lineno) < 0) 1537 break; 1538 nline++; 1539 } 1540 1541 if (nline == 0) 1542 pr_err("No output from %s\n", command); 1543 1544 /* 1545 * kallsyms does not have symbol sizes so there may a nop at the end. 1546 * Remove it. 1547 */ 1548 if (dso__is_kcore(dso)) 1549 delete_last_nop(sym); 1550 1551 fclose(file); 1552 err = 0; 1553 out_remove_tmp: 1554 close(stdout_fd[0]); 1555 1556 if (dso__needs_decompress(dso)) 1557 unlink(symfs_filename); 1558 1559 if (delete_extract) 1560 kcore_extract__delete(&kce); 1561 out: 1562 return err; 1563 1564 out_close_stdout: 1565 close(stdout_fd[1]); 1566 goto out_remove_tmp; 1567 } 1568 1569 static void calc_percent(struct sym_hist *hist, 1570 struct annotation_data *sample, 1571 s64 offset, s64 end) 1572 { 1573 unsigned int hits = 0; 1574 u64 period = 0; 1575 1576 while (offset < end) { 1577 hits += hist->addr[offset].nr_samples; 1578 period += hist->addr[offset].period; 1579 ++offset; 1580 } 1581 1582 if (hist->nr_samples) { 1583 sample->he.period = period; 1584 sample->he.nr_samples = hits; 1585 sample->percent = 100.0 * hits / hist->nr_samples; 1586 } 1587 } 1588 1589 static void annotation__calc_percent(struct annotation *notes, 1590 struct perf_evsel *evsel, s64 len) 1591 { 1592 struct annotation_line *al, *next; 1593 1594 list_for_each_entry(al, ¬es->src->source, node) { 1595 s64 end; 1596 int i; 1597 1598 if (al->offset == -1) 1599 continue; 1600 1601 next = annotation_line__next(al, ¬es->src->source); 1602 end = next ? next->offset : len; 1603 1604 for (i = 0; i < al->samples_nr; i++) { 1605 struct annotation_data *sample; 1606 struct sym_hist *hist; 1607 1608 hist = annotation__histogram(notes, evsel->idx + i); 1609 sample = &al->samples[i]; 1610 1611 calc_percent(hist, sample, al->offset, end); 1612 } 1613 } 1614 } 1615 1616 void symbol__calc_percent(struct symbol *sym, struct perf_evsel *evsel) 1617 { 1618 struct annotation *notes = symbol__annotation(sym); 1619 1620 annotation__calc_percent(notes, evsel, symbol__size(sym)); 1621 } 1622 1623 int symbol__annotate(struct symbol *sym, struct map *map, 1624 struct perf_evsel *evsel, size_t privsize, 1625 struct arch **parch, char *cpuid) 1626 { 1627 struct annotate_args args = { 1628 .privsize = privsize, 1629 .map = map, 1630 .evsel = evsel, 1631 }; 1632 const char *arch_name = NULL; 1633 struct arch *arch; 1634 int err; 1635 1636 if (evsel) 1637 arch_name = perf_evsel__env_arch(evsel); 1638 1639 arch_name = annotate__norm_arch(arch_name); 1640 if (!arch_name) 1641 return -1; 1642 1643 args.arch = arch = arch__find(arch_name); 1644 if (arch == NULL) 1645 return -ENOTSUP; 1646 1647 if (parch) 1648 *parch = arch; 1649 1650 if (arch->init) { 1651 err = arch->init(arch, cpuid); 1652 if (err) { 1653 pr_err("%s: failed to initialize %s arch priv area\n", __func__, arch->name); 1654 return err; 1655 } 1656 } 1657 1658 return symbol__disassemble(sym, &args); 1659 } 1660 1661 static void insert_source_line(struct rb_root *root, struct annotation_line *al) 1662 { 1663 struct annotation_line *iter; 1664 struct rb_node **p = &root->rb_node; 1665 struct rb_node *parent = NULL; 1666 int i, ret; 1667 1668 while (*p != NULL) { 1669 parent = *p; 1670 iter = rb_entry(parent, struct annotation_line, rb_node); 1671 1672 ret = strcmp(iter->path, al->path); 1673 if (ret == 0) { 1674 for (i = 0; i < al->samples_nr; i++) 1675 iter->samples[i].percent_sum += al->samples[i].percent; 1676 return; 1677 } 1678 1679 if (ret < 0) 1680 p = &(*p)->rb_left; 1681 else 1682 p = &(*p)->rb_right; 1683 } 1684 1685 for (i = 0; i < al->samples_nr; i++) 1686 al->samples[i].percent_sum = al->samples[i].percent; 1687 1688 rb_link_node(&al->rb_node, parent, p); 1689 rb_insert_color(&al->rb_node, root); 1690 } 1691 1692 static int cmp_source_line(struct annotation_line *a, struct annotation_line *b) 1693 { 1694 int i; 1695 1696 for (i = 0; i < a->samples_nr; i++) { 1697 if (a->samples[i].percent_sum == b->samples[i].percent_sum) 1698 continue; 1699 return a->samples[i].percent_sum > b->samples[i].percent_sum; 1700 } 1701 1702 return 0; 1703 } 1704 1705 static void __resort_source_line(struct rb_root *root, struct annotation_line *al) 1706 { 1707 struct annotation_line *iter; 1708 struct rb_node **p = &root->rb_node; 1709 struct rb_node *parent = NULL; 1710 1711 while (*p != NULL) { 1712 parent = *p; 1713 iter = rb_entry(parent, struct annotation_line, rb_node); 1714 1715 if (cmp_source_line(al, iter)) 1716 p = &(*p)->rb_left; 1717 else 1718 p = &(*p)->rb_right; 1719 } 1720 1721 rb_link_node(&al->rb_node, parent, p); 1722 rb_insert_color(&al->rb_node, root); 1723 } 1724 1725 static void resort_source_line(struct rb_root *dest_root, struct rb_root *src_root) 1726 { 1727 struct annotation_line *al; 1728 struct rb_node *node; 1729 1730 node = rb_first(src_root); 1731 while (node) { 1732 struct rb_node *next; 1733 1734 al = rb_entry(node, struct annotation_line, rb_node); 1735 next = rb_next(node); 1736 rb_erase(node, src_root); 1737 1738 __resort_source_line(dest_root, al); 1739 node = next; 1740 } 1741 } 1742 1743 static void print_summary(struct rb_root *root, const char *filename) 1744 { 1745 struct annotation_line *al; 1746 struct rb_node *node; 1747 1748 printf("\nSorted summary for file %s\n", filename); 1749 printf("----------------------------------------------\n\n"); 1750 1751 if (RB_EMPTY_ROOT(root)) { 1752 printf(" Nothing higher than %1.1f%%\n", MIN_GREEN); 1753 return; 1754 } 1755 1756 node = rb_first(root); 1757 while (node) { 1758 double percent, percent_max = 0.0; 1759 const char *color; 1760 char *path; 1761 int i; 1762 1763 al = rb_entry(node, struct annotation_line, rb_node); 1764 for (i = 0; i < al->samples_nr; i++) { 1765 percent = al->samples[i].percent_sum; 1766 color = get_percent_color(percent); 1767 color_fprintf(stdout, color, " %7.2f", percent); 1768 1769 if (percent > percent_max) 1770 percent_max = percent; 1771 } 1772 1773 path = al->path; 1774 color = get_percent_color(percent_max); 1775 color_fprintf(stdout, color, " %s\n", path); 1776 1777 node = rb_next(node); 1778 } 1779 } 1780 1781 static void symbol__annotate_hits(struct symbol *sym, struct perf_evsel *evsel) 1782 { 1783 struct annotation *notes = symbol__annotation(sym); 1784 struct sym_hist *h = annotation__histogram(notes, evsel->idx); 1785 u64 len = symbol__size(sym), offset; 1786 1787 for (offset = 0; offset < len; ++offset) 1788 if (h->addr[offset].nr_samples != 0) 1789 printf("%*" PRIx64 ": %" PRIu64 "\n", BITS_PER_LONG / 2, 1790 sym->start + offset, h->addr[offset].nr_samples); 1791 printf("%*s: %" PRIu64 "\n", BITS_PER_LONG / 2, "h->nr_samples", h->nr_samples); 1792 } 1793 1794 static int annotated_source__addr_fmt_width(struct list_head *lines, u64 start) 1795 { 1796 char bf[32]; 1797 struct annotation_line *line; 1798 1799 list_for_each_entry_reverse(line, lines, node) { 1800 if (line->offset != -1) 1801 return scnprintf(bf, sizeof(bf), "%" PRIx64, start + line->offset); 1802 } 1803 1804 return 0; 1805 } 1806 1807 int symbol__annotate_printf(struct symbol *sym, struct map *map, 1808 struct perf_evsel *evsel, bool full_paths, 1809 int min_pcnt, int max_lines, int context) 1810 { 1811 struct dso *dso = map->dso; 1812 char *filename; 1813 const char *d_filename; 1814 const char *evsel_name = perf_evsel__name(evsel); 1815 struct annotation *notes = symbol__annotation(sym); 1816 struct sym_hist *h = annotation__histogram(notes, evsel->idx); 1817 struct annotation_line *pos, *queue = NULL; 1818 u64 start = map__rip_2objdump(map, sym->start); 1819 int printed = 2, queue_len = 0, addr_fmt_width; 1820 int more = 0; 1821 u64 len; 1822 int width = symbol_conf.show_total_period ? 12 : 8; 1823 int graph_dotted_len; 1824 1825 filename = strdup(dso->long_name); 1826 if (!filename) 1827 return -ENOMEM; 1828 1829 if (full_paths) 1830 d_filename = filename; 1831 else 1832 d_filename = basename(filename); 1833 1834 len = symbol__size(sym); 1835 1836 if (perf_evsel__is_group_event(evsel)) 1837 width *= evsel->nr_members; 1838 1839 graph_dotted_len = printf(" %-*.*s| Source code & Disassembly of %s for %s (%" PRIu64 " samples)\n", 1840 width, width, symbol_conf.show_total_period ? "Period" : 1841 symbol_conf.show_nr_samples ? "Samples" : "Percent", 1842 d_filename, evsel_name, h->nr_samples); 1843 1844 printf("%-*.*s----\n", 1845 graph_dotted_len, graph_dotted_len, graph_dotted_line); 1846 1847 if (verbose > 0) 1848 symbol__annotate_hits(sym, evsel); 1849 1850 addr_fmt_width = annotated_source__addr_fmt_width(¬es->src->source, start); 1851 1852 list_for_each_entry(pos, ¬es->src->source, node) { 1853 int err; 1854 1855 if (context && queue == NULL) { 1856 queue = pos; 1857 queue_len = 0; 1858 } 1859 1860 err = annotation_line__print(pos, sym, start, evsel, len, 1861 min_pcnt, printed, max_lines, 1862 queue, addr_fmt_width); 1863 1864 switch (err) { 1865 case 0: 1866 ++printed; 1867 if (context) { 1868 printed += queue_len; 1869 queue = NULL; 1870 queue_len = 0; 1871 } 1872 break; 1873 case 1: 1874 /* filtered by max_lines */ 1875 ++more; 1876 break; 1877 case -1: 1878 default: 1879 /* 1880 * Filtered by min_pcnt or non IP lines when 1881 * context != 0 1882 */ 1883 if (!context) 1884 break; 1885 if (queue_len == context) 1886 queue = list_entry(queue->node.next, typeof(*queue), node); 1887 else 1888 ++queue_len; 1889 break; 1890 } 1891 } 1892 1893 free(filename); 1894 1895 return more; 1896 } 1897 1898 void symbol__annotate_zero_histogram(struct symbol *sym, int evidx) 1899 { 1900 struct annotation *notes = symbol__annotation(sym); 1901 struct sym_hist *h = annotation__histogram(notes, evidx); 1902 1903 memset(h, 0, notes->src->sizeof_sym_hist); 1904 } 1905 1906 void symbol__annotate_decay_histogram(struct symbol *sym, int evidx) 1907 { 1908 struct annotation *notes = symbol__annotation(sym); 1909 struct sym_hist *h = annotation__histogram(notes, evidx); 1910 int len = symbol__size(sym), offset; 1911 1912 h->nr_samples = 0; 1913 for (offset = 0; offset < len; ++offset) { 1914 h->addr[offset].nr_samples = h->addr[offset].nr_samples * 7 / 8; 1915 h->nr_samples += h->addr[offset].nr_samples; 1916 } 1917 } 1918 1919 void annotated_source__purge(struct annotated_source *as) 1920 { 1921 struct annotation_line *al, *n; 1922 1923 list_for_each_entry_safe(al, n, &as->source, node) { 1924 list_del(&al->node); 1925 disasm_line__free(disasm_line(al)); 1926 } 1927 } 1928 1929 static size_t disasm_line__fprintf(struct disasm_line *dl, FILE *fp) 1930 { 1931 size_t printed; 1932 1933 if (dl->al.offset == -1) 1934 return fprintf(fp, "%s\n", dl->al.line); 1935 1936 printed = fprintf(fp, "%#" PRIx64 " %s", dl->al.offset, dl->ins.name); 1937 1938 if (dl->ops.raw[0] != '\0') { 1939 printed += fprintf(fp, "%.*s %s\n", 6 - (int)printed, " ", 1940 dl->ops.raw); 1941 } 1942 1943 return printed + fprintf(fp, "\n"); 1944 } 1945 1946 size_t disasm__fprintf(struct list_head *head, FILE *fp) 1947 { 1948 struct disasm_line *pos; 1949 size_t printed = 0; 1950 1951 list_for_each_entry(pos, head, al.node) 1952 printed += disasm_line__fprintf(pos, fp); 1953 1954 return printed; 1955 } 1956 1957 static void annotation__calc_lines(struct annotation *notes, struct map *map, 1958 struct rb_root *root, u64 start) 1959 { 1960 struct annotation_line *al; 1961 struct rb_root tmp_root = RB_ROOT; 1962 1963 list_for_each_entry(al, ¬es->src->source, node) { 1964 double percent_max = 0.0; 1965 int i; 1966 1967 for (i = 0; i < al->samples_nr; i++) { 1968 struct annotation_data *sample; 1969 1970 sample = &al->samples[i]; 1971 1972 if (sample->percent > percent_max) 1973 percent_max = sample->percent; 1974 } 1975 1976 if (percent_max <= 0.5) 1977 continue; 1978 1979 al->path = get_srcline(map->dso, start + al->offset, NULL, false, true); 1980 insert_source_line(&tmp_root, al); 1981 } 1982 1983 resort_source_line(root, &tmp_root); 1984 } 1985 1986 static void symbol__calc_lines(struct symbol *sym, struct map *map, 1987 struct rb_root *root) 1988 { 1989 struct annotation *notes = symbol__annotation(sym); 1990 u64 start = map__rip_2objdump(map, sym->start); 1991 1992 annotation__calc_lines(notes, map, root, start); 1993 } 1994 1995 int symbol__tty_annotate(struct symbol *sym, struct map *map, 1996 struct perf_evsel *evsel, bool print_lines, 1997 bool full_paths, int min_pcnt, int max_lines) 1998 { 1999 struct dso *dso = map->dso; 2000 struct rb_root source_line = RB_ROOT; 2001 2002 if (symbol__annotate(sym, map, evsel, 0, NULL, NULL) < 0) 2003 return -1; 2004 2005 symbol__calc_percent(sym, evsel); 2006 2007 if (print_lines) { 2008 srcline_full_filename = full_paths; 2009 symbol__calc_lines(sym, map, &source_line); 2010 print_summary(&source_line, dso->long_name); 2011 } 2012 2013 symbol__annotate_printf(sym, map, evsel, full_paths, 2014 min_pcnt, max_lines, 0); 2015 2016 annotated_source__purge(symbol__annotation(sym)->src); 2017 2018 return 0; 2019 } 2020 2021 bool ui__has_annotation(void) 2022 { 2023 return use_browser == 1 && perf_hpp_list.sym; 2024 } 2025