1 // SPDX-License-Identifier: GPL-2.0-only 2 #include <ctype.h> 3 #include <errno.h> 4 #include <fcntl.h> 5 #include <inttypes.h> 6 #include <libgen.h> 7 #include <regex.h> 8 #include <stdlib.h> 9 #include <unistd.h> 10 11 #include <linux/string.h> 12 #include <subcmd/run-command.h> 13 14 #include "annotate.h" 15 #include "build-id.h" 16 #include "debug.h" 17 #include "disasm.h" 18 #include "dso.h" 19 #include "env.h" 20 #include "evsel.h" 21 #include "map.h" 22 #include "maps.h" 23 #include "namespaces.h" 24 #include "srcline.h" 25 #include "symbol.h" 26 #include "util.h" 27 28 static regex_t file_lineno; 29 30 /* These can be referred from the arch-dependent code */ 31 static struct ins_ops call_ops; 32 static struct ins_ops dec_ops; 33 static struct ins_ops jump_ops; 34 static struct ins_ops mov_ops; 35 static struct ins_ops nop_ops; 36 static struct ins_ops lock_ops; 37 static struct ins_ops ret_ops; 38 39 static int jump__scnprintf(struct ins *ins, char *bf, size_t size, 40 struct ins_operands *ops, int max_ins_name); 41 static int call__scnprintf(struct ins *ins, char *bf, size_t size, 42 struct ins_operands *ops, int max_ins_name); 43 44 static void ins__sort(struct arch *arch); 45 static int disasm_line__parse(char *line, const char **namep, char **rawp); 46 47 static __attribute__((constructor)) void symbol__init_regexpr(void) 48 { 49 regcomp(&file_lineno, "^/[^:]+:([0-9]+)", REG_EXTENDED); 50 } 51 52 static int arch__grow_instructions(struct arch *arch) 53 { 54 struct ins *new_instructions; 55 size_t new_nr_allocated; 56 57 if (arch->nr_instructions_allocated == 0 && arch->instructions) 58 goto grow_from_non_allocated_table; 59 60 new_nr_allocated = arch->nr_instructions_allocated + 128; 61 new_instructions = realloc(arch->instructions, new_nr_allocated * sizeof(struct ins)); 62 if (new_instructions == NULL) 63 return -1; 64 65 out_update_instructions: 66 arch->instructions = new_instructions; 67 arch->nr_instructions_allocated = new_nr_allocated; 68 return 0; 69 70 grow_from_non_allocated_table: 71 new_nr_allocated = arch->nr_instructions + 128; 72 new_instructions = calloc(new_nr_allocated, sizeof(struct ins)); 73 if (new_instructions == NULL) 74 return -1; 75 76 memcpy(new_instructions, arch->instructions, arch->nr_instructions); 77 goto out_update_instructions; 78 } 79 80 static int arch__associate_ins_ops(struct arch* arch, const char *name, struct ins_ops *ops) 81 { 82 struct ins *ins; 83 84 if (arch->nr_instructions == arch->nr_instructions_allocated && 85 arch__grow_instructions(arch)) 86 return -1; 87 88 ins = &arch->instructions[arch->nr_instructions]; 89 ins->name = strdup(name); 90 if (!ins->name) 91 return -1; 92 93 ins->ops = ops; 94 arch->nr_instructions++; 95 96 ins__sort(arch); 97 return 0; 98 } 99 100 #include "arch/arc/annotate/instructions.c" 101 #include "arch/arm/annotate/instructions.c" 102 #include "arch/arm64/annotate/instructions.c" 103 #include "arch/csky/annotate/instructions.c" 104 #include "arch/loongarch/annotate/instructions.c" 105 #include "arch/mips/annotate/instructions.c" 106 #include "arch/x86/annotate/instructions.c" 107 #include "arch/powerpc/annotate/instructions.c" 108 #include "arch/riscv64/annotate/instructions.c" 109 #include "arch/s390/annotate/instructions.c" 110 #include "arch/sparc/annotate/instructions.c" 111 112 static struct arch architectures[] = { 113 { 114 .name = "arc", 115 .init = arc__annotate_init, 116 }, 117 { 118 .name = "arm", 119 .init = arm__annotate_init, 120 }, 121 { 122 .name = "arm64", 123 .init = arm64__annotate_init, 124 }, 125 { 126 .name = "csky", 127 .init = csky__annotate_init, 128 }, 129 { 130 .name = "mips", 131 .init = mips__annotate_init, 132 .objdump = { 133 .comment_char = '#', 134 }, 135 }, 136 { 137 .name = "x86", 138 .init = x86__annotate_init, 139 .instructions = x86__instructions, 140 .nr_instructions = ARRAY_SIZE(x86__instructions), 141 .insn_suffix = "bwlq", 142 .objdump = { 143 .comment_char = '#', 144 .register_char = '%', 145 .memory_ref_char = '(', 146 .imm_char = '$', 147 }, 148 }, 149 { 150 .name = "powerpc", 151 .init = powerpc__annotate_init, 152 }, 153 { 154 .name = "riscv64", 155 .init = riscv64__annotate_init, 156 }, 157 { 158 .name = "s390", 159 .init = s390__annotate_init, 160 .objdump = { 161 .comment_char = '#', 162 }, 163 }, 164 { 165 .name = "sparc", 166 .init = sparc__annotate_init, 167 .objdump = { 168 .comment_char = '#', 169 }, 170 }, 171 { 172 .name = "loongarch", 173 .init = loongarch__annotate_init, 174 .objdump = { 175 .comment_char = '#', 176 }, 177 }, 178 }; 179 180 static int arch__key_cmp(const void *name, const void *archp) 181 { 182 const struct arch *arch = archp; 183 184 return strcmp(name, arch->name); 185 } 186 187 static int arch__cmp(const void *a, const void *b) 188 { 189 const struct arch *aa = a; 190 const struct arch *ab = b; 191 192 return strcmp(aa->name, ab->name); 193 } 194 195 static void arch__sort(void) 196 { 197 const int nmemb = ARRAY_SIZE(architectures); 198 199 qsort(architectures, nmemb, sizeof(struct arch), arch__cmp); 200 } 201 202 struct arch *arch__find(const char *name) 203 { 204 const int nmemb = ARRAY_SIZE(architectures); 205 static bool sorted; 206 207 if (!sorted) { 208 arch__sort(); 209 sorted = true; 210 } 211 212 return bsearch(name, architectures, nmemb, sizeof(struct arch), arch__key_cmp); 213 } 214 215 bool arch__is(struct arch *arch, const char *name) 216 { 217 return !strcmp(arch->name, name); 218 } 219 220 static void ins_ops__delete(struct ins_operands *ops) 221 { 222 if (ops == NULL) 223 return; 224 zfree(&ops->source.raw); 225 zfree(&ops->source.name); 226 zfree(&ops->target.raw); 227 zfree(&ops->target.name); 228 } 229 230 static int ins__raw_scnprintf(struct ins *ins, char *bf, size_t size, 231 struct ins_operands *ops, int max_ins_name) 232 { 233 return scnprintf(bf, size, "%-*s %s", max_ins_name, ins->name, ops->raw); 234 } 235 236 int ins__scnprintf(struct ins *ins, char *bf, size_t size, 237 struct ins_operands *ops, int max_ins_name) 238 { 239 if (ins->ops->scnprintf) 240 return ins->ops->scnprintf(ins, bf, size, ops, max_ins_name); 241 242 return ins__raw_scnprintf(ins, bf, size, ops, max_ins_name); 243 } 244 245 bool ins__is_fused(struct arch *arch, const char *ins1, const char *ins2) 246 { 247 if (!arch || !arch->ins_is_fused) 248 return false; 249 250 return arch->ins_is_fused(arch, ins1, ins2); 251 } 252 253 static int call__parse(struct arch *arch, struct ins_operands *ops, struct map_symbol *ms) 254 { 255 char *endptr, *tok, *name; 256 struct map *map = ms->map; 257 struct addr_map_symbol target = { 258 .ms = { .map = map, }, 259 }; 260 261 ops->target.addr = strtoull(ops->raw, &endptr, 16); 262 263 name = strchr(endptr, '<'); 264 if (name == NULL) 265 goto indirect_call; 266 267 name++; 268 269 if (arch->objdump.skip_functions_char && 270 strchr(name, arch->objdump.skip_functions_char)) 271 return -1; 272 273 tok = strchr(name, '>'); 274 if (tok == NULL) 275 return -1; 276 277 *tok = '\0'; 278 ops->target.name = strdup(name); 279 *tok = '>'; 280 281 if (ops->target.name == NULL) 282 return -1; 283 find_target: 284 target.addr = map__objdump_2mem(map, ops->target.addr); 285 286 if (maps__find_ams(ms->maps, &target) == 0 && 287 map__rip_2objdump(target.ms.map, map__map_ip(target.ms.map, target.addr)) == ops->target.addr) 288 ops->target.sym = target.ms.sym; 289 290 return 0; 291 292 indirect_call: 293 tok = strchr(endptr, '*'); 294 if (tok != NULL) { 295 endptr++; 296 297 /* Indirect call can use a non-rip register and offset: callq *0x8(%rbx). 298 * Do not parse such instruction. */ 299 if (strstr(endptr, "(%r") == NULL) 300 ops->target.addr = strtoull(endptr, NULL, 16); 301 } 302 goto find_target; 303 } 304 305 static int call__scnprintf(struct ins *ins, char *bf, size_t size, 306 struct ins_operands *ops, int max_ins_name) 307 { 308 if (ops->target.sym) 309 return scnprintf(bf, size, "%-*s %s", max_ins_name, ins->name, ops->target.sym->name); 310 311 if (ops->target.addr == 0) 312 return ins__raw_scnprintf(ins, bf, size, ops, max_ins_name); 313 314 if (ops->target.name) 315 return scnprintf(bf, size, "%-*s %s", max_ins_name, ins->name, ops->target.name); 316 317 return scnprintf(bf, size, "%-*s *%" PRIx64, max_ins_name, ins->name, ops->target.addr); 318 } 319 320 static struct ins_ops call_ops = { 321 .parse = call__parse, 322 .scnprintf = call__scnprintf, 323 }; 324 325 bool ins__is_call(const struct ins *ins) 326 { 327 return ins->ops == &call_ops || ins->ops == &s390_call_ops || ins->ops == &loongarch_call_ops; 328 } 329 330 /* 331 * Prevents from matching commas in the comment section, e.g.: 332 * ffff200008446e70: b.cs ffff2000084470f4 <generic_exec_single+0x314> // b.hs, b.nlast 333 * 334 * and skip comma as part of function arguments, e.g.: 335 * 1d8b4ac <linemap_lookup(line_maps const*, unsigned int)+0xcc> 336 */ 337 static inline const char *validate_comma(const char *c, struct ins_operands *ops) 338 { 339 if (ops->jump.raw_comment && c > ops->jump.raw_comment) 340 return NULL; 341 342 if (ops->jump.raw_func_start && c > ops->jump.raw_func_start) 343 return NULL; 344 345 return c; 346 } 347 348 static int jump__parse(struct arch *arch, struct ins_operands *ops, struct map_symbol *ms) 349 { 350 struct map *map = ms->map; 351 struct symbol *sym = ms->sym; 352 struct addr_map_symbol target = { 353 .ms = { .map = map, }, 354 }; 355 const char *c = strchr(ops->raw, ','); 356 u64 start, end; 357 358 ops->jump.raw_comment = strchr(ops->raw, arch->objdump.comment_char); 359 ops->jump.raw_func_start = strchr(ops->raw, '<'); 360 361 c = validate_comma(c, ops); 362 363 /* 364 * Examples of lines to parse for the _cpp_lex_token@@Base 365 * function: 366 * 367 * 1159e6c: jne 115aa32 <_cpp_lex_token@@Base+0xf92> 368 * 1159e8b: jne c469be <cpp_named_operator2name@@Base+0xa72> 369 * 370 * The first is a jump to an offset inside the same function, 371 * the second is to another function, i.e. that 0xa72 is an 372 * offset in the cpp_named_operator2name@@base function. 373 */ 374 /* 375 * skip over possible up to 2 operands to get to address, e.g.: 376 * tbnz w0, #26, ffff0000083cd190 <security_file_permission+0xd0> 377 */ 378 if (c++ != NULL) { 379 ops->target.addr = strtoull(c, NULL, 16); 380 if (!ops->target.addr) { 381 c = strchr(c, ','); 382 c = validate_comma(c, ops); 383 if (c++ != NULL) 384 ops->target.addr = strtoull(c, NULL, 16); 385 } 386 } else { 387 ops->target.addr = strtoull(ops->raw, NULL, 16); 388 } 389 390 target.addr = map__objdump_2mem(map, ops->target.addr); 391 start = map__unmap_ip(map, sym->start); 392 end = map__unmap_ip(map, sym->end); 393 394 ops->target.outside = target.addr < start || target.addr > end; 395 396 /* 397 * FIXME: things like this in _cpp_lex_token (gcc's cc1 program): 398 399 cpp_named_operator2name@@Base+0xa72 400 401 * Point to a place that is after the cpp_named_operator2name 402 * boundaries, i.e. in the ELF symbol table for cc1 403 * cpp_named_operator2name is marked as being 32-bytes long, but it in 404 * fact is much larger than that, so we seem to need a symbols__find() 405 * routine that looks for >= current->start and < next_symbol->start, 406 * possibly just for C++ objects? 407 * 408 * For now lets just make some progress by marking jumps to outside the 409 * current function as call like. 410 * 411 * Actual navigation will come next, with further understanding of how 412 * the symbol searching and disassembly should be done. 413 */ 414 if (maps__find_ams(ms->maps, &target) == 0 && 415 map__rip_2objdump(target.ms.map, map__map_ip(target.ms.map, target.addr)) == ops->target.addr) 416 ops->target.sym = target.ms.sym; 417 418 if (!ops->target.outside) { 419 ops->target.offset = target.addr - start; 420 ops->target.offset_avail = true; 421 } else { 422 ops->target.offset_avail = false; 423 } 424 425 return 0; 426 } 427 428 static int jump__scnprintf(struct ins *ins, char *bf, size_t size, 429 struct ins_operands *ops, int max_ins_name) 430 { 431 const char *c; 432 433 if (!ops->target.addr || ops->target.offset < 0) 434 return ins__raw_scnprintf(ins, bf, size, ops, max_ins_name); 435 436 if (ops->target.outside && ops->target.sym != NULL) 437 return scnprintf(bf, size, "%-*s %s", max_ins_name, ins->name, ops->target.sym->name); 438 439 c = strchr(ops->raw, ','); 440 c = validate_comma(c, ops); 441 442 if (c != NULL) { 443 const char *c2 = strchr(c + 1, ','); 444 445 c2 = validate_comma(c2, ops); 446 /* check for 3-op insn */ 447 if (c2 != NULL) 448 c = c2; 449 c++; 450 451 /* mirror arch objdump's space-after-comma style */ 452 if (*c == ' ') 453 c++; 454 } 455 456 return scnprintf(bf, size, "%-*s %.*s%" PRIx64, max_ins_name, 457 ins->name, c ? c - ops->raw : 0, ops->raw, 458 ops->target.offset); 459 } 460 461 static void jump__delete(struct ins_operands *ops __maybe_unused) 462 { 463 /* 464 * The ops->jump.raw_comment and ops->jump.raw_func_start belong to the 465 * raw string, don't free them. 466 */ 467 } 468 469 static struct ins_ops jump_ops = { 470 .free = jump__delete, 471 .parse = jump__parse, 472 .scnprintf = jump__scnprintf, 473 }; 474 475 bool ins__is_jump(const struct ins *ins) 476 { 477 return ins->ops == &jump_ops || ins->ops == &loongarch_jump_ops; 478 } 479 480 static int comment__symbol(char *raw, char *comment, u64 *addrp, char **namep) 481 { 482 char *endptr, *name, *t; 483 484 if (strstr(raw, "(%rip)") == NULL) 485 return 0; 486 487 *addrp = strtoull(comment, &endptr, 16); 488 if (endptr == comment) 489 return 0; 490 name = strchr(endptr, '<'); 491 if (name == NULL) 492 return -1; 493 494 name++; 495 496 t = strchr(name, '>'); 497 if (t == NULL) 498 return 0; 499 500 *t = '\0'; 501 *namep = strdup(name); 502 *t = '>'; 503 504 return 0; 505 } 506 507 static int lock__parse(struct arch *arch, struct ins_operands *ops, struct map_symbol *ms) 508 { 509 ops->locked.ops = zalloc(sizeof(*ops->locked.ops)); 510 if (ops->locked.ops == NULL) 511 return 0; 512 513 if (disasm_line__parse(ops->raw, &ops->locked.ins.name, &ops->locked.ops->raw) < 0) 514 goto out_free_ops; 515 516 ops->locked.ins.ops = ins__find(arch, ops->locked.ins.name); 517 518 if (ops->locked.ins.ops == NULL) 519 goto out_free_ops; 520 521 if (ops->locked.ins.ops->parse && 522 ops->locked.ins.ops->parse(arch, ops->locked.ops, ms) < 0) 523 goto out_free_ops; 524 525 return 0; 526 527 out_free_ops: 528 zfree(&ops->locked.ops); 529 return 0; 530 } 531 532 static int lock__scnprintf(struct ins *ins, char *bf, size_t size, 533 struct ins_operands *ops, int max_ins_name) 534 { 535 int printed; 536 537 if (ops->locked.ins.ops == NULL) 538 return ins__raw_scnprintf(ins, bf, size, ops, max_ins_name); 539 540 printed = scnprintf(bf, size, "%-*s ", max_ins_name, ins->name); 541 return printed + ins__scnprintf(&ops->locked.ins, bf + printed, 542 size - printed, ops->locked.ops, max_ins_name); 543 } 544 545 static void lock__delete(struct ins_operands *ops) 546 { 547 struct ins *ins = &ops->locked.ins; 548 549 if (ins->ops && ins->ops->free) 550 ins->ops->free(ops->locked.ops); 551 else 552 ins_ops__delete(ops->locked.ops); 553 554 zfree(&ops->locked.ops); 555 zfree(&ops->target.raw); 556 zfree(&ops->target.name); 557 } 558 559 static struct ins_ops lock_ops = { 560 .free = lock__delete, 561 .parse = lock__parse, 562 .scnprintf = lock__scnprintf, 563 }; 564 565 /* 566 * Check if the operand has more than one registers like x86 SIB addressing: 567 * 0x1234(%rax, %rbx, 8) 568 * 569 * But it doesn't care segment selectors like %gs:0x5678(%rcx), so just check 570 * the input string after 'memory_ref_char' if exists. 571 */ 572 static bool check_multi_regs(struct arch *arch, const char *op) 573 { 574 int count = 0; 575 576 if (arch->objdump.register_char == 0) 577 return false; 578 579 if (arch->objdump.memory_ref_char) { 580 op = strchr(op, arch->objdump.memory_ref_char); 581 if (op == NULL) 582 return false; 583 } 584 585 while ((op = strchr(op, arch->objdump.register_char)) != NULL) { 586 count++; 587 op++; 588 } 589 590 return count > 1; 591 } 592 593 static int mov__parse(struct arch *arch, struct ins_operands *ops, struct map_symbol *ms __maybe_unused) 594 { 595 char *s = strchr(ops->raw, ','), *target, *comment, prev; 596 597 if (s == NULL) 598 return -1; 599 600 *s = '\0'; 601 602 /* 603 * x86 SIB addressing has something like 0x8(%rax, %rcx, 1) 604 * then it needs to have the closing parenthesis. 605 */ 606 if (strchr(ops->raw, '(')) { 607 *s = ','; 608 s = strchr(ops->raw, ')'); 609 if (s == NULL || s[1] != ',') 610 return -1; 611 *++s = '\0'; 612 } 613 614 ops->source.raw = strdup(ops->raw); 615 *s = ','; 616 617 if (ops->source.raw == NULL) 618 return -1; 619 620 ops->source.multi_regs = check_multi_regs(arch, ops->source.raw); 621 622 target = skip_spaces(++s); 623 comment = strchr(s, arch->objdump.comment_char); 624 625 if (comment != NULL) 626 s = comment - 1; 627 else 628 s = strchr(s, '\0') - 1; 629 630 while (s > target && isspace(s[0])) 631 --s; 632 s++; 633 prev = *s; 634 *s = '\0'; 635 636 ops->target.raw = strdup(target); 637 *s = prev; 638 639 if (ops->target.raw == NULL) 640 goto out_free_source; 641 642 ops->target.multi_regs = check_multi_regs(arch, ops->target.raw); 643 644 if (comment == NULL) 645 return 0; 646 647 comment = skip_spaces(comment); 648 comment__symbol(ops->source.raw, comment + 1, &ops->source.addr, &ops->source.name); 649 comment__symbol(ops->target.raw, comment + 1, &ops->target.addr, &ops->target.name); 650 651 return 0; 652 653 out_free_source: 654 zfree(&ops->source.raw); 655 return -1; 656 } 657 658 static int mov__scnprintf(struct ins *ins, char *bf, size_t size, 659 struct ins_operands *ops, int max_ins_name) 660 { 661 return scnprintf(bf, size, "%-*s %s,%s", max_ins_name, ins->name, 662 ops->source.name ?: ops->source.raw, 663 ops->target.name ?: ops->target.raw); 664 } 665 666 static struct ins_ops mov_ops = { 667 .parse = mov__parse, 668 .scnprintf = mov__scnprintf, 669 }; 670 671 static int dec__parse(struct arch *arch __maybe_unused, struct ins_operands *ops, struct map_symbol *ms __maybe_unused) 672 { 673 char *target, *comment, *s, prev; 674 675 target = s = ops->raw; 676 677 while (s[0] != '\0' && !isspace(s[0])) 678 ++s; 679 prev = *s; 680 *s = '\0'; 681 682 ops->target.raw = strdup(target); 683 *s = prev; 684 685 if (ops->target.raw == NULL) 686 return -1; 687 688 comment = strchr(s, arch->objdump.comment_char); 689 if (comment == NULL) 690 return 0; 691 692 comment = skip_spaces(comment); 693 comment__symbol(ops->target.raw, comment + 1, &ops->target.addr, &ops->target.name); 694 695 return 0; 696 } 697 698 static int dec__scnprintf(struct ins *ins, char *bf, size_t size, 699 struct ins_operands *ops, int max_ins_name) 700 { 701 return scnprintf(bf, size, "%-*s %s", max_ins_name, ins->name, 702 ops->target.name ?: ops->target.raw); 703 } 704 705 static struct ins_ops dec_ops = { 706 .parse = dec__parse, 707 .scnprintf = dec__scnprintf, 708 }; 709 710 static int nop__scnprintf(struct ins *ins __maybe_unused, char *bf, size_t size, 711 struct ins_operands *ops __maybe_unused, int max_ins_name) 712 { 713 return scnprintf(bf, size, "%-*s", max_ins_name, "nop"); 714 } 715 716 static struct ins_ops nop_ops = { 717 .scnprintf = nop__scnprintf, 718 }; 719 720 static struct ins_ops ret_ops = { 721 .scnprintf = ins__raw_scnprintf, 722 }; 723 724 bool ins__is_nop(const struct ins *ins) 725 { 726 return ins->ops == &nop_ops; 727 } 728 729 bool ins__is_ret(const struct ins *ins) 730 { 731 return ins->ops == &ret_ops; 732 } 733 734 bool ins__is_lock(const struct ins *ins) 735 { 736 return ins->ops == &lock_ops; 737 } 738 739 static int ins__key_cmp(const void *name, const void *insp) 740 { 741 const struct ins *ins = insp; 742 743 return strcmp(name, ins->name); 744 } 745 746 static int ins__cmp(const void *a, const void *b) 747 { 748 const struct ins *ia = a; 749 const struct ins *ib = b; 750 751 return strcmp(ia->name, ib->name); 752 } 753 754 static void ins__sort(struct arch *arch) 755 { 756 const int nmemb = arch->nr_instructions; 757 758 qsort(arch->instructions, nmemb, sizeof(struct ins), ins__cmp); 759 } 760 761 static struct ins_ops *__ins__find(struct arch *arch, const char *name) 762 { 763 struct ins *ins; 764 const int nmemb = arch->nr_instructions; 765 766 if (!arch->sorted_instructions) { 767 ins__sort(arch); 768 arch->sorted_instructions = true; 769 } 770 771 ins = bsearch(name, arch->instructions, nmemb, sizeof(struct ins), ins__key_cmp); 772 if (ins) 773 return ins->ops; 774 775 if (arch->insn_suffix) { 776 char tmp[32]; 777 char suffix; 778 size_t len = strlen(name); 779 780 if (len == 0 || len >= sizeof(tmp)) 781 return NULL; 782 783 suffix = name[len - 1]; 784 if (strchr(arch->insn_suffix, suffix) == NULL) 785 return NULL; 786 787 strcpy(tmp, name); 788 tmp[len - 1] = '\0'; /* remove the suffix and check again */ 789 790 ins = bsearch(tmp, arch->instructions, nmemb, sizeof(struct ins), ins__key_cmp); 791 } 792 return ins ? ins->ops : NULL; 793 } 794 795 struct ins_ops *ins__find(struct arch *arch, const char *name) 796 { 797 struct ins_ops *ops = __ins__find(arch, name); 798 799 if (!ops && arch->associate_instruction_ops) 800 ops = arch->associate_instruction_ops(arch, name); 801 802 return ops; 803 } 804 805 static void disasm_line__init_ins(struct disasm_line *dl, struct arch *arch, struct map_symbol *ms) 806 { 807 dl->ins.ops = ins__find(arch, dl->ins.name); 808 809 if (!dl->ins.ops) 810 return; 811 812 if (dl->ins.ops->parse && dl->ins.ops->parse(arch, &dl->ops, ms) < 0) 813 dl->ins.ops = NULL; 814 } 815 816 static int disasm_line__parse(char *line, const char **namep, char **rawp) 817 { 818 char tmp, *name = skip_spaces(line); 819 820 if (name[0] == '\0') 821 return -1; 822 823 *rawp = name + 1; 824 825 while ((*rawp)[0] != '\0' && !isspace((*rawp)[0])) 826 ++*rawp; 827 828 tmp = (*rawp)[0]; 829 (*rawp)[0] = '\0'; 830 *namep = strdup(name); 831 832 if (*namep == NULL) 833 goto out; 834 835 (*rawp)[0] = tmp; 836 *rawp = strim(*rawp); 837 838 return 0; 839 840 out: 841 return -1; 842 } 843 844 static void annotation_line__init(struct annotation_line *al, 845 struct annotate_args *args, 846 int nr) 847 { 848 al->offset = args->offset; 849 al->line = strdup(args->line); 850 al->line_nr = args->line_nr; 851 al->fileloc = args->fileloc; 852 al->data_nr = nr; 853 } 854 855 static void annotation_line__exit(struct annotation_line *al) 856 { 857 zfree_srcline(&al->path); 858 zfree(&al->line); 859 zfree(&al->cycles); 860 } 861 862 static size_t disasm_line_size(int nr) 863 { 864 struct annotation_line *al; 865 866 return (sizeof(struct disasm_line) + (sizeof(al->data[0]) * nr)); 867 } 868 869 /* 870 * Allocating the disasm annotation line data with 871 * following structure: 872 * 873 * ------------------------------------------- 874 * struct disasm_line | struct annotation_line 875 * ------------------------------------------- 876 * 877 * We have 'struct annotation_line' member as last member 878 * of 'struct disasm_line' to have an easy access. 879 */ 880 struct disasm_line *disasm_line__new(struct annotate_args *args) 881 { 882 struct disasm_line *dl = NULL; 883 int nr = 1; 884 885 if (evsel__is_group_event(args->evsel)) 886 nr = args->evsel->core.nr_members; 887 888 dl = zalloc(disasm_line_size(nr)); 889 if (!dl) 890 return NULL; 891 892 annotation_line__init(&dl->al, args, nr); 893 if (dl->al.line == NULL) 894 goto out_delete; 895 896 if (args->offset != -1) { 897 if (disasm_line__parse(dl->al.line, &dl->ins.name, &dl->ops.raw) < 0) 898 goto out_free_line; 899 900 disasm_line__init_ins(dl, args->arch, &args->ms); 901 } 902 903 return dl; 904 905 out_free_line: 906 zfree(&dl->al.line); 907 out_delete: 908 free(dl); 909 return NULL; 910 } 911 912 void disasm_line__free(struct disasm_line *dl) 913 { 914 if (dl->ins.ops && dl->ins.ops->free) 915 dl->ins.ops->free(&dl->ops); 916 else 917 ins_ops__delete(&dl->ops); 918 zfree(&dl->ins.name); 919 annotation_line__exit(&dl->al); 920 free(dl); 921 } 922 923 int disasm_line__scnprintf(struct disasm_line *dl, char *bf, size_t size, bool raw, int max_ins_name) 924 { 925 if (raw || !dl->ins.ops) 926 return scnprintf(bf, size, "%-*s %s", max_ins_name, dl->ins.name, dl->ops.raw); 927 928 return ins__scnprintf(&dl->ins, bf, size, &dl->ops, max_ins_name); 929 } 930 931 /* 932 * symbol__parse_objdump_line() parses objdump output (with -d --no-show-raw) 933 * which looks like following 934 * 935 * 0000000000415500 <_init>: 936 * 415500: sub $0x8,%rsp 937 * 415504: mov 0x2f5ad5(%rip),%rax # 70afe0 <_DYNAMIC+0x2f8> 938 * 41550b: test %rax,%rax 939 * 41550e: je 415515 <_init+0x15> 940 * 415510: callq 416e70 <__gmon_start__@plt> 941 * 415515: add $0x8,%rsp 942 * 415519: retq 943 * 944 * it will be parsed and saved into struct disasm_line as 945 * <offset> <name> <ops.raw> 946 * 947 * The offset will be a relative offset from the start of the symbol and -1 948 * means that it's not a disassembly line so should be treated differently. 949 * The ops.raw part will be parsed further according to type of the instruction. 950 */ 951 static int symbol__parse_objdump_line(struct symbol *sym, 952 struct annotate_args *args, 953 char *parsed_line, int *line_nr, char **fileloc) 954 { 955 struct map *map = args->ms.map; 956 struct annotation *notes = symbol__annotation(sym); 957 struct disasm_line *dl; 958 char *tmp; 959 s64 line_ip, offset = -1; 960 regmatch_t match[2]; 961 962 /* /filename:linenr ? Save line number and ignore. */ 963 if (regexec(&file_lineno, parsed_line, 2, match, 0) == 0) { 964 *line_nr = atoi(parsed_line + match[1].rm_so); 965 free(*fileloc); 966 *fileloc = strdup(parsed_line); 967 return 0; 968 } 969 970 /* Process hex address followed by ':'. */ 971 line_ip = strtoull(parsed_line, &tmp, 16); 972 if (parsed_line != tmp && tmp[0] == ':' && tmp[1] != '\0') { 973 u64 start = map__rip_2objdump(map, sym->start), 974 end = map__rip_2objdump(map, sym->end); 975 976 offset = line_ip - start; 977 if ((u64)line_ip < start || (u64)line_ip >= end) 978 offset = -1; 979 else 980 parsed_line = tmp + 1; 981 } 982 983 args->offset = offset; 984 args->line = parsed_line; 985 args->line_nr = *line_nr; 986 args->fileloc = *fileloc; 987 args->ms.sym = sym; 988 989 dl = disasm_line__new(args); 990 (*line_nr)++; 991 992 if (dl == NULL) 993 return -1; 994 995 if (!disasm_line__has_local_offset(dl)) { 996 dl->ops.target.offset = dl->ops.target.addr - 997 map__rip_2objdump(map, sym->start); 998 dl->ops.target.offset_avail = true; 999 } 1000 1001 /* kcore has no symbols, so add the call target symbol */ 1002 if (dl->ins.ops && ins__is_call(&dl->ins) && !dl->ops.target.sym) { 1003 struct addr_map_symbol target = { 1004 .addr = dl->ops.target.addr, 1005 .ms = { .map = map, }, 1006 }; 1007 1008 if (!maps__find_ams(args->ms.maps, &target) && 1009 target.ms.sym->start == target.al_addr) 1010 dl->ops.target.sym = target.ms.sym; 1011 } 1012 1013 annotation_line__add(&dl->al, ¬es->src->source); 1014 return 0; 1015 } 1016 1017 static void delete_last_nop(struct symbol *sym) 1018 { 1019 struct annotation *notes = symbol__annotation(sym); 1020 struct list_head *list = ¬es->src->source; 1021 struct disasm_line *dl; 1022 1023 while (!list_empty(list)) { 1024 dl = list_entry(list->prev, struct disasm_line, al.node); 1025 1026 if (dl->ins.ops) { 1027 if (!ins__is_nop(&dl->ins)) 1028 return; 1029 } else { 1030 if (!strstr(dl->al.line, " nop ") && 1031 !strstr(dl->al.line, " nopl ") && 1032 !strstr(dl->al.line, " nopw ")) 1033 return; 1034 } 1035 1036 list_del_init(&dl->al.node); 1037 disasm_line__free(dl); 1038 } 1039 } 1040 1041 int symbol__strerror_disassemble(struct map_symbol *ms, int errnum, char *buf, size_t buflen) 1042 { 1043 struct dso *dso = map__dso(ms->map); 1044 1045 BUG_ON(buflen == 0); 1046 1047 if (errnum >= 0) { 1048 str_error_r(errnum, buf, buflen); 1049 return 0; 1050 } 1051 1052 switch (errnum) { 1053 case SYMBOL_ANNOTATE_ERRNO__NO_VMLINUX: { 1054 char bf[SBUILD_ID_SIZE + 15] = " with build id "; 1055 char *build_id_msg = NULL; 1056 1057 if (dso__has_build_id(dso)) { 1058 build_id__sprintf(dso__bid(dso), bf + 15); 1059 build_id_msg = bf; 1060 } 1061 scnprintf(buf, buflen, 1062 "No vmlinux file%s\nwas found in the path.\n\n" 1063 "Note that annotation using /proc/kcore requires CAP_SYS_RAWIO capability.\n\n" 1064 "Please use:\n\n" 1065 " perf buildid-cache -vu vmlinux\n\n" 1066 "or:\n\n" 1067 " --vmlinux vmlinux\n", build_id_msg ?: ""); 1068 } 1069 break; 1070 case SYMBOL_ANNOTATE_ERRNO__NO_LIBOPCODES_FOR_BPF: 1071 scnprintf(buf, buflen, "Please link with binutils's libopcode to enable BPF annotation"); 1072 break; 1073 case SYMBOL_ANNOTATE_ERRNO__ARCH_INIT_REGEXP: 1074 scnprintf(buf, buflen, "Problems with arch specific instruction name regular expressions."); 1075 break; 1076 case SYMBOL_ANNOTATE_ERRNO__ARCH_INIT_CPUID_PARSING: 1077 scnprintf(buf, buflen, "Problems while parsing the CPUID in the arch specific initialization."); 1078 break; 1079 case SYMBOL_ANNOTATE_ERRNO__BPF_INVALID_FILE: 1080 scnprintf(buf, buflen, "Invalid BPF file: %s.", dso__long_name(dso)); 1081 break; 1082 case SYMBOL_ANNOTATE_ERRNO__BPF_MISSING_BTF: 1083 scnprintf(buf, buflen, "The %s BPF file has no BTF section, compile with -g or use pahole -J.", 1084 dso__long_name(dso)); 1085 break; 1086 default: 1087 scnprintf(buf, buflen, "Internal error: Invalid %d error code\n", errnum); 1088 break; 1089 } 1090 1091 return 0; 1092 } 1093 1094 static int dso__disassemble_filename(struct dso *dso, char *filename, size_t filename_size) 1095 { 1096 char linkname[PATH_MAX]; 1097 char *build_id_filename; 1098 char *build_id_path = NULL; 1099 char *pos; 1100 int len; 1101 1102 if (dso__symtab_type(dso) == DSO_BINARY_TYPE__KALLSYMS && 1103 !dso__is_kcore(dso)) 1104 return SYMBOL_ANNOTATE_ERRNO__NO_VMLINUX; 1105 1106 build_id_filename = dso__build_id_filename(dso, NULL, 0, false); 1107 if (build_id_filename) { 1108 __symbol__join_symfs(filename, filename_size, build_id_filename); 1109 free(build_id_filename); 1110 } else { 1111 if (dso__has_build_id(dso)) 1112 return ENOMEM; 1113 goto fallback; 1114 } 1115 1116 build_id_path = strdup(filename); 1117 if (!build_id_path) 1118 return ENOMEM; 1119 1120 /* 1121 * old style build-id cache has name of XX/XXXXXXX.. while 1122 * new style has XX/XXXXXXX../{elf,kallsyms,vdso}. 1123 * extract the build-id part of dirname in the new style only. 1124 */ 1125 pos = strrchr(build_id_path, '/'); 1126 if (pos && strlen(pos) < SBUILD_ID_SIZE - 2) 1127 dirname(build_id_path); 1128 1129 if (dso__is_kcore(dso)) 1130 goto fallback; 1131 1132 len = readlink(build_id_path, linkname, sizeof(linkname) - 1); 1133 if (len < 0) 1134 goto fallback; 1135 1136 linkname[len] = '\0'; 1137 if (strstr(linkname, DSO__NAME_KALLSYMS) || 1138 access(filename, R_OK)) { 1139 fallback: 1140 /* 1141 * If we don't have build-ids or the build-id file isn't in the 1142 * cache, or is just a kallsyms file, well, lets hope that this 1143 * DSO is the same as when 'perf record' ran. 1144 */ 1145 if (dso__kernel(dso) && dso__long_name(dso)[0] == '/') 1146 snprintf(filename, filename_size, "%s", dso__long_name(dso)); 1147 else 1148 __symbol__join_symfs(filename, filename_size, dso__long_name(dso)); 1149 1150 mutex_lock(dso__lock(dso)); 1151 if (access(filename, R_OK) && errno == ENOENT && dso__nsinfo(dso)) { 1152 char *new_name = dso__filename_with_chroot(dso, filename); 1153 if (new_name) { 1154 strlcpy(filename, new_name, filename_size); 1155 free(new_name); 1156 } 1157 } 1158 mutex_unlock(dso__lock(dso)); 1159 } else if (dso__binary_type(dso) == DSO_BINARY_TYPE__NOT_FOUND) { 1160 dso__set_binary_type(dso, DSO_BINARY_TYPE__BUILD_ID_CACHE); 1161 } 1162 1163 free(build_id_path); 1164 return 0; 1165 } 1166 1167 #if defined(HAVE_LIBBFD_SUPPORT) && defined(HAVE_LIBBPF_SUPPORT) 1168 #define PACKAGE "perf" 1169 #include <bfd.h> 1170 #include <dis-asm.h> 1171 #include <bpf/bpf.h> 1172 #include <bpf/btf.h> 1173 #include <bpf/libbpf.h> 1174 #include <linux/btf.h> 1175 #include <tools/dis-asm-compat.h> 1176 1177 #include "bpf-event.h" 1178 #include "bpf-utils.h" 1179 1180 static int symbol__disassemble_bpf(struct symbol *sym, 1181 struct annotate_args *args) 1182 { 1183 struct annotation *notes = symbol__annotation(sym); 1184 struct bpf_prog_linfo *prog_linfo = NULL; 1185 struct bpf_prog_info_node *info_node; 1186 int len = sym->end - sym->start; 1187 disassembler_ftype disassemble; 1188 struct map *map = args->ms.map; 1189 struct perf_bpil *info_linear; 1190 struct disassemble_info info; 1191 struct dso *dso = map__dso(map); 1192 int pc = 0, count, sub_id; 1193 struct btf *btf = NULL; 1194 char tpath[PATH_MAX]; 1195 size_t buf_size; 1196 int nr_skip = 0; 1197 char *buf; 1198 bfd *bfdf; 1199 int ret; 1200 FILE *s; 1201 1202 if (dso__binary_type(dso) != DSO_BINARY_TYPE__BPF_PROG_INFO) 1203 return SYMBOL_ANNOTATE_ERRNO__BPF_INVALID_FILE; 1204 1205 pr_debug("%s: handling sym %s addr %" PRIx64 " len %" PRIx64 "\n", __func__, 1206 sym->name, sym->start, sym->end - sym->start); 1207 1208 memset(tpath, 0, sizeof(tpath)); 1209 perf_exe(tpath, sizeof(tpath)); 1210 1211 bfdf = bfd_openr(tpath, NULL); 1212 if (bfdf == NULL) 1213 abort(); 1214 1215 if (!bfd_check_format(bfdf, bfd_object)) 1216 abort(); 1217 1218 s = open_memstream(&buf, &buf_size); 1219 if (!s) { 1220 ret = errno; 1221 goto out; 1222 } 1223 init_disassemble_info_compat(&info, s, 1224 (fprintf_ftype) fprintf, 1225 fprintf_styled); 1226 info.arch = bfd_get_arch(bfdf); 1227 info.mach = bfd_get_mach(bfdf); 1228 1229 info_node = perf_env__find_bpf_prog_info(dso__bpf_prog(dso)->env, 1230 dso__bpf_prog(dso)->id); 1231 if (!info_node) { 1232 ret = SYMBOL_ANNOTATE_ERRNO__BPF_MISSING_BTF; 1233 goto out; 1234 } 1235 info_linear = info_node->info_linear; 1236 sub_id = dso__bpf_prog(dso)->sub_id; 1237 1238 info.buffer = (void *)(uintptr_t)(info_linear->info.jited_prog_insns); 1239 info.buffer_length = info_linear->info.jited_prog_len; 1240 1241 if (info_linear->info.nr_line_info) 1242 prog_linfo = bpf_prog_linfo__new(&info_linear->info); 1243 1244 if (info_linear->info.btf_id) { 1245 struct btf_node *node; 1246 1247 node = perf_env__find_btf(dso__bpf_prog(dso)->env, 1248 info_linear->info.btf_id); 1249 if (node) 1250 btf = btf__new((__u8 *)(node->data), 1251 node->data_size); 1252 } 1253 1254 disassemble_init_for_target(&info); 1255 1256 #ifdef DISASM_FOUR_ARGS_SIGNATURE 1257 disassemble = disassembler(info.arch, 1258 bfd_big_endian(bfdf), 1259 info.mach, 1260 bfdf); 1261 #else 1262 disassemble = disassembler(bfdf); 1263 #endif 1264 if (disassemble == NULL) 1265 abort(); 1266 1267 fflush(s); 1268 do { 1269 const struct bpf_line_info *linfo = NULL; 1270 struct disasm_line *dl; 1271 size_t prev_buf_size; 1272 const char *srcline; 1273 u64 addr; 1274 1275 addr = pc + ((u64 *)(uintptr_t)(info_linear->info.jited_ksyms))[sub_id]; 1276 count = disassemble(pc, &info); 1277 1278 if (prog_linfo) 1279 linfo = bpf_prog_linfo__lfind_addr_func(prog_linfo, 1280 addr, sub_id, 1281 nr_skip); 1282 1283 if (linfo && btf) { 1284 srcline = btf__name_by_offset(btf, linfo->line_off); 1285 nr_skip++; 1286 } else 1287 srcline = NULL; 1288 1289 fprintf(s, "\n"); 1290 prev_buf_size = buf_size; 1291 fflush(s); 1292 1293 if (!annotate_opts.hide_src_code && srcline) { 1294 args->offset = -1; 1295 args->line = strdup(srcline); 1296 args->line_nr = 0; 1297 args->fileloc = NULL; 1298 args->ms.sym = sym; 1299 dl = disasm_line__new(args); 1300 if (dl) { 1301 annotation_line__add(&dl->al, 1302 ¬es->src->source); 1303 } 1304 } 1305 1306 args->offset = pc; 1307 args->line = buf + prev_buf_size; 1308 args->line_nr = 0; 1309 args->fileloc = NULL; 1310 args->ms.sym = sym; 1311 dl = disasm_line__new(args); 1312 if (dl) 1313 annotation_line__add(&dl->al, ¬es->src->source); 1314 1315 pc += count; 1316 } while (count > 0 && pc < len); 1317 1318 ret = 0; 1319 out: 1320 free(prog_linfo); 1321 btf__free(btf); 1322 fclose(s); 1323 bfd_close(bfdf); 1324 return ret; 1325 } 1326 #else // defined(HAVE_LIBBFD_SUPPORT) && defined(HAVE_LIBBPF_SUPPORT) 1327 static int symbol__disassemble_bpf(struct symbol *sym __maybe_unused, 1328 struct annotate_args *args __maybe_unused) 1329 { 1330 return SYMBOL_ANNOTATE_ERRNO__NO_LIBOPCODES_FOR_BPF; 1331 } 1332 #endif // defined(HAVE_LIBBFD_SUPPORT) && defined(HAVE_LIBBPF_SUPPORT) 1333 1334 static int 1335 symbol__disassemble_bpf_image(struct symbol *sym, 1336 struct annotate_args *args) 1337 { 1338 struct annotation *notes = symbol__annotation(sym); 1339 struct disasm_line *dl; 1340 1341 args->offset = -1; 1342 args->line = strdup("to be implemented"); 1343 args->line_nr = 0; 1344 args->fileloc = NULL; 1345 dl = disasm_line__new(args); 1346 if (dl) 1347 annotation_line__add(&dl->al, ¬es->src->source); 1348 1349 zfree(&args->line); 1350 return 0; 1351 } 1352 1353 #ifdef HAVE_LIBCAPSTONE_SUPPORT 1354 #include <capstone/capstone.h> 1355 1356 static int open_capstone_handle(struct annotate_args *args, bool is_64bit, 1357 csh *handle) 1358 { 1359 struct annotation_options *opt = args->options; 1360 cs_mode mode = is_64bit ? CS_MODE_64 : CS_MODE_32; 1361 1362 /* TODO: support more architectures */ 1363 if (!arch__is(args->arch, "x86")) 1364 return -1; 1365 1366 if (cs_open(CS_ARCH_X86, mode, handle) != CS_ERR_OK) 1367 return -1; 1368 1369 if (!opt->disassembler_style || 1370 !strcmp(opt->disassembler_style, "att")) 1371 cs_option(*handle, CS_OPT_SYNTAX, CS_OPT_SYNTAX_ATT); 1372 1373 /* 1374 * Resolving address operands to symbols is implemented 1375 * on x86 by investigating instruction details. 1376 */ 1377 cs_option(*handle, CS_OPT_DETAIL, CS_OPT_ON); 1378 1379 return 0; 1380 } 1381 1382 struct find_file_offset_data { 1383 u64 ip; 1384 u64 offset; 1385 }; 1386 1387 /* This will be called for each PHDR in an ELF binary */ 1388 static int find_file_offset(u64 start, u64 len, u64 pgoff, void *arg) 1389 { 1390 struct find_file_offset_data *data = arg; 1391 1392 if (start <= data->ip && data->ip < start + len) { 1393 data->offset = pgoff + data->ip - start; 1394 return 1; 1395 } 1396 return 0; 1397 } 1398 1399 static void print_capstone_detail(cs_insn *insn, char *buf, size_t len, 1400 struct annotate_args *args, u64 addr) 1401 { 1402 int i; 1403 struct map *map = args->ms.map; 1404 struct symbol *sym; 1405 1406 /* TODO: support more architectures */ 1407 if (!arch__is(args->arch, "x86")) 1408 return; 1409 1410 if (insn->detail == NULL) 1411 return; 1412 1413 for (i = 0; i < insn->detail->x86.op_count; i++) { 1414 cs_x86_op *op = &insn->detail->x86.operands[i]; 1415 u64 orig_addr; 1416 1417 if (op->type != X86_OP_MEM) 1418 continue; 1419 1420 /* only print RIP-based global symbols for now */ 1421 if (op->mem.base != X86_REG_RIP) 1422 continue; 1423 1424 /* get the target address */ 1425 orig_addr = addr + insn->size + op->mem.disp; 1426 addr = map__objdump_2mem(map, orig_addr); 1427 1428 if (dso__kernel(map__dso(map))) { 1429 /* 1430 * The kernel maps can be splitted into sections, 1431 * let's find the map first and the search the symbol. 1432 */ 1433 map = maps__find(map__kmaps(map), addr); 1434 if (map == NULL) 1435 continue; 1436 } 1437 1438 /* convert it to map-relative address for search */ 1439 addr = map__map_ip(map, addr); 1440 1441 sym = map__find_symbol(map, addr); 1442 if (sym == NULL) 1443 continue; 1444 1445 if (addr == sym->start) { 1446 scnprintf(buf, len, "\t# %"PRIx64" <%s>", 1447 orig_addr, sym->name); 1448 } else { 1449 scnprintf(buf, len, "\t# %"PRIx64" <%s+%#"PRIx64">", 1450 orig_addr, sym->name, addr - sym->start); 1451 } 1452 break; 1453 } 1454 } 1455 1456 static int symbol__disassemble_capstone(char *filename, struct symbol *sym, 1457 struct annotate_args *args) 1458 { 1459 struct annotation *notes = symbol__annotation(sym); 1460 struct map *map = args->ms.map; 1461 struct dso *dso = map__dso(map); 1462 struct nscookie nsc; 1463 u64 start = map__rip_2objdump(map, sym->start); 1464 u64 end = map__rip_2objdump(map, sym->end); 1465 u64 len = end - start; 1466 u64 offset; 1467 int i, fd, count; 1468 bool is_64bit = false; 1469 bool needs_cs_close = false; 1470 u8 *buf = NULL; 1471 struct find_file_offset_data data = { 1472 .ip = start, 1473 }; 1474 csh handle; 1475 cs_insn *insn; 1476 char disasm_buf[512]; 1477 struct disasm_line *dl; 1478 1479 if (args->options->objdump_path) 1480 return -1; 1481 1482 nsinfo__mountns_enter(dso__nsinfo(dso), &nsc); 1483 fd = open(filename, O_RDONLY); 1484 nsinfo__mountns_exit(&nsc); 1485 if (fd < 0) 1486 return -1; 1487 1488 if (file__read_maps(fd, /*exe=*/true, find_file_offset, &data, 1489 &is_64bit) == 0) 1490 goto err; 1491 1492 if (open_capstone_handle(args, is_64bit, &handle) < 0) 1493 goto err; 1494 1495 needs_cs_close = true; 1496 1497 buf = malloc(len); 1498 if (buf == NULL) 1499 goto err; 1500 1501 count = pread(fd, buf, len, data.offset); 1502 close(fd); 1503 fd = -1; 1504 1505 if ((u64)count != len) 1506 goto err; 1507 1508 /* add the function address and name */ 1509 scnprintf(disasm_buf, sizeof(disasm_buf), "%#"PRIx64" <%s>:", 1510 start, sym->name); 1511 1512 args->offset = -1; 1513 args->line = disasm_buf; 1514 args->line_nr = 0; 1515 args->fileloc = NULL; 1516 args->ms.sym = sym; 1517 1518 dl = disasm_line__new(args); 1519 if (dl == NULL) 1520 goto err; 1521 1522 annotation_line__add(&dl->al, ¬es->src->source); 1523 1524 count = cs_disasm(handle, buf, len, start, len, &insn); 1525 for (i = 0, offset = 0; i < count; i++) { 1526 int printed; 1527 1528 printed = scnprintf(disasm_buf, sizeof(disasm_buf), 1529 " %-7s %s", 1530 insn[i].mnemonic, insn[i].op_str); 1531 print_capstone_detail(&insn[i], disasm_buf + printed, 1532 sizeof(disasm_buf) - printed, args, 1533 start + offset); 1534 1535 args->offset = offset; 1536 args->line = disasm_buf; 1537 1538 dl = disasm_line__new(args); 1539 if (dl == NULL) 1540 goto err; 1541 1542 annotation_line__add(&dl->al, ¬es->src->source); 1543 1544 offset += insn[i].size; 1545 } 1546 1547 /* It failed in the middle: probably due to unknown instructions */ 1548 if (offset != len) { 1549 struct list_head *list = ¬es->src->source; 1550 1551 /* Discard all lines and fallback to objdump */ 1552 while (!list_empty(list)) { 1553 dl = list_first_entry(list, struct disasm_line, al.node); 1554 1555 list_del_init(&dl->al.node); 1556 disasm_line__free(dl); 1557 } 1558 count = -1; 1559 } 1560 1561 out: 1562 if (needs_cs_close) 1563 cs_close(&handle); 1564 free(buf); 1565 return count < 0 ? count : 0; 1566 1567 err: 1568 if (fd >= 0) 1569 close(fd); 1570 if (needs_cs_close) { 1571 struct disasm_line *tmp; 1572 1573 /* 1574 * It probably failed in the middle of the above loop. 1575 * Release any resources it might add. 1576 */ 1577 list_for_each_entry_safe(dl, tmp, ¬es->src->source, al.node) { 1578 list_del(&dl->al.node); 1579 free(dl); 1580 } 1581 } 1582 count = -1; 1583 goto out; 1584 } 1585 #endif 1586 1587 /* 1588 * Possibly create a new version of line with tabs expanded. Returns the 1589 * existing or new line, storage is updated if a new line is allocated. If 1590 * allocation fails then NULL is returned. 1591 */ 1592 static char *expand_tabs(char *line, char **storage, size_t *storage_len) 1593 { 1594 size_t i, src, dst, len, new_storage_len, num_tabs; 1595 char *new_line; 1596 size_t line_len = strlen(line); 1597 1598 for (num_tabs = 0, i = 0; i < line_len; i++) 1599 if (line[i] == '\t') 1600 num_tabs++; 1601 1602 if (num_tabs == 0) 1603 return line; 1604 1605 /* 1606 * Space for the line and '\0', less the leading and trailing 1607 * spaces. Each tab may introduce 7 additional spaces. 1608 */ 1609 new_storage_len = line_len + 1 + (num_tabs * 7); 1610 1611 new_line = malloc(new_storage_len); 1612 if (new_line == NULL) { 1613 pr_err("Failure allocating memory for tab expansion\n"); 1614 return NULL; 1615 } 1616 1617 /* 1618 * Copy regions starting at src and expand tabs. If there are two 1619 * adjacent tabs then 'src == i', the memcpy is of size 0 and the spaces 1620 * are inserted. 1621 */ 1622 for (i = 0, src = 0, dst = 0; i < line_len && num_tabs; i++) { 1623 if (line[i] == '\t') { 1624 len = i - src; 1625 memcpy(&new_line[dst], &line[src], len); 1626 dst += len; 1627 new_line[dst++] = ' '; 1628 while (dst % 8 != 0) 1629 new_line[dst++] = ' '; 1630 src = i + 1; 1631 num_tabs--; 1632 } 1633 } 1634 1635 /* Expand the last region. */ 1636 len = line_len - src; 1637 memcpy(&new_line[dst], &line[src], len); 1638 dst += len; 1639 new_line[dst] = '\0'; 1640 1641 free(*storage); 1642 *storage = new_line; 1643 *storage_len = new_storage_len; 1644 return new_line; 1645 } 1646 1647 int symbol__disassemble(struct symbol *sym, struct annotate_args *args) 1648 { 1649 struct annotation_options *opts = &annotate_opts; 1650 struct map *map = args->ms.map; 1651 struct dso *dso = map__dso(map); 1652 char *command; 1653 FILE *file; 1654 char symfs_filename[PATH_MAX]; 1655 struct kcore_extract kce; 1656 bool delete_extract = false; 1657 bool decomp = false; 1658 int lineno = 0; 1659 char *fileloc = NULL; 1660 int nline; 1661 char *line; 1662 size_t line_len; 1663 const char *objdump_argv[] = { 1664 "/bin/sh", 1665 "-c", 1666 NULL, /* Will be the objdump command to run. */ 1667 "--", 1668 NULL, /* Will be the symfs path. */ 1669 NULL, 1670 }; 1671 struct child_process objdump_process; 1672 int err = dso__disassemble_filename(dso, symfs_filename, sizeof(symfs_filename)); 1673 1674 if (err) 1675 return err; 1676 1677 pr_debug("%s: filename=%s, sym=%s, start=%#" PRIx64 ", end=%#" PRIx64 "\n", __func__, 1678 symfs_filename, sym->name, map__unmap_ip(map, sym->start), 1679 map__unmap_ip(map, sym->end)); 1680 1681 pr_debug("annotating [%p] %30s : [%p] %30s\n", 1682 dso, dso__long_name(dso), sym, sym->name); 1683 1684 if (dso__binary_type(dso) == DSO_BINARY_TYPE__BPF_PROG_INFO) { 1685 return symbol__disassemble_bpf(sym, args); 1686 } else if (dso__binary_type(dso) == DSO_BINARY_TYPE__BPF_IMAGE) { 1687 return symbol__disassemble_bpf_image(sym, args); 1688 } else if (dso__binary_type(dso) == DSO_BINARY_TYPE__NOT_FOUND) { 1689 return -1; 1690 } else if (dso__is_kcore(dso)) { 1691 kce.kcore_filename = symfs_filename; 1692 kce.addr = map__rip_2objdump(map, sym->start); 1693 kce.offs = sym->start; 1694 kce.len = sym->end - sym->start; 1695 if (!kcore_extract__create(&kce)) { 1696 delete_extract = true; 1697 strlcpy(symfs_filename, kce.extract_filename, 1698 sizeof(symfs_filename)); 1699 } 1700 } else if (dso__needs_decompress(dso)) { 1701 char tmp[KMOD_DECOMP_LEN]; 1702 1703 if (dso__decompress_kmodule_path(dso, symfs_filename, 1704 tmp, sizeof(tmp)) < 0) 1705 return -1; 1706 1707 decomp = true; 1708 strcpy(symfs_filename, tmp); 1709 } 1710 1711 #ifdef HAVE_LIBCAPSTONE_SUPPORT 1712 err = symbol__disassemble_capstone(symfs_filename, sym, args); 1713 if (err == 0) 1714 goto out_remove_tmp; 1715 #endif 1716 1717 err = asprintf(&command, 1718 "%s %s%s --start-address=0x%016" PRIx64 1719 " --stop-address=0x%016" PRIx64 1720 " %s -d %s %s %s %c%s%c %s%s -C \"$1\"", 1721 opts->objdump_path ?: "objdump", 1722 opts->disassembler_style ? "-M " : "", 1723 opts->disassembler_style ?: "", 1724 map__rip_2objdump(map, sym->start), 1725 map__rip_2objdump(map, sym->end), 1726 opts->show_linenr ? "-l" : "", 1727 opts->show_asm_raw ? "" : "--no-show-raw-insn", 1728 opts->annotate_src ? "-S" : "", 1729 opts->prefix ? "--prefix " : "", 1730 opts->prefix ? '"' : ' ', 1731 opts->prefix ?: "", 1732 opts->prefix ? '"' : ' ', 1733 opts->prefix_strip ? "--prefix-strip=" : "", 1734 opts->prefix_strip ?: ""); 1735 1736 if (err < 0) { 1737 pr_err("Failure allocating memory for the command to run\n"); 1738 goto out_remove_tmp; 1739 } 1740 1741 pr_debug("Executing: %s\n", command); 1742 1743 objdump_argv[2] = command; 1744 objdump_argv[4] = symfs_filename; 1745 1746 /* Create a pipe to read from for stdout */ 1747 memset(&objdump_process, 0, sizeof(objdump_process)); 1748 objdump_process.argv = objdump_argv; 1749 objdump_process.out = -1; 1750 objdump_process.err = -1; 1751 objdump_process.no_stderr = 1; 1752 if (start_command(&objdump_process)) { 1753 pr_err("Failure starting to run %s\n", command); 1754 err = -1; 1755 goto out_free_command; 1756 } 1757 1758 file = fdopen(objdump_process.out, "r"); 1759 if (!file) { 1760 pr_err("Failure creating FILE stream for %s\n", command); 1761 /* 1762 * If we were using debug info should retry with 1763 * original binary. 1764 */ 1765 err = -1; 1766 goto out_close_stdout; 1767 } 1768 1769 /* Storage for getline. */ 1770 line = NULL; 1771 line_len = 0; 1772 1773 nline = 0; 1774 while (!feof(file)) { 1775 const char *match; 1776 char *expanded_line; 1777 1778 if (getline(&line, &line_len, file) < 0 || !line) 1779 break; 1780 1781 /* Skip lines containing "filename:" */ 1782 match = strstr(line, symfs_filename); 1783 if (match && match[strlen(symfs_filename)] == ':') 1784 continue; 1785 1786 expanded_line = strim(line); 1787 expanded_line = expand_tabs(expanded_line, &line, &line_len); 1788 if (!expanded_line) 1789 break; 1790 1791 /* 1792 * The source code line number (lineno) needs to be kept in 1793 * across calls to symbol__parse_objdump_line(), so that it 1794 * can associate it with the instructions till the next one. 1795 * See disasm_line__new() and struct disasm_line::line_nr. 1796 */ 1797 if (symbol__parse_objdump_line(sym, args, expanded_line, 1798 &lineno, &fileloc) < 0) 1799 break; 1800 nline++; 1801 } 1802 free(line); 1803 free(fileloc); 1804 1805 err = finish_command(&objdump_process); 1806 if (err) 1807 pr_err("Error running %s\n", command); 1808 1809 if (nline == 0) { 1810 err = -1; 1811 pr_err("No output from %s\n", command); 1812 } 1813 1814 /* 1815 * kallsyms does not have symbol sizes so there may a nop at the end. 1816 * Remove it. 1817 */ 1818 if (dso__is_kcore(dso)) 1819 delete_last_nop(sym); 1820 1821 fclose(file); 1822 1823 out_close_stdout: 1824 close(objdump_process.out); 1825 1826 out_free_command: 1827 free(command); 1828 1829 out_remove_tmp: 1830 if (decomp) 1831 unlink(symfs_filename); 1832 1833 if (delete_extract) 1834 kcore_extract__delete(&kce); 1835 1836 return err; 1837 } 1838