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