xref: /linux/arch/csky/kernel/probes/simulate-insn.c (revision 2da68a77) 
1 // SPDX-License-Identifier: GPL-2.0+
2 
3 #include <linux/bitops.h>
4 #include <linux/kernel.h>
5 #include <linux/kprobes.h>
6 
7 #include "decode-insn.h"
8 #include "simulate-insn.h"
9 
10 static inline bool csky_insn_reg_get_val(struct pt_regs *regs,
11 					 unsigned long index,
12 					 unsigned long *ptr)
13 {
14 	if (index < 14)
15 		*ptr = *(&regs->a0 + index);
16 
17 	if (index > 15 && index < 31)
18 		*ptr = *(&regs->exregs[0] + index - 16);
19 
20 	switch (index) {
21 	case 14:
22 		*ptr = regs->usp;
23 		break;
24 	case 15:
25 		*ptr = regs->lr;
26 		break;
27 	case 31:
28 		*ptr = regs->tls;
29 		break;
30 	default:
31 		goto fail;
32 	}
33 
34 	return true;
35 fail:
36 	return false;
37 }
38 
39 static inline bool csky_insn_reg_set_val(struct pt_regs *regs,
40 					 unsigned long index,
41 					 unsigned long val)
42 {
43 	if (index < 14)
44 		*(&regs->a0 + index) = val;
45 
46 	if (index > 15 && index < 31)
47 		*(&regs->exregs[0] + index - 16) = val;
48 
49 	switch (index) {
50 	case 14:
51 		regs->usp = val;
52 		break;
53 	case 15:
54 		regs->lr = val;
55 		break;
56 	case 31:
57 		regs->tls = val;
58 		break;
59 	default:
60 		goto fail;
61 	}
62 
63 	return true;
64 fail:
65 	return false;
66 }
67 
68 void __kprobes
69 simulate_br16(u32 opcode, long addr, struct pt_regs *regs)
70 {
71 	instruction_pointer_set(regs,
72 		addr + sign_extend32((opcode & 0x3ff) << 1, 9));
73 }
74 
75 void __kprobes
76 simulate_br32(u32 opcode, long addr, struct pt_regs *regs)
77 {
78 	instruction_pointer_set(regs,
79 		addr + sign_extend32((opcode & 0xffff0000) >> 15, 15));
80 }
81 
82 void __kprobes
83 simulate_bt16(u32 opcode, long addr, struct pt_regs *regs)
84 {
85 	if (regs->sr & 1)
86 		instruction_pointer_set(regs,
87 			addr + sign_extend32((opcode & 0x3ff) << 1, 9));
88 	else
89 		instruction_pointer_set(regs, addr + 2);
90 }
91 
92 void __kprobes
93 simulate_bt32(u32 opcode, long addr, struct pt_regs *regs)
94 {
95 	if (regs->sr & 1)
96 		instruction_pointer_set(regs,
97 			addr + sign_extend32((opcode & 0xffff0000) >> 15, 15));
98 	else
99 		instruction_pointer_set(regs, addr + 4);
100 }
101 
102 void __kprobes
103 simulate_bf16(u32 opcode, long addr, struct pt_regs *regs)
104 {
105 	if (!(regs->sr & 1))
106 		instruction_pointer_set(regs,
107 			addr + sign_extend32((opcode & 0x3ff) << 1, 9));
108 	else
109 		instruction_pointer_set(regs, addr + 2);
110 }
111 
112 void __kprobes
113 simulate_bf32(u32 opcode, long addr, struct pt_regs *regs)
114 {
115 	if (!(regs->sr & 1))
116 		instruction_pointer_set(regs,
117 			addr + sign_extend32((opcode & 0xffff0000) >> 15, 15));
118 	else
119 		instruction_pointer_set(regs, addr + 4);
120 }
121 
122 void __kprobes
123 simulate_jmp16(u32 opcode, long addr, struct pt_regs *regs)
124 {
125 	unsigned long tmp = (opcode >> 2) & 0xf;
126 
127 	csky_insn_reg_get_val(regs, tmp, &tmp);
128 
129 	instruction_pointer_set(regs, tmp & 0xfffffffe);
130 }
131 
132 void __kprobes
133 simulate_jmp32(u32 opcode, long addr, struct pt_regs *regs)
134 {
135 	unsigned long tmp = opcode & 0x1f;
136 
137 	csky_insn_reg_get_val(regs, tmp, &tmp);
138 
139 	instruction_pointer_set(regs, tmp & 0xfffffffe);
140 }
141 
142 void __kprobes
143 simulate_jsr16(u32 opcode, long addr, struct pt_regs *regs)
144 {
145 	unsigned long tmp = (opcode >> 2) & 0xf;
146 
147 	csky_insn_reg_get_val(regs, tmp, &tmp);
148 
149 	regs->lr = addr + 2;
150 
151 	instruction_pointer_set(regs, tmp & 0xfffffffe);
152 }
153 
154 void __kprobes
155 simulate_jsr32(u32 opcode, long addr, struct pt_regs *regs)
156 {
157 	unsigned long tmp = opcode & 0x1f;
158 
159 	csky_insn_reg_get_val(regs, tmp, &tmp);
160 
161 	regs->lr = addr + 4;
162 
163 	instruction_pointer_set(regs, tmp & 0xfffffffe);
164 }
165 
166 void __kprobes
167 simulate_lrw16(u32 opcode, long addr, struct pt_regs *regs)
168 {
169 	unsigned long val;
170 	unsigned long tmp = (opcode & 0x300) >> 3;
171 	unsigned long offset = ((opcode & 0x1f) | tmp) << 2;
172 
173 	tmp = (opcode & 0xe0) >> 5;
174 
175 	val = *(unsigned int *)(instruction_pointer(regs) + offset);
176 
177 	csky_insn_reg_set_val(regs, tmp, val);
178 }
179 
180 void __kprobes
181 simulate_lrw32(u32 opcode, long addr, struct pt_regs *regs)
182 {
183 	unsigned long val;
184 	unsigned long offset = (opcode & 0xffff0000) >> 14;
185 	unsigned long tmp = opcode & 0x0000001f;
186 
187 	val = *(unsigned int *)
188 		((instruction_pointer(regs) + offset) & 0xfffffffc);
189 
190 	csky_insn_reg_set_val(regs, tmp, val);
191 }
192 
193 void __kprobes
194 simulate_pop16(u32 opcode, long addr, struct pt_regs *regs)
195 {
196 	unsigned long *tmp = (unsigned long *)regs->usp;
197 	int i;
198 
199 	for (i = 0; i < (opcode & 0xf); i++) {
200 		csky_insn_reg_set_val(regs, i + 4, *tmp);
201 		tmp += 1;
202 	}
203 
204 	if (opcode & 0x10) {
205 		csky_insn_reg_set_val(regs, 15, *tmp);
206 		tmp += 1;
207 	}
208 
209 	regs->usp = (unsigned long)tmp;
210 
211 	instruction_pointer_set(regs, regs->lr);
212 }
213 
214 void __kprobes
215 simulate_pop32(u32 opcode, long addr, struct pt_regs *regs)
216 {
217 	unsigned long *tmp = (unsigned long *)regs->usp;
218 	int i;
219 
220 	for (i = 0; i < ((opcode & 0xf0000) >> 16); i++) {
221 		csky_insn_reg_set_val(regs, i + 4, *tmp);
222 		tmp += 1;
223 	}
224 
225 	if (opcode & 0x100000) {
226 		csky_insn_reg_set_val(regs, 15, *tmp);
227 		tmp += 1;
228 	}
229 
230 	for (i = 0; i < ((opcode & 0xe00000) >> 21); i++) {
231 		csky_insn_reg_set_val(regs, i + 16, *tmp);
232 		tmp += 1;
233 	}
234 
235 	if (opcode & 0x1000000) {
236 		csky_insn_reg_set_val(regs, 29, *tmp);
237 		tmp += 1;
238 	}
239 
240 	regs->usp = (unsigned long)tmp;
241 
242 	instruction_pointer_set(regs, regs->lr);
243 }
244 
245 void __kprobes
246 simulate_bez32(u32 opcode, long addr, struct pt_regs *regs)
247 {
248 	unsigned long tmp = opcode & 0x1f;
249 
250 	csky_insn_reg_get_val(regs, tmp, &tmp);
251 
252 	if (tmp == 0) {
253 		instruction_pointer_set(regs,
254 			addr + sign_extend32((opcode & 0xffff0000) >> 15, 15));
255 	} else
256 		instruction_pointer_set(regs, addr + 4);
257 }
258 
259 void __kprobes
260 simulate_bnez32(u32 opcode, long addr, struct pt_regs *regs)
261 {
262 	unsigned long tmp = opcode & 0x1f;
263 
264 	csky_insn_reg_get_val(regs, tmp, &tmp);
265 
266 	if (tmp != 0) {
267 		instruction_pointer_set(regs,
268 			addr + sign_extend32((opcode & 0xffff0000) >> 15, 15));
269 	} else
270 		instruction_pointer_set(regs, addr + 4);
271 }
272 
273 void __kprobes
274 simulate_bnezad32(u32 opcode, long addr, struct pt_regs *regs)
275 {
276 	unsigned long tmp = opcode & 0x1f;
277 	long val;
278 
279 	csky_insn_reg_get_val(regs, tmp, (unsigned long *)&val);
280 
281 	val -= 1;
282 
283 	if (val > 0) {
284 		instruction_pointer_set(regs,
285 			addr + sign_extend32((opcode & 0xffff0000) >> 15, 15));
286 	} else
287 		instruction_pointer_set(regs, addr + 4);
288 
289 	csky_insn_reg_set_val(regs, tmp, (unsigned long)val);
290 }
291 
292 void __kprobes
293 simulate_bhsz32(u32 opcode, long addr, struct pt_regs *regs)
294 {
295 	unsigned long tmp = opcode & 0x1f;
296 	unsigned long val;
297 
298 	csky_insn_reg_get_val(regs, tmp, &val);
299 
300 	if ((long) val >= 0) {
301 		instruction_pointer_set(regs,
302 			addr + sign_extend32((opcode & 0xffff0000) >> 15, 15));
303 	} else
304 		instruction_pointer_set(regs, addr + 4);
305 }
306 
307 void __kprobes
308 simulate_bhz32(u32 opcode, long addr, struct pt_regs *regs)
309 {
310 	unsigned long tmp = opcode & 0x1f;
311 	unsigned long val;
312 
313 	csky_insn_reg_get_val(regs, tmp, &val);
314 
315 	if ((long) val > 0) {
316 		instruction_pointer_set(regs,
317 			addr + sign_extend32((opcode & 0xffff0000) >> 15, 15));
318 	} else
319 		instruction_pointer_set(regs, addr + 4);
320 }
321 
322 void __kprobes
323 simulate_blsz32(u32 opcode, long addr, struct pt_regs *regs)
324 {
325 	unsigned long tmp = opcode & 0x1f;
326 	unsigned long val;
327 
328 	csky_insn_reg_get_val(regs, tmp, &val);
329 
330 	if ((long) val <= 0) {
331 		instruction_pointer_set(regs,
332 			addr + sign_extend32((opcode & 0xffff0000) >> 15, 15));
333 	} else
334 		instruction_pointer_set(regs, addr + 4);
335 }
336 
337 void __kprobes
338 simulate_blz32(u32 opcode, long addr, struct pt_regs *regs)
339 {
340 	unsigned long tmp = opcode & 0x1f;
341 	unsigned long val;
342 
343 	csky_insn_reg_get_val(regs, tmp, &val);
344 
345 	if ((long) val < 0) {
346 		instruction_pointer_set(regs,
347 			addr + sign_extend32((opcode & 0xffff0000) >> 15, 15));
348 	} else
349 		instruction_pointer_set(regs, addr + 4);
350 }
351 
352 void __kprobes
353 simulate_bsr32(u32 opcode, long addr, struct pt_regs *regs)
354 {
355 	unsigned long tmp;
356 
357 	tmp = (opcode & 0xffff) << 16;
358 	tmp |= (opcode & 0xffff0000) >> 16;
359 
360 	instruction_pointer_set(regs,
361 		addr + sign_extend32((tmp & 0x3ffffff) << 1, 15));
362 
363 	regs->lr = addr + 4;
364 }
365 
366 void __kprobes
367 simulate_jmpi32(u32 opcode, long addr, struct pt_regs *regs)
368 {
369 	unsigned long val;
370 	unsigned long offset = ((opcode & 0xffff0000) >> 14);
371 
372 	val = *(unsigned int *)
373 		((instruction_pointer(regs) + offset) & 0xfffffffc);
374 
375 	instruction_pointer_set(regs, val);
376 }
377 
378 void __kprobes
379 simulate_jsri32(u32 opcode, long addr, struct pt_regs *regs)
380 {
381 	unsigned long val;
382 	unsigned long offset = ((opcode & 0xffff0000) >> 14);
383 
384 	val = *(unsigned int *)
385 		((instruction_pointer(regs) + offset) & 0xfffffffc);
386 
387 	regs->lr = addr + 4;
388 
389 	instruction_pointer_set(regs, val);
390 }
391