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 if (start_command(&objdump_process)) { 2040 pr_err("Failure starting to run %s\n", command); 2041 err = -1; 2042 goto out_free_command; 2043 } 2044 2045 file = fdopen(objdump_process.out, "r"); 2046 if (!file) { 2047 pr_err("Failure creating FILE stream for %s\n", command); 2048 /* 2049 * If we were using debug info should retry with 2050 * original binary. 2051 */ 2052 err = -1; 2053 goto out_close_stdout; 2054 } 2055 2056 /* Storage for getline. */ 2057 line = NULL; 2058 line_len = 0; 2059 2060 nline = 0; 2061 while (!feof(file)) { 2062 const char *match; 2063 char *expanded_line; 2064 2065 if (getline(&line, &line_len, file) < 0 || !line) 2066 break; 2067 2068 /* Skip lines containing "filename:" */ 2069 match = strstr(line, symfs_filename); 2070 if (match && match[strlen(symfs_filename)] == ':') 2071 continue; 2072 2073 expanded_line = strim(line); 2074 expanded_line = expand_tabs(expanded_line, &line, &line_len); 2075 if (!expanded_line) 2076 break; 2077 2078 /* 2079 * The source code line number (lineno) needs to be kept in 2080 * across calls to symbol__parse_objdump_line(), so that it 2081 * can associate it with the instructions till the next one. 2082 * See disasm_line__new() and struct disasm_line::line_nr. 2083 */ 2084 if (symbol__parse_objdump_line(sym, args, expanded_line, 2085 &lineno, &fileloc) < 0) 2086 break; 2087 nline++; 2088 } 2089 free(line); 2090 2091 err = finish_command(&objdump_process); 2092 if (err) 2093 pr_err("Error running %s\n", command); 2094 2095 if (nline == 0) { 2096 err = -1; 2097 pr_err("No output from %s\n", command); 2098 } 2099 2100 /* 2101 * kallsyms does not have symbol sizes so there may a nop at the end. 2102 * Remove it. 2103 */ 2104 if (dso__is_kcore(dso)) 2105 delete_last_nop(sym); 2106 2107 fclose(file); 2108 2109 out_close_stdout: 2110 close(objdump_process.out); 2111 2112 out_free_command: 2113 free(command); 2114 2115 out_remove_tmp: 2116 if (decomp) 2117 unlink(symfs_filename); 2118 2119 if (delete_extract) 2120 kcore_extract__delete(&kce); 2121 2122 return err; 2123 } 2124 2125 static void calc_percent(struct sym_hist *sym_hist, 2126 struct hists *hists, 2127 struct annotation_data *data, 2128 s64 offset, s64 end) 2129 { 2130 unsigned int hits = 0; 2131 u64 period = 0; 2132 2133 while (offset < end) { 2134 hits += sym_hist->addr[offset].nr_samples; 2135 period += sym_hist->addr[offset].period; 2136 ++offset; 2137 } 2138 2139 if (sym_hist->nr_samples) { 2140 data->he.period = period; 2141 data->he.nr_samples = hits; 2142 data->percent[PERCENT_HITS_LOCAL] = 100.0 * hits / sym_hist->nr_samples; 2143 } 2144 2145 if (hists->stats.nr_non_filtered_samples) 2146 data->percent[PERCENT_HITS_GLOBAL] = 100.0 * hits / hists->stats.nr_non_filtered_samples; 2147 2148 if (sym_hist->period) 2149 data->percent[PERCENT_PERIOD_LOCAL] = 100.0 * period / sym_hist->period; 2150 2151 if (hists->stats.total_period) 2152 data->percent[PERCENT_PERIOD_GLOBAL] = 100.0 * period / hists->stats.total_period; 2153 } 2154 2155 static void annotation__calc_percent(struct annotation *notes, 2156 struct evsel *leader, s64 len) 2157 { 2158 struct annotation_line *al, *next; 2159 struct evsel *evsel; 2160 2161 list_for_each_entry(al, ¬es->src->source, node) { 2162 s64 end; 2163 int i = 0; 2164 2165 if (al->offset == -1) 2166 continue; 2167 2168 next = annotation_line__next(al, ¬es->src->source); 2169 end = next ? next->offset : len; 2170 2171 for_each_group_evsel(evsel, leader) { 2172 struct hists *hists = evsel__hists(evsel); 2173 struct annotation_data *data; 2174 struct sym_hist *sym_hist; 2175 2176 BUG_ON(i >= al->data_nr); 2177 2178 sym_hist = annotation__histogram(notes, evsel->core.idx); 2179 data = &al->data[i++]; 2180 2181 calc_percent(sym_hist, hists, data, al->offset, end); 2182 } 2183 } 2184 } 2185 2186 void symbol__calc_percent(struct symbol *sym, struct evsel *evsel) 2187 { 2188 struct annotation *notes = symbol__annotation(sym); 2189 2190 annotation__calc_percent(notes, evsel, symbol__size(sym)); 2191 } 2192 2193 int symbol__annotate(struct map_symbol *ms, struct evsel *evsel, 2194 struct annotation_options *options, struct arch **parch) 2195 { 2196 struct symbol *sym = ms->sym; 2197 struct annotation *notes = symbol__annotation(sym); 2198 struct annotate_args args = { 2199 .evsel = evsel, 2200 .options = options, 2201 }; 2202 struct perf_env *env = evsel__env(evsel); 2203 const char *arch_name = perf_env__arch(env); 2204 struct arch *arch; 2205 int err; 2206 2207 if (!arch_name) 2208 return errno; 2209 2210 args.arch = arch = arch__find(arch_name); 2211 if (arch == NULL) { 2212 pr_err("%s: unsupported arch %s\n", __func__, arch_name); 2213 return ENOTSUP; 2214 } 2215 2216 if (parch) 2217 *parch = arch; 2218 2219 if (arch->init) { 2220 err = arch->init(arch, env ? env->cpuid : NULL); 2221 if (err) { 2222 pr_err("%s: failed to initialize %s arch priv area\n", __func__, arch->name); 2223 return err; 2224 } 2225 } 2226 2227 args.ms = *ms; 2228 notes->start = map__rip_2objdump(ms->map, sym->start); 2229 2230 return symbol__disassemble(sym, &args); 2231 } 2232 2233 static void insert_source_line(struct rb_root *root, struct annotation_line *al, 2234 struct annotation_options *opts) 2235 { 2236 struct annotation_line *iter; 2237 struct rb_node **p = &root->rb_node; 2238 struct rb_node *parent = NULL; 2239 int i, ret; 2240 2241 while (*p != NULL) { 2242 parent = *p; 2243 iter = rb_entry(parent, struct annotation_line, rb_node); 2244 2245 ret = strcmp(iter->path, al->path); 2246 if (ret == 0) { 2247 for (i = 0; i < al->data_nr; i++) { 2248 iter->data[i].percent_sum += annotation_data__percent(&al->data[i], 2249 opts->percent_type); 2250 } 2251 return; 2252 } 2253 2254 if (ret < 0) 2255 p = &(*p)->rb_left; 2256 else 2257 p = &(*p)->rb_right; 2258 } 2259 2260 for (i = 0; i < al->data_nr; i++) { 2261 al->data[i].percent_sum = annotation_data__percent(&al->data[i], 2262 opts->percent_type); 2263 } 2264 2265 rb_link_node(&al->rb_node, parent, p); 2266 rb_insert_color(&al->rb_node, root); 2267 } 2268 2269 static int cmp_source_line(struct annotation_line *a, struct annotation_line *b) 2270 { 2271 int i; 2272 2273 for (i = 0; i < a->data_nr; i++) { 2274 if (a->data[i].percent_sum == b->data[i].percent_sum) 2275 continue; 2276 return a->data[i].percent_sum > b->data[i].percent_sum; 2277 } 2278 2279 return 0; 2280 } 2281 2282 static void __resort_source_line(struct rb_root *root, struct annotation_line *al) 2283 { 2284 struct annotation_line *iter; 2285 struct rb_node **p = &root->rb_node; 2286 struct rb_node *parent = NULL; 2287 2288 while (*p != NULL) { 2289 parent = *p; 2290 iter = rb_entry(parent, struct annotation_line, rb_node); 2291 2292 if (cmp_source_line(al, iter)) 2293 p = &(*p)->rb_left; 2294 else 2295 p = &(*p)->rb_right; 2296 } 2297 2298 rb_link_node(&al->rb_node, parent, p); 2299 rb_insert_color(&al->rb_node, root); 2300 } 2301 2302 static void resort_source_line(struct rb_root *dest_root, struct rb_root *src_root) 2303 { 2304 struct annotation_line *al; 2305 struct rb_node *node; 2306 2307 node = rb_first(src_root); 2308 while (node) { 2309 struct rb_node *next; 2310 2311 al = rb_entry(node, struct annotation_line, rb_node); 2312 next = rb_next(node); 2313 rb_erase(node, src_root); 2314 2315 __resort_source_line(dest_root, al); 2316 node = next; 2317 } 2318 } 2319 2320 static void print_summary(struct rb_root *root, const char *filename) 2321 { 2322 struct annotation_line *al; 2323 struct rb_node *node; 2324 2325 printf("\nSorted summary for file %s\n", filename); 2326 printf("----------------------------------------------\n\n"); 2327 2328 if (RB_EMPTY_ROOT(root)) { 2329 printf(" Nothing higher than %1.1f%%\n", MIN_GREEN); 2330 return; 2331 } 2332 2333 node = rb_first(root); 2334 while (node) { 2335 double percent, percent_max = 0.0; 2336 const char *color; 2337 char *path; 2338 int i; 2339 2340 al = rb_entry(node, struct annotation_line, rb_node); 2341 for (i = 0; i < al->data_nr; i++) { 2342 percent = al->data[i].percent_sum; 2343 color = get_percent_color(percent); 2344 color_fprintf(stdout, color, " %7.2f", percent); 2345 2346 if (percent > percent_max) 2347 percent_max = percent; 2348 } 2349 2350 path = al->path; 2351 color = get_percent_color(percent_max); 2352 color_fprintf(stdout, color, " %s\n", path); 2353 2354 node = rb_next(node); 2355 } 2356 } 2357 2358 static void symbol__annotate_hits(struct symbol *sym, struct evsel *evsel) 2359 { 2360 struct annotation *notes = symbol__annotation(sym); 2361 struct sym_hist *h = annotation__histogram(notes, evsel->core.idx); 2362 u64 len = symbol__size(sym), offset; 2363 2364 for (offset = 0; offset < len; ++offset) 2365 if (h->addr[offset].nr_samples != 0) 2366 printf("%*" PRIx64 ": %" PRIu64 "\n", BITS_PER_LONG / 2, 2367 sym->start + offset, h->addr[offset].nr_samples); 2368 printf("%*s: %" PRIu64 "\n", BITS_PER_LONG / 2, "h->nr_samples", h->nr_samples); 2369 } 2370 2371 static int annotated_source__addr_fmt_width(struct list_head *lines, u64 start) 2372 { 2373 char bf[32]; 2374 struct annotation_line *line; 2375 2376 list_for_each_entry_reverse(line, lines, node) { 2377 if (line->offset != -1) 2378 return scnprintf(bf, sizeof(bf), "%" PRIx64, start + line->offset); 2379 } 2380 2381 return 0; 2382 } 2383 2384 int symbol__annotate_printf(struct map_symbol *ms, struct evsel *evsel, 2385 struct annotation_options *opts) 2386 { 2387 struct map *map = ms->map; 2388 struct symbol *sym = ms->sym; 2389 struct dso *dso = map->dso; 2390 char *filename; 2391 const char *d_filename; 2392 const char *evsel_name = evsel__name(evsel); 2393 struct annotation *notes = symbol__annotation(sym); 2394 struct sym_hist *h = annotation__histogram(notes, evsel->core.idx); 2395 struct annotation_line *pos, *queue = NULL; 2396 u64 start = map__rip_2objdump(map, sym->start); 2397 int printed = 2, queue_len = 0, addr_fmt_width; 2398 int more = 0; 2399 bool context = opts->context; 2400 u64 len; 2401 int width = symbol_conf.show_total_period ? 12 : 8; 2402 int graph_dotted_len; 2403 char buf[512]; 2404 2405 filename = strdup(dso->long_name); 2406 if (!filename) 2407 return -ENOMEM; 2408 2409 if (opts->full_path) 2410 d_filename = filename; 2411 else 2412 d_filename = basename(filename); 2413 2414 len = symbol__size(sym); 2415 2416 if (evsel__is_group_event(evsel)) { 2417 width *= evsel->core.nr_members; 2418 evsel__group_desc(evsel, buf, sizeof(buf)); 2419 evsel_name = buf; 2420 } 2421 2422 graph_dotted_len = printf(" %-*.*s| Source code & Disassembly of %s for %s (%" PRIu64 " samples, " 2423 "percent: %s)\n", 2424 width, width, symbol_conf.show_total_period ? "Period" : 2425 symbol_conf.show_nr_samples ? "Samples" : "Percent", 2426 d_filename, evsel_name, h->nr_samples, 2427 percent_type_str(opts->percent_type)); 2428 2429 printf("%-*.*s----\n", 2430 graph_dotted_len, graph_dotted_len, graph_dotted_line); 2431 2432 if (verbose > 0) 2433 symbol__annotate_hits(sym, evsel); 2434 2435 addr_fmt_width = annotated_source__addr_fmt_width(¬es->src->source, start); 2436 2437 list_for_each_entry(pos, ¬es->src->source, node) { 2438 int err; 2439 2440 if (context && queue == NULL) { 2441 queue = pos; 2442 queue_len = 0; 2443 } 2444 2445 err = annotation_line__print(pos, sym, start, evsel, len, 2446 opts->min_pcnt, printed, opts->max_lines, 2447 queue, addr_fmt_width, opts->percent_type); 2448 2449 switch (err) { 2450 case 0: 2451 ++printed; 2452 if (context) { 2453 printed += queue_len; 2454 queue = NULL; 2455 queue_len = 0; 2456 } 2457 break; 2458 case 1: 2459 /* filtered by max_lines */ 2460 ++more; 2461 break; 2462 case -1: 2463 default: 2464 /* 2465 * Filtered by min_pcnt or non IP lines when 2466 * context != 0 2467 */ 2468 if (!context) 2469 break; 2470 if (queue_len == context) 2471 queue = list_entry(queue->node.next, typeof(*queue), node); 2472 else 2473 ++queue_len; 2474 break; 2475 } 2476 } 2477 2478 free(filename); 2479 2480 return more; 2481 } 2482 2483 static void FILE__set_percent_color(void *fp __maybe_unused, 2484 double percent __maybe_unused, 2485 bool current __maybe_unused) 2486 { 2487 } 2488 2489 static int FILE__set_jumps_percent_color(void *fp __maybe_unused, 2490 int nr __maybe_unused, bool current __maybe_unused) 2491 { 2492 return 0; 2493 } 2494 2495 static int FILE__set_color(void *fp __maybe_unused, int color __maybe_unused) 2496 { 2497 return 0; 2498 } 2499 2500 static void FILE__printf(void *fp, const char *fmt, ...) 2501 { 2502 va_list args; 2503 2504 va_start(args, fmt); 2505 vfprintf(fp, fmt, args); 2506 va_end(args); 2507 } 2508 2509 static void FILE__write_graph(void *fp, int graph) 2510 { 2511 const char *s; 2512 switch (graph) { 2513 2514 case DARROW_CHAR: s = "↓"; break; 2515 case UARROW_CHAR: s = "↑"; break; 2516 case LARROW_CHAR: s = "←"; break; 2517 case RARROW_CHAR: s = "→"; break; 2518 default: s = "?"; break; 2519 } 2520 2521 fputs(s, fp); 2522 } 2523 2524 static int symbol__annotate_fprintf2(struct symbol *sym, FILE *fp, 2525 struct annotation_options *opts) 2526 { 2527 struct annotation *notes = symbol__annotation(sym); 2528 struct annotation_write_ops wops = { 2529 .first_line = true, 2530 .obj = fp, 2531 .set_color = FILE__set_color, 2532 .set_percent_color = FILE__set_percent_color, 2533 .set_jumps_percent_color = FILE__set_jumps_percent_color, 2534 .printf = FILE__printf, 2535 .write_graph = FILE__write_graph, 2536 }; 2537 struct annotation_line *al; 2538 2539 list_for_each_entry(al, ¬es->src->source, node) { 2540 if (annotation_line__filter(al, notes)) 2541 continue; 2542 annotation_line__write(al, notes, &wops, opts); 2543 fputc('\n', fp); 2544 wops.first_line = false; 2545 } 2546 2547 return 0; 2548 } 2549 2550 int map_symbol__annotation_dump(struct map_symbol *ms, struct evsel *evsel, 2551 struct annotation_options *opts) 2552 { 2553 const char *ev_name = evsel__name(evsel); 2554 char buf[1024]; 2555 char *filename; 2556 int err = -1; 2557 FILE *fp; 2558 2559 if (asprintf(&filename, "%s.annotation", ms->sym->name) < 0) 2560 return -1; 2561 2562 fp = fopen(filename, "w"); 2563 if (fp == NULL) 2564 goto out_free_filename; 2565 2566 if (evsel__is_group_event(evsel)) { 2567 evsel__group_desc(evsel, buf, sizeof(buf)); 2568 ev_name = buf; 2569 } 2570 2571 fprintf(fp, "%s() %s\nEvent: %s\n\n", 2572 ms->sym->name, ms->map->dso->long_name, ev_name); 2573 symbol__annotate_fprintf2(ms->sym, fp, opts); 2574 2575 fclose(fp); 2576 err = 0; 2577 out_free_filename: 2578 free(filename); 2579 return err; 2580 } 2581 2582 void symbol__annotate_zero_histogram(struct symbol *sym, int evidx) 2583 { 2584 struct annotation *notes = symbol__annotation(sym); 2585 struct sym_hist *h = annotation__histogram(notes, evidx); 2586 2587 memset(h, 0, notes->src->sizeof_sym_hist); 2588 } 2589 2590 void symbol__annotate_decay_histogram(struct symbol *sym, int evidx) 2591 { 2592 struct annotation *notes = symbol__annotation(sym); 2593 struct sym_hist *h = annotation__histogram(notes, evidx); 2594 int len = symbol__size(sym), offset; 2595 2596 h->nr_samples = 0; 2597 for (offset = 0; offset < len; ++offset) { 2598 h->addr[offset].nr_samples = h->addr[offset].nr_samples * 7 / 8; 2599 h->nr_samples += h->addr[offset].nr_samples; 2600 } 2601 } 2602 2603 void annotated_source__purge(struct annotated_source *as) 2604 { 2605 struct annotation_line *al, *n; 2606 2607 list_for_each_entry_safe(al, n, &as->source, node) { 2608 list_del_init(&al->node); 2609 disasm_line__free(disasm_line(al)); 2610 } 2611 } 2612 2613 static size_t disasm_line__fprintf(struct disasm_line *dl, FILE *fp) 2614 { 2615 size_t printed; 2616 2617 if (dl->al.offset == -1) 2618 return fprintf(fp, "%s\n", dl->al.line); 2619 2620 printed = fprintf(fp, "%#" PRIx64 " %s", dl->al.offset, dl->ins.name); 2621 2622 if (dl->ops.raw[0] != '\0') { 2623 printed += fprintf(fp, "%.*s %s\n", 6 - (int)printed, " ", 2624 dl->ops.raw); 2625 } 2626 2627 return printed + fprintf(fp, "\n"); 2628 } 2629 2630 size_t disasm__fprintf(struct list_head *head, FILE *fp) 2631 { 2632 struct disasm_line *pos; 2633 size_t printed = 0; 2634 2635 list_for_each_entry(pos, head, al.node) 2636 printed += disasm_line__fprintf(pos, fp); 2637 2638 return printed; 2639 } 2640 2641 bool disasm_line__is_valid_local_jump(struct disasm_line *dl, struct symbol *sym) 2642 { 2643 if (!dl || !dl->ins.ops || !ins__is_jump(&dl->ins) || 2644 !disasm_line__has_local_offset(dl) || dl->ops.target.offset < 0 || 2645 dl->ops.target.offset >= (s64)symbol__size(sym)) 2646 return false; 2647 2648 return true; 2649 } 2650 2651 void annotation__mark_jump_targets(struct annotation *notes, struct symbol *sym) 2652 { 2653 u64 offset, size = symbol__size(sym); 2654 2655 /* PLT symbols contain external offsets */ 2656 if (strstr(sym->name, "@plt")) 2657 return; 2658 2659 for (offset = 0; offset < size; ++offset) { 2660 struct annotation_line *al = notes->offsets[offset]; 2661 struct disasm_line *dl; 2662 2663 dl = disasm_line(al); 2664 2665 if (!disasm_line__is_valid_local_jump(dl, sym)) 2666 continue; 2667 2668 al = notes->offsets[dl->ops.target.offset]; 2669 2670 /* 2671 * FIXME: Oops, no jump target? Buggy disassembler? Or do we 2672 * have to adjust to the previous offset? 2673 */ 2674 if (al == NULL) 2675 continue; 2676 2677 if (++al->jump_sources > notes->max_jump_sources) 2678 notes->max_jump_sources = al->jump_sources; 2679 } 2680 } 2681 2682 void annotation__set_offsets(struct annotation *notes, s64 size) 2683 { 2684 struct annotation_line *al; 2685 2686 notes->max_line_len = 0; 2687 notes->nr_entries = 0; 2688 notes->nr_asm_entries = 0; 2689 2690 list_for_each_entry(al, ¬es->src->source, node) { 2691 size_t line_len = strlen(al->line); 2692 2693 if (notes->max_line_len < line_len) 2694 notes->max_line_len = line_len; 2695 al->idx = notes->nr_entries++; 2696 if (al->offset != -1) { 2697 al->idx_asm = notes->nr_asm_entries++; 2698 /* 2699 * FIXME: short term bandaid to cope with assembly 2700 * routines that comes with labels in the same column 2701 * as the address in objdump, sigh. 2702 * 2703 * E.g. copy_user_generic_unrolled 2704 */ 2705 if (al->offset < size) 2706 notes->offsets[al->offset] = al; 2707 } else 2708 al->idx_asm = -1; 2709 } 2710 } 2711 2712 static inline int width_jumps(int n) 2713 { 2714 if (n >= 100) 2715 return 5; 2716 if (n / 10) 2717 return 2; 2718 return 1; 2719 } 2720 2721 static int annotation__max_ins_name(struct annotation *notes) 2722 { 2723 int max_name = 0, len; 2724 struct annotation_line *al; 2725 2726 list_for_each_entry(al, ¬es->src->source, node) { 2727 if (al->offset == -1) 2728 continue; 2729 2730 len = strlen(disasm_line(al)->ins.name); 2731 if (max_name < len) 2732 max_name = len; 2733 } 2734 2735 return max_name; 2736 } 2737 2738 void annotation__init_column_widths(struct annotation *notes, struct symbol *sym) 2739 { 2740 notes->widths.addr = notes->widths.target = 2741 notes->widths.min_addr = hex_width(symbol__size(sym)); 2742 notes->widths.max_addr = hex_width(sym->end); 2743 notes->widths.jumps = width_jumps(notes->max_jump_sources); 2744 notes->widths.max_ins_name = annotation__max_ins_name(notes); 2745 } 2746 2747 void annotation__update_column_widths(struct annotation *notes) 2748 { 2749 if (notes->options->use_offset) 2750 notes->widths.target = notes->widths.min_addr; 2751 else 2752 notes->widths.target = notes->widths.max_addr; 2753 2754 notes->widths.addr = notes->widths.target; 2755 2756 if (notes->options->show_nr_jumps) 2757 notes->widths.addr += notes->widths.jumps + 1; 2758 } 2759 2760 static void annotation__calc_lines(struct annotation *notes, struct map *map, 2761 struct rb_root *root, 2762 struct annotation_options *opts) 2763 { 2764 struct annotation_line *al; 2765 struct rb_root tmp_root = RB_ROOT; 2766 2767 list_for_each_entry(al, ¬es->src->source, node) { 2768 double percent_max = 0.0; 2769 int i; 2770 2771 for (i = 0; i < al->data_nr; i++) { 2772 double percent; 2773 2774 percent = annotation_data__percent(&al->data[i], 2775 opts->percent_type); 2776 2777 if (percent > percent_max) 2778 percent_max = percent; 2779 } 2780 2781 if (percent_max <= 0.5) 2782 continue; 2783 2784 al->path = get_srcline(map->dso, notes->start + al->offset, NULL, 2785 false, true, notes->start + al->offset); 2786 insert_source_line(&tmp_root, al, opts); 2787 } 2788 2789 resort_source_line(root, &tmp_root); 2790 } 2791 2792 static void symbol__calc_lines(struct map_symbol *ms, struct rb_root *root, 2793 struct annotation_options *opts) 2794 { 2795 struct annotation *notes = symbol__annotation(ms->sym); 2796 2797 annotation__calc_lines(notes, ms->map, root, opts); 2798 } 2799 2800 int symbol__tty_annotate2(struct map_symbol *ms, struct evsel *evsel, 2801 struct annotation_options *opts) 2802 { 2803 struct dso *dso = ms->map->dso; 2804 struct symbol *sym = ms->sym; 2805 struct rb_root source_line = RB_ROOT; 2806 struct hists *hists = evsel__hists(evsel); 2807 char buf[1024]; 2808 int err; 2809 2810 err = symbol__annotate2(ms, evsel, opts, NULL); 2811 if (err) { 2812 char msg[BUFSIZ]; 2813 2814 dso->annotate_warned = true; 2815 symbol__strerror_disassemble(ms, err, msg, sizeof(msg)); 2816 ui__error("Couldn't annotate %s:\n%s", sym->name, msg); 2817 return -1; 2818 } 2819 2820 if (opts->print_lines) { 2821 srcline_full_filename = opts->full_path; 2822 symbol__calc_lines(ms, &source_line, opts); 2823 print_summary(&source_line, dso->long_name); 2824 } 2825 2826 hists__scnprintf_title(hists, buf, sizeof(buf)); 2827 fprintf(stdout, "%s, [percent: %s]\n%s() %s\n", 2828 buf, percent_type_str(opts->percent_type), sym->name, dso->long_name); 2829 symbol__annotate_fprintf2(sym, stdout, opts); 2830 2831 annotated_source__purge(symbol__annotation(sym)->src); 2832 2833 return 0; 2834 } 2835 2836 int symbol__tty_annotate(struct map_symbol *ms, struct evsel *evsel, 2837 struct annotation_options *opts) 2838 { 2839 struct dso *dso = ms->map->dso; 2840 struct symbol *sym = ms->sym; 2841 struct rb_root source_line = RB_ROOT; 2842 int err; 2843 2844 err = symbol__annotate(ms, evsel, opts, NULL); 2845 if (err) { 2846 char msg[BUFSIZ]; 2847 2848 dso->annotate_warned = true; 2849 symbol__strerror_disassemble(ms, err, msg, sizeof(msg)); 2850 ui__error("Couldn't annotate %s:\n%s", sym->name, msg); 2851 return -1; 2852 } 2853 2854 symbol__calc_percent(sym, evsel); 2855 2856 if (opts->print_lines) { 2857 srcline_full_filename = opts->full_path; 2858 symbol__calc_lines(ms, &source_line, opts); 2859 print_summary(&source_line, dso->long_name); 2860 } 2861 2862 symbol__annotate_printf(ms, evsel, opts); 2863 2864 annotated_source__purge(symbol__annotation(sym)->src); 2865 2866 return 0; 2867 } 2868 2869 bool ui__has_annotation(void) 2870 { 2871 return use_browser == 1 && perf_hpp_list.sym; 2872 } 2873 2874 2875 static double annotation_line__max_percent(struct annotation_line *al, 2876 struct annotation *notes, 2877 unsigned int percent_type) 2878 { 2879 double percent_max = 0.0; 2880 int i; 2881 2882 for (i = 0; i < notes->nr_events; i++) { 2883 double percent; 2884 2885 percent = annotation_data__percent(&al->data[i], 2886 percent_type); 2887 2888 if (percent > percent_max) 2889 percent_max = percent; 2890 } 2891 2892 return percent_max; 2893 } 2894 2895 static void disasm_line__write(struct disasm_line *dl, struct annotation *notes, 2896 void *obj, char *bf, size_t size, 2897 void (*obj__printf)(void *obj, const char *fmt, ...), 2898 void (*obj__write_graph)(void *obj, int graph)) 2899 { 2900 if (dl->ins.ops && dl->ins.ops->scnprintf) { 2901 if (ins__is_jump(&dl->ins)) { 2902 bool fwd; 2903 2904 if (dl->ops.target.outside) 2905 goto call_like; 2906 fwd = dl->ops.target.offset > dl->al.offset; 2907 obj__write_graph(obj, fwd ? DARROW_CHAR : UARROW_CHAR); 2908 obj__printf(obj, " "); 2909 } else if (ins__is_call(&dl->ins)) { 2910 call_like: 2911 obj__write_graph(obj, RARROW_CHAR); 2912 obj__printf(obj, " "); 2913 } else if (ins__is_ret(&dl->ins)) { 2914 obj__write_graph(obj, LARROW_CHAR); 2915 obj__printf(obj, " "); 2916 } else { 2917 obj__printf(obj, " "); 2918 } 2919 } else { 2920 obj__printf(obj, " "); 2921 } 2922 2923 disasm_line__scnprintf(dl, bf, size, !notes->options->use_offset, notes->widths.max_ins_name); 2924 } 2925 2926 static void ipc_coverage_string(char *bf, int size, struct annotation *notes) 2927 { 2928 double ipc = 0.0, coverage = 0.0; 2929 2930 if (notes->hit_cycles) 2931 ipc = notes->hit_insn / ((double)notes->hit_cycles); 2932 2933 if (notes->total_insn) { 2934 coverage = notes->cover_insn * 100.0 / 2935 ((double)notes->total_insn); 2936 } 2937 2938 scnprintf(bf, size, "(Average IPC: %.2f, IPC Coverage: %.1f%%)", 2939 ipc, coverage); 2940 } 2941 2942 static void __annotation_line__write(struct annotation_line *al, struct annotation *notes, 2943 bool first_line, bool current_entry, bool change_color, int width, 2944 void *obj, unsigned int percent_type, 2945 int (*obj__set_color)(void *obj, int color), 2946 void (*obj__set_percent_color)(void *obj, double percent, bool current), 2947 int (*obj__set_jumps_percent_color)(void *obj, int nr, bool current), 2948 void (*obj__printf)(void *obj, const char *fmt, ...), 2949 void (*obj__write_graph)(void *obj, int graph)) 2950 2951 { 2952 double percent_max = annotation_line__max_percent(al, notes, percent_type); 2953 int pcnt_width = annotation__pcnt_width(notes), 2954 cycles_width = annotation__cycles_width(notes); 2955 bool show_title = false; 2956 char bf[256]; 2957 int printed; 2958 2959 if (first_line && (al->offset == -1 || percent_max == 0.0)) { 2960 if (notes->have_cycles) { 2961 if (al->ipc == 0.0 && al->cycles == 0) 2962 show_title = true; 2963 } else 2964 show_title = true; 2965 } 2966 2967 if (al->offset != -1 && percent_max != 0.0) { 2968 int i; 2969 2970 for (i = 0; i < notes->nr_events; i++) { 2971 double percent; 2972 2973 percent = annotation_data__percent(&al->data[i], percent_type); 2974 2975 obj__set_percent_color(obj, percent, current_entry); 2976 if (symbol_conf.show_total_period) { 2977 obj__printf(obj, "%11" PRIu64 " ", al->data[i].he.period); 2978 } else if (symbol_conf.show_nr_samples) { 2979 obj__printf(obj, "%6" PRIu64 " ", 2980 al->data[i].he.nr_samples); 2981 } else { 2982 obj__printf(obj, "%6.2f ", percent); 2983 } 2984 } 2985 } else { 2986 obj__set_percent_color(obj, 0, current_entry); 2987 2988 if (!show_title) 2989 obj__printf(obj, "%-*s", pcnt_width, " "); 2990 else { 2991 obj__printf(obj, "%-*s", pcnt_width, 2992 symbol_conf.show_total_period ? "Period" : 2993 symbol_conf.show_nr_samples ? "Samples" : "Percent"); 2994 } 2995 } 2996 2997 if (notes->have_cycles) { 2998 if (al->ipc) 2999 obj__printf(obj, "%*.2f ", ANNOTATION__IPC_WIDTH - 1, al->ipc); 3000 else if (!show_title) 3001 obj__printf(obj, "%*s", ANNOTATION__IPC_WIDTH, " "); 3002 else 3003 obj__printf(obj, "%*s ", ANNOTATION__IPC_WIDTH - 1, "IPC"); 3004 3005 if (!notes->options->show_minmax_cycle) { 3006 if (al->cycles) 3007 obj__printf(obj, "%*" PRIu64 " ", 3008 ANNOTATION__CYCLES_WIDTH - 1, al->cycles); 3009 else if (!show_title) 3010 obj__printf(obj, "%*s", 3011 ANNOTATION__CYCLES_WIDTH, " "); 3012 else 3013 obj__printf(obj, "%*s ", 3014 ANNOTATION__CYCLES_WIDTH - 1, 3015 "Cycle"); 3016 } else { 3017 if (al->cycles) { 3018 char str[32]; 3019 3020 scnprintf(str, sizeof(str), 3021 "%" PRIu64 "(%" PRIu64 "/%" PRIu64 ")", 3022 al->cycles, al->cycles_min, 3023 al->cycles_max); 3024 3025 obj__printf(obj, "%*s ", 3026 ANNOTATION__MINMAX_CYCLES_WIDTH - 1, 3027 str); 3028 } else if (!show_title) 3029 obj__printf(obj, "%*s", 3030 ANNOTATION__MINMAX_CYCLES_WIDTH, 3031 " "); 3032 else 3033 obj__printf(obj, "%*s ", 3034 ANNOTATION__MINMAX_CYCLES_WIDTH - 1, 3035 "Cycle(min/max)"); 3036 } 3037 3038 if (show_title && !*al->line) { 3039 ipc_coverage_string(bf, sizeof(bf), notes); 3040 obj__printf(obj, "%*s", ANNOTATION__AVG_IPC_WIDTH, bf); 3041 } 3042 } 3043 3044 obj__printf(obj, " "); 3045 3046 if (!*al->line) 3047 obj__printf(obj, "%-*s", width - pcnt_width - cycles_width, " "); 3048 else if (al->offset == -1) { 3049 if (al->line_nr && notes->options->show_linenr) 3050 printed = scnprintf(bf, sizeof(bf), "%-*d ", notes->widths.addr + 1, al->line_nr); 3051 else 3052 printed = scnprintf(bf, sizeof(bf), "%-*s ", notes->widths.addr, " "); 3053 obj__printf(obj, bf); 3054 obj__printf(obj, "%-*s", width - printed - pcnt_width - cycles_width + 1, al->line); 3055 } else { 3056 u64 addr = al->offset; 3057 int color = -1; 3058 3059 if (!notes->options->use_offset) 3060 addr += notes->start; 3061 3062 if (!notes->options->use_offset) { 3063 printed = scnprintf(bf, sizeof(bf), "%" PRIx64 ": ", addr); 3064 } else { 3065 if (al->jump_sources && 3066 notes->options->offset_level >= ANNOTATION__OFFSET_JUMP_TARGETS) { 3067 if (notes->options->show_nr_jumps) { 3068 int prev; 3069 printed = scnprintf(bf, sizeof(bf), "%*d ", 3070 notes->widths.jumps, 3071 al->jump_sources); 3072 prev = obj__set_jumps_percent_color(obj, al->jump_sources, 3073 current_entry); 3074 obj__printf(obj, bf); 3075 obj__set_color(obj, prev); 3076 } 3077 print_addr: 3078 printed = scnprintf(bf, sizeof(bf), "%*" PRIx64 ": ", 3079 notes->widths.target, addr); 3080 } else if (ins__is_call(&disasm_line(al)->ins) && 3081 notes->options->offset_level >= ANNOTATION__OFFSET_CALL) { 3082 goto print_addr; 3083 } else if (notes->options->offset_level == ANNOTATION__MAX_OFFSET_LEVEL) { 3084 goto print_addr; 3085 } else { 3086 printed = scnprintf(bf, sizeof(bf), "%-*s ", 3087 notes->widths.addr, " "); 3088 } 3089 } 3090 3091 if (change_color) 3092 color = obj__set_color(obj, HE_COLORSET_ADDR); 3093 obj__printf(obj, bf); 3094 if (change_color) 3095 obj__set_color(obj, color); 3096 3097 disasm_line__write(disasm_line(al), notes, obj, bf, sizeof(bf), obj__printf, obj__write_graph); 3098 3099 obj__printf(obj, "%-*s", width - pcnt_width - cycles_width - 3 - printed, bf); 3100 } 3101 3102 } 3103 3104 void annotation_line__write(struct annotation_line *al, struct annotation *notes, 3105 struct annotation_write_ops *wops, 3106 struct annotation_options *opts) 3107 { 3108 __annotation_line__write(al, notes, wops->first_line, wops->current_entry, 3109 wops->change_color, wops->width, wops->obj, 3110 opts->percent_type, 3111 wops->set_color, wops->set_percent_color, 3112 wops->set_jumps_percent_color, wops->printf, 3113 wops->write_graph); 3114 } 3115 3116 int symbol__annotate2(struct map_symbol *ms, struct evsel *evsel, 3117 struct annotation_options *options, struct arch **parch) 3118 { 3119 struct symbol *sym = ms->sym; 3120 struct annotation *notes = symbol__annotation(sym); 3121 size_t size = symbol__size(sym); 3122 int nr_pcnt = 1, err; 3123 3124 notes->offsets = zalloc(size * sizeof(struct annotation_line *)); 3125 if (notes->offsets == NULL) 3126 return ENOMEM; 3127 3128 if (evsel__is_group_event(evsel)) 3129 nr_pcnt = evsel->core.nr_members; 3130 3131 err = symbol__annotate(ms, evsel, options, parch); 3132 if (err) 3133 goto out_free_offsets; 3134 3135 notes->options = options; 3136 3137 symbol__calc_percent(sym, evsel); 3138 3139 annotation__set_offsets(notes, size); 3140 annotation__mark_jump_targets(notes, sym); 3141 annotation__compute_ipc(notes, size); 3142 annotation__init_column_widths(notes, sym); 3143 notes->nr_events = nr_pcnt; 3144 3145 annotation__update_column_widths(notes); 3146 sym->annotate2 = 1; 3147 3148 return 0; 3149 3150 out_free_offsets: 3151 zfree(¬es->offsets); 3152 return err; 3153 } 3154 3155 static int annotation__config(const char *var, const char *value, void *data) 3156 { 3157 struct annotation_options *opt = data; 3158 3159 if (!strstarts(var, "annotate.")) 3160 return 0; 3161 3162 if (!strcmp(var, "annotate.offset_level")) { 3163 perf_config_u8(&opt->offset_level, "offset_level", value); 3164 3165 if (opt->offset_level > ANNOTATION__MAX_OFFSET_LEVEL) 3166 opt->offset_level = ANNOTATION__MAX_OFFSET_LEVEL; 3167 else if (opt->offset_level < ANNOTATION__MIN_OFFSET_LEVEL) 3168 opt->offset_level = ANNOTATION__MIN_OFFSET_LEVEL; 3169 } else if (!strcmp(var, "annotate.hide_src_code")) { 3170 opt->hide_src_code = perf_config_bool("hide_src_code", value); 3171 } else if (!strcmp(var, "annotate.jump_arrows")) { 3172 opt->jump_arrows = perf_config_bool("jump_arrows", value); 3173 } else if (!strcmp(var, "annotate.show_linenr")) { 3174 opt->show_linenr = perf_config_bool("show_linenr", value); 3175 } else if (!strcmp(var, "annotate.show_nr_jumps")) { 3176 opt->show_nr_jumps = perf_config_bool("show_nr_jumps", value); 3177 } else if (!strcmp(var, "annotate.show_nr_samples")) { 3178 symbol_conf.show_nr_samples = perf_config_bool("show_nr_samples", 3179 value); 3180 } else if (!strcmp(var, "annotate.show_total_period")) { 3181 symbol_conf.show_total_period = perf_config_bool("show_total_period", 3182 value); 3183 } else if (!strcmp(var, "annotate.use_offset")) { 3184 opt->use_offset = perf_config_bool("use_offset", value); 3185 } else if (!strcmp(var, "annotate.disassembler_style")) { 3186 opt->disassembler_style = value; 3187 } else if (!strcmp(var, "annotate.demangle")) { 3188 symbol_conf.demangle = perf_config_bool("demangle", value); 3189 } else if (!strcmp(var, "annotate.demangle_kernel")) { 3190 symbol_conf.demangle_kernel = perf_config_bool("demangle_kernel", value); 3191 } else { 3192 pr_debug("%s variable unknown, ignoring...", var); 3193 } 3194 3195 return 0; 3196 } 3197 3198 void annotation_config__init(struct annotation_options *opt) 3199 { 3200 perf_config(annotation__config, opt); 3201 } 3202 3203 static unsigned int parse_percent_type(char *str1, char *str2) 3204 { 3205 unsigned int type = (unsigned int) -1; 3206 3207 if (!strcmp("period", str1)) { 3208 if (!strcmp("local", str2)) 3209 type = PERCENT_PERIOD_LOCAL; 3210 else if (!strcmp("global", str2)) 3211 type = PERCENT_PERIOD_GLOBAL; 3212 } 3213 3214 if (!strcmp("hits", str1)) { 3215 if (!strcmp("local", str2)) 3216 type = PERCENT_HITS_LOCAL; 3217 else if (!strcmp("global", str2)) 3218 type = PERCENT_HITS_GLOBAL; 3219 } 3220 3221 return type; 3222 } 3223 3224 int annotate_parse_percent_type(const struct option *opt, const char *_str, 3225 int unset __maybe_unused) 3226 { 3227 struct annotation_options *opts = opt->value; 3228 unsigned int type; 3229 char *str1, *str2; 3230 int err = -1; 3231 3232 str1 = strdup(_str); 3233 if (!str1) 3234 return -ENOMEM; 3235 3236 str2 = strchr(str1, '-'); 3237 if (!str2) 3238 goto out; 3239 3240 *str2++ = 0; 3241 3242 type = parse_percent_type(str1, str2); 3243 if (type == (unsigned int) -1) 3244 type = parse_percent_type(str2, str1); 3245 if (type != (unsigned int) -1) { 3246 opts->percent_type = type; 3247 err = 0; 3248 } 3249 3250 out: 3251 free(str1); 3252 return err; 3253 } 3254 3255 int annotate_check_args(struct annotation_options *args) 3256 { 3257 if (args->prefix_strip && !args->prefix) { 3258 pr_err("--prefix-strip requires --prefix\n"); 3259 return -1; 3260 } 3261 return 0; 3262 } 3263