vm/compiler/codegen/arm/Assemble.c

   1 /*
   2  * Copyright (C) 2009 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include "Dalvik.h"
  18 #include "libdex/OpCode.h"
  19 #include "dexdump/OpCodeNames.h"
  20
  21 #include "../../CompilerInternals.h"
  22 #include "ArmLIR.h"
  23 #include <unistd.h>             /* for cacheflush */
  24
  25 /*
  26  * opcode: ArmOpCode enum
  27  * skeleton: pre-designated bit-pattern for this opcode
  28  * k0: key to applying ds/de
  29  * ds: dest start bit position
  30  * de: dest end bit position
  31  * k1: key to applying s1s/s1e
  32  * s1s: src1 start bit position
  33  * s1e: src1 end bit position
  34  * k2: key to applying s2s/s2e
  35  * s2s: src2 start bit position
  36  * s2e: src2 end bit position
  37  * operands: number of operands (for sanity check purposes)
  38  * name: mnemonic name
  39  * fmt: for pretty-prining
  40  */
  41 #define ENCODING_MAP(opcode, skeleton, k0, ds, de, k1, s1s, s1e, k2, s2s, s2e, \
  42                      k3, k3s, k3e, flags, name, fmt, size) \
  43         {skeleton, {{k0, ds, de}, {k1, s1s, s1e}, {k2, s2s, s2e}, \
  44                     {k3, k3s, k3e}}, opcode, flags, name, fmt, size}
  45
  46 /* Instruction dump string format keys: !pf, where "!" is the start
  47  * of the key, "p" is which numeric operand to use and "f" is the
  48  * print format.
  49  *
  50  * [p]ositions:
  51  *     0 -> operands[0] (dest)
  52  *     1 -> operands[1] (src1)
  53  *     2 -> operands[2] (src2)
  54  *     3 -> operands[3] (extra)
  55  *
  56  * [f]ormats:
  57  *     h -> 4-digit hex
  58  *     d -> decimal
  59  *     E -> decimal*4
  60  *     F -> decimal*2
  61  *     c -> branch condition (beq, bne, etc.)
  62  *     t -> pc-relative target
  63  *     u -> 1st half of bl[x] target
  64  *     v -> 2nd half ob bl[x] target
  65  *     R -> register list
  66  *     s -> single precision floating point register
  67  *     S -> double precision floating point register
  68  *     m -> Thumb2 modified immediate
  69  *     n -> complimented Thumb2 modified immediate
  70  *     M -> Thumb2 16-bit zero-extended immediate
  71  *     b -> 4-digit binary
  72  *
  73  *  [!] escape.  To insert "!", use "!!"
  74  */
  75 /* NOTE: must be kept in sync with enum ArmOpcode from ArmLIR.h */
  76 ArmEncodingMap EncodingMap[kArmLast] = {
  77     ENCODING_MAP(kArm16BitData,    0x0000,
  78                  kFmtBitBlt, 15, 0, kFmtUnused, -1, -1, kFmtUnused, -1, -1,
  79                  kFmtUnused, -1, -1, IS_UNARY_OP, "data", "0x!0h(!0d)", 1),
  80     ENCODING_MAP(kThumbAdcRR,        0x4140,
  81                  kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtUnused, -1, -1,
  82                  kFmtUnused, -1, -1,
  83                  IS_BINARY_OP | REG_DEF0_USE01 | SETS_CCODES | USES_CCODES,
  84                  "adcs", "r!0d, r!1d", 1),
  85     ENCODING_MAP(kThumbAddRRI3,      0x1c00,
  86                  kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtBitBlt, 8, 6,
  87                  kFmtUnused, -1, -1,
  88                  IS_TERTIARY_OP | REG_DEF0_USE1 | SETS_CCODES,
  89                  "adds", "r!0d, r!1d, #!2d", 1),
  90     ENCODING_MAP(kThumbAddRI8,       0x3000,
  91                  kFmtBitBlt, 10, 8, kFmtBitBlt, 7, 0, kFmtUnused, -1, -1,
  92                  kFmtUnused, -1, -1,
  93                  IS_BINARY_OP | REG_DEF0_USE0 | SETS_CCODES,
  94                  "adds", "r!0d, r!0d, #!1d", 1),
  95     ENCODING_MAP(kThumbAddRRR,       0x1800,
  96                  kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtBitBlt, 8, 6,
  97                  kFmtUnused, -1, -1,
  98                  IS_TERTIARY_OP | REG_DEF0_USE12 | SETS_CCODES,
  99                  "adds", "r!0d, r!1d, r!2d", 1),
 100     ENCODING_MAP(kThumbAddRRLH,     0x4440,
 101                  kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtUnused, -1, -1,
 102                  kFmtUnused, -1, -1, IS_BINARY_OP | REG_DEF0_USE01,
 103                  "add", "r!0d, r!1d", 1),
 104     ENCODING_MAP(kThumbAddRRHL,     0x4480,
 105                  kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtUnused, -1, -1,
 106                  kFmtUnused, -1, -1, IS_BINARY_OP | REG_DEF0_USE01,
 107                  "add", "r!0d, r!1d", 1),
 108     ENCODING_MAP(kThumbAddRRHH,     0x44c0,
 109                  kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtUnused, -1, -1,
 110                  kFmtUnused, -1, -1, IS_BINARY_OP | REG_DEF0_USE01,
 111                  "add", "r!0d, r!1d", 1),
 112     ENCODING_MAP(kThumbAddPcRel,    0xa000,
 113                  kFmtBitBlt, 10, 8, kFmtBitBlt, 7, 0, kFmtUnused, -1, -1,
 114                  kFmtUnused, -1, -1, IS_TERTIARY_OP | IS_BRANCH,
 115                  "add", "r!0d, pc, #!1E", 1),
 116     ENCODING_MAP(kThumbAddSpRel,    0xa800,
 117                  kFmtBitBlt, 10, 8, kFmtUnused, -1, -1, kFmtBitBlt, 7, 0,
 118                  kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF_SP | REG_USE_SP,
 119                  "add", "r!0d, sp, #!2E", 1),
 120     ENCODING_MAP(kThumbAddSpI7,      0xb000,
 121                  kFmtBitBlt, 6, 0, kFmtUnused, -1, -1, kFmtUnused, -1, -1,
 122                  kFmtUnused, -1, -1, IS_UNARY_OP | REG_DEF_SP | REG_USE_SP,
 123                  "add", "sp, #!0d*4", 1),
 124     ENCODING_MAP(kThumbAndRR,        0x4000,
 125                  kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtUnused, -1, -1,
 126                  kFmtUnused, -1, -1,
 127                  IS_BINARY_OP | REG_DEF0_USE01 | SETS_CCODES,
 128                  "ands", "r!0d, r!1d", 1),
 129     ENCODING_MAP(kThumbAsrRRI5,      0x1000,
 130                  kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtBitBlt, 10, 6,
 131                  kFmtUnused, -1, -1,
 132                  IS_TERTIARY_OP | REG_DEF0_USE1 | SETS_CCODES,
 133                  "asrs", "r!0d, r!1d, #!2d", 1),
 134     ENCODING_MAP(kThumbAsrRR,        0x4100,
 135                  kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtUnused, -1, -1,
 136                  kFmtUnused, -1, -1,
 137                  IS_BINARY_OP | REG_DEF0_USE01 | SETS_CCODES,
 138                  "asrs", "r!0d, r!1d", 1),
 139     ENCODING_MAP(kThumbBCond,        0xd000,
 140                  kFmtBitBlt, 7, 0, kFmtBitBlt, 11, 8, kFmtUnused, -1, -1,
 141                  kFmtUnused, -1, -1, IS_BINARY_OP | IS_BRANCH | USES_CCODES,
 142                  "b!1c", "!0t", 1),
 143     ENCODING_MAP(kThumbBUncond,      0xe000,
 144                  kFmtBitBlt, 10, 0, kFmtUnused, -1, -1, kFmtUnused, -1, -1,
 145                  kFmtUnused, -1, -1, NO_OPERAND | IS_BRANCH,
 146                  "b", "!0t", 1),
 147     ENCODING_MAP(kThumbBicRR,        0x4380,
 148                  kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtUnused, -1, -1,
 149                  kFmtUnused, -1, -1,
 150                  IS_BINARY_OP | REG_DEF0_USE01 | SETS_CCODES,
 151                  "bics", "r!0d, r!1d", 1),
 152     ENCODING_MAP(kThumbBkpt,          0xbe00,
 153                  kFmtBitBlt, 7, 0, kFmtUnused, -1, -1, kFmtUnused, -1, -1,
 154                  kFmtUnused, -1, -1, IS_UNARY_OP | IS_BRANCH,
 155                  "bkpt", "!0d", 1),
 156     ENCODING_MAP(kThumbBlx1,         0xf000,
 157                  kFmtBitBlt, 10, 0, kFmtUnused, -1, -1, kFmtUnused, -1, -1,
 158                  kFmtUnused, -1, -1, IS_BINARY_OP | IS_BRANCH | REG_DEF_LR,
 159                  "blx_1", "!0u", 1),
 160     ENCODING_MAP(kThumbBlx2,         0xe800,
 161                  kFmtBitBlt, 10, 0, kFmtUnused, -1, -1, kFmtUnused, -1, -1,
 162                  kFmtUnused, -1, -1, IS_BINARY_OP | IS_BRANCH | REG_DEF_LR,
 163                  "blx_2", "!0v", 1),
 164     ENCODING_MAP(kThumbBl1,          0xf000,
 165                  kFmtBitBlt, 10, 0, kFmtUnused, -1, -1, kFmtUnused, -1, -1,
 166                  kFmtUnused, -1, -1, IS_UNARY_OP | IS_BRANCH | REG_DEF_LR,
 167                  "bl_1", "!0u", 1),
 168     ENCODING_MAP(kThumbBl2,          0xf800,
 169                  kFmtBitBlt, 10, 0, kFmtUnused, -1, -1, kFmtUnused, -1, -1,
 170                  kFmtUnused, -1, -1, IS_UNARY_OP | IS_BRANCH | REG_DEF_LR,
 171                  "bl_2", "!0v", 1),
 172     ENCODING_MAP(kThumbBlxR,         0x4780,
 173                  kFmtBitBlt, 6, 3, kFmtUnused, -1, -1, kFmtUnused, -1, -1,
 174                  kFmtUnused, -1, -1,
 175                  IS_UNARY_OP | REG_USE0 | IS_BRANCH | REG_DEF_LR,
 176                  "blx", "r!0d", 1),
 177     ENCODING_MAP(kThumbBx,            0x4700,
 178                  kFmtBitBlt, 6, 3, kFmtUnused, -1, -1, kFmtUnused, -1, -1,
 179                  kFmtUnused, -1, -1, IS_UNARY_OP | IS_BRANCH,
 180                  "bx", "r!0d", 1),
 181     ENCODING_MAP(kThumbCmnRR,        0x42c0,
 182                  kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtUnused, -1, -1,
 183                  kFmtUnused, -1, -1, IS_BINARY_OP | REG_USE01 | SETS_CCODES,
 184                  "cmn", "r!0d, r!1d", 1),
 185     ENCODING_MAP(kThumbCmpRI8,       0x2800,
 186                  kFmtBitBlt, 10, 8, kFmtBitBlt, 7, 0, kFmtUnused, -1, -1,
 187                  kFmtUnused, -1, -1, IS_BINARY_OP | REG_USE0 | SETS_CCODES,
 188                  "cmp", "r!0d, #!1d", 1),
 189     ENCODING_MAP(kThumbCmpRR,        0x4280,
 190                  kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtUnused, -1, -1,
 191                  kFmtUnused, -1, -1, IS_BINARY_OP | REG_USE01 | SETS_CCODES,
 192                  "cmp", "r!0d, r!1d", 1),
 193     ENCODING_MAP(kThumbCmpLH,        0x4540,
 194                  kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtUnused, -1, -1,
 195                  kFmtUnused, -1, -1, IS_BINARY_OP | REG_USE01 | SETS_CCODES,
 196                  "cmp", "r!0d, r!1d", 1),
 197     ENCODING_MAP(kThumbCmpHL,        0x4580,
 198                  kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtUnused, -1, -1,
 199                  kFmtUnused, -1, -1, IS_BINARY_OP | REG_USE01 | SETS_CCODES,
 200                  "cmp", "r!0d, r!1d", 1),
 201     ENCODING_MAP(kThumbCmpHH,        0x45c0,
 202                  kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtUnused, -1, -1,
 203                  kFmtUnused, -1, -1, IS_BINARY_OP | REG_USE01 | SETS_CCODES,
 204                  "cmp", "r!0d, r!1d", 1),
 205     ENCODING_MAP(kThumbEorRR,        0x4040,
 206                  kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtUnused, -1, -1,
 207                  kFmtUnused, -1, -1,
 208                  IS_BINARY_OP | REG_DEF0_USE01 | SETS_CCODES,
 209                  "eors", "r!0d, r!1d", 1),
 210     ENCODING_MAP(kThumbLdmia,         0xc800,
 211                  kFmtBitBlt, 10, 8, kFmtBitBlt, 7, 0, kFmtUnused, -1, -1,
 212                  kFmtUnused, -1, -1,
 213                  IS_BINARY_OP | REG_DEF0_USE0 | REG_DEF_LIST1,
 214                  "ldmia", "r!0d!!, <!1R>", 1),
 215     ENCODING_MAP(kThumbLdrRRI5,      0x6800,
 216                  kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtBitBlt, 10, 6,
 217                  kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0_USE1,
 218                  "ldr", "r!0d, [r!1d, #!2E]", 1),
 219     ENCODING_MAP(kThumbLdrRRR,       0x5800,
 220                  kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtBitBlt, 8, 6,
 221                  kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0_USE12,
 222                  "ldr", "r!0d, [r!1d, r!2d]", 1),
 223     ENCODING_MAP(kThumbLdrPcRel,    0x4800,
 224                  kFmtBitBlt, 10, 8, kFmtBitBlt, 7, 0, kFmtUnused, -1, -1,
 225                  kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0 | REG_USE_PC,
 226                  "ldr", "r!0d, [pc, #!1E]", 1),
 227     ENCODING_MAP(kThumbLdrSpRel,    0x9800,
 228                  kFmtBitBlt, 10, 8, kFmtUnused, -1, -1, kFmtBitBlt, 7, 0,
 229                  kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0 | REG_USE_SP,
 230                  "ldr", "r!0d, [sp, #!2E]", 1),
 231     ENCODING_MAP(kThumbLdrbRRI5,     0x7800,
 232                  kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtBitBlt, 10, 6,
 233                  kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0_USE1,
 234                  "ldrb", "r!0d, [r!1d, #2d]", 1),
 235     ENCODING_MAP(kThumbLdrbRRR,      0x5c00,
 236                  kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtBitBlt, 8, 6,
 237                  kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0_USE12,
 238                  "ldrb", "r!0d, [r!1d, r!2d]", 1),
 239     ENCODING_MAP(kThumbLdrhRRI5,     0x8800,
 240                  kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtBitBlt, 10, 6,
 241                  kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0_USE1,
 242                  "ldrh", "r!0d, [r!1d, #!2F]", 1),
 243     ENCODING_MAP(kThumbLdrhRRR,      0x5a00,
 244                  kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtBitBlt, 8, 6,
 245                  kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0_USE12,
 246                  "ldrh", "r!0d, [r!1d, r!2d]", 1),
 247     ENCODING_MAP(kThumbLdrsbRRR,     0x5600,
 248                  kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtBitBlt, 8, 6,
 249                  kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0_USE12,
 250                  "ldrsb", "r!0d, [r!1d, r!2d]", 1),
 251     ENCODING_MAP(kThumbLdrshRRR,     0x5e00,
 252                  kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtBitBlt, 8, 6,
 253                  kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0_USE12,
 254                  "ldrsh", "r!0d, [r!1d, r!2d]", 1),
 255     ENCODING_MAP(kThumbLslRRI5,      0x0000,
 256                  kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtBitBlt, 10, 6,
 257                  kFmtUnused, -1, -1,
 258                  IS_TERTIARY_OP | REG_DEF0_USE1 | SETS_CCODES,
 259                  "lsls", "r!0d, r!1d, #!2d", 1),
 260     ENCODING_MAP(kThumbLslRR,        0x4080,
 261                  kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtUnused, -1, -1,
 262                  kFmtUnused, -1, -1,
 263                  IS_BINARY_OP | REG_DEF0_USE01 | SETS_CCODES,
 264                  "lsls", "r!0d, r!1d", 1),
 265     ENCODING_MAP(kThumbLsrRRI5,      0x0800,
 266                  kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtBitBlt, 10, 6,
 267                  kFmtUnused, -1, -1,
 268                  IS_TERTIARY_OP | REG_DEF0_USE1 | SETS_CCODES,
 269                  "lsrs", "r!0d, r!1d, #!2d", 1),
 270     ENCODING_MAP(kThumbLsrRR,        0x40c0,
 271                  kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtUnused, -1, -1,
 272                  kFmtUnused, -1, -1,
 273                  IS_BINARY_OP | REG_DEF0_USE01 | SETS_CCODES,
 274                  "lsrs", "r!0d, r!1d", 1),
 275     ENCODING_MAP(kThumbMovImm,       0x2000,
 276                  kFmtBitBlt, 10, 8, kFmtBitBlt, 7, 0, kFmtUnused, -1, -1,
 277                  kFmtUnused, -1, -1,
 278                  IS_BINARY_OP | REG_DEF0 | SETS_CCODES,
 279                  "movs", "r!0d, #!1d", 1),
 280     ENCODING_MAP(kThumbMovRR,        0x1c00,
 281                  kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtUnused, -1, -1,
 282                  kFmtUnused, -1, -1,
 283                  IS_BINARY_OP | REG_DEF0_USE1 | SETS_CCODES,
 284                  "movs", "r!0d, r!1d", 1),
 285     ENCODING_MAP(kThumbMovRR_H2H,    0x46c0,
 286                  kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtUnused, -1, -1,
 287                  kFmtUnused, -1, -1, IS_BINARY_OP | REG_DEF0_USE1,
 288                  "mov", "r!0d, r!1d", 1),
 289     ENCODING_MAP(kThumbMovRR_H2L,    0x4640,
 290                  kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtUnused, -1, -1,
 291                  kFmtUnused, -1, -1, IS_BINARY_OP | REG_DEF0_USE1,
 292                  "mov", "r!0d, r!1d", 1),
 293     ENCODING_MAP(kThumbMovRR_L2H,    0x4680,
 294                  kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtUnused, -1, -1,
 295                  kFmtUnused, -1, -1, IS_BINARY_OP | REG_DEF0_USE1,
 296                  "mov", "r!0d, r!1d", 1),
 297     ENCODING_MAP(kThumbMul,           0x4340,
 298                  kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtUnused, -1, -1,
 299                  kFmtUnused, -1, -1,
 300                  IS_BINARY_OP | REG_DEF0_USE01 | SETS_CCODES,
 301                  "muls", "r!0d, r!1d", 1),
 302     ENCODING_MAP(kThumbMvn,           0x43c0,
 303                  kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtUnused, -1, -1,
 304                  kFmtUnused, -1, -1,
 305                  IS_BINARY_OP | REG_DEF0_USE1 | SETS_CCODES,
 306                  "mvns", "r!0d, r!1d", 1),
 307     ENCODING_MAP(kThumbNeg,           0x4240,
 308                  kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtUnused, -1, -1,
 309                  kFmtUnused, -1, -1,
 310                  IS_BINARY_OP | REG_DEF0_USE1 | SETS_CCODES,
 311                  "negs", "r!0d, r!1d", 1),
 312     ENCODING_MAP(kThumbOrr,           0x4300,
 313                  kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtUnused, -1, -1,
 314                  kFmtUnused, -1, -1,
 315                  IS_BINARY_OP | REG_DEF0_USE01 | SETS_CCODES,
 316                  "orrs", "r!0d, r!1d", 1),
 317     ENCODING_MAP(kThumbPop,           0xbc00,
 318                  kFmtBitBlt, 8, 0, kFmtUnused, -1, -1, kFmtUnused, -1, -1,
 319                  kFmtUnused, -1, -1,
 320                  IS_UNARY_OP | REG_DEF_SP | REG_USE_SP | REG_DEF_LIST0,
 321                  "pop", "<!0R>", 1),
 322     ENCODING_MAP(kThumbPush,          0xb400,
 323                  kFmtBitBlt, 8, 0, kFmtUnused, -1, -1, kFmtUnused, -1, -1,
 324                  kFmtUnused, -1, -1,
 325                  IS_UNARY_OP | REG_DEF_SP | REG_USE_SP | REG_USE_LIST0,
 326                  "push", "<!0R>", 1),
 327     ENCODING_MAP(kThumbRorRR,        0x41c0,
 328                  kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtUnused, -1, -1,
 329                  kFmtUnused, -1, -1,
 330                  IS_BINARY_OP | REG_DEF0_USE01 | SETS_CCODES,
 331                  "rors", "r!0d, r!1d", 1),
 332     ENCODING_MAP(kThumbSbc,           0x4180,
 333                  kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtUnused, -1, -1,
 334                  kFmtUnused, -1, -1,
 335                  IS_BINARY_OP | REG_DEF0_USE01 | USES_CCODES | SETS_CCODES,
 336                  "sbcs", "r!0d, r!1d", 1),
 337     ENCODING_MAP(kThumbStmia,         0xc000,
 338                  kFmtBitBlt, 10, 8, kFmtBitBlt, 7, 0, kFmtUnused, -1, -1,
 339                  kFmtUnused, -1, -1,
 340                  IS_BINARY_OP | REG_DEF0 | REG_USE0 | REG_USE_LIST1,
 341                  "stmia", "r!0d!!, <!1R>", 1),
 342     ENCODING_MAP(kThumbStrRRI5,      0x6000,
 343                  kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtBitBlt, 10, 6,
 344                  kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_USE01,
 345                  "str", "r!0d, [r!1d, #!2E]", 1),
 346     ENCODING_MAP(kThumbStrRRR,       0x5000,
 347                  kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtBitBlt, 8, 6,
 348                  kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_USE012,
 349                  "str", "r!0d, [r!1d, r!2d]", 1),
 350     ENCODING_MAP(kThumbStrSpRel,    0x9000,
 351                  kFmtBitBlt, 10, 8, kFmtUnused, -1, -1, kFmtBitBlt, 7, 0,
 352                  kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_USE0 | REG_USE_SP,
 353                  "str", "r!0d, [sp, #!2E]", 1),
 354     ENCODING_MAP(kThumbStrbRRI5,     0x7000,
 355                  kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtBitBlt, 10, 6,
 356                  kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_USE01,
 357                  "strb", "r!0d, [r!1d, #!2d]", 1),
 358     ENCODING_MAP(kThumbStrbRRR,      0x5400,
 359                  kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtBitBlt, 8, 6,
 360                  kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_USE012,
 361                  "strb", "r!0d, [r!1d, r!2d]", 1),
 362     ENCODING_MAP(kThumbStrhRRI5,     0x8000,
 363                  kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtBitBlt, 10, 6,
 364                  kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_USE01,
 365                  "strh", "r!0d, [r!1d, #!2F]", 1),
 366     ENCODING_MAP(kThumbStrhRRR,      0x5200,
 367                  kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtBitBlt, 8, 6,
 368                  kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_USE012,
 369                  "strh", "r!0d, [r!1d, r!2d]", 1),
 370     ENCODING_MAP(kThumbSubRRI3,      0x1e00,
 371                  kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtBitBlt, 8, 6,
 372                  kFmtUnused, -1, -1,
 373                  IS_TERTIARY_OP | REG_DEF0_USE1 | SETS_CCODES,
 374                  "subs", "r!0d, r!1d, #!2d]", 1),
 375     ENCODING_MAP(kThumbSubRI8,       0x3800,
 376                  kFmtBitBlt, 10, 8, kFmtBitBlt, 7, 0, kFmtUnused, -1, -1,
 377                  kFmtUnused, -1, -1,
 378                  IS_BINARY_OP | REG_DEF0_USE0 | SETS_CCODES,
 379                  "subs", "r!0d, #!1d", 1),
 380     ENCODING_MAP(kThumbSubRRR,       0x1a00,
 381                  kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtBitBlt, 8, 6,
 382                  kFmtUnused, -1, -1,
 383                  IS_TERTIARY_OP | REG_DEF0_USE12 | SETS_CCODES,
 384                  "subs", "r!0d, r!1d, r!2d", 1),
 385     ENCODING_MAP(kThumbSubSpI7,      0xb080,
 386                  kFmtBitBlt, 6, 0, kFmtUnused, -1, -1, kFmtUnused, -1, -1,
 387                  kFmtUnused, -1, -1,
 388                  IS_UNARY_OP | REG_DEF_SP | REG_USE_SP,
 389                  "sub", "sp, #!0d", 1),
 390     ENCODING_MAP(kThumbSwi,           0xdf00,
 391                  kFmtBitBlt, 7, 0, kFmtUnused, -1, -1, kFmtUnused, -1, -1,                       kFmtUnused, -1, -1, IS_UNARY_OP | IS_BRANCH,
 392                  "swi", "!0d", 1),
 393     ENCODING_MAP(kThumbTst,           0x4200,
 394                  kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtUnused, -1, -1,
 395                  kFmtUnused, -1, -1, IS_UNARY_OP | REG_USE01 | SETS_CCODES,
 396                  "tst", "r!0d, r!1d", 1),
 397     ENCODING_MAP(kThumb2Vldrs,       0xed900a00,
 398                  kFmtSfp, 22, 12, kFmtBitBlt, 19, 16, kFmtBitBlt, 7, 0,
 399                  kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0_USE1,
 400                  "vldr", "!0s, [r!1d, #!2E]", 2),
 401     ENCODING_MAP(kThumb2Vldrd,       0xed900b00,
 402                  kFmtDfp, 22, 12, kFmtBitBlt, 19, 16, kFmtBitBlt, 7, 0,
 403                  kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0_USE1,
 404                  "vldr", "!0S, [r!1d, #!2E]", 2),
 405     ENCODING_MAP(kThumb2Vmuls,        0xee200a00,
 406                  kFmtSfp, 22, 12, kFmtSfp, 7, 16, kFmtSfp, 5, 0,
 407                  kFmtUnused, -1, -1,
 408                  IS_TERTIARY_OP | REG_DEF0_USE12,
 409                  "vmuls", "!0s, !1s, !2s", 2),
 410     ENCODING_MAP(kThumb2Vmuld,        0xee200b00,
 411                  kFmtDfp, 22, 12, kFmtDfp, 7, 16, kFmtDfp, 5, 0,
 412                  kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0_USE12,
 413                  "vmuld", "!0S, !1S, !2S", 2),
 414     ENCODING_MAP(kThumb2Vstrs,       0xed800a00,
 415                  kFmtSfp, 22, 12, kFmtBitBlt, 19, 16, kFmtBitBlt, 7, 0,
 416                  kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_USE01,
 417                  "vstr", "!0s, [r!1d, #!2E]", 2),
 418     ENCODING_MAP(kThumb2Vstrd,       0xed800b00,
 419                  kFmtDfp, 22, 12, kFmtBitBlt, 19, 16, kFmtBitBlt, 7, 0,
 420                  kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_USE01,
 421                  "vstr", "!0S, [r!1d, #!2E]", 2),
 422     ENCODING_MAP(kThumb2Vsubs,        0xee300a40,
 423                  kFmtSfp, 22, 12, kFmtSfp, 7, 16, kFmtSfp, 5, 0,
 424                  kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0_USE12,
 425                  "vsub", "!0s, !1s, !2s", 2),
 426     ENCODING_MAP(kThumb2Vsubd,        0xee300b40,
 427                  kFmtDfp, 22, 12, kFmtDfp, 7, 16, kFmtDfp, 5, 0,
 428                  kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0_USE12,
 429                  "vsub", "!0S, !1S, !2S", 2),
 430     ENCODING_MAP(kThumb2Vadds,        0xee300a00,
 431                  kFmtSfp, 22, 12, kFmtSfp, 7, 16, kFmtSfp, 5, 0,
 432                  kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0_USE12,
 433                  "vadd", "!0s, !1s, !2s", 2),
 434     ENCODING_MAP(kThumb2Vaddd,        0xee300b00,
 435                  kFmtDfp, 22, 12, kFmtDfp, 7, 16, kFmtDfp, 5, 0,
 436                  kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0_USE12,
 437                  "vadd", "!0S, !1S, !2S", 2),
 438     ENCODING_MAP(kThumb2Vdivs,        0xee800a00,
 439                  kFmtSfp, 22, 12, kFmtSfp, 7, 16, kFmtSfp, 5, 0,
 440                  kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0_USE12,
 441                  "vdivs", "!0s, !1s, !2s", 2),
 442     ENCODING_MAP(kThumb2Vdivd,        0xee800b00,
 443                  kFmtDfp, 22, 12, kFmtDfp, 7, 16, kFmtDfp, 5, 0,
 444                  kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0_USE12,
 445                  "vdivd", "!0S, !1S, !2S", 2),
 446     ENCODING_MAP(kThumb2VcvtIF,       0xeeb80ac0,
 447                  kFmtSfp, 22, 12, kFmtSfp, 5, 0, kFmtUnused, -1, -1,
 448                  kFmtUnused, -1, -1, IS_BINARY_OP | REG_DEF0_USE1,
 449                  "vcvt.f32", "!0s, !1s", 2),
 450     ENCODING_MAP(kThumb2VcvtID,       0xeeb80bc0,
 451                  kFmtDfp, 22, 12, kFmtSfp, 5, 0, kFmtUnused, -1, -1,
 452                  kFmtUnused, -1, -1, IS_BINARY_OP | REG_DEF0_USE1,
 453                  "vcvt.f64", "!0S, !1s", 2),
 454     ENCODING_MAP(kThumb2VcvtFI,       0xeebd0ac0,
 455                  kFmtSfp, 22, 12, kFmtSfp, 5, 0, kFmtUnused, -1, -1,
 456                  kFmtUnused, -1, -1, IS_BINARY_OP | REG_DEF0_USE1,
 457                  "vcvt.s32.f32 ", "!0s, !1s", 2),
 458     ENCODING_MAP(kThumb2VcvtDI,       0xeebd0bc0,
 459                  kFmtSfp, 22, 12, kFmtDfp, 5, 0, kFmtUnused, -1, -1,
 460                  kFmtUnused, -1, -1, IS_BINARY_OP | REG_DEF0_USE1,
 461                  "vcvt.s32.f64 ", "!0s, !1S", 2),
 462     ENCODING_MAP(kThumb2VcvtFd,       0xeeb70ac0,
 463                  kFmtDfp, 22, 12, kFmtSfp, 5, 0, kFmtUnused, -1, -1,
 464                  kFmtUnused, -1, -1, IS_BINARY_OP | REG_DEF0_USE1,
 465                  "vcvt.f64.f32 ", "!0S, !1s", 2),
 466     ENCODING_MAP(kThumb2VcvtDF,       0xeeb70bc0,
 467                  kFmtSfp, 22, 12, kFmtDfp, 5, 0, kFmtUnused, -1, -1,
 468                  kFmtUnused, -1, -1, IS_BINARY_OP | REG_DEF0_USE1,
 469                  "vcvt.f32.f64 ", "!0s, !1S", 2),
 470     ENCODING_MAP(kThumb2Vsqrts,       0xeeb10ac0,
 471                  kFmtSfp, 22, 12, kFmtSfp, 5, 0, kFmtUnused, -1, -1,
 472                  kFmtUnused, -1, -1, IS_BINARY_OP | REG_DEF0_USE1,
 473                  "vsqrt.f32 ", "!0s, !1s", 2),
 474     ENCODING_MAP(kThumb2Vsqrtd,       0xeeb10bc0,
 475                  kFmtDfp, 22, 12, kFmtDfp, 5, 0, kFmtUnused, -1, -1,
 476                  kFmtUnused, -1, -1, IS_BINARY_OP | REG_DEF0_USE1,
 477                  "vsqrt.f64 ", "!0S, !1S", 2),
 478     ENCODING_MAP(kThumb2MovImmShift, 0xf04f0000, /* no setflags encoding */
 479                  kFmtBitBlt, 11, 8, kFmtModImm, -1, -1, kFmtUnused, -1, -1,
 480                  kFmtUnused, -1, -1, IS_BINARY_OP | REG_DEF0,
 481                  "mov", "r!0d, #!1m", 2),
 482     ENCODING_MAP(kThumb2MovImm16,       0xf2400000,
 483                  kFmtBitBlt, 11, 8, kFmtImm16, -1, -1, kFmtUnused, -1, -1,
 484                  kFmtUnused, -1, -1, IS_BINARY_OP | REG_DEF0,
 485                  "mov", "r!0d, #!1M", 2),
 486     ENCODING_MAP(kThumb2StrRRI12,       0xf8c00000,
 487                  kFmtBitBlt, 15, 12, kFmtBitBlt, 19, 16, kFmtBitBlt, 11, 0,
 488                  kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_USE01,
 489                  "str", "r!0d,[r!1d, #!2d", 2),
 490     ENCODING_MAP(kThumb2LdrRRI12,       0xf8d00000,
 491                  kFmtBitBlt, 15, 12, kFmtBitBlt, 19, 16, kFmtBitBlt, 11, 0,
 492                  kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0_USE1,
 493                  "ldr", "r!0d,[r!1d, #!2d", 2),
 494     ENCODING_MAP(kThumb2StrRRI8Predec,       0xf8400c00,
 495                  kFmtBitBlt, 15, 12, kFmtBitBlt, 19, 16, kFmtBitBlt, 8, 0,
 496                  kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_USE01,
 497                  "str", "r!0d,[r!1d, #-!2d]", 2),
 498     ENCODING_MAP(kThumb2LdrRRI8Predec,       0xf8500c00,
 499                  kFmtBitBlt, 15, 12, kFmtBitBlt, 19, 16, kFmtBitBlt, 8, 0,
 500                  kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0_USE1,
 501                  "ldr", "r!0d,[r!1d, #-!2d]", 2),
 502     ENCODING_MAP(kThumb2Cbnz,       0xb900, /* Note: does not affect flags */
 503                  kFmtBitBlt, 2, 0, kFmtImm6, -1, -1, kFmtUnused, -1, -1,
 504                  kFmtUnused, -1, -1, IS_BINARY_OP | REG_USE0 | IS_BRANCH,
 505                  "cbnz", "r!0d,!1t", 1),
 506     ENCODING_MAP(kThumb2Cbz,       0xb100, /* Note: does not affect flags */
 507                  kFmtBitBlt, 2, 0, kFmtImm6, -1, -1, kFmtUnused, -1, -1,
 508                  kFmtUnused, -1, -1, IS_BINARY_OP | REG_USE0 | IS_BRANCH,
 509                  "cbz", "r!0d,!1t", 1),
 510     ENCODING_MAP(kThumb2AddRRI12,       0xf2000000,
 511                  kFmtBitBlt, 11, 8, kFmtBitBlt, 19, 16, kFmtImm12, -1, -1,
 512                  kFmtUnused, -1, -1,
 513                  IS_TERTIARY_OP | REG_DEF0_USE1,/* Note: doesn't affect flags */
 514                  "add", "r!0d,r!1d,#!2d", 2),
 515     ENCODING_MAP(kThumb2MovRR,       0xea4f0000, /* no setflags encoding */
 516                  kFmtBitBlt, 11, 8, kFmtBitBlt, 3, 0, kFmtUnused, -1, -1,
 517                  kFmtUnused, -1, -1, IS_BINARY_OP | REG_DEF0_USE1,
 518                  "mov", "r!0d, r!1d", 2),
 519     ENCODING_MAP(kThumb2Vmovs,       0xeeb00a40,
 520                  kFmtSfp, 22, 12, kFmtSfp, 5, 0, kFmtUnused, -1, -1,
 521                  kFmtUnused, -1, -1, IS_BINARY_OP | REG_DEF0_USE1,
 522                  "vmov.f32 ", " !0s, !1s", 2),
 523     ENCODING_MAP(kThumb2Vmovd,       0xeeb00b40,
 524                  kFmtDfp, 22, 12, kFmtDfp, 5, 0, kFmtUnused, -1, -1,
 525                  kFmtUnused, -1, -1, IS_BINARY_OP | REG_DEF0_USE1,
 526                  "vmov.f64 ", " !0S, !1S", 2),
 527     ENCODING_MAP(kThumb2Ldmia,         0xe8900000,
 528                  kFmtBitBlt, 19, 16, kFmtBitBlt, 15, 0, kFmtUnused, -1, -1,
 529                  kFmtUnused, -1, -1,
 530                  IS_BINARY_OP | REG_DEF0_USE0 | REG_DEF_LIST1,
 531                  "ldmia", "r!0d!!, <!1R>", 2),
 532     ENCODING_MAP(kThumb2Stmia,         0xe8800000,
 533                  kFmtBitBlt, 19, 16, kFmtBitBlt, 15, 0, kFmtUnused, -1, -1,
 534                  kFmtUnused, -1, -1,
 535                  IS_BINARY_OP | REG_DEF0_USE0 | REG_USE_LIST1,
 536                  "stmia", "r!0d!!, <!1R>", 2),
 537     ENCODING_MAP(kThumb2AddRRR,  0xeb100000, /* setflags encoding */
 538                  kFmtBitBlt, 11, 8, kFmtBitBlt, 19, 16, kFmtBitBlt, 3, 0,
 539                  kFmtShift, -1, -1,
 540                  IS_QUAD_OP | REG_DEF0_USE12 | SETS_CCODES,
 541                  "adds", "r!0d, r!1d, r!2d", 2),
 542     ENCODING_MAP(kThumb2SubRRR,       0xebb00000, /* setflags enconding */
 543                  kFmtBitBlt, 11, 8, kFmtBitBlt, 19, 16, kFmtBitBlt, 3, 0,
 544                  kFmtShift, -1, -1,
 545                  IS_QUAD_OP | REG_DEF0_USE12 | SETS_CCODES,
 546                  "subs", "r!0d, r!1d, r!2d", 2),
 547     ENCODING_MAP(kThumb2SbcRRR,       0xeb700000, /* setflags encoding */
 548                  kFmtBitBlt, 11, 8, kFmtBitBlt, 19, 16, kFmtBitBlt, 3, 0,
 549                  kFmtShift, -1, -1,
 550                  IS_QUAD_OP | REG_DEF0_USE12 | USES_CCODES | SETS_CCODES,
 551                  "sbcs", "r!0d, r!1d, r!2d", 2),
 552     ENCODING_MAP(kThumb2CmpRR,       0xebb00f00,
 553                  kFmtBitBlt, 19, 16, kFmtBitBlt, 3, 0, kFmtShift, -1, -1,
 554                  kFmtUnused, -1, -1,
 555                  IS_TERTIARY_OP | REG_USE01 | SETS_CCODES,
 556                  "cmp", "r!0d, r!1d", 2),
 557     ENCODING_MAP(kThumb2SubRRI12,       0xf2a00000,
 558                  kFmtBitBlt, 11, 8, kFmtBitBlt, 19, 16, kFmtImm12, -1, -1,
 559                  kFmtUnused, -1, -1,
 560                  IS_TERTIARY_OP | REG_DEF0_USE1,/* Note: doesn't affect flags */
 561                  "sub", "r!0d,r!1d,#!2d", 2),
 562     ENCODING_MAP(kThumb2MvnImmShift,  0xf06f0000, /* no setflags encoding */
 563                  kFmtBitBlt, 11, 8, kFmtModImm, -1, -1, kFmtUnused, -1, -1,
 564                  kFmtUnused, -1, -1, IS_BINARY_OP | REG_DEF0,
 565                  "mvn", "r!0d, #!1n", 2),
 566     ENCODING_MAP(kThumb2Sel,       0xfaa0f080,
 567                  kFmtBitBlt, 11, 8, kFmtBitBlt, 19, 16, kFmtBitBlt, 3, 0,
 568                  kFmtUnused, -1, -1,
 569                  IS_TERTIARY_OP | REG_DEF0_USE12 | USES_CCODES,
 570                  "sel", "r!0d, r!1d, r!2d", 2),
 571     ENCODING_MAP(kThumb2Ubfx,       0xf3c00000,
 572                  kFmtBitBlt, 11, 8, kFmtBitBlt, 19, 16, kFmtLsb, -1, -1,
 573                  kFmtBWidth, 4, 0, IS_QUAD_OP | REG_DEF0_USE1,
 574                  "ubfx", "r!0d, r!1d, #!2d, #!3d", 2),
 575     ENCODING_MAP(kThumb2Sbfx,       0xf3400000,
 576                  kFmtBitBlt, 11, 8, kFmtBitBlt, 19, 16, kFmtLsb, -1, -1,
 577                  kFmtBWidth, 4, 0, IS_QUAD_OP | REG_DEF0_USE1,
 578                  "sbfx", "r!0d, r!1d, #!2d, #!3d", 2),
 579     ENCODING_MAP(kThumb2LdrRRR,    0xf8500000,
 580                  kFmtBitBlt, 15, 12, kFmtBitBlt, 19, 16, kFmtBitBlt, 3, 0,
 581                  kFmtBitBlt, 5, 4, IS_QUAD_OP | REG_DEF0_USE12,
 582                  "ldr", "r!0d,[r!1d, r!2d, LSL #!3d]", 2),
 583     ENCODING_MAP(kThumb2LdrhRRR,    0xf8300000,
 584                  kFmtBitBlt, 15, 12, kFmtBitBlt, 19, 16, kFmtBitBlt, 3, 0,
 585                  kFmtBitBlt, 5, 4, IS_QUAD_OP | REG_DEF0_USE12,
 586                  "ldrh", "r!0d,[r!1d, r!2d, LSL #!3d]", 2),
 587     ENCODING_MAP(kThumb2LdrshRRR,    0xf9300000,
 588                  kFmtBitBlt, 15, 12, kFmtBitBlt, 19, 16, kFmtBitBlt, 3, 0,
 589                  kFmtBitBlt, 5, 4, IS_QUAD_OP | REG_DEF0_USE12,
 590                  "ldrsh", "r!0d,[r!1d, r!2d, LSL #!3d]", 2),
 591     ENCODING_MAP(kThumb2LdrbRRR,    0xf8100000,
 592                  kFmtBitBlt, 15, 12, kFmtBitBlt, 19, 16, kFmtBitBlt, 3, 0,
 593                  kFmtBitBlt, 5, 4, IS_QUAD_OP | REG_DEF0_USE12,
 594                  "ldrb", "r!0d,[r!1d, r!2d, LSL #!3d]", 2),
 595     ENCODING_MAP(kThumb2LdrsbRRR,    0xf9100000,
 596                  kFmtBitBlt, 15, 12, kFmtBitBlt, 19, 16, kFmtBitBlt, 3, 0,
 597                  kFmtBitBlt, 5, 4, IS_QUAD_OP | REG_DEF0_USE12,
 598                  "ldrsb", "r!0d,[r!1d, r!2d, LSL #!3d]", 2),
 599     ENCODING_MAP(kThumb2StrRRR,    0xf8400000,
 600                  kFmtBitBlt, 15, 12, kFmtBitBlt, 19, 16, kFmtBitBlt, 3, 0,
 601                  kFmtBitBlt, 5, 4, IS_QUAD_OP | REG_USE012,
 602                  "str", "r!0d,[r!1d, r!2d, LSL #!3d]", 2),
 603     ENCODING_MAP(kThumb2StrhRRR,    0xf8200000,
 604                  kFmtBitBlt, 15, 12, kFmtBitBlt, 19, 16, kFmtBitBlt, 3, 0,
 605                  kFmtBitBlt, 5, 4, IS_QUAD_OP | REG_USE012,
 606                  "strh", "r!0d,[r!1d, r!2d, LSL #!3d]", 2),
 607     ENCODING_MAP(kThumb2StrbRRR,    0xf8000000,
 608                  kFmtBitBlt, 15, 12, kFmtBitBlt, 19, 16, kFmtBitBlt, 3, 0,
 609                  kFmtBitBlt, 5, 4, IS_QUAD_OP | REG_USE012,
 610                  "strb", "r!0d,[r!1d, r!2d, LSL #!3d]", 2),
 611     ENCODING_MAP(kThumb2LdrhRRI12,       0xf8b00000,
 612                  kFmtBitBlt, 15, 12, kFmtBitBlt, 19, 16, kFmtBitBlt, 11, 0,
 613                  kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0_USE1,
 614                  "ldrh", "r!0d,[r!1d, #!2d]", 2),
 615     ENCODING_MAP(kThumb2LdrshRRI12,       0xf9b00000,
 616                  kFmtBitBlt, 15, 12, kFmtBitBlt, 19, 16, kFmtBitBlt, 11, 0,
 617                  kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0_USE1,
 618                  "ldrsh", "r!0d,[r!1d, #!2d]", 2),
 619     ENCODING_MAP(kThumb2LdrbRRI12,       0xf8900000,
 620                  kFmtBitBlt, 15, 12, kFmtBitBlt, 19, 16, kFmtBitBlt, 11, 0,
 621                  kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0_USE1,
 622                  "ldrb", "r!0d,[r!1d, #!2d]", 2),
 623     ENCODING_MAP(kThumb2LdrsbRRI12,       0xf9900000,
 624                  kFmtBitBlt, 15, 12, kFmtBitBlt, 19, 16, kFmtBitBlt, 11, 0,
 625                  kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0_USE1,
 626                  "ldrsb", "r!0d,[r!1d, #!2d]", 2),
 627     ENCODING_MAP(kThumb2StrhRRI12,       0xf8a00000,
 628                  kFmtBitBlt, 15, 12, kFmtBitBlt, 19, 16, kFmtBitBlt, 11, 0,
 629                  kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_USE01,
 630                  "strh", "r!0d,[r!1d, #!2d]", 2),
 631     ENCODING_MAP(kThumb2StrbRRI12,       0xf8800000,
 632                  kFmtBitBlt, 15, 12, kFmtBitBlt, 19, 16, kFmtBitBlt, 11, 0,
 633                  kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_USE01,
 634                  "strb", "r!0d,[r!1d, #!2d]", 2),
 635     ENCODING_MAP(kThumb2Pop,           0xe8bd0000,
 636                  kFmtBitBlt, 15, 0, kFmtUnused, -1, -1, kFmtUnused, -1, -1,
 637                  kFmtUnused, -1, -1,
 638                  IS_UNARY_OP | REG_DEF_SP | REG_USE_SP | REG_DEF_LIST0,
 639                  "pop", "<!0R>", 2),
 640     ENCODING_MAP(kThumb2Push,          0xe8ad0000,
 641                  kFmtBitBlt, 15, 0, kFmtUnused, -1, -1, kFmtUnused, -1, -1,
 642                  kFmtUnused, -1, -1,
 643                  IS_UNARY_OP | REG_DEF_SP | REG_USE_SP | REG_USE_LIST0,
 644                  "push", "<!0R>", 2),
 645     ENCODING_MAP(kThumb2CmpRI8, 0xf1b00f00,
 646                  kFmtBitBlt, 19, 16, kFmtModImm, -1, -1, kFmtUnused, -1, -1,
 647                  kFmtUnused, -1, -1,
 648                  IS_BINARY_OP | REG_USE0 | SETS_CCODES,
 649                  "cmp", "r!0d, #!1m", 2),
 650     ENCODING_MAP(kThumb2AdcRRR,  0xeb500000, /* setflags encoding */
 651                  kFmtBitBlt, 11, 8, kFmtBitBlt, 19, 16, kFmtBitBlt, 3, 0,
 652                  kFmtShift, -1, -1,
 653                  IS_QUAD_OP | REG_DEF0_USE12 | SETS_CCODES,
 654                  "acds", "r!0d, r!1d, r!2d, shift !3d", 2),
 655     ENCODING_MAP(kThumb2AndRRR,  0xea000000,
 656                  kFmtBitBlt, 11, 8, kFmtBitBlt, 19, 16, kFmtBitBlt, 3, 0,
 657                  kFmtShift, -1, -1, IS_QUAD_OP | REG_DEF0_USE12,
 658                  "and", "r!0d, r!1d, r!2d, shift !3d", 2),
 659     ENCODING_MAP(kThumb2BicRRR,  0xea200000,
 660                  kFmtBitBlt, 11, 8, kFmtBitBlt, 19, 16, kFmtBitBlt, 3, 0,
 661                  kFmtShift, -1, -1, IS_QUAD_OP | REG_DEF0_USE12,
 662                  "bic", "r!0d, r!1d, r!2d, shift !3d", 2),
 663     ENCODING_MAP(kThumb2CmnRR,  0xeb000000,
 664                  kFmtBitBlt, 19, 16, kFmtBitBlt, 3, 0, kFmtShift, -1, -1,
 665                  kFmtUnused, -1, -1,
 666                  IS_TERTIARY_OP | REG_DEF0_USE1 | SETS_CCODES,
 667                  "cmn", "r!0d, r!1d, shift !2d", 2),
 668     ENCODING_MAP(kThumb2EorRRR,  0xea800000,
 669                  kFmtBitBlt, 11, 8, kFmtBitBlt, 19, 16, kFmtBitBlt, 3, 0,
 670                  kFmtShift, -1, -1, IS_QUAD_OP | REG_DEF0_USE12,
 671                  "eor", "r!0d, r!1d, r!2d, shift !3d", 2),
 672     ENCODING_MAP(kThumb2MulRRR,  0xfb00f000,
 673                  kFmtBitBlt, 11, 8, kFmtBitBlt, 19, 16, kFmtBitBlt, 3, 0,
 674                  kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0_USE12,
 675                  "mul", "r!0d, r!1d, r!2d", 2),
 676     ENCODING_MAP(kThumb2MnvRR,  0xea6f0000,
 677                  kFmtBitBlt, 11, 8, kFmtBitBlt, 3, 0, kFmtShift, -1, -1,
 678                  kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0_USE1,
 679                  "mvn", "r!0d, r!1d, shift !2d", 2),
 680     ENCODING_MAP(kThumb2RsubRRI8,       0xf1d00000,
 681                  kFmtBitBlt, 11, 8, kFmtBitBlt, 19, 16, kFmtModImm, -1, -1,
 682                  kFmtUnused, -1, -1,
 683                  IS_TERTIARY_OP | REG_DEF0_USE1 | SETS_CCODES,
 684                  "rsb", "r!0d,r!1d,#!2m", 2),
 685     ENCODING_MAP(kThumb2NegRR,       0xf1d00000, /* instance of rsub */
 686                  kFmtBitBlt, 11, 8, kFmtBitBlt, 19, 16, kFmtUnused, -1, -1,
 687                  kFmtUnused, -1, -1,
 688                  IS_BINARY_OP | REG_DEF0_USE1 | SETS_CCODES,
 689                  "neg", "r!0d,r!1d", 2),
 690     ENCODING_MAP(kThumb2OrrRRR,  0xea400000,
 691                  kFmtBitBlt, 11, 8, kFmtBitBlt, 19, 16, kFmtBitBlt, 3, 0,
 692                  kFmtShift, -1, -1, IS_QUAD_OP | REG_DEF0_USE12,
 693                  "orr", "r!0d, r!1d, r!2d, shift !3d", 2),
 694     ENCODING_MAP(kThumb2TstRR,       0xea100f00,
 695                  kFmtBitBlt, 19, 16, kFmtBitBlt, 3, 0, kFmtShift, -1, -1,
 696                  kFmtUnused, -1, -1,
 697                  IS_TERTIARY_OP | REG_USE01 | SETS_CCODES,
 698                  "tst", "r!0d, r!1d, shift !2d", 2),
 699     ENCODING_MAP(kThumb2LslRRR,  0xfa00f000,
 700                  kFmtBitBlt, 11, 8, kFmtBitBlt, 19, 16, kFmtBitBlt, 3, 0,
 701                  kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0_USE12,
 702                  "lsl", "r!0d, r!1d, r!2d", 2),
 703     ENCODING_MAP(kThumb2LsrRRR,  0xfa20f000,
 704                  kFmtBitBlt, 11, 8, kFmtBitBlt, 19, 16, kFmtBitBlt, 3, 0,
 705                  kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0_USE12,
 706                  "lsr", "r!0d, r!1d, r!2d", 2),
 707     ENCODING_MAP(kThumb2AsrRRR,  0xfa40f000,
 708                  kFmtBitBlt, 11, 8, kFmtBitBlt, 19, 16, kFmtBitBlt, 3, 0,
 709                  kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0_USE12,
 710                  "asr", "r!0d, r!1d, r!2d", 2),
 711     ENCODING_MAP(kThumb2RorRRR,  0xfa60f000,
 712                  kFmtBitBlt, 11, 8, kFmtBitBlt, 19, 16, kFmtBitBlt, 3, 0,
 713                  kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0_USE12,
 714                  "ror", "r!0d, r!1d, r!2d", 2),
 715     ENCODING_MAP(kThumb2LslRRI5,  0xea4f0000,
 716                  kFmtBitBlt, 11, 8, kFmtBitBlt, 3, 0, kFmtShift5, -1, -1,
 717                  kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0_USE1,
 718                  "lsl", "r!0d, r!1d, #!2d", 2),
 719     ENCODING_MAP(kThumb2LsrRRI5,  0xea4f0010,
 720                  kFmtBitBlt, 11, 8, kFmtBitBlt, 3, 0, kFmtShift5, -1, -1,
 721                  kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0_USE1,
 722                  "lsr", "r!0d, r!1d, #!2d", 2),
 723     ENCODING_MAP(kThumb2AsrRRI5,  0xea4f0020,
 724                  kFmtBitBlt, 11, 8, kFmtBitBlt, 3, 0, kFmtShift5, -1, -1,
 725                  kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0_USE1,
 726                  "asr", "r!0d, r!1d, #!2d", 2),
 727     ENCODING_MAP(kThumb2RorRRI5,  0xea4f0030,
 728                  kFmtBitBlt, 11, 8, kFmtBitBlt, 3, 0, kFmtShift5, -1, -1,
 729                  kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0_USE1,
 730                  "ror", "r!0d, r!1d, #!2d", 2),
 731     ENCODING_MAP(kThumb2BicRRI8,  0xf0200000,
 732                  kFmtBitBlt, 11, 8, kFmtBitBlt, 19, 16, kFmtModImm, -1, -1,
 733                  kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0_USE1,
 734                  "bic", "r!0d, r!1d, #!2m", 2),
 735     ENCODING_MAP(kThumb2AndRRI8,  0xf0000000,
 736                  kFmtBitBlt, 11, 8, kFmtBitBlt, 19, 16, kFmtModImm, -1, -1,
 737                  kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0_USE1,
 738                  "and", "r!0d, r!1d, #!2m", 2),
 739     ENCODING_MAP(kThumb2OrrRRI8,  0xf0400000,
 740                  kFmtBitBlt, 11, 8, kFmtBitBlt, 19, 16, kFmtModImm, -1, -1,
 741                  kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0_USE1,
 742                  "orr", "r!0d, r!1d, #!2m", 2),
 743     ENCODING_MAP(kThumb2EorRRI8,  0xf0800000,
 744                  kFmtBitBlt, 11, 8, kFmtBitBlt, 19, 16, kFmtModImm, -1, -1,
 745                  kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0_USE1,
 746                  "eor", "r!0d, r!1d, #!2m", 2),
 747     ENCODING_MAP(kThumb2AddRRI8,  0xf1100000,
 748                  kFmtBitBlt, 11, 8, kFmtBitBlt, 19, 16, kFmtModImm, -1, -1,
 749                  kFmtUnused, -1, -1,
 750                  IS_TERTIARY_OP | REG_DEF0_USE1 | SETS_CCODES,
 751                  "adds", "r!0d, r!1d, #!2m", 2),
 752     ENCODING_MAP(kThumb2AdcRRI8,  0xf1500000,
 753                  kFmtBitBlt, 11, 8, kFmtBitBlt, 19, 16, kFmtModImm, -1, -1,
 754                  kFmtUnused, -1, -1,
 755                  IS_TERTIARY_OP | REG_DEF0_USE1 | SETS_CCODES | USES_CCODES,
 756                  "adcs", "r!0d, r!1d, #!2m", 2),
 757     ENCODING_MAP(kThumb2SubRRI8,  0xf1b00000,
 758                  kFmtBitBlt, 11, 8, kFmtBitBlt, 19, 16, kFmtModImm, -1, -1,
 759                  kFmtUnused, -1, -1,
 760                  IS_TERTIARY_OP | REG_DEF0_USE1 | SETS_CCODES,
 761                  "subs", "r!0d, r!1d, #!2m", 2),
 762     ENCODING_MAP(kThumb2SbcRRI8,  0xf1700000,
 763                  kFmtBitBlt, 11, 8, kFmtBitBlt, 19, 16, kFmtModImm, -1, -1,
 764                  kFmtUnused, -1, -1,
 765                  IS_TERTIARY_OP | REG_DEF0_USE1 | SETS_CCODES | USES_CCODES,
 766                  "sbcs", "r!0d, r!1d, #!2m", 2),
 767     ENCODING_MAP(kThumb2It,  0xbf00,
 768                  kFmtBitBlt, 7, 4, kFmtBitBlt, 3, 0, kFmtModImm, -1, -1,
 769                  kFmtUnused, -1, -1, IS_BINARY_OP | IS_IT | USES_CCODES,
 770                  "it:!1b", "!0c", 1),
 771     ENCODING_MAP(kThumb2Fmstat,  0xeef1fa10,
 772                  kFmtUnused, -1, -1, kFmtUnused, -1, -1, kFmtUnused, -1, -1,
 773                  kFmtUnused, -1, -1, NO_OPERAND | SETS_CCODES,
 774                  "fmstat", "", 2),
 775     ENCODING_MAP(kThumb2Vcmpd,        0xeeb40b40,
 776                  kFmtDfp, 22, 12, kFmtDfp, 5, 0, kFmtUnused, -1, -1,
 777                  kFmtUnused, -1, -1, IS_BINARY_OP | REG_USE01,
 778                  "vcmp.f64", "!0S, !1S", 2),
 779     ENCODING_MAP(kThumb2Vcmps,        0xeeb40a40,
 780                  kFmtSfp, 22, 12, kFmtSfp, 5, 0, kFmtUnused, -1, -1,
 781                  kFmtUnused, -1, -1, IS_BINARY_OP | REG_USE01,
 782                  "vcmp.f32", "!0s, !1s", 2),
 783     ENCODING_MAP(kThumb2LdrPcRel12,       0xf8df0000,
 784                  kFmtBitBlt, 15, 12, kFmtBitBlt, 11, 0, kFmtUnused, -1, -1,
 785                  kFmtUnused, -1, -1,
 786                  IS_TERTIARY_OP | REG_DEF0 | REG_USE_PC,
 787                  "ldr", "r!0d,[rpc, #!1d]", 2),
 788     ENCODING_MAP(kThumb2BCond,        0xf0008000,
 789                  kFmtBrOffset, -1, -1, kFmtBitBlt, 25, 22, kFmtUnused, -1, -1,
 790                  kFmtUnused, -1, -1,
 791                  IS_BINARY_OP | IS_BRANCH | USES_CCODES,
 792                  "b!1c", "!0t", 2),
 793     ENCODING_MAP(kThumb2Vmovd_RR,       0xeeb00b40,
 794                  kFmtDfp, 22, 12, kFmtDfp, 5, 0, kFmtUnused, -1, -1,
 795                  kFmtUnused, -1, -1, IS_BINARY_OP | REG_DEF0_USE1,
 796                  "vmov.f64", "!0S, !1S", 2),
 797     ENCODING_MAP(kThumb2Vmovs_RR,       0xeeb00a40,
 798                  kFmtSfp, 22, 12, kFmtSfp, 5, 0, kFmtUnused, -1, -1,
 799                  kFmtUnused, -1, -1, IS_BINARY_OP | REG_DEF0_USE1,
 800                  "vmov.f32", "!0s, !1s", 2),
 801     ENCODING_MAP(kThumb2Fmrs,       0xee100a10,
 802                  kFmtBitBlt, 15, 12, kFmtSfp, 7, 16, kFmtUnused, -1, -1,
 803                  kFmtUnused, -1, -1, IS_BINARY_OP | REG_DEF0_USE1,
 804                  "fmrs", "r!0d, !1s", 2),
 805     ENCODING_MAP(kThumb2Fmsr,       0xee000a10,
 806                  kFmtSfp, 7, 16, kFmtBitBlt, 15, 12, kFmtUnused, -1, -1,
 807                  kFmtUnused, -1, -1, IS_BINARY_OP | REG_DEF0_USE1,
 808                  "fmsr", "!0s, r!1d", 2),
 809     ENCODING_MAP(kThumb2Fmrrd,       0xec500b10,
 810                  kFmtBitBlt, 15, 12, kFmtBitBlt, 19, 16, kFmtDfp, 5, 0,
 811                  kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF01_USE2,
 812                  "fmrrd", "r!0d, r!1d, !2S", 2),
 813     ENCODING_MAP(kThumb2Fmdrr,       0xec400b10,
 814                  kFmtDfp, 5, 0, kFmtBitBlt, 15, 12, kFmtBitBlt, 19, 16,
 815                  kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0_USE12,
 816                  "fmdrr", "!0S, r!1d, r!2d", 2),
 817     ENCODING_MAP(kThumb2Vabsd,       0xeeb00bc0,
 818                  kFmtDfp, 22, 12, kFmtDfp, 5, 0, kFmtUnused, -1, -1,
 819                  kFmtUnused, -1, -1, IS_BINARY_OP | REG_DEF0_USE1,
 820                  "vabs.f64", "!0S, !1S", 2),
 821     ENCODING_MAP(kThumb2Vabss,       0xeeb00ac0,
 822                  kFmtSfp, 22, 12, kFmtSfp, 5, 0, kFmtUnused, -1, -1,
 823                  kFmtUnused, -1, -1, IS_BINARY_OP | REG_DEF0_USE1,
 824                  "vabs.f32", "!0s, !1s", 2),
 825     ENCODING_MAP(kThumb2Vnegd,       0xeeb10b40,
 826                  kFmtDfp, 22, 12, kFmtDfp, 5, 0, kFmtUnused, -1, -1,
 827                  kFmtUnused, -1, -1, IS_BINARY_OP | REG_DEF0_USE1,
 828                  "vneg.f64", "!0S, !1S", 2),
 829     ENCODING_MAP(kThumb2Vnegs,       0xeeb10a40,
 830                  kFmtSfp, 22, 12, kFmtSfp, 5, 0, kFmtUnused, -1, -1,
 831                  kFmtUnused, -1, -1, IS_BINARY_OP | REG_DEF0_USE1,
 832                  "vneg.f32", "!0s, !1s", 2),
 833     ENCODING_MAP(kThumb2Vmovs_IMM8,       0xeeb00a00,
 834                  kFmtSfp, 22, 12, kFmtFPImm, 16, 0, kFmtUnused, -1, -1,
 835                  kFmtUnused, -1, -1, IS_BINARY_OP | REG_DEF0,
 836                  "vmov.f32", "!0s, #0x!1h", 2),
 837     ENCODING_MAP(kThumb2Vmovd_IMM8,       0xeeb00b00,
 838                  kFmtDfp, 22, 12, kFmtFPImm, 16, 0, kFmtUnused, -1, -1,
 839                  kFmtUnused, -1, -1, IS_BINARY_OP | REG_DEF0,
 840                  "vmov.f64", "!0S, #0x!1h", 2),
 841     ENCODING_MAP(kThumb2Mla,  0xfb000000,
 842                  kFmtBitBlt, 11, 8, kFmtBitBlt, 19, 16, kFmtBitBlt, 3, 0,
 843                  kFmtBitBlt, 15, 12,
 844                  IS_QUAD_OP | REG_DEF0 | REG_USE1 | REG_USE2 | REG_USE3,
 845                  "mla", "r!0d, r!1d, r!2d, r!3d", 2),
 846     ENCODING_MAP(kThumb2Umull,  0xfba00000,
 847                  kFmtBitBlt, 15, 12, kFmtBitBlt, 11, 8, kFmtBitBlt, 19, 16,
 848                  kFmtBitBlt, 3, 0,
 849                  IS_QUAD_OP | REG_DEF0 | REG_DEF1 | REG_USE2 | REG_USE3,
 850                  "umull", "r!0d, r!1d, r!2d, r!3d", 2),
 851     ENCODING_MAP(kThumb2Ldrex,       0xe8500f00,
 852                  kFmtBitBlt, 15, 12, kFmtBitBlt, 19, 16, kFmtBitBlt, 7, 0,
 853                  kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0_USE1,
 854                  "ldrex", "r!0d,[r!1d, #!2E]", 2),
 855     ENCODING_MAP(kThumb2Strex,       0xe8400000,
 856                  kFmtBitBlt, 11, 8, kFmtBitBlt, 15, 12, kFmtBitBlt, 19, 16,
 857                  kFmtBitBlt, 7, 0, IS_QUAD_OP | REG_DEF0_USE12,
 858                  "strex", "r!0d,r!1d, [r!2d, #!2E]", 2),
 859     ENCODING_MAP(kThumb2Clrex,       0xf3bf8f2f,
 860                  kFmtUnused, -1, -1, kFmtUnused, -1, -1, kFmtUnused, -1, -1,
 861                  kFmtUnused, -1, -1, NO_OPERAND, "clrex", "", 2),
 862     ENCODING_MAP(kThumb2Bfi,         0xf3600000,
 863                  kFmtBitBlt, 11, 8, kFmtBitBlt, 19, 16, kFmtShift5, -1, -1,
 864                  kFmtBitBlt, 4, 0, IS_QUAD_OP | REG_DEF0_USE1,
 865                  "bfi", "r!0d,r!1d,#!2d,#!3d", 2),
 866     ENCODING_MAP(kThumb2Bfc,         0xf36f0000,
 867                  kFmtBitBlt, 11, 8, kFmtShift5, -1, -1, kFmtBitBlt, 4, 0,
 868                  kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0,
 869                  "bfc", "r!0d,#!1d,#!2d", 2),
 870 };
 871
 872 /*
 873  * The fake NOP of moving r0 to r0 actually will incur data stalls if r0 is
 874  * not ready. Since r5 (rFP) is not updated often, it is less likely to
 875  * generate unnecessary stall cycles.
 876  */
 877 #define PADDING_MOV_R5_R5               0x1C2D
 878
 879 /* Write the numbers in the literal pool to the codegen stream */
 880 static void installDataContent(CompilationUnit *cUnit)
 881 {
 882     int *dataPtr = (int *) ((char *) cUnit->baseAddr + cUnit->dataOffset);
 883     ArmLIR *dataLIR = (ArmLIR *) cUnit->wordList;
 884     while (dataLIR) {
 885         *dataPtr++ = dataLIR->operands[0];
 886         dataLIR = NEXT_LIR(dataLIR);
 887     }
 888 }
 889
 890 /* Returns the size of a Jit trace description */
 891 static int jitTraceDescriptionSize(const JitTraceDescription *desc)
 892 {
 893     int runCount;
 894     for (runCount = 0; ; runCount++) {
 895         if (desc->trace[runCount].frag.runEnd)
 896            break;
 897     }
 898     return sizeof(JitCodeDesc) + ((runCount+1) * sizeof(JitTraceRun));
 899 }
 900
 901 /* Return TRUE if error happens */
 902 static bool assembleInstructions(CompilationUnit *cUnit, intptr_t startAddr)
 903 {
 904     short *bufferAddr = (short *) cUnit->codeBuffer;
 905     ArmLIR *lir;
 906
 907     for (lir = (ArmLIR *) cUnit->firstLIRInsn; lir; lir = NEXT_LIR(lir)) {
 908         if (lir->opCode < 0) {
 909             if ((lir->opCode == kArmPseudoPseudoAlign4) &&
 910                 /* 1 means padding is needed */
 911                 (lir->operands[0] == 1)) {
 912                 *bufferAddr++ = PADDING_MOV_R5_R5;
 913             }
 914             continue;
 915         }
 916
 917         if (lir->isNop) {
 918             continue;
 919         }
 920
 921         if (lir->opCode == kThumbLdrPcRel ||
 922             lir->opCode == kThumb2LdrPcRel12 ||
 923             lir->opCode == kThumbAddPcRel ||
 924             ((lir->opCode == kThumb2Vldrs) && (lir->operands[1] == rpc))) {
 925             ArmLIR *lirTarget = (ArmLIR *) lir->generic.target;
 926             intptr_t pc = (lir->generic.offset + 4) & ~3;
 927             /*
 928              * Allow an offset (stored in operands[2] to be added to the
 929              * PC-relative target. Useful to get to a fixed field inside a
 930              * chaining cell.
 931              */
 932             intptr_t target = lirTarget->generic.offset + lir->operands[2];
 933             int delta = target - pc;
 934             if (delta & 0x3) {
 935                 LOGE("PC-rel distance is not multiples of 4: %d\n", delta);
 936                 dvmAbort();
 937             }
 938             if ((lir->opCode == kThumb2LdrPcRel12) && (delta > 4091)) {
 939                 return true;
 940             } else if (delta > 1020) {
 941                 return true;
 942             }
 943             if (lir->opCode == kThumb2Vldrs) {
 944                 lir->operands[2] = delta >> 2;
 945             } else {
 946                 lir->operands[1] = (lir->opCode == kThumb2LdrPcRel12) ?
 947                                     delta : delta >> 2;
 948             }
 949         } else if (lir->opCode == kThumb2Cbnz || lir->opCode == kThumb2Cbz) {
 950             ArmLIR *targetLIR = (ArmLIR *) lir->generic.target;
 951             intptr_t pc = lir->generic.offset + 4;
 952             intptr_t target = targetLIR->generic.offset;
 953             int delta = target - pc;
 954             if (delta > 126 || delta < 0) {
 955                 /*
 956                  * TODO: allow multiple kinds of assembler failure to allow
 957                  * change of code patterns when things don't fit.
 958                  */
 959                 return true;
 960             } else {
 961                 lir->operands[1] = delta >> 1;
 962             }
 963         } else if (lir->opCode == kThumbBCond ||
 964                    lir->opCode == kThumb2BCond) {
 965             ArmLIR *targetLIR = (ArmLIR *) lir->generic.target;
 966             intptr_t pc = lir->generic.offset + 4;
 967             intptr_t target = targetLIR->generic.offset;
 968             int delta = target - pc;
 969             if ((lir->opCode == kThumbBCond) && (delta > 254 || delta < -256)) {
 970                 return true;
 971             }
 972             lir->operands[0] = delta >> 1;
 973         } else if (lir->opCode == kThumbBUncond) {
 974             ArmLIR *targetLIR = (ArmLIR *) lir->generic.target;
 975             intptr_t pc = lir->generic.offset + 4;
 976             intptr_t target = targetLIR->generic.offset;
 977             int delta = target - pc;
 978             if (delta > 2046 || delta < -2048) {
 979                 LOGE("Unconditional branch distance out of range: %d\n", delta);
 980                 dvmAbort();
 981             }
 982             lir->operands[0] = delta >> 1;
 983         } else if (lir->opCode == kThumbBlx1) {
 984             assert(NEXT_LIR(lir)->opCode == kThumbBlx2);
 985             /* curPC is Thumb */
 986             intptr_t curPC = (startAddr + lir->generic.offset + 4) & ~3;
 987             intptr_t target = lir->operands[1];
 988
 989             /* Match bit[1] in target with base */
 990             if (curPC & 0x2) {
 991                 target |= 0x2;
 992             }
 993             int delta = target - curPC;
 994             assert((delta >= -(1<<22)) && (delta <= ((1<<22)-2)));
 995
 996             lir->operands[0] = (delta >> 12) & 0x7ff;
 997             NEXT_LIR(lir)->operands[0] = (delta>> 1) & 0x7ff;
 998         }
 999
1000         ArmEncodingMap *encoder = &EncodingMap[lir->opCode];
1001         u4 bits = encoder->skeleton;
1002         int i;
1003         for (i = 0; i < 4; i++) {
1004             u4 operand;
1005             u4 value;
1006             operand = lir->operands[i];
1007             switch(encoder->fieldLoc[i].kind) {
1008                 case kFmtUnused:
1009                     break;
1010                 case kFmtFPImm:
1011                     value = ((operand & 0xF0) >> 4) << encoder->fieldLoc[i].end;
1012                     value |= (operand & 0x0F) << encoder->fieldLoc[i].start;
1013                     bits |= value;
1014                     break;
1015                 case kFmtBrOffset:
1016                     /*
1017                      * NOTE: branch offsets are not handled here, but
1018                      * in the main assembly loop (where label values
1019                      * are known).  For reference, here is what the
1020                      * encoder handing would be:
1021                          value = ((operand  & 0x80000) >> 19) << 26;
1022                          value |= ((operand & 0x40000) >> 18) << 11;
1023                          value |= ((operand & 0x20000) >> 17) << 13;
1024                          value |= ((operand & 0x1f800) >> 11) << 16;
1025                          value |= (operand  & 0x007ff);
1026                          bits |= value;
1027                      */
1028                     break;
1029                 case kFmtShift5:
1030                     value = ((operand & 0x1c) >> 2) << 12;
1031                     value |= (operand & 0x03) << 6;
1032                     bits |= value;
1033                     break;
1034                 case kFmtShift:
1035                     value = ((operand & 0x70) >> 4) << 12;
1036                     value |= (operand & 0x0f) << 4;
1037                     bits |= value;
1038                     break;
1039                 case kFmtBWidth:
1040                     value = operand - 1;
1041                     bits |= value;
1042                     break;
1043                 case kFmtLsb:
1044                     value = ((operand & 0x1c) >> 2) << 12;
1045                     value |= (operand & 0x03) << 6;
1046                     bits |= value;
1047                     break;
1048                 case kFmtImm6:
1049                     value = ((operand & 0x20) >> 5) << 9;
1050                     value |= (operand & 0x1f) << 3;
1051                     bits |= value;
1052                     break;
1053                 case kFmtBitBlt:
1054                     value = (operand << encoder->fieldLoc[i].start) &
1055                             ((1 << (encoder->fieldLoc[i].end + 1)) - 1);
1056                     bits |= value;
1057                     break;
1058                 case kFmtDfp: {
1059                     assert(DOUBLEREG(operand));
1060                     assert((operand & 0x1) == 0);
1061                     int regName = (operand & FP_REG_MASK) >> 1;
1062                     /* Snag the 1-bit slice and position it */
1063                     value = ((regName & 0x10) >> 4) <<
1064                             encoder->fieldLoc[i].end;
1065                     /* Extract and position the 4-bit slice */
1066                     value |= (regName & 0x0f) <<
1067                             encoder->fieldLoc[i].start;
1068                     bits |= value;
1069                     break;
1070                 }
1071                 case kFmtSfp:
1072                     assert(SINGLEREG(operand));
1073                     /* Snag the 1-bit slice and position it */
1074                     value = (operand & 0x1) <<
1075                             encoder->fieldLoc[i].end;
1076                     /* Extract and position the 4-bit slice */
1077                     value |= ((operand & 0x1e) >> 1) <<
1078                             encoder->fieldLoc[i].start;
1079                     bits |= value;
1080                     break;
1081                 case kFmtImm12:
1082                 case kFmtModImm:
1083                     value = ((operand & 0x800) >> 11) << 26;
1084                     value |= ((operand & 0x700) >> 8) << 12;
1085                     value |= operand & 0x0ff;
1086                     bits |= value;
1087                     break;
1088                 case kFmtImm16:
1089                     value = ((operand & 0x0800) >> 11) << 26;
1090                     value |= ((operand & 0xf000) >> 12) << 16;
1091                     value |= ((operand & 0x0700) >> 8) << 12;
1092                     value |= operand & 0x0ff;
1093                     bits |= value;
1094                     break;
1095                 default:
1096                     assert(0);
1097             }
1098         }
1099         if (encoder->size == 2) {
1100             *bufferAddr++ = (bits >> 16) & 0xffff;
1101         }
1102         *bufferAddr++ = bits & 0xffff;
1103     }
1104     return false;
1105 }
1106
1107 /*
1108  * Translation layout in the code cache.  Note that the codeAddress pointer
1109  * in JitTable will point directly to the code body (field codeAddress).  The
1110  * chain cell offset codeAddress - 2, and (if present) executionCount is at
1111  * codeAddress - 6.
1112  *
1113  *      +----------------------------+
1114  *      | Execution count            |  -> [Optional] 4 bytes
1115  *      +----------------------------+
1116  *   +--| Offset to chain cell counts|  -> 2 bytes
1117  *   |  +----------------------------+
1118  *   |  | Code body                  |  -> Start address for translation
1119  *   |  |                            |     variable in 2-byte chunks
1120  *   |  .                            .     (JitTable's codeAddress points here)
1121  *   |  .                            .
1122  *   |  |                            |
1123  *   |  +----------------------------+
1124  *   |  | Chaining Cells             |  -> 8 bytes each, must be 4 byte aligned
1125  *   |  .                            .
1126  *   |  .                            .
1127  *   |  |                            |
1128  *   |  +----------------------------+
1129  *   |  | Gap for large switch stmt  |  -> # cases >= MAX_CHAINED_SWITCH_CASES
1130  *   |  +----------------------------+
1131  *   +->| Chaining cell counts       |  -> 8 bytes, chain cell counts by type
1132  *      +----------------------------+
1133  *      | Trace description          |  -> variable sized
1134  *      .                            .
1135  *      |                            |
1136  *      +----------------------------+
1137  *      | Literal pool               |  -> 4-byte aligned, variable size
1138  *      .                            .
1139  *      .                            .
1140  *      |                            |
1141  *      +----------------------------+
1142  *
1143  * Go over each instruction in the list and calculate the offset from the top
1144  * before sending them off to the assembler. If out-of-range branch distance is
1145  * seen rearrange the instructions a bit to correct it.
1146  */
1147 void dvmCompilerAssembleLIR(CompilationUnit *cUnit, JitTranslationInfo *info)
1148 {
1149     LIR *lir;
1150     ArmLIR *armLIR;
1151     int offset = 0;
1152     int i;
1153     ChainCellCounts chainCellCounts;
1154     int descSize = jitTraceDescriptionSize(cUnit->traceDesc);
1155     int chainingCellGap;
1156
1157     info->instructionSet = cUnit->instructionSet;
1158
1159     /* Beginning offset needs to allow space for chain cell offset */
1160     for (armLIR = (ArmLIR *) cUnit->firstLIRInsn;
1161          armLIR;
1162          armLIR = NEXT_LIR(armLIR)) {
1163         armLIR->generic.offset = offset;
1164         if (armLIR->opCode >= 0 && !armLIR->isNop) {
1165             armLIR->size = EncodingMap[armLIR->opCode].size * 2;
1166             offset += armLIR->size;
1167         } else if (armLIR->opCode == kArmPseudoPseudoAlign4) {
1168             if (offset & 0x2) {
1169                 offset += 2;
1170                 armLIR->operands[0] = 1;
1171             } else {
1172                 armLIR->operands[0] = 0;
1173             }
1174         }
1175         /* Pseudo opcodes don't consume space */
1176     }
1177
1178     /* Const values have to be word aligned */
1179     offset = (offset + 3) & ~3;
1180
1181     /*
1182      * Get the gap (# of u4) between the offset of chaining cell count and
1183      * the bottom of real chaining cells. If the translation has chaining
1184      * cells, the gap is guaranteed to be multiples of 4.
1185      */
1186     chainingCellGap = (offset - cUnit->chainingCellBottom->offset) >> 2;
1187
1188     /* Add space for chain cell counts & trace description */
1189     u4 chainCellOffset = offset;
1190     ArmLIR *chainCellOffsetLIR = (ArmLIR *) cUnit->chainCellOffsetLIR;
1191     assert(chainCellOffsetLIR);
1192     assert(chainCellOffset < 0x10000);
1193     assert(chainCellOffsetLIR->opCode == kArm16BitData &&
1194            chainCellOffsetLIR->operands[0] == CHAIN_CELL_OFFSET_TAG);
1195
1196     /*
1197      * Replace the CHAIN_CELL_OFFSET_TAG with the real value. If trace
1198      * profiling is enabled, subtract 4 (occupied by the counter word) from
1199      * the absolute offset as the value stored in chainCellOffsetLIR is the
1200      * delta from &chainCellOffsetLIR to &ChainCellCounts.
1201      */
1202     chainCellOffsetLIR->operands[0] =
1203         gDvmJit.profile ? (chainCellOffset - 4) : chainCellOffset;
1204
1205     offset += sizeof(chainCellCounts) + descSize;
1206
1207     assert((offset & 0x3) == 0);  /* Should still be word aligned */
1208
1209     /* Set up offsets for literals */
1210     cUnit->dataOffset = offset;
1211
1212     for (lir = cUnit->wordList; lir; lir = lir->next) {
1213         lir->offset = offset;
1214         offset += 4;
1215     }
1216
1217     cUnit->totalSize = offset;
1218
1219     if (gDvmJit.codeCacheByteUsed + cUnit->totalSize > gDvmJit.codeCacheSize) {
1220         gDvmJit.codeCacheFull = true;
1221         cUnit->baseAddr = NULL;
1222         return;
1223     }
1224
1225     /* Allocate enough space for the code block */
1226     cUnit->codeBuffer = dvmCompilerNew(chainCellOffset, true);
1227     if (cUnit->codeBuffer == NULL) {
1228         LOGE("Code buffer allocation failure\n");
1229         cUnit->baseAddr = NULL;
1230         return;
1231     }
1232
1233     bool assemblerFailure = assembleInstructions(
1234         cUnit, (intptr_t) gDvmJit.codeCache + gDvmJit.codeCacheByteUsed);
1235
1236     /*
1237      * Currently the only reason that can cause the assembler to fail is due to
1238      * trace length - cut it in half and retry.
1239      */
1240     if (assemblerFailure) {
1241         cUnit->halveInstCount = true;
1242         return;
1243     }
1244
1245     /* Don't go all the way if the goal is just to get the verbose output */
1246     if (info->discardResult) return;
1247
1248     cUnit->baseAddr = (char *) gDvmJit.codeCache + gDvmJit.codeCacheByteUsed;
1249     gDvmJit.codeCacheByteUsed += offset;
1250
1251     /* Install the code block */
1252     memcpy((char*)cUnit->baseAddr, cUnit->codeBuffer, chainCellOffset);
1253     gDvmJit.numCompilations++;
1254
1255     /* Install the chaining cell counts */
1256     for (i=0; i< kChainingCellGap; i++) {
1257         chainCellCounts.u.count[i] = cUnit->numChainingCells[i];
1258     }
1259
1260     /* Set the gap number in the chaining cell count structure */
1261     chainCellCounts.u.count[kChainingCellGap] = chainingCellGap;
1262
1263     memcpy((char*)cUnit->baseAddr + chainCellOffset, &chainCellCounts,
1264            sizeof(chainCellCounts));
1265
1266     /* Install the trace description */
1267     memcpy((char*)cUnit->baseAddr + chainCellOffset + sizeof(chainCellCounts),
1268            cUnit->traceDesc, descSize);
1269
1270     /* Write the literals directly into the code cache */
1271     installDataContent(cUnit);
1272
1273     /* Flush dcache and invalidate the icache to maintain coherence */
1274     cacheflush((long)cUnit->baseAddr,
1275                (long)((char *) cUnit->baseAddr + offset), 0);
1276
1277     /* Record code entry point and instruction set */
1278     info->codeAddress = (char*)cUnit->baseAddr + cUnit->headerSize;
1279     /* If applicable, mark low bit to denote thumb */
1280     if (info->instructionSet != DALVIK_JIT_ARM)
1281         info->codeAddress = (char*)info->codeAddress + 1;
1282 }
1283
1284 /*
1285  * Returns the skeleton bit pattern associated with an opcode.  All
1286  * variable fields are zeroed.
1287  */
1288 static u4 getSkeleton(ArmOpCode op)
1289 {
1290     return EncodingMap[op].skeleton;
1291 }
1292
1293 static u4 assembleChainingBranch(int branchOffset, bool thumbTarget)
1294 {
1295     u4 thumb1, thumb2;
1296
1297     if (!thumbTarget) {
1298         thumb1 =  (getSkeleton(kThumbBlx1) | ((branchOffset>>12) & 0x7ff));
1299         thumb2 =  (getSkeleton(kThumbBlx2) | ((branchOffset>> 1) & 0x7ff));
1300     } else if ((branchOffset < -2048) | (branchOffset > 2046)) {
1301         thumb1 =  (getSkeleton(kThumbBl1) | ((branchOffset>>12) & 0x7ff));
1302         thumb2 =  (getSkeleton(kThumbBl2) | ((branchOffset>> 1) & 0x7ff));
1303     } else {
1304         thumb1 =  (getSkeleton(kThumbBUncond) | ((branchOffset>> 1) & 0x7ff));
1305         thumb2 =  getSkeleton(kThumbOrr);  /* nop -> or r0, r0 */
1306     }
1307
1308     return thumb2<<16 | thumb1;
1309 }
1310
1311 /*
1312  * Perform translation chain operation.
1313  * For ARM, we'll use a pair of thumb instructions to generate
1314  * an unconditional chaining branch of up to 4MB in distance.
1315  * Use a BL, because the generic "interpret" translation needs
1316  * the link register to find the dalvik pc of teh target.
1317  *     111HHooooooooooo
1318  * Where HH is 10 for the 1st inst, and 11 for the second and
1319  * the "o" field is each instruction's 11-bit contribution to the
1320  * 22-bit branch offset.
1321  * If the target is nearby, use a single-instruction bl.
1322  * If one or more threads is suspended, don't chain.
1323  */
1324 void* dvmJitChain(void* tgtAddr, u4* branchAddr)
1325 {
1326     int baseAddr = (u4) branchAddr + 4;
1327     int branchOffset = (int) tgtAddr - baseAddr;
1328     u4 newInst;
1329     bool thumbTarget;
1330
1331     /*
1332      * Only chain translations when there is no urge to ask all threads to
1333      * suspend themselves via the interpreter.
1334      */
1335     if ((gDvmJit.pProfTable != NULL) && (gDvm.sumThreadSuspendCount == 0) &&
1336         (gDvmJit.codeCacheFull == false)) {
1337         assert((branchOffset >= -(1<<22)) && (branchOffset <= ((1<<22)-2)));
1338
1339         gDvmJit.translationChains++;
1340
1341         COMPILER_TRACE_CHAINING(
1342             LOGD("Jit Runtime: chaining 0x%x to 0x%x\n",
1343                  (int) branchAddr, (int) tgtAddr & -2));
1344
1345         /*
1346          * NOTE: normally, all translations are Thumb[2] mode, with
1347          * a single exception: the default TEMPLATE_INTERPRET
1348          * pseudo-translation.  If the need ever arises to
1349          * mix Arm & Thumb[2] translations, the following code should be
1350          * generalized.
1351          */
1352         thumbTarget = (tgtAddr != gDvmJit.interpretTemplate);
1353
1354         newInst = assembleChainingBranch(branchOffset, thumbTarget);
1355
1356         *branchAddr = newInst;
1357         cacheflush((long)branchAddr, (long)branchAddr + 4, 0);
1358         gDvmJit.hasNewChain = true;
1359     }
1360
1361     return tgtAddr;
1362 }
1363
1364 /*
1365  * Attempt to enqueue a work order to patch an inline cache for a predicted
1366  * chaining cell for virtual/interface calls.
1367  */
1368 bool inlineCachePatchEnqueue(PredictedChainingCell *cellAddr,
1369                              PredictedChainingCell *newContent)
1370 {
1371     bool result = true;
1372
1373     dvmLockMutex(&gDvmJit.compilerICPatchLock);
1374
1375     if (cellAddr->clazz == NULL &&
1376         cellAddr->branch == PREDICTED_CHAIN_BX_PAIR_INIT) {
1377         /*
1378          * The update order matters - make sure clazz is updated last since it
1379          * will bring the uninitialized chaining cell to life.
1380          */
1381         cellAddr->method = newContent->method;
1382         cellAddr->branch = newContent->branch;
1383         cellAddr->counter = newContent->counter;
1384         cellAddr->clazz = newContent->clazz;
1385         cacheflush((intptr_t) cellAddr, (intptr_t) (cellAddr+1), 0);
1386     }
1387     else if (gDvmJit.compilerICPatchIndex < COMPILER_IC_PATCH_QUEUE_SIZE)  {
1388         int index = gDvmJit.compilerICPatchIndex++;
1389         gDvmJit.compilerICPatchQueue[index].cellAddr = cellAddr;
1390         gDvmJit.compilerICPatchQueue[index].cellContent = *newContent;
1391     } else {
1392         result = false;
1393     }
1394
1395     dvmUnlockMutex(&gDvmJit.compilerICPatchLock);
1396     return result;
1397 }
1398
1399 /*
1400  * This method is called from the invoke templates for virtual and interface
1401  * methods to speculatively setup a chain to the callee. The templates are
1402  * written in assembly and have setup method, cell, and clazz at r0, r2, and
1403  * r3 respectively, so there is a unused argument in the list. Upon return one
1404  * of the following three results may happen:
1405  *   1) Chain is not setup because the callee is native. Reset the rechain
1406  *      count to a big number so that it will take a long time before the next
1407  *      rechain attempt to happen.
1408  *   2) Chain is not setup because the callee has not been created yet. Reset
1409  *      the rechain count to a small number and retry in the near future.
1410  *   3) Ask all other threads to stop before patching this chaining cell.
1411  *      This is required because another thread may have passed the class check
1412  *      but hasn't reached the chaining cell yet to follow the chain. If we
1413  *      patch the content before halting the other thread, there could be a
1414  *      small window for race conditions to happen that it may follow the new
1415  *      but wrong chain to invoke a different method.
1416  */
1417 const Method *dvmJitToPatchPredictedChain(const Method *method,
1418                                           void *unused,
1419                                           PredictedChainingCell *cell,
1420                                           const ClassObject *clazz)
1421 {
1422 #if defined(WITH_SELF_VERIFICATION)
1423     /* Disable chaining and prevent this from triggering again for a while */
1424     cell->counter = PREDICTED_CHAIN_COUNTER_AVOID;
1425     cacheflush((long) cell, (long) (cell+1), 0);
1426     goto done;
1427 #else
1428     /* Don't come back here for a long time if the method is native */
1429     if (dvmIsNativeMethod(method)) {
1430         cell->counter = PREDICTED_CHAIN_COUNTER_AVOID;
1431         cacheflush((long) cell, (long) (cell+1), 0);
1432         COMPILER_TRACE_CHAINING(
1433             LOGD("Jit Runtime: predicted chain %p to native method %s ignored",
1434                  cell, method->name));
1435         goto done;
1436     }
1437     int tgtAddr = (int) dvmJitGetCodeAddr(method->insns);
1438
1439     /*
1440      * Compilation not made yet for the callee. Reset the counter to a small
1441      * value and come back to check soon.
1442      */
1443     if ((tgtAddr == 0) || ((void*)tgtAddr == gDvmJit.interpretTemplate)) {
1444         /*
1445          * Wait for a few invocations (currently set to be 16) before trying
1446          * to setup the chain again.
1447          */
1448         cell->counter = PREDICTED_CHAIN_COUNTER_DELAY;
1449         cacheflush((long) cell, (long) (cell+1), 0);
1450         COMPILER_TRACE_CHAINING(
1451             LOGD("Jit Runtime: predicted chain %p to method %s%s delayed",
1452                  cell, method->clazz->descriptor, method->name));
1453         goto done;
1454     }
1455
1456     PredictedChainingCell newCell;
1457
1458     /* Avoid back-to-back orders to the same cell */
1459     cell->counter = PREDICTED_CHAIN_COUNTER_AVOID;
1460
1461     int baseAddr = (int) cell + 4;   // PC is cur_addr + 4
1462     int branchOffset = tgtAddr - baseAddr;
1463
1464     newCell.branch = assembleChainingBranch(branchOffset, true);
1465     newCell.clazz = clazz;
1466     newCell.method = method;
1467     newCell.counter = PREDICTED_CHAIN_COUNTER_RECHAIN;
1468
1469     /*
1470      * Enter the work order to the queue and the chaining cell will be patched
1471      * the next time a safe point is entered.
1472      *
1473      * If the enqueuing fails reset the rechain count to a normal value so that
1474      * it won't get indefinitely delayed.
1475      */
1476     if (!inlineCachePatchEnqueue(cell, &newCell)) {
1477         cell->counter = PREDICTED_CHAIN_COUNTER_RECHAIN;
1478     }
1479 #endif
1480 done:
1481     return method;
1482 }
1483
1484 /*
1485  * Patch the inline cache content based on the content passed from the work
1486  * order.
1487  */
1488 void dvmCompilerPatchInlineCache(void)
1489 {
1490     int i;
1491     PredictedChainingCell *minAddr, *maxAddr;
1492
1493     /* Nothing to be done */
1494     if (gDvmJit.compilerICPatchIndex == 0) return;
1495
1496     /*
1497      * Since all threads are already stopped we don't really need to acquire
1498      * the lock. But race condition can be easily introduced in the future w/o
1499      * paying attention so we still acquire the lock here.
1500      */
1501     dvmLockMutex(&gDvmJit.compilerICPatchLock);
1502
1503     //LOGD("Number of IC patch work orders: %d", gDvmJit.compilerICPatchIndex);
1504
1505     /* Initialize the min/max address range */
1506     minAddr = (PredictedChainingCell *)
1507         ((char *) gDvmJit.codeCache + gDvmJit.codeCacheSize);
1508     maxAddr = (PredictedChainingCell *) gDvmJit.codeCache;
1509
1510     for (i = 0; i < gDvmJit.compilerICPatchIndex; i++) {
1511         PredictedChainingCell *cellAddr =
1512             gDvmJit.compilerICPatchQueue[i].cellAddr;
1513         PredictedChainingCell *cellContent =
1514             &gDvmJit.compilerICPatchQueue[i].cellContent;
1515
1516         if (cellAddr->clazz == NULL) {
1517             COMPILER_TRACE_CHAINING(
1518                 LOGD("Jit Runtime: predicted chain %p to %s (%s) initialized",
1519                      cellAddr,
1520                      cellContent->clazz->descriptor,
1521                      cellContent->method->name));
1522         } else {
1523             COMPILER_TRACE_CHAINING(
1524                 LOGD("Jit Runtime: predicted chain %p from %s to %s (%s) "
1525                      "patched",
1526                      cellAddr,
1527                      cellAddr->clazz->descriptor,
1528                      cellContent->clazz->descriptor,
1529                      cellContent->method->name));
1530         }
1531
1532         /* Patch the chaining cell */
1533         *cellAddr = *cellContent;
1534         minAddr = (cellAddr < minAddr) ? cellAddr : minAddr;
1535         maxAddr = (cellAddr > maxAddr) ? cellAddr : maxAddr;
1536     }
1537
1538     /* Then synchronize the I/D cache */
1539     cacheflush((long) minAddr, (long) (maxAddr+1), 0);
1540
1541     gDvmJit.compilerICPatchIndex = 0;
1542     dvmUnlockMutex(&gDvmJit.compilerICPatchLock);
1543 }
1544
1545 /*
1546  * Unchain a trace given the starting address of the translation
1547  * in the code cache.  Refer to the diagram in dvmCompilerAssembleLIR.
1548  * Returns the address following the last cell unchained.  Note that
1549  * the incoming codeAddr is a thumb code address, and therefore has
1550  * the low bit set.
1551  */
1552 u4* dvmJitUnchain(void* codeAddr)
1553 {
1554     u2* pChainCellOffset = (u2*)((char*)codeAddr - 3);
1555     u2 chainCellOffset = *pChainCellOffset;
1556     ChainCellCounts *pChainCellCounts =
1557           (ChainCellCounts*)((char*)codeAddr + chainCellOffset - 3);
1558     int cellSize;
1559     u4* pChainCells;
1560     u4* pStart;
1561     u4 thumb1;
1562     u4 thumb2;
1563     u4 newInst;
1564     int i,j;
1565     PredictedChainingCell *predChainCell;
1566
1567     /* Get total count of chain cells */
1568     for (i = 0, cellSize = 0; i < kChainingCellGap; i++) {
1569         if (i != kChainingCellInvokePredicted) {
1570             cellSize += pChainCellCounts->u.count[i] * 2;
1571         } else {
1572             cellSize += pChainCellCounts->u.count[i] * 4;
1573         }
1574     }
1575
1576     if (cellSize == 0)
1577         return (u4 *) pChainCellCounts;
1578
1579     /* Locate the beginning of the chain cell region */
1580     pStart = pChainCells = ((u4 *) pChainCellCounts) - cellSize -
1581              pChainCellCounts->u.count[kChainingCellGap];
1582
1583     /* The cells are sorted in order - walk through them and reset */
1584     for (i = 0; i < kChainingCellGap; i++) {
1585         int elemSize = 2; /* Most chaining cell has two words */
1586         if (i == kChainingCellInvokePredicted) {
1587             elemSize = 4;
1588         }
1589
1590         for (j = 0; j < pChainCellCounts->u.count[i]; j++) {
1591             int targetOffset;
1592             switch(i) {
1593                 case kChainingCellNormal:
1594                     targetOffset = offsetof(InterpState,
1595                           jitToInterpEntries.dvmJitToInterpNormal);
1596                     break;
1597                 case kChainingCellHot:
1598                 case kChainingCellInvokeSingleton:
1599                     targetOffset = offsetof(InterpState,
1600                           jitToInterpEntries.dvmJitToTraceSelect);
1601                     break;
1602                 case kChainingCellInvokePredicted:
1603                     targetOffset = 0;
1604                     predChainCell = (PredictedChainingCell *) pChainCells;
1605                     /*
1606                      * There could be a race on another mutator thread to use
1607                      * this particular predicted cell and the check has passed
1608                      * the clazz comparison. So we cannot safely wipe the
1609                      * method and branch but it is safe to clear the clazz,
1610                      * which serves as the key.
1611                      */
1612                     predChainCell->clazz = PREDICTED_CHAIN_CLAZZ_INIT;
1613                     break;
1614 #if defined(WITH_SELF_VERIFICATION)
1615                 case kChainingCellBackwardBranch:
1616                     targetOffset = offsetof(InterpState,
1617                           jitToInterpEntries.dvmJitToBackwardBranch);
1618                     break;
1619 #elif defined(WITH_JIT_TUNING)
1620                 case kChainingCellBackwardBranch:
1621                     targetOffset = offsetof(InterpState,
1622                           jitToInterpEntries.dvmJitToInterpNormal);
1623                     break;
1624 #endif
1625                 default:
1626                     targetOffset = 0; // make gcc happy
1627                     LOGE("Unexpected chaining type: %d", i);
1628                     dvmAbort();
1629             }
1630             COMPILER_TRACE_CHAINING(
1631                 LOGD("Jit Runtime: unchaining 0x%x", (int)pChainCells));
1632             /*
1633              * Thumb code sequence for a chaining cell is:
1634              *     ldr  r0, rGLUE, #<word offset>
1635              *     blx  r0
1636              */
1637             if (i != kChainingCellInvokePredicted) {
1638                 targetOffset = targetOffset >> 2;  /* convert to word offset */
1639                 thumb1 = 0x6800 | (targetOffset << 6) |
1640                          (rGLUE << 3) | (r0 << 0);
1641                 thumb2 = 0x4780 | (r0 << 3);
1642                 newInst = thumb2<<16 | thumb1;
1643                 *pChainCells = newInst;
1644             }
1645             pChainCells += elemSize;  /* Advance by a fixed number of words */
1646         }
1647     }
1648     return pChainCells;
1649 }
1650
1651 /* Unchain all translation in the cache. */
1652 void dvmJitUnchainAll()
1653 {
1654     u4* lowAddress = NULL;
1655     u4* highAddress = NULL;
1656     unsigned int i;
1657     if (gDvmJit.pJitEntryTable != NULL) {
1658         COMPILER_TRACE_CHAINING(LOGD("Jit Runtime: unchaining all"));
1659         dvmLockMutex(&gDvmJit.tableLock);
1660         for (i = 0; i < gDvmJit.jitTableSize; i++) {
1661             if (gDvmJit.pJitEntryTable[i].dPC &&
1662                    gDvmJit.pJitEntryTable[i].codeAddress &&
1663                    (gDvmJit.pJitEntryTable[i].codeAddress !=
1664                     gDvmJit.interpretTemplate)) {
1665                 u4* lastAddress;
1666                 lastAddress =
1667                       dvmJitUnchain(gDvmJit.pJitEntryTable[i].codeAddress);
1668                 if (lowAddress == NULL ||
1669                       (u4*)gDvmJit.pJitEntryTable[i].codeAddress < lowAddress)
1670                     lowAddress = lastAddress;
1671                 if (lastAddress > highAddress)
1672                     highAddress = lastAddress;
1673             }
1674         }
1675         cacheflush((long)lowAddress, (long)highAddress, 0);
1676         dvmUnlockMutex(&gDvmJit.tableLock);
1677         gDvmJit.translationChains = 0;
1678     }
1679     gDvmJit.hasNewChain = false;
1680 }
1681
1682 typedef struct jitProfileAddrToLine {
1683     u4 lineNum;
1684     u4 bytecodeOffset;
1685 } jitProfileAddrToLine;
1686
1687
1688 /* Callback function to track the bytecode offset/line number relationiship */
1689 static int addrToLineCb (void *cnxt, u4 bytecodeOffset, u4 lineNum)
1690 {
1691     jitProfileAddrToLine *addrToLine = (jitProfileAddrToLine *) cnxt;
1692
1693     /* Best match so far for this offset */
1694     if (addrToLine->bytecodeOffset >= bytecodeOffset) {
1695         addrToLine->lineNum = lineNum;
1696     }
1697     return 0;
1698 }
1699
1700 char *getTraceBase(const JitEntry *p)
1701 {
1702     return (char*)p->codeAddress -
1703         (6 + (p->u.info.instructionSet == DALVIK_JIT_ARM ? 0 : 1));
1704 }
1705
1706 /* Dumps profile info for a single trace */
1707 static int dumpTraceProfile(JitEntry *p)
1708 {
1709     ChainCellCounts* pCellCounts;
1710     char* traceBase;
1711     u4* pExecutionCount;
1712     u2* pCellOffset;
1713     JitTraceDescription *desc;
1714     const Method* method;
1715
1716     traceBase = getTraceBase(p);
1717
1718     if (p->codeAddress == NULL) {
1719         LOGD("TRACEPROFILE 0x%08x 0 NULL 0 0", (int)traceBase);
1720         return 0;
1721     }
1722     if (p->codeAddress == gDvmJit.interpretTemplate) {
1723         LOGD("TRACEPROFILE 0x%08x 0 INTERPRET_ONLY  0 0", (int)traceBase);
1724         return 0;
1725     }
1726
1727     pExecutionCount = (u4*) (traceBase);
1728     pCellOffset = (u2*) (traceBase + 4);
1729     pCellCounts = (ChainCellCounts*) ((char *)pCellOffset + *pCellOffset);
1730     desc = (JitTraceDescription*) ((char*)pCellCounts + sizeof(*pCellCounts));
1731     method = desc->method;
1732     char *methodDesc = dexProtoCopyMethodDescriptor(&method->prototype);
1733     jitProfileAddrToLine addrToLine = {0, desc->trace[0].frag.startOffset};
1734
1735     /*
1736      * We may end up decoding the debug information for the same method
1737      * multiple times, but the tradeoff is we don't need to allocate extra
1738      * space to store the addr/line mapping. Since this is a debugging feature
1739      * and done infrequently so the slower but simpler mechanism should work
1740      * just fine.
1741      */
1742     dexDecodeDebugInfo(method->clazz->pDvmDex->pDexFile,
1743                        dvmGetMethodCode(method),
1744                        method->clazz->descriptor,
1745                        method->prototype.protoIdx,
1746                        method->accessFlags,
1747                        addrToLineCb, NULL, &addrToLine);
1748
1749     LOGD("TRACEPROFILE 0x%08x % 10d [%#x(+%d), %d] %s%s;%s",
1750          (int)traceBase,
1751          *pExecutionCount,
1752          desc->trace[0].frag.startOffset,
1753          desc->trace[0].frag.numInsts,
1754          addrToLine.lineNum,
1755          method->clazz->descriptor, method->name, methodDesc);
1756     free(methodDesc);
1757
1758     return *pExecutionCount;
1759 }
1760
1761 /* Create a copy of the trace descriptor of an existing compilation */
1762 JitTraceDescription *dvmCopyTraceDescriptor(const u2 *pc)
1763 {
1764     JitEntry *jitEntry = dvmFindJitEntry(pc);
1765     if (jitEntry == NULL) return NULL;
1766
1767     /* Find out the startint point */
1768     char *traceBase = getTraceBase(jitEntry);
1769
1770     /* Then find out the starting point of the chaining cell */
1771     u2 *pCellOffset = (u2*) (traceBase + 4);
1772     ChainCellCounts *pCellCounts =
1773         (ChainCellCounts*) ((char *)pCellOffset + *pCellOffset);
1774
1775     /* From there we can find out the starting point of the trace descriptor */
1776     JitTraceDescription *desc =
1777         (JitTraceDescription*) ((char*)pCellCounts + sizeof(*pCellCounts));
1778
1779     /* Now make a copy and return */
1780     int descSize = jitTraceDescriptionSize(desc);
1781     JitTraceDescription *newCopy = (JitTraceDescription *) malloc(descSize);
1782     memcpy(newCopy, desc, descSize);
1783     return newCopy;
1784 }
1785
1786 /* Handy function to retrieve the profile count */
1787 static inline int getProfileCount(const JitEntry *entry)
1788 {
1789     if (entry->dPC == 0 || entry->codeAddress == 0)
1790         return 0;
1791     u4 *pExecutionCount = (u4 *) getTraceBase(entry);
1792
1793     return *pExecutionCount;
1794 }
1795
1796
1797 /* qsort callback function */
1798 static int sortTraceProfileCount(const void *entry1, const void *entry2)
1799 {
1800     const JitEntry *jitEntry1 = entry1;
1801     const JitEntry *jitEntry2 = entry2;
1802
1803     int count1 = getProfileCount(jitEntry1);
1804     int count2 = getProfileCount(jitEntry2);
1805     return (count1 == count2) ? 0 : ((count1 > count2) ? -1 : 1);
1806 }
1807
1808 /* Sort the trace profile counts and dump them */
1809 void dvmCompilerSortAndPrintTraceProfiles()
1810 {
1811     JitEntry *sortedEntries;
1812     int numTraces = 0;
1813     unsigned long counts = 0;
1814     unsigned int i;
1815
1816     /* Make sure that the table is not changing */
1817     dvmLockMutex(&gDvmJit.tableLock);
1818
1819     /* Sort the entries by descending order */
1820     sortedEntries = malloc(sizeof(JitEntry) * gDvmJit.jitTableSize);
1821     if (sortedEntries == NULL)
1822         goto done;
1823     memcpy(sortedEntries, gDvmJit.pJitEntryTable,
1824            sizeof(JitEntry) * gDvmJit.jitTableSize);
1825     qsort(sortedEntries, gDvmJit.jitTableSize, sizeof(JitEntry),
1826           sortTraceProfileCount);
1827
1828     /* Dump the sorted entries */
1829     for (i=0; i < gDvmJit.jitTableSize; i++) {
1830         if (sortedEntries[i].dPC != 0) {
1831             counts += dumpTraceProfile(&sortedEntries[i]);
1832             numTraces++;
1833         }
1834     }
1835     if (numTraces == 0)
1836         numTraces = 1;
1837     LOGD("JIT: Average execution count -> %d",(int)(counts / numTraces));
1838
1839     free(sortedEntries);
1840 done:
1841     dvmUnlockMutex(&gDvmJit.tableLock);
1842     return;
1843 }
1844
1845 #if defined(WITH_SELF_VERIFICATION)
1846 /*
1847  * The following are used to keep compiled loads and stores from modifying
1848  * memory during self verification mode.
1849  *
1850  * Stores do not modify memory. Instead, the address and value pair are stored
1851  * into heapSpace. Addresses within heapSpace are unique. For accesses smaller
1852  * than a word, the word containing the address is loaded first before being
1853  * updated.
1854  *
1855  * Loads check heapSpace first and return data from there if an entry exists.
1856  * Otherwise, data is loaded from memory as usual.
1857  */
1858
1859 /* Used to specify sizes of memory operations */
1860 enum {
1861     kSVByte,
1862     kSVSignedByte,
1863     kSVHalfword,
1864     kSVSignedHalfword,
1865     kSVWord,
1866     kSVDoubleword,
1867 };
1868
1869 /* Load the value of a decoded register from the stack */
1870 static int selfVerificationMemRegLoad(int* sp, int reg)
1871 {
1872     return *(sp + reg);
1873 }
1874
1875 /* Load the value of a decoded doubleword register from the stack */
1876 static s8 selfVerificationMemRegLoadDouble(int* sp, int reg)
1877 {
1878     return *((s8*)(sp + reg));
1879 }
1880
1881 /* Store the value of a decoded register out to the stack */
1882 static void selfVerificationMemRegStore(int* sp, int data, int reg)
1883 {
1884     *(sp + reg) = data;
1885 }
1886
1887 /* Store the value of a decoded doubleword register out to the stack */
1888 static void selfVerificationMemRegStoreDouble(int* sp, s8 data, int reg)
1889 {
1890     *((s8*)(sp + reg)) = data;
1891 }
1892
1893 /*
1894  * Load the specified size of data from the specified address, checking
1895  * heapSpace first if Self Verification mode wrote to it previously, and
1896  * falling back to actual memory otherwise.
1897  */
1898 static int selfVerificationLoad(int addr, int size)
1899 {
1900     Thread *self = dvmThreadSelf();
1901     ShadowSpace *shadowSpace = self->shadowSpace;
1902     ShadowHeap *heapSpacePtr;
1903
1904     int data;
1905     int maskedAddr = addr & 0xFFFFFFFC;
1906     int alignment = addr & 0x3;
1907
1908     for (heapSpacePtr = shadowSpace->heapSpace;
1909          heapSpacePtr != shadowSpace->heapSpaceTail; heapSpacePtr++) {
1910         if (heapSpacePtr->addr == maskedAddr) {
1911             addr = ((unsigned int) &(heapSpacePtr->data)) | alignment;
1912             break;
1913         }
1914     }
1915
1916     switch (size) {
1917         case kSVByte:
1918             data = *((u1*) addr);
1919             break;
1920         case kSVSignedByte:
1921             data = *((s1*) addr);
1922             break;
1923         case kSVHalfword:
1924             data = *((u2*) addr);
1925             break;
1926         case kSVSignedHalfword:
1927             data = *((s2*) addr);
1928             break;
1929         case kSVWord:
1930             data = *((u4*) addr);
1931             break;
1932         default:
1933             LOGE("*** ERROR: BAD SIZE IN selfVerificationLoad: %d", size);
1934             data = 0;
1935             dvmAbort();
1936     }
1937
1938     //LOGD("*** HEAP LOAD: Addr: 0x%x Data: 0x%x Size: %d", addr, data, size);
1939     return data;
1940 }
1941
1942 /* Like selfVerificationLoad, but specifically for doublewords */
1943 static s8 selfVerificationLoadDoubleword(int addr)
1944 {
1945     Thread *self = dvmThreadSelf();
1946     ShadowSpace* shadowSpace = self->shadowSpace;
1947     ShadowHeap* heapSpacePtr;
1948
1949     int addr2 = addr+4;
1950     unsigned int data = *((unsigned int*) addr);
1951     unsigned int data2 = *((unsigned int*) addr2);
1952
1953     for (heapSpacePtr = shadowSpace->heapSpace;
1954          heapSpacePtr != shadowSpace->heapSpaceTail; heapSpacePtr++) {
1955         if (heapSpacePtr->addr == addr) {
1956             data = heapSpacePtr->data;
1957         } else if (heapSpacePtr->addr == addr2) {
1958             data2 = heapSpacePtr->data;
1959         }
1960     }
1961
1962     //LOGD("*** HEAP LOAD DOUBLEWORD: Addr: 0x%x Data: 0x%x Data2: 0x%x",
1963     //    addr, data, data2);
1964     return (((s8) data2) << 32) | data;
1965 }
1966
1967 /*
1968  * Handles a store of a specified size of data to a specified address.
1969  * This gets logged as an addr/data pair in heapSpace instead of modifying
1970  * memory.  Addresses in heapSpace are unique, and accesses smaller than a
1971  * word pull the entire word from memory first before updating.
1972  */
1973 static void selfVerificationStore(int addr, int data, int size)
1974 {
1975     Thread *self = dvmThreadSelf();
1976     ShadowSpace *shadowSpace = self->shadowSpace;
1977     ShadowHeap *heapSpacePtr;
1978
1979     int maskedAddr = addr & 0xFFFFFFFC;
1980     int alignment = addr & 0x3;
1981
1982     //LOGD("*** HEAP STORE: Addr: 0x%x Data: 0x%x Size: %d", addr, data, size);
1983
1984     for (heapSpacePtr = shadowSpace->heapSpace;
1985          heapSpacePtr != shadowSpace->heapSpaceTail; heapSpacePtr++) {
1986         if (heapSpacePtr->addr == maskedAddr) break;
1987     }
1988
1989     if (heapSpacePtr == shadowSpace->heapSpaceTail) {
1990         heapSpacePtr->addr = maskedAddr;
1991         heapSpacePtr->data = *((unsigned int*) maskedAddr);
1992         shadowSpace->heapSpaceTail++;
1993     }
1994
1995     addr = ((unsigned int) &(heapSpacePtr->data)) | alignment;
1996     switch (size) {
1997         case kSVByte:
1998             *((u1*) addr) = data;
1999             break;
2000         case kSVSignedByte:
2001             *((s1*) addr) = data;
2002             break;
2003         case kSVHalfword:
2004             *((u2*) addr) = data;
2005             break;
2006         case kSVSignedHalfword:
2007             *((s2*) addr) = data;
2008             break;
2009         case kSVWord:
2010             *((u4*) addr) = data;
2011             break;
2012         default:
2013             LOGE("*** ERROR: BAD SIZE IN selfVerificationSave: %d", size);
2014             dvmAbort();
2015     }
2016 }
2017
2018 /* Like selfVerificationStore, but specifically for doublewords */
2019 static void selfVerificationStoreDoubleword(int addr, s8 double_data)
2020 {
2021     Thread *self = dvmThreadSelf();
2022     ShadowSpace *shadowSpace = self->shadowSpace;
2023     ShadowHeap *heapSpacePtr;
2024
2025     int addr2 = addr+4;
2026     int data = double_data;
2027     int data2 = double_data >> 32;
2028     bool store1 = false, store2 = false;
2029
2030     //LOGD("*** HEAP STORE DOUBLEWORD: Addr: 0x%x Data: 0x%x, Data2: 0x%x",
2031     //    addr, data, data2);
2032
2033     for (heapSpacePtr = shadowSpace->heapSpace;
2034          heapSpacePtr != shadowSpace->heapSpaceTail; heapSpacePtr++) {
2035         if (heapSpacePtr->addr == addr) {
2036             heapSpacePtr->data = data;
2037             store1 = true;
2038         } else if (heapSpacePtr->addr == addr2) {
2039             heapSpacePtr->data = data2;
2040             store2 = true;
2041         }
2042     }
2043
2044     if (!store1) {
2045         shadowSpace->heapSpaceTail->addr = addr;
2046         shadowSpace->heapSpaceTail->data = data;
2047         shadowSpace->heapSpaceTail++;
2048     }
2049     if (!store2) {
2050         shadowSpace->heapSpaceTail->addr = addr2;
2051         shadowSpace->heapSpaceTail->data = data2;
2052         shadowSpace->heapSpaceTail++;
2053     }
2054 }
2055
2056 /*
2057  * Decodes the memory instruction at the address specified in the link
2058  * register. All registers (r0-r12,lr) and fp registers (d0-d15) are stored
2059  * consecutively on the stack beginning at the specified stack pointer.
2060  * Calls the proper Self Verification handler for the memory instruction and
2061  * updates the link register to point past the decoded memory instruction.
2062  */
2063 void dvmSelfVerificationMemOpDecode(int lr, int* sp)
2064 {
2065     enum {
2066         kMemOpLdrPcRel = 0x09, // ldr(3)  [01001] rd[10..8] imm_8[7..0]
2067         kMemOpRRR      = 0x0A, // Full opcode is 7 bits
2068         kMemOp2Single  = 0x0A, // Used for Vstrs and Vldrs
2069         kMemOpRRR2     = 0x0B, // Full opcode is 7 bits
2070         kMemOp2Double  = 0x0B, // Used for Vstrd and Vldrd
2071         kMemOpStrRRI5  = 0x0C, // str(1)  [01100] imm_5[10..6] rn[5..3] rd[2..0]
2072         kMemOpLdrRRI5  = 0x0D, // ldr(1)  [01101] imm_5[10..6] rn[5..3] rd[2..0]
2073         kMemOpStrbRRI5 = 0x0E, // strb(1) [01110] imm_5[10..6] rn[5..3] rd[2..0]
2074         kMemOpLdrbRRI5 = 0x0F, // ldrb(1) [01111] imm_5[10..6] rn[5..3] rd[2..0]
2075         kMemOpStrhRRI5 = 0x10, // strh(1) [10000] imm_5[10..6] rn[5..3] rd[2..0]
2076         kMemOpLdrhRRI5 = 0x11, // ldrh(1) [10001] imm_5[10..6] rn[5..3] rd[2..0]
2077         kMemOpLdrSpRel = 0x13, // ldr(4)  [10011] rd[10..8] imm_8[7..0]
2078         kMemOpStrRRR   = 0x28, // str(2)  [0101000] rm[8..6] rn[5..3] rd[2..0]
2079         kMemOpStrhRRR  = 0x29, // strh(2) [0101001] rm[8..6] rn[5..3] rd[2..0]
2080         kMemOpStrbRRR  = 0x2A, // strb(2) [0101010] rm[8..6] rn[5..3] rd[2..0]
2081         kMemOpLdrsbRRR = 0x2B, // ldrsb   [0101011] rm[8..6] rn[5..3] rd[2..0]
2082         kMemOpLdrRRR   = 0x2C, // ldr(2)  [0101100] rm[8..6] rn[5..3] rd[2..0]
2083         kMemOpLdrhRRR  = 0x2D, // ldrh(2) [0101101] rm[8..6] rn[5..3] rd[2..0]
2084         kMemOpLdrbRRR  = 0x2E, // ldrb(2) [0101110] rm[8..6] rn[5..3] rd[2..0]
2085         kMemOpLdrshRRR = 0x2F, // ldrsh   [0101111] rm[8..6] rn[5..3] rd[2..0]
2086         kMemOp2Vstr    = 0xED8, // Used for Vstrs and Vstrd
2087         kMemOp2Vldr    = 0xED9, // Used for Vldrs and Vldrd
2088         kMemOp2Vstr2   = 0xEDC, // Used for Vstrs and Vstrd
2089         kMemOp2Vldr2   = 0xEDD, // Used for Vstrs and Vstrd
2090         kMemOp2StrbRRR = 0xF80, /* str rt,[rn,rm,LSL #imm] [111110000000]
2091                                 rn[19-16] rt[15-12] [000000] imm[5-4] rm[3-0] */
2092         kMemOp2LdrbRRR = 0xF81, /* ldrb rt,[rn,rm,LSL #imm] [111110000001]
2093                                 rn[19-16] rt[15-12] [000000] imm[5-4] rm[3-0] */
2094         kMemOp2StrhRRR = 0xF82, /* str rt,[rn,rm,LSL #imm] [111110000010]
2095                                 rn[19-16] rt[15-12] [000000] imm[5-4] rm[3-0] */
2096         kMemOp2LdrhRRR = 0xF83, /* ldrh rt,[rn,rm,LSL #imm] [111110000011]
2097                                 rn[19-16] rt[15-12] [000000] imm[5-4] rm[3-0] */
2098         kMemOp2StrRRR  = 0xF84, /* str rt,[rn,rm,LSL #imm] [111110000100]
2099                                 rn[19-16] rt[15-12] [000000] imm[5-4] rm[3-0] */
2100         kMemOp2LdrRRR  = 0xF85, /* ldr rt,[rn,rm,LSL #imm] [111110000101]
2101                                 rn[19-16] rt[15-12] [000000] imm[5-4] rm[3-0] */
2102         kMemOp2StrbRRI12 = 0xF88, /* strb rt,[rn,#imm12] [111110001000]
2103                                        rt[15..12] rn[19..16] imm12[11..0] */
2104         kMemOp2LdrbRRI12 = 0xF89, /* ldrb rt,[rn,#imm12] [111110001001]
2105                                        rt[15..12] rn[19..16] imm12[11..0] */
2106         kMemOp2StrhRRI12 = 0xF8A, /* strh rt,[rn,#imm12] [111110001010]
2107                                        rt[15..12] rn[19..16] imm12[11..0] */
2108         kMemOp2LdrhRRI12 = 0xF8B, /* ldrh rt,[rn,#imm12] [111110001011]
2109                                        rt[15..12] rn[19..16] imm12[11..0] */
2110         kMemOp2StrRRI12 = 0xF8C, /* str(Imm,T3) rd,[rn,#imm12] [111110001100]
2111                                        rn[19..16] rt[15..12] imm12[11..0] */
2112         kMemOp2LdrRRI12 = 0xF8D, /* ldr(Imm,T3) rd,[rn,#imm12] [111110001101]
2113                                        rn[19..16] rt[15..12] imm12[11..0] */
2114         kMemOp2LdrsbRRR = 0xF91, /* ldrsb rt,[rn,rm,LSL #imm] [111110010001]
2115                                 rn[19-16] rt[15-12] [000000] imm[5-4] rm[3-0] */
2116         kMemOp2LdrshRRR = 0xF93, /* ldrsh rt,[rn,rm,LSL #imm] [111110010011]
2117                                 rn[19-16] rt[15-12] [000000] imm[5-4] rm[3-0] */
2118         kMemOp2LdrsbRRI12 = 0xF99, /* ldrsb rt,[rn,#imm12] [111110011001]
2119                                        rt[15..12] rn[19..16] imm12[11..0] */
2120         kMemOp2LdrshRRI12 = 0xF9B, /* ldrsh rt,[rn,#imm12] [111110011011]
2121                                        rt[15..12] rn[19..16] imm12[11..0] */
2122         kMemOp2        = 0xE000, // top 3 bits set indicates Thumb2
2123     };
2124
2125     int addr, offset, data;
2126     long long double_data;
2127     int size = kSVWord;
2128     bool store = false;
2129     unsigned int *lr_masked = (unsigned int *) (lr & 0xFFFFFFFE);
2130     unsigned int insn = *lr_masked;
2131
2132     int old_lr;
2133     old_lr = selfVerificationMemRegLoad(sp, 13);
2134
2135     if ((insn & kMemOp2) == kMemOp2) {
2136         insn = (insn << 16) | (insn >> 16);
2137         //LOGD("*** THUMB2 - Addr: 0x%x Insn: 0x%x", lr, insn);
2138
2139         int opcode12 = (insn >> 20) & 0xFFF;
2140         int opcode6 = (insn >> 6) & 0x3F;
2141         int opcode4 = (insn >> 8) & 0xF;
2142         int imm2 = (insn >> 4) & 0x3;
2143         int imm8 = insn & 0xFF;
2144         int imm12 = insn & 0xFFF;
2145         int rd = (insn >> 12) & 0xF;
2146         int rm = insn & 0xF;
2147         int rn = (insn >> 16) & 0xF;
2148         int rt = (insn >> 12) & 0xF;
2149
2150         // Update the link register
2151         selfVerificationMemRegStore(sp, old_lr+4, 13);
2152
2153         // Determine whether the mem op is a store or load
2154         switch (opcode12) {
2155             case kMemOp2Vstr:
2156             case kMemOp2Vstr2:
2157             case kMemOp2StrbRRR:
2158             case kMemOp2StrhRRR:
2159             case kMemOp2StrRRR:
2160             case kMemOp2StrbRRI12:
2161             case kMemOp2StrhRRI12:
2162             case kMemOp2StrRRI12:
2163                 store = true;
2164         }
2165
2166         // Determine the size of the mem access
2167         switch (opcode12) {
2168             case kMemOp2StrbRRR:
2169             case kMemOp2LdrbRRR:
2170             case kMemOp2StrbRRI12:
2171             case kMemOp2LdrbRRI12:
2172                 size = kSVByte;
2173                 break;
2174             case kMemOp2LdrsbRRR:
2175             case kMemOp2LdrsbRRI12:
2176                 size = kSVSignedByte;
2177                 break;
2178             case kMemOp2StrhRRR:
2179             case kMemOp2LdrhRRR:
2180             case kMemOp2StrhRRI12:
2181             case kMemOp2LdrhRRI12:
2182                 size = kSVHalfword;
2183                 break;
2184             case kMemOp2LdrshRRR:
2185             case kMemOp2LdrshRRI12:
2186                 size = kSVSignedHalfword;
2187                 break;
2188             case kMemOp2Vstr:
2189             case kMemOp2Vstr2:
2190             case kMemOp2Vldr:
2191             case kMemOp2Vldr2:
2192                 if (opcode4 == kMemOp2Double) size = kSVDoubleword;
2193                 break;
2194         }
2195
2196         // Load the value of the address
2197         addr = selfVerificationMemRegLoad(sp, rn);
2198
2199         // Figure out the offset
2200         switch (opcode12) {
2201             case kMemOp2Vstr:
2202             case kMemOp2Vstr2:
2203             case kMemOp2Vldr:
2204             case kMemOp2Vldr2:
2205                 offset = imm8 << 2;
2206                 if (opcode4 == kMemOp2Single) {
2207                     rt = rd << 1;
2208                     if (insn & 0x400000) rt |= 0x1;
2209                 } else if (opcode4 == kMemOp2Double) {
2210                     if (insn & 0x400000) rt |= 0x10;
2211                     rt = rt << 1;
2212                 } else {
2213                     LOGE("*** ERROR: UNRECOGNIZED VECTOR MEM OP: %x", opcode4);
2214                     dvmAbort();
2215                 }
2216                 rt += 14;
2217                 break;
2218             case kMemOp2StrbRRR:
2219             case kMemOp2LdrbRRR:
2220             case kMemOp2StrhRRR:
2221             case kMemOp2LdrhRRR:
2222             case kMemOp2StrRRR:
2223             case kMemOp2LdrRRR:
2224             case kMemOp2LdrsbRRR:
2225             case kMemOp2LdrshRRR:
2226                 offset = selfVerificationMemRegLoad(sp, rm) << imm2;
2227                 break;
2228             case kMemOp2StrbRRI12:
2229             case kMemOp2LdrbRRI12:
2230             case kMemOp2StrhRRI12:
2231             case kMemOp2LdrhRRI12:
2232             case kMemOp2StrRRI12:
2233             case kMemOp2LdrRRI12:
2234             case kMemOp2LdrsbRRI12:
2235             case kMemOp2LdrshRRI12:
2236                 offset = imm12;
2237                 break;
2238             default:
2239                 LOGE("*** ERROR: UNRECOGNIZED THUMB2 MEM OP: %x", opcode12);
2240                 offset = 0;
2241                 dvmAbort();
2242         }
2243
2244         // Handle the decoded mem op accordingly
2245         if (store) {
2246             if (size == kSVDoubleword) {
2247                 double_data = selfVerificationMemRegLoadDouble(sp, rt);
2248                 selfVerificationStoreDoubleword(addr+offset, double_data);
2249             } else {
2250                 data = selfVerificationMemRegLoad(sp, rt);
2251                 selfVerificationStore(addr+offset, data, size);
2252             }
2253         } else {
2254             if (size == kSVDoubleword) {
2255                 double_data = selfVerificationLoadDoubleword(addr+offset);
2256                 selfVerificationMemRegStoreDouble(sp, double_data, rt);
2257             } else {
2258                 data = selfVerificationLoad(addr+offset, size);
2259                 selfVerificationMemRegStore(sp, data, rt);
2260             }
2261         }
2262     } else {
2263         //LOGD("*** THUMB - Addr: 0x%x Insn: 0x%x", lr, insn);
2264
2265         // Update the link register
2266         selfVerificationMemRegStore(sp, old_lr+2, 13);
2267
2268         int opcode5 = (insn >> 11) & 0x1F;
2269         int opcode7 = (insn >> 9) & 0x7F;
2270         int imm = (insn >> 6) & 0x1F;
2271         int rd = (insn >> 8) & 0x7;
2272         int rm = (insn >> 6) & 0x7;
2273         int rn = (insn >> 3) & 0x7;
2274         int rt = insn & 0x7;
2275
2276         // Determine whether the mem op is a store or load
2277         switch (opcode5) {
2278             case kMemOpRRR:
2279                 switch (opcode7) {
2280                     case kMemOpStrRRR:
2281                     case kMemOpStrhRRR:
2282                     case kMemOpStrbRRR:
2283                         store = true;
2284                 }
2285                 break;
2286             case kMemOpStrRRI5:
2287             case kMemOpStrbRRI5:
2288             case kMemOpStrhRRI5:
2289                 store = true;
2290         }
2291
2292         // Determine the size of the mem access
2293         switch (opcode5) {
2294             case kMemOpRRR:
2295             case kMemOpRRR2:
2296                 switch (opcode7) {
2297                     case kMemOpStrbRRR:
2298                     case kMemOpLdrbRRR:
2299                         size = kSVByte;
2300                         break;
2301                     case kMemOpLdrsbRRR:
2302                         size = kSVSignedByte;
2303                         break;
2304                     case kMemOpStrhRRR:
2305                     case kMemOpLdrhRRR:
2306                         size = kSVHalfword;
2307                         break;
2308                     case kMemOpLdrshRRR:
2309                         size = kSVSignedHalfword;
2310                         break;
2311                 }
2312                 break;
2313             case kMemOpStrbRRI5:
2314             case kMemOpLdrbRRI5:
2315                 size = kSVByte;
2316                 break;
2317             case kMemOpStrhRRI5:
2318             case kMemOpLdrhRRI5:
2319                 size = kSVHalfword;
2320                 break;
2321         }
2322
2323         // Load the value of the address
2324         if (opcode5 == kMemOpLdrPcRel)
2325             addr = selfVerificationMemRegLoad(sp, 4);
2326         else
2327             addr = selfVerificationMemRegLoad(sp, rn);
2328
2329         // Figure out the offset
2330         switch (opcode5) {
2331             case kMemOpLdrPcRel:
2332                 offset = (insn & 0xFF) << 2;
2333                 rt = rd;
2334                 break;
2335             case kMemOpRRR:
2336             case kMemOpRRR2:
2337                 offset = selfVerificationMemRegLoad(sp, rm);
2338                 break;
2339             case kMemOpStrRRI5:
2340             case kMemOpLdrRRI5:
2341                 offset = imm << 2;
2342                 break;
2343             case kMemOpStrhRRI5:
2344             case kMemOpLdrhRRI5:
2345                 offset = imm << 1;
2346                 break;
2347             case kMemOpStrbRRI5:
2348             case kMemOpLdrbRRI5:
2349                 offset = imm;
2350                 break;
2351             default:
2352                 LOGE("*** ERROR: UNRECOGNIZED THUMB MEM OP: %x", opcode5);
2353                 offset = 0;
2354                 dvmAbort();
2355         }
2356
2357         // Handle the decoded mem op accordingly
2358         if (store) {
2359             data = selfVerificationMemRegLoad(sp, rt);
2360             selfVerificationStore(addr+offset, data, size);
2361         } else {
2362             data = selfVerificationLoad(addr+offset, size);
2363             selfVerificationMemRegStore(sp, data, rt);
2364         }
2365     }
2366 }
2367 #endif