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