Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/cmarinas...
[linux-2.6.git] / arch / arm / kernel / kprobes-decode.c
1 /*
2  * arch/arm/kernel/kprobes-decode.c
3  *
4  * Copyright (C) 2006, 2007 Motorola Inc.
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License version 2 as
8  * published by the Free Software Foundation.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * General Public License for more details.
14  */
15
16 /*
17  * We do not have hardware single-stepping on ARM, This
18  * effort is further complicated by the ARM not having a
19  * "next PC" register.  Instructions that change the PC
20  * can't be safely single-stepped in a MP environment, so
21  * we have a lot of work to do:
22  *
23  * In the prepare phase:
24  *   *) If it is an instruction that does anything
25  *      with the CPU mode, we reject it for a kprobe.
26  *      (This is out of laziness rather than need.  The
27  *      instructions could be simulated.)
28  *
29  *   *) Otherwise, decode the instruction rewriting its
30  *      registers to take fixed, ordered registers and
31  *      setting a handler for it to run the instruction.
32  *
33  * In the execution phase by an instruction's handler:
34  *
35  *   *) If the PC is written to by the instruction, the
36  *      instruction must be fully simulated in software.
37  *
38  *   *) Otherwise, a modified form of the instruction is
39  *      directly executed.  Its handler calls the
40  *      instruction in insn[0].  In insn[1] is a
41  *      "mov pc, lr" to return.
42  *
43  *      Before calling, load up the reordered registers
44  *      from the original instruction's registers.  If one
45  *      of the original input registers is the PC, compute
46  *      and adjust the appropriate input register.
47  *
48  *      After call completes, copy the output registers to
49  *      the original instruction's original registers.
50  *
51  * We don't use a real breakpoint instruction since that
52  * would have us in the kernel go from SVC mode to SVC
53  * mode losing the link register.  Instead we use an
54  * undefined instruction.  To simplify processing, the
55  * undefined instruction used for kprobes must be reserved
56  * exclusively for kprobes use.
57  *
58  * TODO: ifdef out some instruction decoding based on architecture.
59  */
60
61 #include <linux/kernel.h>
62 #include <linux/kprobes.h>
63
64 #define sign_extend(x, signbit) ((x) | (0 - ((x) & (1 << (signbit)))))
65
66 #define branch_displacement(insn) sign_extend(((insn) & 0xffffff) << 2, 25)
67
68 #define is_r15(insn, bitpos) (((insn) & (0xf << bitpos)) == (0xf << bitpos))
69
70 /*
71  * Test if load/store instructions writeback the address register.
72  * if P (bit 24) == 0 or W (bit 21) == 1
73  */
74 #define is_writeback(insn) ((insn ^ 0x01000000) & 0x01200000)
75
76 #define PSR_fs  (PSR_f|PSR_s)
77
78 #define KPROBE_RETURN_INSTRUCTION       0xe1a0f00e      /* mov pc, lr */
79
80 typedef long (insn_0arg_fn_t)(void);
81 typedef long (insn_1arg_fn_t)(long);
82 typedef long (insn_2arg_fn_t)(long, long);
83 typedef long (insn_3arg_fn_t)(long, long, long);
84 typedef long (insn_4arg_fn_t)(long, long, long, long);
85 typedef long long (insn_llret_0arg_fn_t)(void);
86 typedef long long (insn_llret_3arg_fn_t)(long, long, long);
87 typedef long long (insn_llret_4arg_fn_t)(long, long, long, long);
88
89 union reg_pair {
90         long long       dr;
91 #ifdef __LITTLE_ENDIAN
92         struct { long   r0, r1; };
93 #else
94         struct { long   r1, r0; };
95 #endif
96 };
97
98 /*
99  * For STR and STM instructions, an ARM core may choose to use either
100  * a +8 or a +12 displacement from the current instruction's address.
101  * Whichever value is chosen for a given core, it must be the same for
102  * both instructions and may not change.  This function measures it.
103  */
104
105 static int str_pc_offset;
106
107 static void __init find_str_pc_offset(void)
108 {
109         int addr, scratch, ret;
110
111         __asm__ (
112                 "sub    %[ret], pc, #4          \n\t"
113                 "str    pc, %[addr]             \n\t"
114                 "ldr    %[scr], %[addr]         \n\t"
115                 "sub    %[ret], %[scr], %[ret]  \n\t"
116                 : [ret] "=r" (ret), [scr] "=r" (scratch), [addr] "+m" (addr));
117
118         str_pc_offset = ret;
119 }
120
121 /*
122  * The insnslot_?arg_r[w]flags() functions below are to keep the
123  * msr -> *fn -> mrs instruction sequences indivisible so that
124  * the state of the CPSR flags aren't inadvertently modified
125  * just before or just after the call.
126  */
127
128 static inline long __kprobes
129 insnslot_0arg_rflags(long cpsr, insn_0arg_fn_t *fn)
130 {
131         register long ret asm("r0");
132
133         __asm__ __volatile__ (
134                 "msr    cpsr_fs, %[cpsr]        \n\t"
135                 "mov    lr, pc                  \n\t"
136                 "mov    pc, %[fn]               \n\t"
137                 : "=r" (ret)
138                 : [cpsr] "r" (cpsr), [fn] "r" (fn)
139                 : "lr", "cc"
140         );
141         return ret;
142 }
143
144 static inline long long __kprobes
145 insnslot_llret_0arg_rflags(long cpsr, insn_llret_0arg_fn_t *fn)
146 {
147         register long ret0 asm("r0");
148         register long ret1 asm("r1");
149         union reg_pair fnr;
150
151         __asm__ __volatile__ (
152                 "msr    cpsr_fs, %[cpsr]        \n\t"
153                 "mov    lr, pc                  \n\t"
154                 "mov    pc, %[fn]               \n\t"
155                 : "=r" (ret0), "=r" (ret1)
156                 : [cpsr] "r" (cpsr), [fn] "r" (fn)
157                 : "lr", "cc"
158         );
159         fnr.r0 = ret0;
160         fnr.r1 = ret1;
161         return fnr.dr;
162 }
163
164 static inline long __kprobes
165 insnslot_1arg_rflags(long r0, long cpsr, insn_1arg_fn_t *fn)
166 {
167         register long rr0 asm("r0") = r0;
168         register long ret asm("r0");
169
170         __asm__ __volatile__ (
171                 "msr    cpsr_fs, %[cpsr]        \n\t"
172                 "mov    lr, pc                  \n\t"
173                 "mov    pc, %[fn]               \n\t"
174                 : "=r" (ret)
175                 : "0" (rr0), [cpsr] "r" (cpsr), [fn] "r" (fn)
176                 : "lr", "cc"
177         );
178         return ret;
179 }
180
181 static inline long __kprobes
182 insnslot_2arg_rflags(long r0, long r1, long cpsr, insn_2arg_fn_t *fn)
183 {
184         register long rr0 asm("r0") = r0;
185         register long rr1 asm("r1") = r1;
186         register long ret asm("r0");
187
188         __asm__ __volatile__ (
189                 "msr    cpsr_fs, %[cpsr]        \n\t"
190                 "mov    lr, pc                  \n\t"
191                 "mov    pc, %[fn]               \n\t"
192                 : "=r" (ret)
193                 : "0" (rr0), "r" (rr1),
194                   [cpsr] "r" (cpsr), [fn] "r" (fn)
195                 : "lr", "cc"
196         );
197         return ret;
198 }
199
200 static inline long __kprobes
201 insnslot_3arg_rflags(long r0, long r1, long r2, long cpsr, insn_3arg_fn_t *fn)
202 {
203         register long rr0 asm("r0") = r0;
204         register long rr1 asm("r1") = r1;
205         register long rr2 asm("r2") = r2;
206         register long ret asm("r0");
207
208         __asm__ __volatile__ (
209                 "msr    cpsr_fs, %[cpsr]        \n\t"
210                 "mov    lr, pc                  \n\t"
211                 "mov    pc, %[fn]               \n\t"
212                 : "=r" (ret)
213                 : "0" (rr0), "r" (rr1), "r" (rr2),
214                   [cpsr] "r" (cpsr), [fn] "r" (fn)
215                 : "lr", "cc"
216         );
217         return ret;
218 }
219
220 static inline long long __kprobes
221 insnslot_llret_3arg_rflags(long r0, long r1, long r2, long cpsr,
222                            insn_llret_3arg_fn_t *fn)
223 {
224         register long rr0 asm("r0") = r0;
225         register long rr1 asm("r1") = r1;
226         register long rr2 asm("r2") = r2;
227         register long ret0 asm("r0");
228         register long ret1 asm("r1");
229         union reg_pair fnr;
230
231         __asm__ __volatile__ (
232                 "msr    cpsr_fs, %[cpsr]        \n\t"
233                 "mov    lr, pc                  \n\t"
234                 "mov    pc, %[fn]               \n\t"
235                 : "=r" (ret0), "=r" (ret1)
236                 : "0" (rr0), "r" (rr1), "r" (rr2),
237                   [cpsr] "r" (cpsr), [fn] "r" (fn)
238                 : "lr", "cc"
239         );
240         fnr.r0 = ret0;
241         fnr.r1 = ret1;
242         return fnr.dr;
243 }
244
245 static inline long __kprobes
246 insnslot_4arg_rflags(long r0, long r1, long r2, long r3, long cpsr,
247                      insn_4arg_fn_t *fn)
248 {
249         register long rr0 asm("r0") = r0;
250         register long rr1 asm("r1") = r1;
251         register long rr2 asm("r2") = r2;
252         register long rr3 asm("r3") = r3;
253         register long ret asm("r0");
254
255         __asm__ __volatile__ (
256                 "msr    cpsr_fs, %[cpsr]        \n\t"
257                 "mov    lr, pc                  \n\t"
258                 "mov    pc, %[fn]               \n\t"
259                 : "=r" (ret)
260                 : "0" (rr0), "r" (rr1), "r" (rr2), "r" (rr3),
261                   [cpsr] "r" (cpsr), [fn] "r" (fn)
262                 : "lr", "cc"
263         );
264         return ret;
265 }
266
267 static inline long __kprobes
268 insnslot_1arg_rwflags(long r0, long *cpsr, insn_1arg_fn_t *fn)
269 {
270         register long rr0 asm("r0") = r0;
271         register long ret asm("r0");
272         long oldcpsr = *cpsr;
273         long newcpsr;
274
275         __asm__ __volatile__ (
276                 "msr    cpsr_fs, %[oldcpsr]     \n\t"
277                 "mov    lr, pc                  \n\t"
278                 "mov    pc, %[fn]               \n\t"
279                 "mrs    %[newcpsr], cpsr        \n\t"
280                 : "=r" (ret), [newcpsr] "=r" (newcpsr)
281                 : "0" (rr0), [oldcpsr] "r" (oldcpsr), [fn] "r" (fn)
282                 : "lr", "cc"
283         );
284         *cpsr = (oldcpsr & ~PSR_fs) | (newcpsr & PSR_fs);
285         return ret;
286 }
287
288 static inline long __kprobes
289 insnslot_2arg_rwflags(long r0, long r1, long *cpsr, insn_2arg_fn_t *fn)
290 {
291         register long rr0 asm("r0") = r0;
292         register long rr1 asm("r1") = r1;
293         register long ret asm("r0");
294         long oldcpsr = *cpsr;
295         long newcpsr;
296
297         __asm__ __volatile__ (
298                 "msr    cpsr_fs, %[oldcpsr]     \n\t"
299                 "mov    lr, pc                  \n\t"
300                 "mov    pc, %[fn]               \n\t"
301                 "mrs    %[newcpsr], cpsr        \n\t"
302                 : "=r" (ret), [newcpsr] "=r" (newcpsr)
303                 : "0" (rr0), "r" (rr1), [oldcpsr] "r" (oldcpsr), [fn] "r" (fn)
304                 : "lr", "cc"
305         );
306         *cpsr = (oldcpsr & ~PSR_fs) | (newcpsr & PSR_fs);
307         return ret;
308 }
309
310 static inline long __kprobes
311 insnslot_3arg_rwflags(long r0, long r1, long r2, long *cpsr,
312                       insn_3arg_fn_t *fn)
313 {
314         register long rr0 asm("r0") = r0;
315         register long rr1 asm("r1") = r1;
316         register long rr2 asm("r2") = r2;
317         register long ret asm("r0");
318         long oldcpsr = *cpsr;
319         long newcpsr;
320
321         __asm__ __volatile__ (
322                 "msr    cpsr_fs, %[oldcpsr]     \n\t"
323                 "mov    lr, pc                  \n\t"
324                 "mov    pc, %[fn]               \n\t"
325                 "mrs    %[newcpsr], cpsr        \n\t"
326                 : "=r" (ret), [newcpsr] "=r" (newcpsr)
327                 : "0" (rr0), "r" (rr1), "r" (rr2),
328                   [oldcpsr] "r" (oldcpsr), [fn] "r" (fn)
329                 : "lr", "cc"
330         );
331         *cpsr = (oldcpsr & ~PSR_fs) | (newcpsr & PSR_fs);
332         return ret;
333 }
334
335 static inline long __kprobes
336 insnslot_4arg_rwflags(long r0, long r1, long r2, long r3, long *cpsr,
337                       insn_4arg_fn_t *fn)
338 {
339         register long rr0 asm("r0") = r0;
340         register long rr1 asm("r1") = r1;
341         register long rr2 asm("r2") = r2;
342         register long rr3 asm("r3") = r3;
343         register long ret asm("r0");
344         long oldcpsr = *cpsr;
345         long newcpsr;
346
347         __asm__ __volatile__ (
348                 "msr    cpsr_fs, %[oldcpsr]     \n\t"
349                 "mov    lr, pc                  \n\t"
350                 "mov    pc, %[fn]               \n\t"
351                 "mrs    %[newcpsr], cpsr        \n\t"
352                 : "=r" (ret), [newcpsr] "=r" (newcpsr)
353                 : "0" (rr0), "r" (rr1), "r" (rr2), "r" (rr3),
354                   [oldcpsr] "r" (oldcpsr), [fn] "r" (fn)
355                 : "lr", "cc"
356         );
357         *cpsr = (oldcpsr & ~PSR_fs) | (newcpsr & PSR_fs);
358         return ret;
359 }
360
361 static inline long long __kprobes
362 insnslot_llret_4arg_rwflags(long r0, long r1, long r2, long r3, long *cpsr,
363                             insn_llret_4arg_fn_t *fn)
364 {
365         register long rr0 asm("r0") = r0;
366         register long rr1 asm("r1") = r1;
367         register long rr2 asm("r2") = r2;
368         register long rr3 asm("r3") = r3;
369         register long ret0 asm("r0");
370         register long ret1 asm("r1");
371         long oldcpsr = *cpsr;
372         long newcpsr;
373         union reg_pair fnr;
374
375         __asm__ __volatile__ (
376                 "msr    cpsr_fs, %[oldcpsr]     \n\t"
377                 "mov    lr, pc                  \n\t"
378                 "mov    pc, %[fn]               \n\t"
379                 "mrs    %[newcpsr], cpsr        \n\t"
380                 : "=r" (ret0), "=r" (ret1), [newcpsr] "=r" (newcpsr)
381                 : "0" (rr0), "r" (rr1), "r" (rr2), "r" (rr3),
382                   [oldcpsr] "r" (oldcpsr), [fn] "r" (fn)
383                 : "lr", "cc"
384         );
385         *cpsr = (oldcpsr & ~PSR_fs) | (newcpsr & PSR_fs);
386         fnr.r0 = ret0;
387         fnr.r1 = ret1;
388         return fnr.dr;
389 }
390
391 /*
392  * To avoid the complications of mimicing single-stepping on a
393  * processor without a Next-PC or a single-step mode, and to
394  * avoid having to deal with the side-effects of boosting, we
395  * simulate or emulate (almost) all ARM instructions.
396  *
397  * "Simulation" is where the instruction's behavior is duplicated in
398  * C code.  "Emulation" is where the original instruction is rewritten
399  * and executed, often by altering its registers.
400  *
401  * By having all behavior of the kprobe'd instruction completed before
402  * returning from the kprobe_handler(), all locks (scheduler and
403  * interrupt) can safely be released.  There is no need for secondary
404  * breakpoints, no race with MP or preemptable kernels, nor having to
405  * clean up resources counts at a later time impacting overall system
406  * performance.  By rewriting the instruction, only the minimum registers
407  * need to be loaded and saved back optimizing performance.
408  *
409  * Calling the insnslot_*_rwflags version of a function doesn't hurt
410  * anything even when the CPSR flags aren't updated by the
411  * instruction.  It's just a little slower in return for saving
412  * a little space by not having a duplicate function that doesn't
413  * update the flags.  (The same optimization can be said for
414  * instructions that do or don't perform register writeback)
415  * Also, instructions can either read the flags, only write the
416  * flags, or read and write the flags.  To save combinations
417  * rather than for sheer performance, flag functions just assume
418  * read and write of flags.
419  */
420
421 static void __kprobes simulate_bbl(struct kprobe *p, struct pt_regs *regs)
422 {
423         kprobe_opcode_t insn = p->opcode;
424         long iaddr = (long)p->addr;
425         int disp  = branch_displacement(insn);
426
427         if (insn & (1 << 24))
428                 regs->ARM_lr = iaddr + 4;
429
430         regs->ARM_pc = iaddr + 8 + disp;
431 }
432
433 static void __kprobes simulate_blx1(struct kprobe *p, struct pt_regs *regs)
434 {
435         kprobe_opcode_t insn = p->opcode;
436         long iaddr = (long)p->addr;
437         int disp = branch_displacement(insn);
438
439         regs->ARM_lr = iaddr + 4;
440         regs->ARM_pc = iaddr + 8 + disp + ((insn >> 23) & 0x2);
441         regs->ARM_cpsr |= PSR_T_BIT;
442 }
443
444 static void __kprobes simulate_blx2bx(struct kprobe *p, struct pt_regs *regs)
445 {
446         kprobe_opcode_t insn = p->opcode;
447         int rm = insn & 0xf;
448         long rmv = regs->uregs[rm];
449
450         if (insn & (1 << 5))
451                 regs->ARM_lr = (long)p->addr + 4;
452
453         regs->ARM_pc = rmv & ~0x1;
454         regs->ARM_cpsr &= ~PSR_T_BIT;
455         if (rmv & 0x1)
456                 regs->ARM_cpsr |= PSR_T_BIT;
457 }
458
459 static void __kprobes simulate_mrs(struct kprobe *p, struct pt_regs *regs)
460 {
461         kprobe_opcode_t insn = p->opcode;
462         int rd = (insn >> 12) & 0xf;
463         unsigned long mask = 0xf8ff03df; /* Mask out execution state */
464         regs->uregs[rd] = regs->ARM_cpsr & mask;
465 }
466
467 static void __kprobes simulate_ldm1stm1(struct kprobe *p, struct pt_regs *regs)
468 {
469         kprobe_opcode_t insn = p->opcode;
470         int rn = (insn >> 16) & 0xf;
471         int lbit = insn & (1 << 20);
472         int wbit = insn & (1 << 21);
473         int ubit = insn & (1 << 23);
474         int pbit = insn & (1 << 24);
475         long *addr = (long *)regs->uregs[rn];
476         int reg_bit_vector;
477         int reg_count;
478
479         reg_count = 0;
480         reg_bit_vector = insn & 0xffff;
481         while (reg_bit_vector) {
482                 reg_bit_vector &= (reg_bit_vector - 1);
483                 ++reg_count;
484         }
485
486         if (!ubit)
487                 addr -= reg_count;
488         addr += (!pbit == !ubit);
489
490         reg_bit_vector = insn & 0xffff;
491         while (reg_bit_vector) {
492                 int reg = __ffs(reg_bit_vector);
493                 reg_bit_vector &= (reg_bit_vector - 1);
494                 if (lbit)
495                         regs->uregs[reg] = *addr++;
496                 else
497                         *addr++ = regs->uregs[reg];
498         }
499
500         if (wbit) {
501                 if (!ubit)
502                         addr -= reg_count;
503                 addr -= (!pbit == !ubit);
504                 regs->uregs[rn] = (long)addr;
505         }
506 }
507
508 static void __kprobes simulate_stm1_pc(struct kprobe *p, struct pt_regs *regs)
509 {
510         regs->ARM_pc = (long)p->addr + str_pc_offset;
511         simulate_ldm1stm1(p, regs);
512         regs->ARM_pc = (long)p->addr + 4;
513 }
514
515 static void __kprobes simulate_mov_ipsp(struct kprobe *p, struct pt_regs *regs)
516 {
517         regs->uregs[12] = regs->uregs[13];
518 }
519
520 static void __kprobes emulate_ldrd(struct kprobe *p, struct pt_regs *regs)
521 {
522         insn_2arg_fn_t *i_fn = (insn_2arg_fn_t *)&p->ainsn.insn[0];
523         kprobe_opcode_t insn = p->opcode;
524         long ppc = (long)p->addr + 8;
525         int rd = (insn >> 12) & 0xf;
526         int rn = (insn >> 16) & 0xf;
527         int rm = insn & 0xf;  /* rm may be invalid, don't care. */
528         long rmv = (rm == 15) ? ppc : regs->uregs[rm];
529         long rnv = (rn == 15) ? ppc : regs->uregs[rn];
530
531         /* Not following the C calling convention here, so need asm(). */
532         __asm__ __volatile__ (
533                 "ldr    r0, %[rn]       \n\t"
534                 "ldr    r1, %[rm]       \n\t"
535                 "msr    cpsr_fs, %[cpsr]\n\t"
536                 "mov    lr, pc          \n\t"
537                 "mov    pc, %[i_fn]     \n\t"
538                 "str    r0, %[rn]       \n\t"   /* in case of writeback */
539                 "str    r2, %[rd0]      \n\t"
540                 "str    r3, %[rd1]      \n\t"
541                 : [rn]  "+m" (rnv),
542                   [rd0] "=m" (regs->uregs[rd]),
543                   [rd1] "=m" (regs->uregs[rd+1])
544                 : [rm]   "m" (rmv),
545                   [cpsr] "r" (regs->ARM_cpsr),
546                   [i_fn] "r" (i_fn)
547                 : "r0", "r1", "r2", "r3", "lr", "cc"
548         );
549         if (is_writeback(insn))
550                 regs->uregs[rn] = rnv;
551 }
552
553 static void __kprobes emulate_strd(struct kprobe *p, struct pt_regs *regs)
554 {
555         insn_4arg_fn_t *i_fn = (insn_4arg_fn_t *)&p->ainsn.insn[0];
556         kprobe_opcode_t insn = p->opcode;
557         long ppc = (long)p->addr + 8;
558         int rd = (insn >> 12) & 0xf;
559         int rn = (insn >> 16) & 0xf;
560         int rm  = insn & 0xf;
561         long rnv = (rn == 15) ? ppc : regs->uregs[rn];
562         /* rm/rmv may be invalid, don't care. */
563         long rmv = (rm == 15) ? ppc : regs->uregs[rm];
564         long rnv_wb;
565
566         rnv_wb = insnslot_4arg_rflags(rnv, rmv, regs->uregs[rd],
567                                                regs->uregs[rd+1],
568                                                regs->ARM_cpsr, i_fn);
569         if (is_writeback(insn))
570                 regs->uregs[rn] = rnv_wb;
571 }
572
573 static void __kprobes emulate_ldr(struct kprobe *p, struct pt_regs *regs)
574 {
575         insn_llret_3arg_fn_t *i_fn = (insn_llret_3arg_fn_t *)&p->ainsn.insn[0];
576         kprobe_opcode_t insn = p->opcode;
577         long ppc = (long)p->addr + 8;
578         union reg_pair fnr;
579         int rd = (insn >> 12) & 0xf;
580         int rn = (insn >> 16) & 0xf;
581         int rm = insn & 0xf;
582         long rdv;
583         long rnv = (rn == 15) ? ppc : regs->uregs[rn];
584         long rmv = (rm == 15) ? ppc : regs->uregs[rm];
585         long cpsr = regs->ARM_cpsr;
586
587         fnr.dr = insnslot_llret_3arg_rflags(rnv, 0, rmv, cpsr, i_fn);
588         if (rn != 15)
589                 regs->uregs[rn] = fnr.r0;  /* Save Rn in case of writeback. */
590         rdv = fnr.r1;
591
592         if (rd == 15) {
593 #if __LINUX_ARM_ARCH__ >= 5
594                 cpsr &= ~PSR_T_BIT;
595                 if (rdv & 0x1)
596                         cpsr |= PSR_T_BIT;
597                 regs->ARM_cpsr = cpsr;
598                 rdv &= ~0x1;
599 #else
600                 rdv &= ~0x2;
601 #endif
602         }
603         regs->uregs[rd] = rdv;
604 }
605
606 static void __kprobes emulate_str(struct kprobe *p, struct pt_regs *regs)
607 {
608         insn_3arg_fn_t *i_fn = (insn_3arg_fn_t *)&p->ainsn.insn[0];
609         kprobe_opcode_t insn = p->opcode;
610         long iaddr = (long)p->addr;
611         int rd = (insn >> 12) & 0xf;
612         int rn = (insn >> 16) & 0xf;
613         int rm = insn & 0xf;
614         long rdv = (rd == 15) ? iaddr + str_pc_offset : regs->uregs[rd];
615         long rnv = (rn == 15) ? iaddr +  8 : regs->uregs[rn];
616         long rmv = regs->uregs[rm];  /* rm/rmv may be invalid, don't care. */
617         long rnv_wb;
618
619         rnv_wb = insnslot_3arg_rflags(rnv, rdv, rmv, regs->ARM_cpsr, i_fn);
620         if (rn != 15)
621                 regs->uregs[rn] = rnv_wb;  /* Save Rn in case of writeback. */
622 }
623
624 static void __kprobes emulate_sat(struct kprobe *p, struct pt_regs *regs)
625 {
626         insn_1arg_fn_t *i_fn = (insn_1arg_fn_t *)&p->ainsn.insn[0];
627         kprobe_opcode_t insn = p->opcode;
628         int rd = (insn >> 12) & 0xf;
629         int rm = insn & 0xf;
630         long rmv = regs->uregs[rm];
631
632         /* Writes Q flag */
633         regs->uregs[rd] = insnslot_1arg_rwflags(rmv, &regs->ARM_cpsr, i_fn);
634 }
635
636 static void __kprobes emulate_sel(struct kprobe *p, struct pt_regs *regs)
637 {
638         insn_2arg_fn_t *i_fn = (insn_2arg_fn_t *)&p->ainsn.insn[0];
639         kprobe_opcode_t insn = p->opcode;
640         int rd = (insn >> 12) & 0xf;
641         int rn = (insn >> 16) & 0xf;
642         int rm = insn & 0xf;
643         long rnv = regs->uregs[rn];
644         long rmv = regs->uregs[rm];
645
646         /* Reads GE bits */
647         regs->uregs[rd] = insnslot_2arg_rflags(rnv, rmv, regs->ARM_cpsr, i_fn);
648 }
649
650 static void __kprobes emulate_none(struct kprobe *p, struct pt_regs *regs)
651 {
652         insn_0arg_fn_t *i_fn = (insn_0arg_fn_t *)&p->ainsn.insn[0];
653
654         insnslot_0arg_rflags(regs->ARM_cpsr, i_fn);
655 }
656
657 static void __kprobes emulate_nop(struct kprobe *p, struct pt_regs *regs)
658 {
659 }
660
661 static void __kprobes
662 emulate_rd12_modify(struct kprobe *p, struct pt_regs *regs)
663 {
664         insn_1arg_fn_t *i_fn = (insn_1arg_fn_t *)&p->ainsn.insn[0];
665         kprobe_opcode_t insn = p->opcode;
666         int rd = (insn >> 12) & 0xf;
667         long rdv = regs->uregs[rd];
668
669         regs->uregs[rd] = insnslot_1arg_rflags(rdv, regs->ARM_cpsr, i_fn);
670 }
671
672 static void __kprobes
673 emulate_rd12rn0_modify(struct kprobe *p, struct pt_regs *regs)
674 {
675         insn_2arg_fn_t *i_fn = (insn_2arg_fn_t *)&p->ainsn.insn[0];
676         kprobe_opcode_t insn = p->opcode;
677         int rd = (insn >> 12) & 0xf;
678         int rn = insn & 0xf;
679         long rdv = regs->uregs[rd];
680         long rnv = regs->uregs[rn];
681
682         regs->uregs[rd] = insnslot_2arg_rflags(rdv, rnv, regs->ARM_cpsr, i_fn);
683 }
684
685 static void __kprobes emulate_rd12rm0(struct kprobe *p, struct pt_regs *regs)
686 {
687         insn_1arg_fn_t *i_fn = (insn_1arg_fn_t *)&p->ainsn.insn[0];
688         kprobe_opcode_t insn = p->opcode;
689         int rd = (insn >> 12) & 0xf;
690         int rm = insn & 0xf;
691         long rmv = regs->uregs[rm];
692
693         regs->uregs[rd] = insnslot_1arg_rflags(rmv, regs->ARM_cpsr, i_fn);
694 }
695
696 static void __kprobes
697 emulate_rd12rn16rm0_rwflags(struct kprobe *p, struct pt_regs *regs)
698 {
699         insn_2arg_fn_t *i_fn = (insn_2arg_fn_t *)&p->ainsn.insn[0];
700         kprobe_opcode_t insn = p->opcode;
701         int rd = (insn >> 12) & 0xf;
702         int rn = (insn >> 16) & 0xf;
703         int rm = insn & 0xf;
704         long rnv = regs->uregs[rn];
705         long rmv = regs->uregs[rm];
706
707         regs->uregs[rd] =
708                 insnslot_2arg_rwflags(rnv, rmv, &regs->ARM_cpsr, i_fn);
709 }
710
711 static void __kprobes
712 emulate_rd16rn12rs8rm0_rwflags(struct kprobe *p, struct pt_regs *regs)
713 {
714         insn_3arg_fn_t *i_fn = (insn_3arg_fn_t *)&p->ainsn.insn[0];
715         kprobe_opcode_t insn = p->opcode;
716         int rd = (insn >> 16) & 0xf;
717         int rn = (insn >> 12) & 0xf;
718         int rs = (insn >> 8) & 0xf;
719         int rm = insn & 0xf;
720         long rnv = regs->uregs[rn];
721         long rsv = regs->uregs[rs];
722         long rmv = regs->uregs[rm];
723
724         regs->uregs[rd] =
725                 insnslot_3arg_rwflags(rnv, rsv, rmv, &regs->ARM_cpsr, i_fn);
726 }
727
728 static void __kprobes
729 emulate_rd16rs8rm0_rwflags(struct kprobe *p, struct pt_regs *regs)
730 {
731         insn_2arg_fn_t *i_fn = (insn_2arg_fn_t *)&p->ainsn.insn[0];
732         kprobe_opcode_t insn = p->opcode;
733         int rd = (insn >> 16) & 0xf;
734         int rs = (insn >> 8) & 0xf;
735         int rm = insn & 0xf;
736         long rsv = regs->uregs[rs];
737         long rmv = regs->uregs[rm];
738
739         regs->uregs[rd] =
740                 insnslot_2arg_rwflags(rsv, rmv, &regs->ARM_cpsr, i_fn);
741 }
742
743 static void __kprobes
744 emulate_rdhi16rdlo12rs8rm0_rwflags(struct kprobe *p, struct pt_regs *regs)
745 {
746         insn_llret_4arg_fn_t *i_fn = (insn_llret_4arg_fn_t *)&p->ainsn.insn[0];
747         kprobe_opcode_t insn = p->opcode;
748         union reg_pair fnr;
749         int rdhi = (insn >> 16) & 0xf;
750         int rdlo = (insn >> 12) & 0xf;
751         int rs   = (insn >> 8) & 0xf;
752         int rm   = insn & 0xf;
753         long rsv = regs->uregs[rs];
754         long rmv = regs->uregs[rm];
755
756         fnr.dr = insnslot_llret_4arg_rwflags(regs->uregs[rdhi],
757                                              regs->uregs[rdlo], rsv, rmv,
758                                              &regs->ARM_cpsr, i_fn);
759         regs->uregs[rdhi] = fnr.r0;
760         regs->uregs[rdlo] = fnr.r1;
761 }
762
763 static void __kprobes
764 emulate_alu_imm_rflags(struct kprobe *p, struct pt_regs *regs)
765 {
766         insn_1arg_fn_t *i_fn = (insn_1arg_fn_t *)&p->ainsn.insn[0];
767         kprobe_opcode_t insn = p->opcode;
768         int rd = (insn >> 12) & 0xf;
769         int rn = (insn >> 16) & 0xf;
770         long rnv = (rn == 15) ? (long)p->addr + 8 : regs->uregs[rn];
771
772         regs->uregs[rd] = insnslot_1arg_rflags(rnv, regs->ARM_cpsr, i_fn);
773 }
774
775 static void __kprobes
776 emulate_alu_imm_rwflags(struct kprobe *p, struct pt_regs *regs)
777 {
778         insn_1arg_fn_t *i_fn = (insn_1arg_fn_t *)&p->ainsn.insn[0];
779         kprobe_opcode_t insn = p->opcode;
780         int rd = (insn >> 12) & 0xf;
781         int rn = (insn >> 16) & 0xf;
782         long rnv = (rn == 15) ? (long)p->addr + 8 : regs->uregs[rn];
783
784         regs->uregs[rd] = insnslot_1arg_rwflags(rnv, &regs->ARM_cpsr, i_fn);
785 }
786
787 static void __kprobes
788 emulate_alu_tests_imm(struct kprobe *p, struct pt_regs *regs)
789 {
790         insn_1arg_fn_t *i_fn = (insn_1arg_fn_t *)&p->ainsn.insn[0];
791         kprobe_opcode_t insn = p->opcode;
792         int rn = (insn >> 16) & 0xf;
793         long rnv = (rn == 15) ? (long)p->addr + 8 : regs->uregs[rn];
794
795         insnslot_1arg_rwflags(rnv, &regs->ARM_cpsr, i_fn);
796 }
797
798 static void __kprobes
799 emulate_alu_rflags(struct kprobe *p, struct pt_regs *regs)
800 {
801         insn_3arg_fn_t *i_fn = (insn_3arg_fn_t *)&p->ainsn.insn[0];
802         kprobe_opcode_t insn = p->opcode;
803         long ppc = (long)p->addr + 8;
804         int rd = (insn >> 12) & 0xf;
805         int rn = (insn >> 16) & 0xf;    /* rn/rnv/rs/rsv may be */
806         int rs = (insn >> 8) & 0xf;     /* invalid, don't care. */
807         int rm = insn & 0xf;
808         long rnv = (rn == 15) ? ppc : regs->uregs[rn];
809         long rmv = (rm == 15) ? ppc : regs->uregs[rm];
810         long rsv = regs->uregs[rs];
811
812         regs->uregs[rd] =
813                 insnslot_3arg_rflags(rnv, rmv, rsv, regs->ARM_cpsr, i_fn);
814 }
815
816 static void __kprobes
817 emulate_alu_rwflags(struct kprobe *p, struct pt_regs *regs)
818 {
819         insn_3arg_fn_t *i_fn = (insn_3arg_fn_t *)&p->ainsn.insn[0];
820         kprobe_opcode_t insn = p->opcode;
821         long ppc = (long)p->addr + 8;
822         int rd = (insn >> 12) & 0xf;
823         int rn = (insn >> 16) & 0xf;    /* rn/rnv/rs/rsv may be */
824         int rs = (insn >> 8) & 0xf;     /* invalid, don't care. */
825         int rm = insn & 0xf;
826         long rnv = (rn == 15) ? ppc : regs->uregs[rn];
827         long rmv = (rm == 15) ? ppc : regs->uregs[rm];
828         long rsv = regs->uregs[rs];
829
830         regs->uregs[rd] =
831                 insnslot_3arg_rwflags(rnv, rmv, rsv, &regs->ARM_cpsr, i_fn);
832 }
833
834 static void __kprobes
835 emulate_alu_tests(struct kprobe *p, struct pt_regs *regs)
836 {
837         insn_3arg_fn_t *i_fn = (insn_3arg_fn_t *)&p->ainsn.insn[0];
838         kprobe_opcode_t insn = p->opcode;
839         long ppc = (long)p->addr + 8;
840         int rn = (insn >> 16) & 0xf;
841         int rs = (insn >> 8) & 0xf;     /* rs/rsv may be invalid, don't care. */
842         int rm = insn & 0xf;
843         long rnv = (rn == 15) ? ppc : regs->uregs[rn];
844         long rmv = (rm == 15) ? ppc : regs->uregs[rm];
845         long rsv = regs->uregs[rs];
846
847         insnslot_3arg_rwflags(rnv, rmv, rsv, &regs->ARM_cpsr, i_fn);
848 }
849
850 static enum kprobe_insn __kprobes
851 prep_emulate_ldr_str(kprobe_opcode_t insn, struct arch_specific_insn *asi)
852 {
853         int not_imm = (insn & (1 << 26)) ? (insn & (1 << 25))
854                                          : (~insn & (1 << 22));
855
856         if (is_writeback(insn) && is_r15(insn, 16))
857                 return INSN_REJECTED;   /* Writeback to PC */
858
859         insn &= 0xfff00fff;
860         insn |= 0x00001000;     /* Rn = r0, Rd = r1 */
861         if (not_imm) {
862                 insn &= ~0xf;
863                 insn |= 2;      /* Rm = r2 */
864         }
865         asi->insn[0] = insn;
866         asi->insn_handler = (insn & (1 << 20)) ? emulate_ldr : emulate_str;
867         return INSN_GOOD;
868 }
869
870 static enum kprobe_insn __kprobes
871 prep_emulate_rd12_modify(kprobe_opcode_t insn, struct arch_specific_insn *asi)
872 {
873         if (is_r15(insn, 12))
874                 return INSN_REJECTED;   /* Rd is PC */
875
876         insn &= 0xffff0fff;     /* Rd = r0 */
877         asi->insn[0] = insn;
878         asi->insn_handler = emulate_rd12_modify;
879         return INSN_GOOD;
880 }
881
882 static enum kprobe_insn __kprobes
883 prep_emulate_rd12rn0_modify(kprobe_opcode_t insn,
884                             struct arch_specific_insn *asi)
885 {
886         if (is_r15(insn, 12))
887                 return INSN_REJECTED;   /* Rd is PC */
888
889         insn &= 0xffff0ff0;     /* Rd = r0 */
890         insn |= 0x00000001;     /* Rn = r1 */
891         asi->insn[0] = insn;
892         asi->insn_handler = emulate_rd12rn0_modify;
893         return INSN_GOOD;
894 }
895
896 static enum kprobe_insn __kprobes
897 prep_emulate_rd12rm0(kprobe_opcode_t insn, struct arch_specific_insn *asi)
898 {
899         if (is_r15(insn, 12))
900                 return INSN_REJECTED;   /* Rd is PC */
901
902         insn &= 0xffff0ff0;     /* Rd = r0, Rm = r0 */
903         asi->insn[0] = insn;
904         asi->insn_handler = emulate_rd12rm0;
905         return INSN_GOOD;
906 }
907
908 static enum kprobe_insn __kprobes
909 prep_emulate_rd12rn16rm0_wflags(kprobe_opcode_t insn,
910                                 struct arch_specific_insn *asi)
911 {
912         if (is_r15(insn, 12))
913                 return INSN_REJECTED;   /* Rd is PC */
914
915         insn &= 0xfff00ff0;     /* Rd = r0, Rn = r0 */
916         insn |= 0x00000001;     /* Rm = r1 */
917         asi->insn[0] = insn;
918         asi->insn_handler = emulate_rd12rn16rm0_rwflags;
919         return INSN_GOOD;
920 }
921
922 static enum kprobe_insn __kprobes
923 prep_emulate_rd16rs8rm0_wflags(kprobe_opcode_t insn,
924                                struct arch_specific_insn *asi)
925 {
926         if (is_r15(insn, 16))
927                 return INSN_REJECTED;   /* Rd is PC */
928
929         insn &= 0xfff0f0f0;     /* Rd = r0, Rs = r0 */
930         insn |= 0x00000001;     /* Rm = r1          */
931         asi->insn[0] = insn;
932         asi->insn_handler = emulate_rd16rs8rm0_rwflags;
933         return INSN_GOOD;
934 }
935
936 static enum kprobe_insn __kprobes
937 prep_emulate_rd16rn12rs8rm0_wflags(kprobe_opcode_t insn,
938                                    struct arch_specific_insn *asi)
939 {
940         if (is_r15(insn, 16))
941                 return INSN_REJECTED;   /* Rd is PC */
942
943         insn &= 0xfff000f0;     /* Rd = r0, Rn = r0 */
944         insn |= 0x00000102;     /* Rs = r1, Rm = r2 */
945         asi->insn[0] = insn;
946         asi->insn_handler = emulate_rd16rn12rs8rm0_rwflags;
947         return INSN_GOOD;
948 }
949
950 static enum kprobe_insn __kprobes
951 prep_emulate_rdhi16rdlo12rs8rm0_wflags(kprobe_opcode_t insn,
952                                        struct arch_specific_insn *asi)
953 {
954         if (is_r15(insn, 16) || is_r15(insn, 12))
955                 return INSN_REJECTED;   /* RdHi or RdLo is PC */
956
957         insn &= 0xfff000f0;     /* RdHi = r0, RdLo = r1 */
958         insn |= 0x00001203;     /* Rs = r2, Rm = r3 */
959         asi->insn[0] = insn;
960         asi->insn_handler = emulate_rdhi16rdlo12rs8rm0_rwflags;
961         return INSN_GOOD;
962 }
963
964 /*
965  * For the instruction masking and comparisons in all the "space_*"
966  * functions below, Do _not_ rearrange the order of tests unless
967  * you're very, very sure of what you are doing.  For the sake of
968  * efficiency, the masks for some tests sometimes assume other test
969  * have been done prior to them so the number of patterns to test
970  * for an instruction set can be as broad as possible to reduce the
971  * number of tests needed.
972  */
973
974 static enum kprobe_insn __kprobes
975 space_1111(kprobe_opcode_t insn, struct arch_specific_insn *asi)
976 {
977         /* memory hint : 1111 0100 x001 xxxx xxxx xxxx xxxx xxxx : */
978         /* PLDI        : 1111 0100 x101 xxxx xxxx xxxx xxxx xxxx : */
979         /* PLDW        : 1111 0101 x001 xxxx xxxx xxxx xxxx xxxx : */
980         /* PLD         : 1111 0101 x101 xxxx xxxx xxxx xxxx xxxx : */
981         if ((insn & 0xfe300000) == 0xf4100000) {
982                 asi->insn_handler = emulate_nop;
983                 return INSN_GOOD_NO_SLOT;
984         }
985
986         /* BLX(1) : 1111 101x xxxx xxxx xxxx xxxx xxxx xxxx : */
987         if ((insn & 0xfe000000) == 0xfa000000) {
988                 asi->insn_handler = simulate_blx1;
989                 return INSN_GOOD_NO_SLOT;
990         }
991
992         /* CPS   : 1111 0001 0000 xxx0 xxxx xxxx xx0x xxxx */
993         /* SETEND: 1111 0001 0000 0001 xxxx xxxx 0000 xxxx */
994
995         /* SRS   : 1111 100x x1x0 xxxx xxxx xxxx xxxx xxxx */
996         /* RFE   : 1111 100x x0x1 xxxx xxxx xxxx xxxx xxxx */
997
998         /* Coprocessor instructions... */
999         /* MCRR2 : 1111 1100 0100 xxxx xxxx xxxx xxxx xxxx : (Rd != Rn) */
1000         /* MRRC2 : 1111 1100 0101 xxxx xxxx xxxx xxxx xxxx : (Rd != Rn) */
1001         /* LDC2  : 1111 110x xxx1 xxxx xxxx xxxx xxxx xxxx */
1002         /* STC2  : 1111 110x xxx0 xxxx xxxx xxxx xxxx xxxx */
1003         /* CDP2  : 1111 1110 xxxx xxxx xxxx xxxx xxx0 xxxx */
1004         /* MCR2  : 1111 1110 xxx0 xxxx xxxx xxxx xxx1 xxxx */
1005         /* MRC2  : 1111 1110 xxx1 xxxx xxxx xxxx xxx1 xxxx */
1006
1007         return INSN_REJECTED;
1008 }
1009
1010 static enum kprobe_insn __kprobes
1011 space_cccc_000x(kprobe_opcode_t insn, struct arch_specific_insn *asi)
1012 {
1013         /* cccc 0001 0xx0 xxxx xxxx xxxx xxxx xxx0 xxxx */
1014         if ((insn & 0x0f900010) == 0x01000000) {
1015
1016                 /* MRS cpsr : cccc 0001 0000 xxxx xxxx xxxx 0000 xxxx */
1017                 if ((insn & 0x0ff000f0) == 0x01000000) {
1018                         if (is_r15(insn, 12))
1019                                 return INSN_REJECTED;   /* Rd is PC */
1020                         asi->insn_handler = simulate_mrs;
1021                         return INSN_GOOD_NO_SLOT;
1022                 }
1023
1024                 /* SMLALxy : cccc 0001 0100 xxxx xxxx xxxx 1xx0 xxxx */
1025                 if ((insn & 0x0ff00090) == 0x01400080)
1026                         return prep_emulate_rdhi16rdlo12rs8rm0_wflags(insn,
1027                                                                         asi);
1028
1029                 /* SMULWy : cccc 0001 0010 xxxx xxxx xxxx 1x10 xxxx */
1030                 /* SMULxy : cccc 0001 0110 xxxx xxxx xxxx 1xx0 xxxx */
1031                 if ((insn & 0x0ff000b0) == 0x012000a0 ||
1032                     (insn & 0x0ff00090) == 0x01600080)
1033                         return prep_emulate_rd16rs8rm0_wflags(insn, asi);
1034
1035                 /* SMLAxy : cccc 0001 0000 xxxx xxxx xxxx 1xx0 xxxx : Q */
1036                 /* SMLAWy : cccc 0001 0010 xxxx xxxx xxxx 1x00 xxxx : Q */
1037                 if ((insn & 0x0ff00090) == 0x01000080 ||
1038                     (insn & 0x0ff000b0) == 0x01200080)
1039                         return prep_emulate_rd16rn12rs8rm0_wflags(insn, asi);
1040
1041                 /* BXJ      : cccc 0001 0010 xxxx xxxx xxxx 0010 xxxx */
1042                 /* MSR      : cccc 0001 0x10 xxxx xxxx xxxx 0000 xxxx */
1043                 /* MRS spsr : cccc 0001 0100 xxxx xxxx xxxx 0000 xxxx */
1044
1045                 /* Other instruction encodings aren't yet defined */
1046                 return INSN_REJECTED;
1047         }
1048
1049         /* cccc 0001 0xx0 xxxx xxxx xxxx xxxx 0xx1 xxxx */
1050         else if ((insn & 0x0f900090) == 0x01000010) {
1051
1052                 /* BLX(2) : cccc 0001 0010 xxxx xxxx xxxx 0011 xxxx */
1053                 /* BX     : cccc 0001 0010 xxxx xxxx xxxx 0001 xxxx */
1054                 if ((insn & 0x0ff000d0) == 0x01200010) {
1055                         if ((insn & 0x0ff000ff) == 0x0120003f)
1056                                 return INSN_REJECTED; /* BLX pc */
1057                         asi->insn_handler = simulate_blx2bx;
1058                         return INSN_GOOD_NO_SLOT;
1059                 }
1060
1061                 /* CLZ : cccc 0001 0110 xxxx xxxx xxxx 0001 xxxx */
1062                 if ((insn & 0x0ff000f0) == 0x01600010)
1063                         return prep_emulate_rd12rm0(insn, asi);
1064
1065                 /* QADD    : cccc 0001 0000 xxxx xxxx xxxx 0101 xxxx :Q */
1066                 /* QSUB    : cccc 0001 0010 xxxx xxxx xxxx 0101 xxxx :Q */
1067                 /* QDADD   : cccc 0001 0100 xxxx xxxx xxxx 0101 xxxx :Q */
1068                 /* QDSUB   : cccc 0001 0110 xxxx xxxx xxxx 0101 xxxx :Q */
1069                 if ((insn & 0x0f9000f0) == 0x01000050)
1070                         return prep_emulate_rd12rn16rm0_wflags(insn, asi);
1071
1072                 /* BKPT : 1110 0001 0010 xxxx xxxx xxxx 0111 xxxx */
1073                 /* SMC  : cccc 0001 0110 xxxx xxxx xxxx 0111 xxxx */
1074
1075                 /* Other instruction encodings aren't yet defined */
1076                 return INSN_REJECTED;
1077         }
1078
1079         /* cccc 0000 xxxx xxxx xxxx xxxx xxxx 1001 xxxx */
1080         else if ((insn & 0x0f0000f0) == 0x00000090) {
1081
1082                 /* MUL    : cccc 0000 0000 xxxx xxxx xxxx 1001 xxxx :   */
1083                 /* MULS   : cccc 0000 0001 xxxx xxxx xxxx 1001 xxxx :cc */
1084                 /* MLA    : cccc 0000 0010 xxxx xxxx xxxx 1001 xxxx :   */
1085                 /* MLAS   : cccc 0000 0011 xxxx xxxx xxxx 1001 xxxx :cc */
1086                 /* UMAAL  : cccc 0000 0100 xxxx xxxx xxxx 1001 xxxx :   */
1087                 /* undef  : cccc 0000 0101 xxxx xxxx xxxx 1001 xxxx :   */
1088                 /* MLS    : cccc 0000 0110 xxxx xxxx xxxx 1001 xxxx :   */
1089                 /* undef  : cccc 0000 0111 xxxx xxxx xxxx 1001 xxxx :   */
1090                 /* UMULL  : cccc 0000 1000 xxxx xxxx xxxx 1001 xxxx :   */
1091                 /* UMULLS : cccc 0000 1001 xxxx xxxx xxxx 1001 xxxx :cc */
1092                 /* UMLAL  : cccc 0000 1010 xxxx xxxx xxxx 1001 xxxx :   */
1093                 /* UMLALS : cccc 0000 1011 xxxx xxxx xxxx 1001 xxxx :cc */
1094                 /* SMULL  : cccc 0000 1100 xxxx xxxx xxxx 1001 xxxx :   */
1095                 /* SMULLS : cccc 0000 1101 xxxx xxxx xxxx 1001 xxxx :cc */
1096                 /* SMLAL  : cccc 0000 1110 xxxx xxxx xxxx 1001 xxxx :   */
1097                 /* SMLALS : cccc 0000 1111 xxxx xxxx xxxx 1001 xxxx :cc */
1098                 if ((insn & 0x00d00000) == 0x00500000)
1099                         return INSN_REJECTED;
1100                 else if ((insn & 0x00e00000) == 0x00000000)
1101                         return prep_emulate_rd16rs8rm0_wflags(insn, asi);
1102                 else if ((insn & 0x00a00000) == 0x00200000)
1103                         return prep_emulate_rd16rn12rs8rm0_wflags(insn, asi);
1104                 else
1105                         return prep_emulate_rdhi16rdlo12rs8rm0_wflags(insn,
1106                                                                         asi);
1107         }
1108
1109         /* cccc 000x xxxx xxxx xxxx xxxx xxxx 1xx1 xxxx */
1110         else if ((insn & 0x0e000090) == 0x00000090) {
1111
1112                 /* SWP   : cccc 0001 0000 xxxx xxxx xxxx 1001 xxxx */
1113                 /* SWPB  : cccc 0001 0100 xxxx xxxx xxxx 1001 xxxx */
1114                 /* ???   : cccc 0001 0x01 xxxx xxxx xxxx 1001 xxxx */
1115                 /* ???   : cccc 0001 0x10 xxxx xxxx xxxx 1001 xxxx */
1116                 /* ???   : cccc 0001 0x11 xxxx xxxx xxxx 1001 xxxx */
1117                 /* STREX : cccc 0001 1000 xxxx xxxx xxxx 1001 xxxx */
1118                 /* LDREX : cccc 0001 1001 xxxx xxxx xxxx 1001 xxxx */
1119                 /* STREXD: cccc 0001 1010 xxxx xxxx xxxx 1001 xxxx */
1120                 /* LDREXD: cccc 0001 1011 xxxx xxxx xxxx 1001 xxxx */
1121                 /* STREXB: cccc 0001 1100 xxxx xxxx xxxx 1001 xxxx */
1122                 /* LDREXB: cccc 0001 1101 xxxx xxxx xxxx 1001 xxxx */
1123                 /* STREXH: cccc 0001 1110 xxxx xxxx xxxx 1001 xxxx */
1124                 /* LDREXH: cccc 0001 1111 xxxx xxxx xxxx 1001 xxxx */
1125
1126                 /* LDRD  : cccc 000x xxx0 xxxx xxxx xxxx 1101 xxxx */
1127                 /* STRD  : cccc 000x xxx0 xxxx xxxx xxxx 1111 xxxx */
1128                 /* LDRH  : cccc 000x xxx1 xxxx xxxx xxxx 1011 xxxx */
1129                 /* STRH  : cccc 000x xxx0 xxxx xxxx xxxx 1011 xxxx */
1130                 /* LDRSB : cccc 000x xxx1 xxxx xxxx xxxx 1101 xxxx */
1131                 /* LDRSH : cccc 000x xxx1 xxxx xxxx xxxx 1111 xxxx */
1132                 if ((insn & 0x0f0000f0) == 0x01000090) {
1133                         if ((insn & 0x0fb000f0) == 0x01000090) {
1134                                 /* SWP/SWPB */
1135                                 return prep_emulate_rd12rn16rm0_wflags(insn,
1136                                                                         asi);
1137                         } else {
1138                                 /* STREX/LDREX variants and unallocaed space */
1139                                 return INSN_REJECTED;
1140                         }
1141
1142                 } else if ((insn & 0x0e1000d0) == 0x00000d0) {
1143                         /* STRD/LDRD */
1144                         if ((insn & 0x0000e000) == 0x0000e000)
1145                                 return INSN_REJECTED;   /* Rd is LR or PC */
1146                         if (is_writeback(insn) && is_r15(insn, 16))
1147                                 return INSN_REJECTED;   /* Writeback to PC */
1148
1149                         insn &= 0xfff00fff;
1150                         insn |= 0x00002000;     /* Rn = r0, Rd = r2 */
1151                         if (!(insn & (1 << 22))) {
1152                                 /* Register index */
1153                                 insn &= ~0xf;
1154                                 insn |= 1;      /* Rm = r1 */
1155                         }
1156                         asi->insn[0] = insn;
1157                         asi->insn_handler =
1158                                 (insn & (1 << 5)) ? emulate_strd : emulate_ldrd;
1159                         return INSN_GOOD;
1160                 }
1161
1162                 /* LDRH/STRH/LDRSB/LDRSH */
1163                 if (is_r15(insn, 12))
1164                         return INSN_REJECTED;   /* Rd is PC */
1165                 return prep_emulate_ldr_str(insn, asi);
1166         }
1167
1168         /* cccc 000x xxxx xxxx xxxx xxxx xxxx xxxx xxxx */
1169
1170         /*
1171          * ALU op with S bit and Rd == 15 :
1172          *      cccc 000x xxx1 xxxx 1111 xxxx xxxx xxxx
1173          */
1174         if ((insn & 0x0e10f000) == 0x0010f000)
1175                 return INSN_REJECTED;
1176
1177         /*
1178          * "mov ip, sp" is the most common kprobe'd instruction by far.
1179          * Check and optimize for it explicitly.
1180          */
1181         if (insn == 0xe1a0c00d) {
1182                 asi->insn_handler = simulate_mov_ipsp;
1183                 return INSN_GOOD_NO_SLOT;
1184         }
1185
1186         /*
1187          * Data processing: Immediate-shift / Register-shift
1188          * ALU op : cccc 000x xxxx xxxx xxxx xxxx xxxx xxxx
1189          * CPY    : cccc 0001 1010 xxxx xxxx 0000 0000 xxxx
1190          * MOV    : cccc 0001 101x xxxx xxxx xxxx xxxx xxxx
1191          * *S (bit 20) updates condition codes
1192          * ADC/SBC/RSC reads the C flag
1193          */
1194         insn &= 0xfff00ff0;     /* Rn = r0, Rd = r0 */
1195         insn |= 0x00000001;     /* Rm = r1 */
1196         if (insn & 0x010) {
1197                 insn &= 0xfffff0ff;     /* register shift */
1198                 insn |= 0x00000200;     /* Rs = r2 */
1199         }
1200         asi->insn[0] = insn;
1201
1202         if ((insn & 0x0f900000) == 0x01100000) {
1203                 /*
1204                  * TST : cccc 0001 0001 xxxx xxxx xxxx xxxx xxxx
1205                  * TEQ : cccc 0001 0011 xxxx xxxx xxxx xxxx xxxx
1206                  * CMP : cccc 0001 0101 xxxx xxxx xxxx xxxx xxxx
1207                  * CMN : cccc 0001 0111 xxxx xxxx xxxx xxxx xxxx
1208                  */
1209                 asi->insn_handler = emulate_alu_tests;
1210         } else {
1211                 /* ALU ops which write to Rd */
1212                 asi->insn_handler = (insn & (1 << 20)) ?  /* S-bit */
1213                                 emulate_alu_rwflags : emulate_alu_rflags;
1214         }
1215         return INSN_GOOD;
1216 }
1217
1218 static enum kprobe_insn __kprobes
1219 space_cccc_001x(kprobe_opcode_t insn, struct arch_specific_insn *asi)
1220 {
1221         /* MOVW  : cccc 0011 0000 xxxx xxxx xxxx xxxx xxxx */
1222         /* MOVT  : cccc 0011 0100 xxxx xxxx xxxx xxxx xxxx */
1223         if ((insn & 0x0fb00000) == 0x03000000)
1224                 return prep_emulate_rd12_modify(insn, asi);
1225
1226         /* hints : cccc 0011 0010 0000 xxxx xxxx xxxx xxxx */
1227         if ((insn & 0x0fff0000) == 0x03200000) {
1228                 unsigned op2 = insn & 0x000000ff;
1229                 if (op2 == 0x01 || op2 == 0x04) {
1230                         /* YIELD : cccc 0011 0010 0000 xxxx xxxx 0000 0001 */
1231                         /* SEV   : cccc 0011 0010 0000 xxxx xxxx 0000 0100 */
1232                         asi->insn[0] = insn;
1233                         asi->insn_handler = emulate_none;
1234                         return INSN_GOOD;
1235                 } else if (op2 <= 0x03) {
1236                         /* NOP   : cccc 0011 0010 0000 xxxx xxxx 0000 0000 */
1237                         /* WFE   : cccc 0011 0010 0000 xxxx xxxx 0000 0010 */
1238                         /* WFI   : cccc 0011 0010 0000 xxxx xxxx 0000 0011 */
1239                         /*
1240                          * We make WFE and WFI true NOPs to avoid stalls due
1241                          * to missing events whilst processing the probe.
1242                          */
1243                         asi->insn_handler = emulate_nop;
1244                         return INSN_GOOD_NO_SLOT;
1245                 }
1246                 /* For DBG and unallocated hints it's safest to reject them */
1247                 return INSN_REJECTED;
1248         }
1249
1250         /*
1251          * MSR   : cccc 0011 0x10 xxxx xxxx xxxx xxxx xxxx
1252          * ALU op with S bit and Rd == 15 :
1253          *         cccc 001x xxx1 xxxx 1111 xxxx xxxx xxxx
1254          */
1255         if ((insn & 0x0fb00000) == 0x03200000 ||        /* MSR */
1256             (insn & 0x0e10f000) == 0x0210f000)          /* ALU s-bit, R15  */
1257                 return INSN_REJECTED;
1258
1259         /*
1260          * Data processing: 32-bit Immediate
1261          * ALU op : cccc 001x xxxx xxxx xxxx xxxx xxxx xxxx
1262          * MOV    : cccc 0011 101x xxxx xxxx xxxx xxxx xxxx
1263          * *S (bit 20) updates condition codes
1264          * ADC/SBC/RSC reads the C flag
1265          */
1266         insn &= 0xfff00fff;     /* Rn = r0 and Rd = r0 */
1267         asi->insn[0] = insn;
1268
1269         if ((insn & 0x0f900000) == 0x03100000) {
1270                 /*
1271                  * TST : cccc 0011 0001 xxxx xxxx xxxx xxxx xxxx
1272                  * TEQ : cccc 0011 0011 xxxx xxxx xxxx xxxx xxxx
1273                  * CMP : cccc 0011 0101 xxxx xxxx xxxx xxxx xxxx
1274                  * CMN : cccc 0011 0111 xxxx xxxx xxxx xxxx xxxx
1275                  */
1276                 asi->insn_handler = emulate_alu_tests_imm;
1277         } else {
1278                 /* ALU ops which write to Rd */
1279                 asi->insn_handler = (insn & (1 << 20)) ?  /* S-bit */
1280                         emulate_alu_imm_rwflags : emulate_alu_imm_rflags;
1281         }
1282         return INSN_GOOD;
1283 }
1284
1285 static enum kprobe_insn __kprobes
1286 space_cccc_0110__1(kprobe_opcode_t insn, struct arch_specific_insn *asi)
1287 {
1288         /* SEL : cccc 0110 1000 xxxx xxxx xxxx 1011 xxxx GE: !!! */
1289         if ((insn & 0x0ff000f0) == 0x068000b0) {
1290                 if (is_r15(insn, 12))
1291                         return INSN_REJECTED;   /* Rd is PC */
1292                 insn &= 0xfff00ff0;     /* Rd = r0, Rn = r0 */
1293                 insn |= 0x00000001;     /* Rm = r1 */
1294                 asi->insn[0] = insn;
1295                 asi->insn_handler = emulate_sel;
1296                 return INSN_GOOD;
1297         }
1298
1299         /* SSAT   : cccc 0110 101x xxxx xxxx xxxx xx01 xxxx :Q */
1300         /* USAT   : cccc 0110 111x xxxx xxxx xxxx xx01 xxxx :Q */
1301         /* SSAT16 : cccc 0110 1010 xxxx xxxx xxxx 0011 xxxx :Q */
1302         /* USAT16 : cccc 0110 1110 xxxx xxxx xxxx 0011 xxxx :Q */
1303         if ((insn & 0x0fa00030) == 0x06a00010 ||
1304             (insn & 0x0fb000f0) == 0x06a00030) {
1305                 if (is_r15(insn, 12))
1306                         return INSN_REJECTED;   /* Rd is PC */
1307                 insn &= 0xffff0ff0;     /* Rd = r0, Rm = r0 */
1308                 asi->insn[0] = insn;
1309                 asi->insn_handler = emulate_sat;
1310                 return INSN_GOOD;
1311         }
1312
1313         /* REV    : cccc 0110 1011 xxxx xxxx xxxx 0011 xxxx */
1314         /* REV16  : cccc 0110 1011 xxxx xxxx xxxx 1011 xxxx */
1315         /* RBIT   : cccc 0110 1111 xxxx xxxx xxxx 0011 xxxx */
1316         /* REVSH  : cccc 0110 1111 xxxx xxxx xxxx 1011 xxxx */
1317         if ((insn & 0x0ff00070) == 0x06b00030 ||
1318             (insn & 0x0ff00070) == 0x06f00030)
1319                 return prep_emulate_rd12rm0(insn, asi);
1320
1321         /* ???       : cccc 0110 0000 xxxx xxxx xxxx xxx1 xxxx :   */
1322         /* SADD16    : cccc 0110 0001 xxxx xxxx xxxx 0001 xxxx :GE */
1323         /* SADDSUBX  : cccc 0110 0001 xxxx xxxx xxxx 0011 xxxx :GE */
1324         /* SSUBADDX  : cccc 0110 0001 xxxx xxxx xxxx 0101 xxxx :GE */
1325         /* SSUB16    : cccc 0110 0001 xxxx xxxx xxxx 0111 xxxx :GE */
1326         /* SADD8     : cccc 0110 0001 xxxx xxxx xxxx 1001 xxxx :GE */
1327         /* ???       : cccc 0110 0001 xxxx xxxx xxxx 1011 xxxx :   */
1328         /* ???       : cccc 0110 0001 xxxx xxxx xxxx 1101 xxxx :   */
1329         /* SSUB8     : cccc 0110 0001 xxxx xxxx xxxx 1111 xxxx :GE */
1330         /* QADD16    : cccc 0110 0010 xxxx xxxx xxxx 0001 xxxx :   */
1331         /* QADDSUBX  : cccc 0110 0010 xxxx xxxx xxxx 0011 xxxx :   */
1332         /* QSUBADDX  : cccc 0110 0010 xxxx xxxx xxxx 0101 xxxx :   */
1333         /* QSUB16    : cccc 0110 0010 xxxx xxxx xxxx 0111 xxxx :   */
1334         /* QADD8     : cccc 0110 0010 xxxx xxxx xxxx 1001 xxxx :   */
1335         /* ???       : cccc 0110 0010 xxxx xxxx xxxx 1011 xxxx :   */
1336         /* ???       : cccc 0110 0010 xxxx xxxx xxxx 1101 xxxx :   */
1337         /* QSUB8     : cccc 0110 0010 xxxx xxxx xxxx 1111 xxxx :   */
1338         /* SHADD16   : cccc 0110 0011 xxxx xxxx xxxx 0001 xxxx :   */
1339         /* SHADDSUBX : cccc 0110 0011 xxxx xxxx xxxx 0011 xxxx :   */
1340         /* SHSUBADDX : cccc 0110 0011 xxxx xxxx xxxx 0101 xxxx :   */
1341         /* SHSUB16   : cccc 0110 0011 xxxx xxxx xxxx 0111 xxxx :   */
1342         /* SHADD8    : cccc 0110 0011 xxxx xxxx xxxx 1001 xxxx :   */
1343         /* ???       : cccc 0110 0011 xxxx xxxx xxxx 1011 xxxx :   */
1344         /* ???       : cccc 0110 0011 xxxx xxxx xxxx 1101 xxxx :   */
1345         /* SHSUB8    : cccc 0110 0011 xxxx xxxx xxxx 1111 xxxx :   */
1346         /* ???       : cccc 0110 0100 xxxx xxxx xxxx xxx1 xxxx :   */
1347         /* UADD16    : cccc 0110 0101 xxxx xxxx xxxx 0001 xxxx :GE */
1348         /* UADDSUBX  : cccc 0110 0101 xxxx xxxx xxxx 0011 xxxx :GE */
1349         /* USUBADDX  : cccc 0110 0101 xxxx xxxx xxxx 0101 xxxx :GE */
1350         /* USUB16    : cccc 0110 0101 xxxx xxxx xxxx 0111 xxxx :GE */
1351         /* UADD8     : cccc 0110 0101 xxxx xxxx xxxx 1001 xxxx :GE */
1352         /* ???       : cccc 0110 0101 xxxx xxxx xxxx 1011 xxxx :   */
1353         /* ???       : cccc 0110 0101 xxxx xxxx xxxx 1101 xxxx :   */
1354         /* USUB8     : cccc 0110 0101 xxxx xxxx xxxx 1111 xxxx :GE */
1355         /* UQADD16   : cccc 0110 0110 xxxx xxxx xxxx 0001 xxxx :   */
1356         /* UQADDSUBX : cccc 0110 0110 xxxx xxxx xxxx 0011 xxxx :   */
1357         /* UQSUBADDX : cccc 0110 0110 xxxx xxxx xxxx 0101 xxxx :   */
1358         /* UQSUB16   : cccc 0110 0110 xxxx xxxx xxxx 0111 xxxx :   */
1359         /* UQADD8    : cccc 0110 0110 xxxx xxxx xxxx 1001 xxxx :   */
1360         /* ???       : cccc 0110 0110 xxxx xxxx xxxx 1011 xxxx :   */
1361         /* ???       : cccc 0110 0110 xxxx xxxx xxxx 1101 xxxx :   */
1362         /* UQSUB8    : cccc 0110 0110 xxxx xxxx xxxx 1111 xxxx :   */
1363         /* UHADD16   : cccc 0110 0111 xxxx xxxx xxxx 0001 xxxx :   */
1364         /* UHADDSUBX : cccc 0110 0111 xxxx xxxx xxxx 0011 xxxx :   */
1365         /* UHSUBADDX : cccc 0110 0111 xxxx xxxx xxxx 0101 xxxx :   */
1366         /* UHSUB16   : cccc 0110 0111 xxxx xxxx xxxx 0111 xxxx :   */
1367         /* UHADD8    : cccc 0110 0111 xxxx xxxx xxxx 1001 xxxx :   */
1368         /* ???       : cccc 0110 0111 xxxx xxxx xxxx 1011 xxxx :   */
1369         /* ???       : cccc 0110 0111 xxxx xxxx xxxx 1101 xxxx :   */
1370         /* UHSUB8    : cccc 0110 0111 xxxx xxxx xxxx 1111 xxxx :   */
1371         if ((insn & 0x0f800010) == 0x06000010) {
1372                 if ((insn & 0x00300000) == 0x00000000 ||
1373                     (insn & 0x000000e0) == 0x000000a0 ||
1374                     (insn & 0x000000e0) == 0x000000c0)
1375                         return INSN_REJECTED;   /* Unallocated space */
1376                 return prep_emulate_rd12rn16rm0_wflags(insn, asi);
1377         }
1378
1379         /* PKHBT     : cccc 0110 1000 xxxx xxxx xxxx x001 xxxx :   */
1380         /* PKHTB     : cccc 0110 1000 xxxx xxxx xxxx x101 xxxx :   */
1381         if ((insn & 0x0ff00030) == 0x06800010)
1382                 return prep_emulate_rd12rn16rm0_wflags(insn, asi);
1383
1384         /* SXTAB16   : cccc 0110 1000 xxxx xxxx xxxx 0111 xxxx :   */
1385         /* SXTB16    : cccc 0110 1000 1111 xxxx xxxx 0111 xxxx :   */
1386         /* ???       : cccc 0110 1001 xxxx xxxx xxxx 0111 xxxx :   */
1387         /* SXTAB     : cccc 0110 1010 xxxx xxxx xxxx 0111 xxxx :   */
1388         /* SXTB      : cccc 0110 1010 1111 xxxx xxxx 0111 xxxx :   */
1389         /* SXTAH     : cccc 0110 1011 xxxx xxxx xxxx 0111 xxxx :   */
1390         /* SXTH      : cccc 0110 1011 1111 xxxx xxxx 0111 xxxx :   */
1391         /* UXTAB16   : cccc 0110 1100 xxxx xxxx xxxx 0111 xxxx :   */
1392         /* UXTB16    : cccc 0110 1100 1111 xxxx xxxx 0111 xxxx :   */
1393         /* ???       : cccc 0110 1101 xxxx xxxx xxxx 0111 xxxx :   */
1394         /* UXTAB     : cccc 0110 1110 xxxx xxxx xxxx 0111 xxxx :   */
1395         /* UXTB      : cccc 0110 1110 1111 xxxx xxxx 0111 xxxx :   */
1396         /* UXTAH     : cccc 0110 1111 xxxx xxxx xxxx 0111 xxxx :   */
1397         /* UXTH      : cccc 0110 1111 1111 xxxx xxxx 0111 xxxx :   */
1398         if ((insn & 0x0f8000f0) == 0x06800070) {
1399                 if ((insn & 0x00300000) == 0x00100000)
1400                         return INSN_REJECTED;   /* Unallocated space */
1401
1402                 if ((insn & 0x000f0000) == 0x000f0000)
1403                         return prep_emulate_rd12rm0(insn, asi);
1404                 else
1405                         return prep_emulate_rd12rn16rm0_wflags(insn, asi);
1406         }
1407
1408         /* Other instruction encodings aren't yet defined */
1409         return INSN_REJECTED;
1410 }
1411
1412 static enum kprobe_insn __kprobes
1413 space_cccc_0111__1(kprobe_opcode_t insn, struct arch_specific_insn *asi)
1414 {
1415         /* Undef : cccc 0111 1111 xxxx xxxx xxxx 1111 xxxx */
1416         if ((insn & 0x0ff000f0) == 0x03f000f0)
1417                 return INSN_REJECTED;
1418
1419         /* SMLALD : cccc 0111 0100 xxxx xxxx xxxx 00x1 xxxx */
1420         /* SMLSLD : cccc 0111 0100 xxxx xxxx xxxx 01x1 xxxx */
1421         if ((insn & 0x0ff00090) == 0x07400010)
1422                 return prep_emulate_rdhi16rdlo12rs8rm0_wflags(insn, asi);
1423
1424         /* SMLAD  : cccc 0111 0000 xxxx xxxx xxxx 00x1 xxxx :Q */
1425         /* SMUAD  : cccc 0111 0000 xxxx 1111 xxxx 00x1 xxxx :Q */
1426         /* SMLSD  : cccc 0111 0000 xxxx xxxx xxxx 01x1 xxxx :Q */
1427         /* SMUSD  : cccc 0111 0000 xxxx 1111 xxxx 01x1 xxxx :  */
1428         /* SMMLA  : cccc 0111 0101 xxxx xxxx xxxx 00x1 xxxx :  */
1429         /* SMMUL  : cccc 0111 0101 xxxx 1111 xxxx 00x1 xxxx :  */
1430         /* USADA8 : cccc 0111 1000 xxxx xxxx xxxx 0001 xxxx :  */
1431         /* USAD8  : cccc 0111 1000 xxxx 1111 xxxx 0001 xxxx :  */
1432         if ((insn & 0x0ff00090) == 0x07000010 ||
1433             (insn & 0x0ff000d0) == 0x07500010 ||
1434             (insn & 0x0ff000f0) == 0x07800010) {
1435
1436                 if ((insn & 0x0000f000) == 0x0000f000)
1437                         return prep_emulate_rd16rs8rm0_wflags(insn, asi);
1438                 else
1439                         return prep_emulate_rd16rn12rs8rm0_wflags(insn, asi);
1440         }
1441
1442         /* SMMLS  : cccc 0111 0101 xxxx xxxx xxxx 11x1 xxxx :  */
1443         if ((insn & 0x0ff000d0) == 0x075000d0)
1444                 return prep_emulate_rd16rn12rs8rm0_wflags(insn, asi);
1445
1446         /* SBFX   : cccc 0111 101x xxxx xxxx xxxx x101 xxxx :  */
1447         /* UBFX   : cccc 0111 111x xxxx xxxx xxxx x101 xxxx :  */
1448         if ((insn & 0x0fa00070) == 0x07a00050)
1449                 return prep_emulate_rd12rm0(insn, asi);
1450
1451         /* BFI    : cccc 0111 110x xxxx xxxx xxxx x001 xxxx :  */
1452         /* BFC    : cccc 0111 110x xxxx xxxx xxxx x001 1111 :  */
1453         if ((insn & 0x0fe00070) == 0x07c00010) {
1454
1455                 if ((insn & 0x0000000f) == 0x0000000f)
1456                         return prep_emulate_rd12_modify(insn, asi);
1457                 else
1458                         return prep_emulate_rd12rn0_modify(insn, asi);
1459         }
1460
1461         return INSN_REJECTED;
1462 }
1463
1464 static enum kprobe_insn __kprobes
1465 space_cccc_01xx(kprobe_opcode_t insn, struct arch_specific_insn *asi)
1466 {
1467         /* LDR   : cccc 01xx x0x1 xxxx xxxx xxxx xxxx xxxx */
1468         /* LDRB  : cccc 01xx x1x1 xxxx xxxx xxxx xxxx xxxx */
1469         /* LDRBT : cccc 01x0 x111 xxxx xxxx xxxx xxxx xxxx */
1470         /* LDRT  : cccc 01x0 x011 xxxx xxxx xxxx xxxx xxxx */
1471         /* STR   : cccc 01xx x0x0 xxxx xxxx xxxx xxxx xxxx */
1472         /* STRB  : cccc 01xx x1x0 xxxx xxxx xxxx xxxx xxxx */
1473         /* STRBT : cccc 01x0 x110 xxxx xxxx xxxx xxxx xxxx */
1474         /* STRT  : cccc 01x0 x010 xxxx xxxx xxxx xxxx xxxx */
1475
1476         if ((insn & 0x00500000) == 0x00500000 && is_r15(insn, 12))
1477                 return INSN_REJECTED;   /* LDRB into PC */
1478
1479         return prep_emulate_ldr_str(insn, asi);
1480 }
1481
1482 static enum kprobe_insn __kprobes
1483 space_cccc_100x(kprobe_opcode_t insn, struct arch_specific_insn *asi)
1484 {
1485         /* LDM(2) : cccc 100x x101 xxxx 0xxx xxxx xxxx xxxx */
1486         /* LDM(3) : cccc 100x x1x1 xxxx 1xxx xxxx xxxx xxxx */
1487         if ((insn & 0x0e708000) == 0x85000000 ||
1488             (insn & 0x0e508000) == 0x85010000)
1489                 return INSN_REJECTED;
1490
1491         /* LDM(1) : cccc 100x x0x1 xxxx xxxx xxxx xxxx xxxx */
1492         /* STM(1) : cccc 100x x0x0 xxxx xxxx xxxx xxxx xxxx */
1493         asi->insn_handler = ((insn & 0x108000) == 0x008000) ? /* STM & R15 */
1494                                 simulate_stm1_pc : simulate_ldm1stm1;
1495         return INSN_GOOD_NO_SLOT;
1496 }
1497
1498 static enum kprobe_insn __kprobes
1499 space_cccc_101x(kprobe_opcode_t insn, struct arch_specific_insn *asi)
1500 {
1501         /* B  : cccc 1010 xxxx xxxx xxxx xxxx xxxx xxxx */
1502         /* BL : cccc 1011 xxxx xxxx xxxx xxxx xxxx xxxx */
1503         asi->insn_handler = simulate_bbl;
1504         return INSN_GOOD_NO_SLOT;
1505 }
1506
1507 static enum kprobe_insn __kprobes
1508 space_cccc_11xx(kprobe_opcode_t insn, struct arch_specific_insn *asi)
1509 {
1510         /* Coprocessor instructions... */
1511         /* MCRR : cccc 1100 0100 xxxx xxxx xxxx xxxx xxxx : (Rd!=Rn) */
1512         /* MRRC : cccc 1100 0101 xxxx xxxx xxxx xxxx xxxx : (Rd!=Rn) */
1513         /* LDC  : cccc 110x xxx1 xxxx xxxx xxxx xxxx xxxx */
1514         /* STC  : cccc 110x xxx0 xxxx xxxx xxxx xxxx xxxx */
1515         /* CDP  : cccc 1110 xxxx xxxx xxxx xxxx xxx0 xxxx */
1516         /* MCR  : cccc 1110 xxx0 xxxx xxxx xxxx xxx1 xxxx */
1517         /* MRC  : cccc 1110 xxx1 xxxx xxxx xxxx xxx1 xxxx */
1518
1519         /* SVC  : cccc 1111 xxxx xxxx xxxx xxxx xxxx xxxx */
1520
1521         return INSN_REJECTED;
1522 }
1523
1524 static unsigned long __kprobes __check_eq(unsigned long cpsr)
1525 {
1526         return cpsr & PSR_Z_BIT;
1527 }
1528
1529 static unsigned long __kprobes __check_ne(unsigned long cpsr)
1530 {
1531         return (~cpsr) & PSR_Z_BIT;
1532 }
1533
1534 static unsigned long __kprobes __check_cs(unsigned long cpsr)
1535 {
1536         return cpsr & PSR_C_BIT;
1537 }
1538
1539 static unsigned long __kprobes __check_cc(unsigned long cpsr)
1540 {
1541         return (~cpsr) & PSR_C_BIT;
1542 }
1543
1544 static unsigned long __kprobes __check_mi(unsigned long cpsr)
1545 {
1546         return cpsr & PSR_N_BIT;
1547 }
1548
1549 static unsigned long __kprobes __check_pl(unsigned long cpsr)
1550 {
1551         return (~cpsr) & PSR_N_BIT;
1552 }
1553
1554 static unsigned long __kprobes __check_vs(unsigned long cpsr)
1555 {
1556         return cpsr & PSR_V_BIT;
1557 }
1558
1559 static unsigned long __kprobes __check_vc(unsigned long cpsr)
1560 {
1561         return (~cpsr) & PSR_V_BIT;
1562 }
1563
1564 static unsigned long __kprobes __check_hi(unsigned long cpsr)
1565 {
1566         cpsr &= ~(cpsr >> 1); /* PSR_C_BIT &= ~PSR_Z_BIT */
1567         return cpsr & PSR_C_BIT;
1568 }
1569
1570 static unsigned long __kprobes __check_ls(unsigned long cpsr)
1571 {
1572         cpsr &= ~(cpsr >> 1); /* PSR_C_BIT &= ~PSR_Z_BIT */
1573         return (~cpsr) & PSR_C_BIT;
1574 }
1575
1576 static unsigned long __kprobes __check_ge(unsigned long cpsr)
1577 {
1578         cpsr ^= (cpsr << 3); /* PSR_N_BIT ^= PSR_V_BIT */
1579         return (~cpsr) & PSR_N_BIT;
1580 }
1581
1582 static unsigned long __kprobes __check_lt(unsigned long cpsr)
1583 {
1584         cpsr ^= (cpsr << 3); /* PSR_N_BIT ^= PSR_V_BIT */
1585         return cpsr & PSR_N_BIT;
1586 }
1587
1588 static unsigned long __kprobes __check_gt(unsigned long cpsr)
1589 {
1590         unsigned long temp = cpsr ^ (cpsr << 3); /* PSR_N_BIT ^= PSR_V_BIT */
1591         temp |= (cpsr << 1);                     /* PSR_N_BIT |= PSR_Z_BIT */
1592         return (~temp) & PSR_N_BIT;
1593 }
1594
1595 static unsigned long __kprobes __check_le(unsigned long cpsr)
1596 {
1597         unsigned long temp = cpsr ^ (cpsr << 3); /* PSR_N_BIT ^= PSR_V_BIT */
1598         temp |= (cpsr << 1);                     /* PSR_N_BIT |= PSR_Z_BIT */
1599         return temp & PSR_N_BIT;
1600 }
1601
1602 static unsigned long __kprobes __check_al(unsigned long cpsr)
1603 {
1604         return true;
1605 }
1606
1607 static kprobe_check_cc * const condition_checks[16] = {
1608         &__check_eq, &__check_ne, &__check_cs, &__check_cc,
1609         &__check_mi, &__check_pl, &__check_vs, &__check_vc,
1610         &__check_hi, &__check_ls, &__check_ge, &__check_lt,
1611         &__check_gt, &__check_le, &__check_al, &__check_al
1612 };
1613
1614 /* Return:
1615  *   INSN_REJECTED     If instruction is one not allowed to kprobe,
1616  *   INSN_GOOD         If instruction is supported and uses instruction slot,
1617  *   INSN_GOOD_NO_SLOT If instruction is supported but doesn't use its slot.
1618  *
1619  * For instructions we don't want to kprobe (INSN_REJECTED return result):
1620  *   These are generally ones that modify the processor state making
1621  *   them "hard" to simulate such as switches processor modes or
1622  *   make accesses in alternate modes.  Any of these could be simulated
1623  *   if the work was put into it, but low return considering they
1624  *   should also be very rare.
1625  */
1626 enum kprobe_insn __kprobes
1627 arm_kprobe_decode_insn(kprobe_opcode_t insn, struct arch_specific_insn *asi)
1628 {
1629         asi->insn_check_cc = condition_checks[insn>>28];
1630         asi->insn[1] = KPROBE_RETURN_INSTRUCTION;
1631
1632         if ((insn & 0xf0000000) == 0xf0000000)
1633
1634                 return space_1111(insn, asi);
1635
1636         else if ((insn & 0x0e000000) == 0x00000000)
1637
1638                 return space_cccc_000x(insn, asi);
1639
1640         else if ((insn & 0x0e000000) == 0x02000000)
1641
1642                 return space_cccc_001x(insn, asi);
1643
1644         else if ((insn & 0x0f000010) == 0x06000010)
1645
1646                 return space_cccc_0110__1(insn, asi);
1647
1648         else if ((insn & 0x0f000010) == 0x07000010)
1649
1650                 return space_cccc_0111__1(insn, asi);
1651
1652         else if ((insn & 0x0c000000) == 0x04000000)
1653
1654                 return space_cccc_01xx(insn, asi);
1655
1656         else if ((insn & 0x0e000000) == 0x08000000)
1657
1658                 return space_cccc_100x(insn, asi);
1659
1660         else if ((insn & 0x0e000000) == 0x0a000000)
1661
1662                 return space_cccc_101x(insn, asi);
1663
1664         return space_cccc_11xx(insn, asi);
1665 }
1666
1667 void __init arm_kprobe_decode_init(void)
1668 {
1669         find_str_pc_offset();
1670 }