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
|
