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 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 | // SPDX-License-Identifier: GPL-2.0 /* * Instruction binary disassembler based on capstone. * * Author(s): Changbin Du <changbin.du@huawei.com> */ #include <inttypes.h> #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" #include "dump-insn.h" #include "map.h" #include "dso.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, bool is64) { cs_arch arch; cs_mode mode; if (machine__is(machine, "x86_64") && is64) { 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 thread *thread, u8 cpumode, cs_insn *insn, int print_opts, 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, cpumode, op->imm, &al)) { printed += fprintf(fp, "%s ", insn[0].mnemonic); printed += symbol__fprintf_symname_offs(al.sym, &al, fp); if (print_opts & PRINT_INSN_IMM_HEX) printed += fprintf(fp, " [%#" PRIx64 "]", op->imm); addr_location__exit(&al); return printed; } addr_location__exit(&al); } printed += fprintf(fp, "%s %s", insn[0].mnemonic, insn[0].op_str); return printed; } static bool is64bitip(struct machine *machine, struct addr_location *al) { const struct dso *dso = al->map ? map__dso(al->map) : NULL; if (dso) return dso__is_64_bit(dso); return machine__is(machine, "x86_64") || machine__normalized_is(machine, "arm64") || machine__normalized_is(machine, "s390"); } ssize_t fprintf_insn_asm(struct machine *machine, struct thread *thread, u8 cpumode, bool is64bit, const uint8_t *code, size_t code_size, uint64_t ip, int *lenp, int print_opts, FILE *fp) { size_t printed; cs_insn *insn; csh cs_handle; size_t count; int ret; /* TODO: Try to initiate capstone only once but need a proper place. */ ret = capstone_init(machine, &cs_handle, is64bit); if (ret < 0) return ret; count = cs_disasm(cs_handle, code, code_size, ip, 1, &insn); if (count > 0) { if (machine__normalized_is(machine, "x86")) printed = print_insn_x86(thread, cpumode, &insn[0], print_opts, fp); else printed = fprintf(fp, "%s %s", insn[0].mnemonic, insn[0].op_str); if (lenp) *lenp = insn->size; cs_free(insn, count); } else { printed = -1; } cs_close(&cs_handle); return printed; } size_t sample__fprintf_insn_asm(struct perf_sample *sample, struct thread *thread, struct machine *machine, FILE *fp, struct addr_location *al) { bool is64bit = is64bitip(machine, al); ssize_t printed; printed = fprintf_insn_asm(machine, thread, sample->cpumode, is64bit, (uint8_t *)sample->insn, sample->insn_len, sample->ip, NULL, 0, fp); if (printed < 0) return sample__fprintf_insn_raw(sample, fp); 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, struct addr_location *al __maybe_unused) { return 0; } #endif |