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