1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * intel_pt_insn_decoder.c: Intel Processor Trace support
4  * Copyright (c) 2013-2014, Intel Corporation.
5  */
6 
7 #include <linux/kernel.h>
8 #include <stdio.h>
9 #include <string.h>
10 #include <endian.h>
11 #include <byteswap.h>
12 #include "../../../arch/x86/include/asm/insn.h"
13 
14 #include "../../../arch/x86/lib/inat.c"
15 #include "../../../arch/x86/lib/insn.c"
16 
17 #include "event.h"
18 
19 #include "intel-pt-insn-decoder.h"
20 #include "dump-insn.h"
21 
22 #if INTEL_PT_INSN_BUF_SZ < MAX_INSN_SIZE || INTEL_PT_INSN_BUF_SZ > MAX_INSN
23 #error Instruction buffer size too small
24 #endif
25 
26 /* Based on branch_type() from arch/x86/events/intel/lbr.c */
intel_pt_insn_decoder(struct insn * insn,struct intel_pt_insn * intel_pt_insn)27 static void intel_pt_insn_decoder(struct insn *insn,
28 				  struct intel_pt_insn *intel_pt_insn)
29 {
30 	enum intel_pt_insn_op op = INTEL_PT_OP_OTHER;
31 	enum intel_pt_insn_branch branch = INTEL_PT_BR_NO_BRANCH;
32 	int ext;
33 
34 	intel_pt_insn->rel = 0;
35 	intel_pt_insn->emulated_ptwrite = false;
36 
37 	if (insn_is_avx(insn)) {
38 		intel_pt_insn->op = INTEL_PT_OP_OTHER;
39 		intel_pt_insn->branch = INTEL_PT_BR_NO_BRANCH;
40 		intel_pt_insn->length = insn->length;
41 		return;
42 	}
43 
44 	switch (insn->opcode.bytes[0]) {
45 	case 0xf:
46 		switch (insn->opcode.bytes[1]) {
47 		case 0x01:
48 			switch (insn->modrm.bytes[0]) {
49 			case 0xc2: /* vmlaunch */
50 			case 0xc3: /* vmresume */
51 				op = INTEL_PT_OP_VMENTRY;
52 				branch = INTEL_PT_BR_INDIRECT;
53 				break;
54 			default:
55 				break;
56 			}
57 			break;
58 		case 0x05: /* syscall */
59 		case 0x34: /* sysenter */
60 			op = INTEL_PT_OP_SYSCALL;
61 			branch = INTEL_PT_BR_INDIRECT;
62 			break;
63 		case 0x07: /* sysret */
64 		case 0x35: /* sysexit */
65 			op = INTEL_PT_OP_SYSRET;
66 			branch = INTEL_PT_BR_INDIRECT;
67 			break;
68 		case 0x80 ... 0x8f: /* jcc */
69 			op = INTEL_PT_OP_JCC;
70 			branch = INTEL_PT_BR_CONDITIONAL;
71 			break;
72 		default:
73 			break;
74 		}
75 		break;
76 	case 0x70 ... 0x7f: /* jcc */
77 		op = INTEL_PT_OP_JCC;
78 		branch = INTEL_PT_BR_CONDITIONAL;
79 		break;
80 	case 0xc2: /* near ret */
81 	case 0xc3: /* near ret */
82 	case 0xca: /* far ret */
83 	case 0xcb: /* far ret */
84 		op = INTEL_PT_OP_RET;
85 		branch = INTEL_PT_BR_INDIRECT;
86 		break;
87 	case 0xcf: /* iret */
88 		op = INTEL_PT_OP_IRET;
89 		branch = INTEL_PT_BR_INDIRECT;
90 		break;
91 	case 0xcc ... 0xce: /* int */
92 		op = INTEL_PT_OP_INT;
93 		branch = INTEL_PT_BR_INDIRECT;
94 		break;
95 	case 0xe8: /* call near rel */
96 		op = INTEL_PT_OP_CALL;
97 		branch = INTEL_PT_BR_UNCONDITIONAL;
98 		break;
99 	case 0x9a: /* call far absolute */
100 		op = INTEL_PT_OP_CALL;
101 		branch = INTEL_PT_BR_INDIRECT;
102 		break;
103 	case 0xe0 ... 0xe2: /* loop */
104 		op = INTEL_PT_OP_LOOP;
105 		branch = INTEL_PT_BR_CONDITIONAL;
106 		break;
107 	case 0xe3: /* jcc */
108 		op = INTEL_PT_OP_JCC;
109 		branch = INTEL_PT_BR_CONDITIONAL;
110 		break;
111 	case 0xe9: /* jmp */
112 	case 0xeb: /* jmp */
113 		op = INTEL_PT_OP_JMP;
114 		branch = INTEL_PT_BR_UNCONDITIONAL;
115 		break;
116 	case 0xea: /* far jmp */
117 		op = INTEL_PT_OP_JMP;
118 		branch = INTEL_PT_BR_INDIRECT;
119 		break;
120 	case 0xff: /* call near absolute, call far absolute ind */
121 		ext = (insn->modrm.bytes[0] >> 3) & 0x7;
122 		switch (ext) {
123 		case 2: /* near ind call */
124 		case 3: /* far ind call */
125 			op = INTEL_PT_OP_CALL;
126 			branch = INTEL_PT_BR_INDIRECT;
127 			break;
128 		case 4:
129 		case 5:
130 			op = INTEL_PT_OP_JMP;
131 			branch = INTEL_PT_BR_INDIRECT;
132 			break;
133 		default:
134 			break;
135 		}
136 		break;
137 	default:
138 		break;
139 	}
140 
141 	intel_pt_insn->op = op;
142 	intel_pt_insn->branch = branch;
143 	intel_pt_insn->length = insn->length;
144 
145 	if (branch == INTEL_PT_BR_CONDITIONAL ||
146 	    branch == INTEL_PT_BR_UNCONDITIONAL) {
147 #if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
148 		switch (insn->immediate.nbytes) {
149 		case 1:
150 			intel_pt_insn->rel = insn->immediate.value;
151 			break;
152 		case 2:
153 			intel_pt_insn->rel =
154 					bswap_16((short)insn->immediate.value);
155 			break;
156 		case 4:
157 			intel_pt_insn->rel = bswap_32(insn->immediate.value);
158 			break;
159 		default:
160 			intel_pt_insn->rel = 0;
161 			break;
162 		}
163 #else
164 		intel_pt_insn->rel = insn->immediate.value;
165 #endif
166 	}
167 }
168 
intel_pt_get_insn(const unsigned char * buf,size_t len,int x86_64,struct intel_pt_insn * intel_pt_insn)169 int intel_pt_get_insn(const unsigned char *buf, size_t len, int x86_64,
170 		      struct intel_pt_insn *intel_pt_insn)
171 {
172 	struct insn insn;
173 	int ret;
174 
175 	ret = insn_decode(&insn, buf, len,
176 			  x86_64 ? INSN_MODE_64 : INSN_MODE_32);
177 	if (ret < 0 || insn.length > len)
178 		return -1;
179 
180 	intel_pt_insn_decoder(&insn, intel_pt_insn);
181 	if (insn.length < INTEL_PT_INSN_BUF_SZ)
182 		memcpy(intel_pt_insn->buf, buf, insn.length);
183 	else
184 		memcpy(intel_pt_insn->buf, buf, INTEL_PT_INSN_BUF_SZ);
185 	return 0;
186 }
187 
arch_is_branch(const unsigned char * buf,size_t len,int x86_64)188 int arch_is_branch(const unsigned char *buf, size_t len, int x86_64)
189 {
190 	struct intel_pt_insn in;
191 	if (intel_pt_get_insn(buf, len, x86_64, &in) < 0)
192 		return -1;
193 	return in.branch != INTEL_PT_BR_NO_BRANCH;
194 }
195 
dump_insn(struct perf_insn * x,uint64_t ip __maybe_unused,u8 * inbuf,int inlen,int * lenp)196 const char *dump_insn(struct perf_insn *x, uint64_t ip __maybe_unused,
197 		      u8 *inbuf, int inlen, int *lenp)
198 {
199 	struct insn insn;
200 	int n, i, ret;
201 	int left;
202 
203 	ret = insn_decode(&insn, inbuf, inlen,
204 			  x->is64bit ? INSN_MODE_64 : INSN_MODE_32);
205 
206 	if (ret < 0 || insn.length > inlen)
207 		return "<bad>";
208 	if (lenp)
209 		*lenp = insn.length;
210 	left = sizeof(x->out);
211 	n = snprintf(x->out, left, "insn: ");
212 	left -= n;
213 	for (i = 0; i < insn.length; i++) {
214 		n += snprintf(x->out + n, left, "%02x ", inbuf[i]);
215 		left -= n;
216 	}
217 	return x->out;
218 }
219 
220 const char *branch_name[] = {
221 	[INTEL_PT_OP_OTHER]	= "Other",
222 	[INTEL_PT_OP_CALL]	= "Call",
223 	[INTEL_PT_OP_RET]	= "Ret",
224 	[INTEL_PT_OP_JCC]	= "Jcc",
225 	[INTEL_PT_OP_JMP]	= "Jmp",
226 	[INTEL_PT_OP_LOOP]	= "Loop",
227 	[INTEL_PT_OP_IRET]	= "IRet",
228 	[INTEL_PT_OP_INT]	= "Int",
229 	[INTEL_PT_OP_SYSCALL]	= "Syscall",
230 	[INTEL_PT_OP_SYSRET]	= "Sysret",
231 	[INTEL_PT_OP_VMENTRY]	= "VMentry",
232 };
233 
intel_pt_insn_name(enum intel_pt_insn_op op)234 const char *intel_pt_insn_name(enum intel_pt_insn_op op)
235 {
236 	return branch_name[op];
237 }
238 
intel_pt_insn_desc(const struct intel_pt_insn * intel_pt_insn,char * buf,size_t buf_len)239 int intel_pt_insn_desc(const struct intel_pt_insn *intel_pt_insn, char *buf,
240 		       size_t buf_len)
241 {
242 	switch (intel_pt_insn->branch) {
243 	case INTEL_PT_BR_CONDITIONAL:
244 	case INTEL_PT_BR_UNCONDITIONAL:
245 		return snprintf(buf, buf_len, "%s %s%d",
246 				intel_pt_insn_name(intel_pt_insn->op),
247 				intel_pt_insn->rel > 0 ? "+" : "",
248 				intel_pt_insn->rel);
249 	case INTEL_PT_BR_NO_BRANCH:
250 	case INTEL_PT_BR_INDIRECT:
251 		return snprintf(buf, buf_len, "%s",
252 				intel_pt_insn_name(intel_pt_insn->op));
253 	default:
254 		break;
255 	}
256 	return 0;
257 }
258 
intel_pt_insn_type(enum intel_pt_insn_op op)259 int intel_pt_insn_type(enum intel_pt_insn_op op)
260 {
261 	switch (op) {
262 	case INTEL_PT_OP_OTHER:
263 		return 0;
264 	case INTEL_PT_OP_CALL:
265 		return PERF_IP_FLAG_BRANCH | PERF_IP_FLAG_CALL;
266 	case INTEL_PT_OP_RET:
267 		return PERF_IP_FLAG_BRANCH | PERF_IP_FLAG_RETURN;
268 	case INTEL_PT_OP_JCC:
269 		return PERF_IP_FLAG_BRANCH | PERF_IP_FLAG_CONDITIONAL;
270 	case INTEL_PT_OP_JMP:
271 		return PERF_IP_FLAG_BRANCH;
272 	case INTEL_PT_OP_LOOP:
273 		return PERF_IP_FLAG_BRANCH | PERF_IP_FLAG_CONDITIONAL;
274 	case INTEL_PT_OP_IRET:
275 		return PERF_IP_FLAG_BRANCH | PERF_IP_FLAG_RETURN |
276 		       PERF_IP_FLAG_INTERRUPT;
277 	case INTEL_PT_OP_INT:
278 		return PERF_IP_FLAG_BRANCH | PERF_IP_FLAG_CALL |
279 		       PERF_IP_FLAG_INTERRUPT;
280 	case INTEL_PT_OP_SYSCALL:
281 		return PERF_IP_FLAG_BRANCH | PERF_IP_FLAG_CALL |
282 		       PERF_IP_FLAG_SYSCALLRET;
283 	case INTEL_PT_OP_SYSRET:
284 		return PERF_IP_FLAG_BRANCH | PERF_IP_FLAG_RETURN |
285 		       PERF_IP_FLAG_SYSCALLRET;
286 	case INTEL_PT_OP_VMENTRY:
287 		return PERF_IP_FLAG_BRANCH | PERF_IP_FLAG_CALL |
288 		       PERF_IP_FLAG_VMENTRY;
289 	default:
290 		return 0;
291 	}
292 }
293