Loading...
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 | // SPDX-License-Identifier: GPL-2.0 /* * Instruction binary disassembler based on capstone. * * Author(s): Changbin Du <changbin.du@huawei.com> */ #include <string.h> #include <stdbool.h> #include "debug.h" #include "sample.h" #include "symbol.h" #include "machine.h" #include "thread.h" #include "print_insn.h" size_t sample__fprintf_insn_raw(struct perf_sample *sample, FILE *fp) { int printed = 0; for (int i = 0; i < sample->insn_len; i++) { printed += fprintf(fp, "%02x", (unsigned char)sample->insn[i]); if (sample->insn_len - i > 1) printed += fprintf(fp, " "); } return printed; } #ifdef HAVE_LIBCAPSTONE_SUPPORT #include <capstone/capstone.h> static int capstone_init(struct machine *machine, csh *cs_handle) { cs_arch arch; cs_mode mode; if (machine__is(machine, "x86_64")) { arch = CS_ARCH_X86; mode = CS_MODE_64; } else if (machine__normalized_is(machine, "x86")) { arch = CS_ARCH_X86; mode = CS_MODE_32; } else if (machine__normalized_is(machine, "arm64")) { arch = CS_ARCH_ARM64; mode = CS_MODE_ARM; } else if (machine__normalized_is(machine, "arm")) { arch = CS_ARCH_ARM; mode = CS_MODE_ARM + CS_MODE_V8; } else if (machine__normalized_is(machine, "s390")) { arch = CS_ARCH_SYSZ; mode = CS_MODE_BIG_ENDIAN; } else { return -1; } if (cs_open(arch, mode, cs_handle) != CS_ERR_OK) { pr_warning_once("cs_open failed\n"); return -1; } if (machine__normalized_is(machine, "x86")) { cs_option(*cs_handle, CS_OPT_SYNTAX, CS_OPT_SYNTAX_ATT); /* * Resolving address operands to symbols is implemented * on x86 by investigating instruction details. */ cs_option(*cs_handle, CS_OPT_DETAIL, CS_OPT_ON); } return 0; } static size_t print_insn_x86(struct perf_sample *sample, struct thread *thread, cs_insn *insn, FILE *fp) { struct addr_location al; size_t printed = 0; if (insn->detail && insn->detail->x86.op_count == 1) { cs_x86_op *op = &insn->detail->x86.operands[0]; addr_location__init(&al); if (op->type == X86_OP_IMM && thread__find_symbol(thread, sample->cpumode, op->imm, &al)) { printed += fprintf(fp, "%s ", insn[0].mnemonic); printed += symbol__fprintf_symname_offs(al.sym, &al, fp); addr_location__exit(&al); return printed; } addr_location__exit(&al); } printed += fprintf(fp, "%s %s", insn[0].mnemonic, insn[0].op_str); return printed; } size_t sample__fprintf_insn_asm(struct perf_sample *sample, struct thread *thread, struct machine *machine, FILE *fp) { csh cs_handle; cs_insn *insn; size_t count; size_t printed = 0; int ret; /* TODO: Try to initiate capstone only once but need a proper place. */ ret = capstone_init(machine, &cs_handle); if (ret < 0) { /* fallback */ return sample__fprintf_insn_raw(sample, fp); } count = cs_disasm(cs_handle, (uint8_t *)sample->insn, sample->insn_len, sample->ip, 1, &insn); if (count > 0) { if (machine__normalized_is(machine, "x86")) printed += print_insn_x86(sample, thread, &insn[0], fp); else printed += fprintf(fp, "%s %s", insn[0].mnemonic, insn[0].op_str); cs_free(insn, count); } else { printed += fprintf(fp, "illegal instruction"); } cs_close(&cs_handle); return printed; } #else size_t sample__fprintf_insn_asm(struct perf_sample *sample __maybe_unused, struct thread *thread __maybe_unused, struct machine *machine __maybe_unused, FILE *fp __maybe_unused) { return 0; } #endif |