lib/Target/ARM/Disassembler/ARMDisassembler.cpp

   1 //===- ARMDisassembler.cpp - Disassembler for ARM/Thumb ISA -----*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #define DEBUG_TYPE "arm-disassembler"
  11
  12 #include "ARMDisassembler.h"
  13 #include "ARM.h"
  14 #include "ARMRegisterInfo.h"
  15 #include "MCTargetDesc/ARMAddressingModes.h"
  16 #include "MCTargetDesc/ARMBaseInfo.h"
  17 #include "llvm/MC/EDInstInfo.h"
  18 #include "llvm/MC/MCInst.h"
  19 #include "llvm/MC/MCExpr.h"
  20 #include "llvm/MC/MCContext.h"
  21 #include "llvm/Target/TargetRegistry.h"
  22 #include "llvm/Support/Debug.h"
  23 #include "llvm/Support/MemoryObject.h"
  24 #include "llvm/Support/ErrorHandling.h"
  25 #include "llvm/Support/raw_ostream.h"
  26
  27 // Pull DecodeStatus and its enum values into the global namespace.
  28 typedef llvm::MCDisassembler::DecodeStatus DecodeStatus;
  29 #define Success llvm::MCDisassembler::Success
  30 #define Unpredictable llvm::MCDisassembler::SoftFail
  31 #define Fail llvm::MCDisassembler::Fail
  32
  33 // Helper macro to perform setwise reduction of the current running status
  34 // and another status, and return if the new status is Fail.
  35 #define CHECK(S,X) do {                           \
  36     S = (DecodeStatus) ((int)S & (X));            \
  37     if (S == Fail) return Fail;                   \
  38   } while(0)
  39
  40 // Forward declare these because the autogenerated code will reference them.
  41 // Definitions are further down.
  42 static DecodeStatus DecodeGPRRegisterClass(llvm::MCInst &Inst, unsigned RegNo,
  43                                    uint64_t Address, const void *Decoder);
  44 static DecodeStatus DecodeGPRnopcRegisterClass(llvm::MCInst &Inst,
  45                                                unsigned RegNo, uint64_t Address,
  46                                                const void *Decoder);
  47 static DecodeStatus DecodetGPRRegisterClass(llvm::MCInst &Inst, unsigned RegNo,
  48                                    uint64_t Address, const void *Decoder);
  49 static DecodeStatus DecodetcGPRRegisterClass(llvm::MCInst &Inst, unsigned RegNo,
  50                                    uint64_t Address, const void *Decoder);
  51 static DecodeStatus DecoderGPRRegisterClass(llvm::MCInst &Inst, unsigned RegNo,
  52                                    uint64_t Address, const void *Decoder);
  53 static DecodeStatus DecodeSPRRegisterClass(llvm::MCInst &Inst, unsigned RegNo,
  54                                    uint64_t Address, const void *Decoder);
  55 static DecodeStatus DecodeDPRRegisterClass(llvm::MCInst &Inst, unsigned RegNo,
  56                                    uint64_t Address, const void *Decoder);
  57 static DecodeStatus DecodeDPR_8RegisterClass(llvm::MCInst &Inst, unsigned RegNo,
  58                                    uint64_t Address, const void *Decoder);
  59 static DecodeStatus DecodeDPR_VFP2RegisterClass(llvm::MCInst &Inst,
  60                                                 unsigned RegNo,
  61                                                 uint64_t Address,
  62                                                 const void *Decoder);
  63 static DecodeStatus DecodeQPRRegisterClass(llvm::MCInst &Inst, unsigned RegNo,
  64                                    uint64_t Address, const void *Decoder);
  65
  66 static DecodeStatus DecodePredicateOperand(llvm::MCInst &Inst, unsigned Val,
  67                                uint64_t Address, const void *Decoder);
  68 static DecodeStatus DecodeCCOutOperand(llvm::MCInst &Inst, unsigned Val,
  69                                uint64_t Address, const void *Decoder);
  70 static DecodeStatus DecodeSOImmOperand(llvm::MCInst &Inst, unsigned Val,
  71                                uint64_t Address, const void *Decoder);
  72 static DecodeStatus DecodeBLTargetOperand(llvm::MCInst &Inst, unsigned Val,
  73                                uint64_t Address, const void *Decoder);
  74 static DecodeStatus DecodeRegListOperand(llvm::MCInst &Inst, unsigned Val,
  75                                uint64_t Address, const void *Decoder);
  76 static DecodeStatus DecodeSPRRegListOperand(llvm::MCInst &Inst, unsigned Val,
  77                                uint64_t Address, const void *Decoder);
  78 static DecodeStatus DecodeDPRRegListOperand(llvm::MCInst &Inst, unsigned Val,
  79                                uint64_t Address, const void *Decoder);
  80
  81 static DecodeStatus DecodeBitfieldMaskOperand(llvm::MCInst &Inst, unsigned Insn,
  82                                uint64_t Address, const void *Decoder);
  83 static DecodeStatus DecodeCopMemInstruction(llvm::MCInst &Inst, unsigned Insn,
  84                                uint64_t Address, const void *Decoder);
  85 static DecodeStatus DecodeAddrMode2IdxInstruction(llvm::MCInst &Inst,
  86                                                   unsigned Insn,
  87                                                   uint64_t Address,
  88                                                   const void *Decoder);
  89 static DecodeStatus DecodeSORegMemOperand(llvm::MCInst &Inst, unsigned Insn,
  90                                uint64_t Address, const void *Decoder);
  91 static DecodeStatus DecodeAddrMode3Instruction(llvm::MCInst &Inst,unsigned Insn,
  92                                uint64_t Address, const void *Decoder);
  93 static DecodeStatus DecodeSORegImmOperand(llvm::MCInst &Inst, unsigned Insn,
  94                                uint64_t Address, const void *Decoder);
  95 static DecodeStatus DecodeSORegRegOperand(llvm::MCInst &Inst, unsigned Insn,
  96                                uint64_t Address, const void *Decoder);
  97
  98 static DecodeStatus DecodeMemMultipleWritebackInstruction(llvm::MCInst & Inst,
  99                                                   unsigned Insn,
 100                                                   uint64_t Adddress,
 101                                                   const void *Decoder);
 102 static DecodeStatus DecodeSMLAInstruction(llvm::MCInst &Inst, unsigned Insn,
 103                                uint64_t Address, const void *Decoder);
 104 static DecodeStatus DecodeCPSInstruction(llvm::MCInst &Inst, unsigned Insn,
 105                                uint64_t Address, const void *Decoder);
 106 static DecodeStatus DecodeAddrModeImm12Operand(llvm::MCInst &Inst, unsigned Val,
 107                                uint64_t Address, const void *Decoder);
 108 static DecodeStatus DecodeAddrMode5Operand(llvm::MCInst &Inst, unsigned Val,
 109                                uint64_t Address, const void *Decoder);
 110 static DecodeStatus DecodeAddrMode7Operand(llvm::MCInst &Inst, unsigned Val,
 111                                uint64_t Address, const void *Decoder);
 112 static DecodeStatus DecodeBranchImmInstruction(llvm::MCInst &Inst,unsigned Insn,
 113                                uint64_t Address, const void *Decoder);
 114 static DecodeStatus DecodeVCVTImmOperand(llvm::MCInst &Inst, unsigned Val,
 115                                uint64_t Address, const void *Decoder);
 116 static DecodeStatus DecodeAddrMode6Operand(llvm::MCInst &Inst, unsigned Val,
 117                                uint64_t Address, const void *Decoder);
 118 static DecodeStatus DecodeVLDInstruction(llvm::MCInst &Inst, unsigned Val,
 119                                uint64_t Address, const void *Decoder);
 120 static DecodeStatus DecodeVSTInstruction(llvm::MCInst &Inst, unsigned Val,
 121                                uint64_t Address, const void *Decoder);
 122 static DecodeStatus DecodeVLD1DupInstruction(llvm::MCInst &Inst, unsigned Val,
 123                                uint64_t Address, const void *Decoder);
 124 static DecodeStatus DecodeVLD2DupInstruction(llvm::MCInst &Inst, unsigned Val,
 125                                uint64_t Address, const void *Decoder);
 126 static DecodeStatus DecodeVLD3DupInstruction(llvm::MCInst &Inst, unsigned Val,
 127                                uint64_t Address, const void *Decoder);
 128 static DecodeStatus DecodeVLD4DupInstruction(llvm::MCInst &Inst, unsigned Val,
 129                                uint64_t Address, const void *Decoder);
 130 static DecodeStatus DecodeNEONModImmInstruction(llvm::MCInst &Inst,unsigned Val,
 131                                uint64_t Address, const void *Decoder);
 132 static DecodeStatus DecodeVSHLMaxInstruction(llvm::MCInst &Inst, unsigned Val,
 133                                uint64_t Address, const void *Decoder);
 134 static DecodeStatus DecodeShiftRight8Imm(llvm::MCInst &Inst, unsigned Val,
 135                                uint64_t Address, const void *Decoder);
 136 static DecodeStatus DecodeShiftRight16Imm(llvm::MCInst &Inst, unsigned Val,
 137                                uint64_t Address, const void *Decoder);
 138 static DecodeStatus DecodeShiftRight32Imm(llvm::MCInst &Inst, unsigned Val,
 139                                uint64_t Address, const void *Decoder);
 140 static DecodeStatus DecodeShiftRight64Imm(llvm::MCInst &Inst, unsigned Val,
 141                                uint64_t Address, const void *Decoder);
 142 static DecodeStatus DecodeTBLInstruction(llvm::MCInst &Inst, unsigned Insn,
 143                                uint64_t Address, const void *Decoder);
 144 static DecodeStatus DecodeVFPfpImm(llvm::MCInst &Inst, unsigned Val,
 145                                uint64_t Address, const void *Decoder);
 146 static DecodeStatus DecodePostIdxReg(llvm::MCInst &Inst, unsigned Insn,
 147                                uint64_t Address, const void *Decoder);
 148 static DecodeStatus DecodeCoprocessor(llvm::MCInst &Inst, unsigned Insn,
 149                                uint64_t Address, const void *Decoder);
 150 static DecodeStatus DecodeMemBarrierOption(llvm::MCInst &Inst, unsigned Insn,
 151                                uint64_t Address, const void *Decoder);
 152 static DecodeStatus DecodeMSRMask(llvm::MCInst &Inst, unsigned Insn,
 153                                uint64_t Address, const void *Decoder);
 154 static DecodeStatus DecodeDoubleRegLoad(llvm::MCInst &Inst, unsigned Insn,
 155                                uint64_t Address, const void *Decoder);
 156 static DecodeStatus DecodeDoubleRegStore(llvm::MCInst &Inst, unsigned Insn,
 157                                uint64_t Address, const void *Decoder);
 158 static DecodeStatus DecodeSTRPreImm(llvm::MCInst &Inst, unsigned Insn,
 159                                uint64_t Address, const void *Decoder);
 160 static DecodeStatus DecodeSTRPreReg(llvm::MCInst &Inst, unsigned Insn,
 161                                uint64_t Address, const void *Decoder);
 162 static DecodeStatus DecodeVLD1LN(llvm::MCInst &Inst, unsigned Insn,
 163                                uint64_t Address, const void *Decoder);
 164 static DecodeStatus DecodeVLD2LN(llvm::MCInst &Inst, unsigned Insn,
 165                                uint64_t Address, const void *Decoder);
 166 static DecodeStatus DecodeVLD3LN(llvm::MCInst &Inst, unsigned Insn,
 167                                uint64_t Address, const void *Decoder);
 168 static DecodeStatus DecodeVLD4LN(llvm::MCInst &Inst, unsigned Insn,
 169                                uint64_t Address, const void *Decoder);
 170 static DecodeStatus DecodeVST1LN(llvm::MCInst &Inst, unsigned Insn,
 171                                uint64_t Address, const void *Decoder);
 172 static DecodeStatus DecodeVST2LN(llvm::MCInst &Inst, unsigned Insn,
 173                                uint64_t Address, const void *Decoder);
 174 static DecodeStatus DecodeVST3LN(llvm::MCInst &Inst, unsigned Insn,
 175                                uint64_t Address, const void *Decoder);
 176 static DecodeStatus DecodeVST4LN(llvm::MCInst &Inst, unsigned Insn,
 177                                uint64_t Address, const void *Decoder);
 178
 179
 180 static DecodeStatus DecodeThumbAddSpecialReg(llvm::MCInst &Inst, uint16_t Insn,
 181                                uint64_t Address, const void *Decoder);
 182 static DecodeStatus DecodeThumbBROperand(llvm::MCInst &Inst, unsigned Val,
 183                                uint64_t Address, const void *Decoder);
 184 static DecodeStatus DecodeT2BROperand(llvm::MCInst &Inst, unsigned Val,
 185                                uint64_t Address, const void *Decoder);
 186 static DecodeStatus DecodeThumbCmpBROperand(llvm::MCInst &Inst, unsigned Val,
 187                                uint64_t Address, const void *Decoder);
 188 static DecodeStatus DecodeThumbAddrModeRR(llvm::MCInst &Inst, unsigned Val,
 189                                uint64_t Address, const void *Decoder);
 190 static DecodeStatus DecodeThumbAddrModeIS(llvm::MCInst &Inst, unsigned Val,
 191                                uint64_t Address, const void *Decoder);
 192 static DecodeStatus DecodeThumbAddrModePC(llvm::MCInst &Inst, unsigned Val,
 193                                uint64_t Address, const void *Decoder);
 194 static DecodeStatus DecodeThumbAddrModeSP(llvm::MCInst &Inst, unsigned Val,
 195                                uint64_t Address, const void *Decoder);
 196 static DecodeStatus DecodeT2AddrModeSOReg(llvm::MCInst &Inst, unsigned Val,
 197                                uint64_t Address, const void *Decoder);
 198 static DecodeStatus DecodeT2LoadShift(llvm::MCInst &Inst, unsigned Val,
 199                                uint64_t Address, const void *Decoder);
 200 static DecodeStatus DecodeT2Imm8S4(llvm::MCInst &Inst, unsigned Val,
 201                                uint64_t Address, const void *Decoder);
 202 static DecodeStatus DecodeT2AddrModeImm8s4(llvm::MCInst &Inst, unsigned Val,
 203                                uint64_t Address, const void *Decoder);
 204 static DecodeStatus DecodeT2Imm8(llvm::MCInst &Inst, unsigned Val,
 205                                uint64_t Address, const void *Decoder);
 206 static DecodeStatus DecodeT2AddrModeImm8(llvm::MCInst &Inst, unsigned Val,
 207                                uint64_t Address, const void *Decoder);
 208 static DecodeStatus DecodeThumbAddSPImm(llvm::MCInst &Inst, uint16_t Val,
 209                                uint64_t Address, const void *Decoder);
 210 static DecodeStatus DecodeThumbAddSPReg(llvm::MCInst &Inst, uint16_t Insn,
 211                                 uint64_t Address, const void *Decoder);
 212 static DecodeStatus DecodeThumbCPS(llvm::MCInst &Inst, uint16_t Insn,
 213                                 uint64_t Address, const void *Decoder);
 214 static DecodeStatus DecodeThumbBLXOffset(llvm::MCInst &Inst, unsigned Insn,
 215                                 uint64_t Address, const void *Decoder);
 216 static DecodeStatus DecodeT2AddrModeImm12(llvm::MCInst &Inst, unsigned Val,
 217                                 uint64_t Address, const void *Decoder);
 218 static DecodeStatus DecodeThumb2BCCInstruction(llvm::MCInst &Inst, unsigned Val,
 219                                 uint64_t Address, const void *Decoder);
 220 static DecodeStatus DecodeT2SOImm(llvm::MCInst &Inst, unsigned Val,
 221                                 uint64_t Address, const void *Decoder);
 222 static DecodeStatus DecodeThumbBCCTargetOperand(llvm::MCInst &Inst,unsigned Val,
 223                                 uint64_t Address, const void *Decoder);
 224 static DecodeStatus DecodeThumbBLTargetOperand(llvm::MCInst &Inst, unsigned Val,
 225                                 uint64_t Address, const void *Decoder);
 226
 227 #include "ARMGenDisassemblerTables.inc"
 228 #include "ARMGenInstrInfo.inc"
 229 #include "ARMGenEDInfo.inc"
 230
 231 using namespace llvm;
 232
 233 static MCDisassembler *createARMDisassembler(const Target &T) {
 234   return new ARMDisassembler;
 235 }
 236
 237 static MCDisassembler *createThumbDisassembler(const Target &T) {
 238   return new ThumbDisassembler;
 239 }
 240
 241 EDInstInfo *ARMDisassembler::getEDInfo() const {
 242   return instInfoARM;
 243 }
 244
 245 EDInstInfo *ThumbDisassembler::getEDInfo() const {
 246   return instInfoARM;
 247 }
 248
 249 DecodeStatus ARMDisassembler::getInstruction(MCInst &MI, uint64_t &Size,
 250                                              const MemoryObject &Region,
 251                                              uint64_t Address,
 252                                              raw_ostream &os) const {
 253   uint8_t bytes[4];
 254
 255   // We want to read exactly 4 bytes of data.
 256   if (Region.readBytes(Address, 4, (uint8_t*)bytes, NULL) == -1)
 257     return Fail;
 258
 259   // Encoded as a small-endian 32-bit word in the stream.
 260   uint32_t insn = (bytes[3] << 24) |
 261                   (bytes[2] << 16) |
 262                   (bytes[1] <<  8) |
 263                   (bytes[0] <<  0);
 264
 265   // Calling the auto-generated decoder function.
 266   DecodeStatus result = decodeARMInstruction32(MI, insn, Address, this);
 267   if (result != Fail) {
 268     Size = 4;
 269     return result;
 270   }
 271
 272   // Instructions that are shared between ARM and Thumb modes.
 273   // FIXME: This shouldn't really exist.  It's an artifact of the
 274   // fact that we fail to encode a few instructions properly for Thumb.
 275   MI.clear();
 276   result = decodeCommonInstruction32(MI, insn, Address, this);
 277   if (result != Fail) {
 278     Size = 4;
 279     return result;
 280   }
 281
 282   // VFP and NEON instructions, similarly, are shared between ARM
 283   // and Thumb modes.
 284   MI.clear();
 285   result = decodeVFPInstruction32(MI, insn, Address, this);
 286   if (result != Fail) {
 287     Size = 4;
 288     return result;
 289   }
 290
 291   MI.clear();
 292   result = decodeNEONDataInstruction32(MI, insn, Address, this);
 293   if (result != Fail) {
 294     Size = 4;
 295     // Add a fake predicate operand, because we share these instruction
 296     // definitions with Thumb2 where these instructions are predicable.
 297     if (!DecodePredicateOperand(MI, 0xE, Address, this)) return Fail;
 298     return result;
 299   }
 300
 301   MI.clear();
 302   result = decodeNEONLoadStoreInstruction32(MI, insn, Address, this);
 303   if (result != Fail) {
 304     Size = 4;
 305     // Add a fake predicate operand, because we share these instruction
 306     // definitions with Thumb2 where these instructions are predicable.
 307     if (!DecodePredicateOperand(MI, 0xE, Address, this)) return Fail;
 308     return result;
 309   }
 310
 311   MI.clear();
 312   result = decodeNEONDupInstruction32(MI, insn, Address, this);
 313   if (result != Fail) {
 314     Size = 4;
 315     // Add a fake predicate operand, because we share these instruction
 316     // definitions with Thumb2 where these instructions are predicable.
 317     if (!DecodePredicateOperand(MI, 0xE, Address, this)) return Fail;
 318     return result;
 319   }
 320
 321   MI.clear();
 322
 323   return Fail;
 324 }
 325
 326 namespace llvm {
 327 extern MCInstrDesc ARMInsts[];
 328 }
 329
 330 // Thumb1 instructions don't have explicit S bits.  Rather, they
 331 // implicitly set CPSR.  Since it's not represented in the encoding, the
 332 // auto-generated decoder won't inject the CPSR operand.  We need to fix
 333 // that as a post-pass.
 334 static void AddThumb1SBit(MCInst &MI, bool InITBlock) {
 335   const MCOperandInfo *OpInfo = ARMInsts[MI.getOpcode()].OpInfo;
 336   unsigned short NumOps = ARMInsts[MI.getOpcode()].NumOperands;
 337   MCInst::iterator I = MI.begin();
 338   for (unsigned i = 0; i < NumOps; ++i, ++I) {
 339     if (I == MI.end()) break;
 340     if (OpInfo[i].isOptionalDef() && OpInfo[i].RegClass == ARM::CCRRegClassID) {
 341       if (i > 0 && OpInfo[i-1].isPredicate()) continue;
 342       MI.insert(I, MCOperand::CreateReg(InITBlock ? 0 : ARM::CPSR));
 343       return;
 344     }
 345   }
 346
 347   MI.insert(I, MCOperand::CreateReg(InITBlock ? 0 : ARM::CPSR));
 348 }
 349
 350 // Most Thumb instructions don't have explicit predicates in the
 351 // encoding, but rather get their predicates from IT context.  We need
 352 // to fix up the predicate operands using this context information as a
 353 // post-pass.
 354 void ThumbDisassembler::AddThumbPredicate(MCInst &MI) const {
 355   // A few instructions actually have predicates encoded in them.  Don't
 356   // try to overwrite it if we're seeing one of those.
 357   switch (MI.getOpcode()) {
 358     case ARM::tBcc:
 359     case ARM::t2Bcc:
 360       return;
 361     default:
 362       break;
 363   }
 364
 365   // If we're in an IT block, base the predicate on that.  Otherwise,
 366   // assume a predicate of AL.
 367   unsigned CC;
 368   if (!ITBlock.empty()) {
 369     CC = ITBlock.back();
 370     ITBlock.pop_back();
 371   } else
 372     CC = ARMCC::AL;
 373
 374   const MCOperandInfo *OpInfo = ARMInsts[MI.getOpcode()].OpInfo;
 375   unsigned short NumOps = ARMInsts[MI.getOpcode()].NumOperands;
 376   MCInst::iterator I = MI.begin();
 377   for (unsigned i = 0; i < NumOps; ++i, ++I) {
 378     if (I == MI.end()) break;
 379     if (OpInfo[i].isPredicate()) {
 380       I = MI.insert(I, MCOperand::CreateImm(CC));
 381       ++I;
 382       if (CC == ARMCC::AL)
 383         MI.insert(I, MCOperand::CreateReg(0));
 384       else
 385         MI.insert(I, MCOperand::CreateReg(ARM::CPSR));
 386       return;
 387     }
 388   }
 389
 390   I = MI.insert(I, MCOperand::CreateImm(CC));
 391   ++I;
 392   if (CC == ARMCC::AL)
 393     MI.insert(I, MCOperand::CreateReg(0));
 394   else
 395     MI.insert(I, MCOperand::CreateReg(ARM::CPSR));
 396 }
 397
 398 // Thumb VFP instructions are a special case.  Because we share their
 399 // encodings between ARM and Thumb modes, and they are predicable in ARM
 400 // mode, the auto-generated decoder will give them an (incorrect)
 401 // predicate operand.  We need to rewrite these operands based on the IT
 402 // context as a post-pass.
 403 void ThumbDisassembler::UpdateThumbVFPPredicate(MCInst &MI) const {
 404   unsigned CC;
 405   if (!ITBlock.empty()) {
 406     CC = ITBlock.back();
 407     ITBlock.pop_back();
 408   } else
 409     CC = ARMCC::AL;
 410
 411   const MCOperandInfo *OpInfo = ARMInsts[MI.getOpcode()].OpInfo;
 412   MCInst::iterator I = MI.begin();
 413   for (unsigned i = 0, e = MI.size(); i < e; ++i, ++I) {
 414     if (OpInfo[i].isPredicate() ) {
 415       I->setImm(CC);
 416       ++I;
 417       if (CC == ARMCC::AL)
 418         I->setReg(0);
 419       else
 420         I->setReg(ARM::CPSR);
 421       return;
 422     }
 423   }
 424 }
 425
 426 DecodeStatus ThumbDisassembler::getInstruction(MCInst &MI, uint64_t &Size,
 427                                                const MemoryObject &Region,
 428                                                uint64_t Address,
 429                                                raw_ostream &os) const {
 430   uint8_t bytes[4];
 431
 432   // We want to read exactly 2 bytes of data.
 433   if (Region.readBytes(Address, 2, (uint8_t*)bytes, NULL) == -1)
 434     return Fail;
 435
 436   uint16_t insn16 = (bytes[1] << 8) | bytes[0];
 437   DecodeStatus result = decodeThumbInstruction16(MI, insn16, Address, this);
 438   if (result != Fail) {
 439     Size = 2;
 440     AddThumbPredicate(MI);
 441     return result;
 442   }
 443
 444   MI.clear();
 445   result = decodeThumbSBitInstruction16(MI, insn16, Address, this);
 446   if (result) {
 447     Size = 2;
 448     bool InITBlock = !ITBlock.empty();
 449     AddThumbPredicate(MI);
 450     AddThumb1SBit(MI, InITBlock);
 451     return result;
 452   }
 453
 454   MI.clear();
 455   result = decodeThumb2Instruction16(MI, insn16, Address, this);
 456   if (result != Fail) {
 457     Size = 2;
 458     AddThumbPredicate(MI);
 459
 460     // If we find an IT instruction, we need to parse its condition
 461     // code and mask operands so that we can apply them correctly
 462     // to the subsequent instructions.
 463     if (MI.getOpcode() == ARM::t2IT) {
 464       unsigned firstcond = MI.getOperand(0).getImm();
 465       uint32_t mask = MI.getOperand(1).getImm();
 466       unsigned zeros = CountTrailingZeros_32(mask);
 467       mask >>= zeros+1;
 468
 469       for (unsigned i = 0; i < 4 - (zeros+1); ++i) {
 470         if (firstcond ^ (mask & 1))
 471           ITBlock.push_back(firstcond ^ 1);
 472         else
 473           ITBlock.push_back(firstcond);
 474         mask >>= 1;
 475       }
 476       ITBlock.push_back(firstcond);
 477     }
 478
 479     return result;
 480   }
 481
 482   // We want to read exactly 4 bytes of data.
 483   if (Region.readBytes(Address, 4, (uint8_t*)bytes, NULL) == -1)
 484     return Fail;
 485
 486   uint32_t insn32 = (bytes[3] <<  8) |
 487                     (bytes[2] <<  0) |
 488                     (bytes[1] << 24) |
 489                     (bytes[0] << 16);
 490   MI.clear();
 491   result = decodeThumbInstruction32(MI, insn32, Address, this);
 492   if (result != Fail) {
 493     Size = 4;
 494     bool InITBlock = ITBlock.size();
 495     AddThumbPredicate(MI);
 496     AddThumb1SBit(MI, InITBlock);
 497     return result;
 498   }
 499
 500   MI.clear();
 501   result = decodeThumb2Instruction32(MI, insn32, Address, this);
 502   if (result != Fail) {
 503     Size = 4;
 504     AddThumbPredicate(MI);
 505     return result;
 506   }
 507
 508   MI.clear();
 509   result = decodeCommonInstruction32(MI, insn32, Address, this);
 510   if (result != Fail) {
 511     Size = 4;
 512     AddThumbPredicate(MI);
 513     return result;
 514   }
 515
 516   MI.clear();
 517   result = decodeVFPInstruction32(MI, insn32, Address, this);
 518   if (result != Fail) {
 519     Size = 4;
 520     UpdateThumbVFPPredicate(MI);
 521     return result;
 522   }
 523
 524   MI.clear();
 525   result = decodeNEONDupInstruction32(MI, insn32, Address, this);
 526   if (result != Fail) {
 527     Size = 4;
 528     AddThumbPredicate(MI);
 529     return result;
 530   }
 531
 532   if (fieldFromInstruction32(insn32, 24, 8) == 0xF9) {
 533     MI.clear();
 534     uint32_t NEONLdStInsn = insn32;
 535     NEONLdStInsn &= 0xF0FFFFFF;
 536     NEONLdStInsn |= 0x04000000;
 537     result = decodeNEONLoadStoreInstruction32(MI, NEONLdStInsn, Address, this);
 538     if (result != Fail) {
 539       Size = 4;
 540       AddThumbPredicate(MI);
 541       return result;
 542     }
 543   }
 544
 545   if (fieldFromInstruction32(insn32, 24, 4) == 0xF) {
 546     MI.clear();
 547     uint32_t NEONDataInsn = insn32;
 548     NEONDataInsn &= 0xF0FFFFFF; // Clear bits 27-24
 549     NEONDataInsn |= (NEONDataInsn & 0x10000000) >> 4; // Move bit 28 to bit 24
 550     NEONDataInsn |= 0x12000000; // Set bits 28 and 25
 551     result = decodeNEONDataInstruction32(MI, NEONDataInsn, Address, this);
 552     if (result != Fail) {
 553       Size = 4;
 554       AddThumbPredicate(MI);
 555       return result;
 556     }
 557   }
 558
 559   return Fail;
 560 }
 561
 562
 563 extern "C" void LLVMInitializeARMDisassembler() {
 564   TargetRegistry::RegisterMCDisassembler(TheARMTarget,
 565                                          createARMDisassembler);
 566   TargetRegistry::RegisterMCDisassembler(TheThumbTarget,
 567                                          createThumbDisassembler);
 568 }
 569
 570 static const unsigned GPRDecoderTable[] = {
 571   ARM::R0, ARM::R1, ARM::R2, ARM::R3,
 572   ARM::R4, ARM::R5, ARM::R6, ARM::R7,
 573   ARM::R8, ARM::R9, ARM::R10, ARM::R11,
 574   ARM::R12, ARM::SP, ARM::LR, ARM::PC
 575 };
 576
 577 static DecodeStatus DecodeGPRRegisterClass(llvm::MCInst &Inst, unsigned RegNo,
 578                                    uint64_t Address, const void *Decoder) {
 579   if (RegNo > 15)
 580     return Fail;
 581
 582   unsigned Register = GPRDecoderTable[RegNo];
 583   Inst.addOperand(MCOperand::CreateReg(Register));
 584   return Success;
 585 }
 586
 587 static DecodeStatus
 588 DecodeGPRnopcRegisterClass(llvm::MCInst &Inst, unsigned RegNo,
 589                            uint64_t Address, const void *Decoder) {
 590   if (RegNo == 15) return Fail;
 591   return DecodeGPRRegisterClass(Inst, RegNo, Address, Decoder);
 592 }
 593
 594 static DecodeStatus DecodetGPRRegisterClass(llvm::MCInst &Inst, unsigned RegNo,
 595                                    uint64_t Address, const void *Decoder) {
 596   if (RegNo > 7)
 597     return Fail;
 598   return DecodeGPRRegisterClass(Inst, RegNo, Address, Decoder);
 599 }
 600
 601 static DecodeStatus DecodetcGPRRegisterClass(llvm::MCInst &Inst, unsigned RegNo,
 602                                    uint64_t Address, const void *Decoder) {
 603   unsigned Register = 0;
 604   switch (RegNo) {
 605     case 0:
 606       Register = ARM::R0;
 607       break;
 608     case 1:
 609       Register = ARM::R1;
 610       break;
 611     case 2:
 612       Register = ARM::R2;
 613       break;
 614     case 3:
 615       Register = ARM::R3;
 616       break;
 617     case 9:
 618       Register = ARM::R9;
 619       break;
 620     case 12:
 621       Register = ARM::R12;
 622       break;
 623     default:
 624       return Fail;
 625     }
 626
 627   Inst.addOperand(MCOperand::CreateReg(Register));
 628   return Success;
 629 }
 630
 631 static DecodeStatus DecoderGPRRegisterClass(llvm::MCInst &Inst, unsigned RegNo,
 632                                    uint64_t Address, const void *Decoder) {
 633   if (RegNo == 13 || RegNo == 15) return Fail;
 634   return DecodeGPRRegisterClass(Inst, RegNo, Address, Decoder);
 635 }
 636
 637 static const unsigned SPRDecoderTable[] = {
 638      ARM::S0,  ARM::S1,  ARM::S2,  ARM::S3,
 639      ARM::S4,  ARM::S5,  ARM::S6,  ARM::S7,
 640      ARM::S8,  ARM::S9, ARM::S10, ARM::S11,
 641     ARM::S12, ARM::S13, ARM::S14, ARM::S15,
 642     ARM::S16, ARM::S17, ARM::S18, ARM::S19,
 643     ARM::S20, ARM::S21, ARM::S22, ARM::S23,
 644     ARM::S24, ARM::S25, ARM::S26, ARM::S27,
 645     ARM::S28, ARM::S29, ARM::S30, ARM::S31
 646 };
 647
 648 static DecodeStatus DecodeSPRRegisterClass(llvm::MCInst &Inst, unsigned RegNo,
 649                                    uint64_t Address, const void *Decoder) {
 650   if (RegNo > 31)
 651     return Fail;
 652
 653   unsigned Register = SPRDecoderTable[RegNo];
 654   Inst.addOperand(MCOperand::CreateReg(Register));
 655   return Success;
 656 }
 657
 658 static const unsigned DPRDecoderTable[] = {
 659      ARM::D0,  ARM::D1,  ARM::D2,  ARM::D3,
 660      ARM::D4,  ARM::D5,  ARM::D6,  ARM::D7,
 661      ARM::D8,  ARM::D9, ARM::D10, ARM::D11,
 662     ARM::D12, ARM::D13, ARM::D14, ARM::D15,
 663     ARM::D16, ARM::D17, ARM::D18, ARM::D19,
 664     ARM::D20, ARM::D21, ARM::D22, ARM::D23,
 665     ARM::D24, ARM::D25, ARM::D26, ARM::D27,
 666     ARM::D28, ARM::D29, ARM::D30, ARM::D31
 667 };
 668
 669 static DecodeStatus DecodeDPRRegisterClass(llvm::MCInst &Inst, unsigned RegNo,
 670                                    uint64_t Address, const void *Decoder) {
 671   if (RegNo > 31)
 672     return Fail;
 673
 674   unsigned Register = DPRDecoderTable[RegNo];
 675   Inst.addOperand(MCOperand::CreateReg(Register));
 676   return Success;
 677 }
 678
 679 static DecodeStatus DecodeDPR_8RegisterClass(llvm::MCInst &Inst, unsigned RegNo,
 680                                    uint64_t Address, const void *Decoder) {
 681   if (RegNo > 7)
 682     return Fail;
 683   return DecodeDPRRegisterClass(Inst, RegNo, Address, Decoder);
 684 }
 685
 686 static DecodeStatus
 687 DecodeDPR_VFP2RegisterClass(llvm::MCInst &Inst, unsigned RegNo,
 688                             uint64_t Address, const void *Decoder) {
 689   if (RegNo > 15)
 690     return Fail;
 691   return DecodeDPRRegisterClass(Inst, RegNo, Address, Decoder);
 692 }
 693
 694 static const unsigned QPRDecoderTable[] = {
 695      ARM::Q0,  ARM::Q1,  ARM::Q2,  ARM::Q3,
 696      ARM::Q4,  ARM::Q5,  ARM::Q6,  ARM::Q7,
 697      ARM::Q8,  ARM::Q9, ARM::Q10, ARM::Q11,
 698     ARM::Q12, ARM::Q13, ARM::Q14, ARM::Q15
 699 };
 700
 701
 702 static DecodeStatus DecodeQPRRegisterClass(llvm::MCInst &Inst, unsigned RegNo,
 703                                    uint64_t Address, const void *Decoder) {
 704   if (RegNo > 31)
 705     return Fail;
 706   RegNo >>= 1;
 707
 708   unsigned Register = QPRDecoderTable[RegNo];
 709   Inst.addOperand(MCOperand::CreateReg(Register));
 710   return Success;
 711 }
 712
 713 static DecodeStatus DecodePredicateOperand(llvm::MCInst &Inst, unsigned Val,
 714                                uint64_t Address, const void *Decoder) {
 715   if (Val == 0xF) return Fail;
 716   // AL predicate is not allowed on Thumb1 branches.
 717   if (Inst.getOpcode() == ARM::tBcc && Val == 0xE)
 718     return Fail;
 719   Inst.addOperand(MCOperand::CreateImm(Val));
 720   if (Val == ARMCC::AL) {
 721     Inst.addOperand(MCOperand::CreateReg(0));
 722   } else
 723     Inst.addOperand(MCOperand::CreateReg(ARM::CPSR));
 724   return Success;
 725 }
 726
 727 static DecodeStatus DecodeCCOutOperand(llvm::MCInst &Inst, unsigned Val,
 728                                uint64_t Address, const void *Decoder) {
 729   if (Val)
 730     Inst.addOperand(MCOperand::CreateReg(ARM::CPSR));
 731   else
 732     Inst.addOperand(MCOperand::CreateReg(0));
 733   return Success;
 734 }
 735
 736 static DecodeStatus DecodeSOImmOperand(llvm::MCInst &Inst, unsigned Val,
 737                                uint64_t Address, const void *Decoder) {
 738   uint32_t imm = Val & 0xFF;
 739   uint32_t rot = (Val & 0xF00) >> 7;
 740   uint32_t rot_imm = (imm >> rot) | (imm << (32-rot));
 741   Inst.addOperand(MCOperand::CreateImm(rot_imm));
 742   return Success;
 743 }
 744
 745 static DecodeStatus DecodeBLTargetOperand(llvm::MCInst &Inst, unsigned Val,
 746                                uint64_t Address, const void *Decoder) {
 747   Val <<= 2;
 748   Inst.addOperand(MCOperand::CreateImm(SignExtend32<26>(Val)));
 749   return Success;
 750 }
 751
 752 static DecodeStatus DecodeSORegImmOperand(llvm::MCInst &Inst, unsigned Val,
 753                                uint64_t Address, const void *Decoder) {
 754   DecodeStatus S = Success;
 755
 756   unsigned Rm = fieldFromInstruction32(Val, 0, 4);
 757   unsigned type = fieldFromInstruction32(Val, 5, 2);
 758   unsigned imm = fieldFromInstruction32(Val, 7, 5);
 759
 760   // Register-immediate
 761   CHECK(S, DecodeGPRRegisterClass(Inst, Rm, Address, Decoder));
 762
 763   ARM_AM::ShiftOpc Shift = ARM_AM::lsl;
 764   switch (type) {
 765     case 0:
 766       Shift = ARM_AM::lsl;
 767       break;
 768     case 1:
 769       Shift = ARM_AM::lsr;
 770       break;
 771     case 2:
 772       Shift = ARM_AM::asr;
 773       break;
 774     case 3:
 775       Shift = ARM_AM::ror;
 776       break;
 777   }
 778
 779   if (Shift == ARM_AM::ror && imm == 0)
 780     Shift = ARM_AM::rrx;
 781
 782   unsigned Op = Shift | (imm << 3);
 783   Inst.addOperand(MCOperand::CreateImm(Op));
 784
 785   return S;
 786 }
 787
 788 static DecodeStatus DecodeSORegRegOperand(llvm::MCInst &Inst, unsigned Val,
 789                                uint64_t Address, const void *Decoder) {
 790   DecodeStatus S = Success;
 791
 792   unsigned Rm = fieldFromInstruction32(Val, 0, 4);
 793   unsigned type = fieldFromInstruction32(Val, 5, 2);
 794   unsigned Rs = fieldFromInstruction32(Val, 8, 4);
 795
 796   // Register-register
 797   CHECK(S, DecodeGPRnopcRegisterClass(Inst, Rm, Address, Decoder));
 798   CHECK(S, DecodeGPRnopcRegisterClass(Inst, Rs, Address, Decoder));
 799
 800   ARM_AM::ShiftOpc Shift = ARM_AM::lsl;
 801   switch (type) {
 802     case 0:
 803       Shift = ARM_AM::lsl;
 804       break;
 805     case 1:
 806       Shift = ARM_AM::lsr;
 807       break;
 808     case 2:
 809       Shift = ARM_AM::asr;
 810       break;
 811     case 3:
 812       Shift = ARM_AM::ror;
 813       break;
 814   }
 815
 816   Inst.addOperand(MCOperand::CreateImm(Shift));
 817
 818   return S;
 819 }
 820
 821 static DecodeStatus DecodeRegListOperand(llvm::MCInst &Inst, unsigned Val,
 822                                  uint64_t Address, const void *Decoder) {
 823   DecodeStatus S = Success;
 824
 825   // Empty register lists are not allowed.
 826   if (CountPopulation_32(Val) == 0) return Fail;
 827   for (unsigned i = 0; i < 16; ++i) {
 828     if (Val & (1 << i)) {
 829       CHECK(S, DecodeGPRRegisterClass(Inst, i, Address, Decoder));
 830     }
 831   }
 832
 833   return S;
 834 }
 835
 836 static DecodeStatus DecodeSPRRegListOperand(llvm::MCInst &Inst, unsigned Val,
 837                                  uint64_t Address, const void *Decoder) {
 838   DecodeStatus S = Success;
 839
 840   unsigned Vd = fieldFromInstruction32(Val, 8, 4);
 841   unsigned regs = Val & 0xFF;
 842
 843   CHECK(S, DecodeSPRRegisterClass(Inst, Vd, Address, Decoder));
 844   for (unsigned i = 0; i < (regs - 1); ++i) {
 845     CHECK(S, DecodeSPRRegisterClass(Inst, ++Vd, Address, Decoder));
 846   }
 847
 848   return S;
 849 }
 850
 851 static DecodeStatus DecodeDPRRegListOperand(llvm::MCInst &Inst, unsigned Val,
 852                                  uint64_t Address, const void *Decoder) {
 853   DecodeStatus S = Success;
 854
 855   unsigned Vd = fieldFromInstruction32(Val, 8, 4);
 856   unsigned regs = (Val & 0xFF) / 2;
 857
 858   CHECK(S, DecodeDPRRegisterClass(Inst, Vd, Address, Decoder));
 859   for (unsigned i = 0; i < (regs - 1); ++i) {
 860     CHECK(S, DecodeDPRRegisterClass(Inst, ++Vd, Address, Decoder));
 861   }
 862
 863   return S;
 864 }
 865
 866 static DecodeStatus DecodeBitfieldMaskOperand(llvm::MCInst &Inst, unsigned Val,
 867                                       uint64_t Address, const void *Decoder) {
 868   // This operand encodes a mask of contiguous zeros between a specified MSB
 869   // and LSB.  To decode it, we create the mask of all bits MSB-and-lower,
 870   // the mask of all bits LSB-and-lower, and then xor them to create
 871   // the mask of that's all ones on [msb, lsb].  Finally we not it to
 872   // create the final mask.
 873   unsigned msb = fieldFromInstruction32(Val, 5, 5);
 874   unsigned lsb = fieldFromInstruction32(Val, 0, 5);
 875   uint32_t msb_mask = (1 << (msb+1)) - 1;
 876   uint32_t lsb_mask = (1 << lsb) - 1;
 877   Inst.addOperand(MCOperand::CreateImm(~(msb_mask ^ lsb_mask)));
 878   return Success;
 879 }
 880
 881 static DecodeStatus DecodeCopMemInstruction(llvm::MCInst &Inst, unsigned Insn,
 882                                   uint64_t Address, const void *Decoder) {
 883   DecodeStatus S = Success;
 884
 885   unsigned pred = fieldFromInstruction32(Insn, 28, 4);
 886   unsigned CRd = fieldFromInstruction32(Insn, 12, 4);
 887   unsigned coproc = fieldFromInstruction32(Insn, 8, 4);
 888   unsigned imm = fieldFromInstruction32(Insn, 0, 8);
 889   unsigned Rn = fieldFromInstruction32(Insn, 16, 4);
 890   unsigned U = fieldFromInstruction32(Insn, 23, 1);
 891
 892   switch (Inst.getOpcode()) {
 893     case ARM::LDC_OFFSET:
 894     case ARM::LDC_PRE:
 895     case ARM::LDC_POST:
 896     case ARM::LDC_OPTION:
 897     case ARM::LDCL_OFFSET:
 898     case ARM::LDCL_PRE:
 899     case ARM::LDCL_POST:
 900     case ARM::LDCL_OPTION:
 901     case ARM::STC_OFFSET:
 902     case ARM::STC_PRE:
 903     case ARM::STC_POST:
 904     case ARM::STC_OPTION:
 905     case ARM::STCL_OFFSET:
 906     case ARM::STCL_PRE:
 907     case ARM::STCL_POST:
 908     case ARM::STCL_OPTION:
 909       if (coproc == 0xA || coproc == 0xB)
 910         return Fail;
 911       break;
 912     default:
 913       break;
 914   }
 915
 916   Inst.addOperand(MCOperand::CreateImm(coproc));
 917   Inst.addOperand(MCOperand::CreateImm(CRd));
 918   CHECK(S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder));
 919   switch (Inst.getOpcode()) {
 920     case ARM::LDC_OPTION:
 921     case ARM::LDCL_OPTION:
 922     case ARM::LDC2_OPTION:
 923     case ARM::LDC2L_OPTION:
 924     case ARM::STC_OPTION:
 925     case ARM::STCL_OPTION:
 926     case ARM::STC2_OPTION:
 927     case ARM::STC2L_OPTION:
 928     case ARM::LDCL_POST:
 929     case ARM::STCL_POST:
 930       break;
 931     default:
 932       Inst.addOperand(MCOperand::CreateReg(0));
 933       break;
 934   }
 935
 936   unsigned P = fieldFromInstruction32(Insn, 24, 1);
 937   unsigned W = fieldFromInstruction32(Insn, 21, 1);
 938
 939   bool writeback = (P == 0) || (W == 1);
 940   unsigned idx_mode = 0;
 941   if (P && writeback)
 942     idx_mode = ARMII::IndexModePre;
 943   else if (!P && writeback)
 944     idx_mode = ARMII::IndexModePost;
 945
 946   switch (Inst.getOpcode()) {
 947     case ARM::LDCL_POST:
 948     case ARM::STCL_POST:
 949       imm |= U << 8;
 950     case ARM::LDC_OPTION:
 951     case ARM::LDCL_OPTION:
 952     case ARM::LDC2_OPTION:
 953     case ARM::LDC2L_OPTION:
 954     case ARM::STC_OPTION:
 955     case ARM::STCL_OPTION:
 956     case ARM::STC2_OPTION:
 957     case ARM::STC2L_OPTION:
 958       Inst.addOperand(MCOperand::CreateImm(imm));
 959       break;
 960     default:
 961       if (U)
 962         Inst.addOperand(MCOperand::CreateImm(
 963             ARM_AM::getAM2Opc(ARM_AM::add, imm, ARM_AM::lsl, idx_mode)));
 964       else
 965         Inst.addOperand(MCOperand::CreateImm(
 966             ARM_AM::getAM2Opc(ARM_AM::sub, imm, ARM_AM::lsl, idx_mode)));
 967       break;
 968   }
 969
 970   switch (Inst.getOpcode()) {
 971     case ARM::LDC_OFFSET:
 972     case ARM::LDC_PRE:
 973     case ARM::LDC_POST:
 974     case ARM::LDC_OPTION:
 975     case ARM::LDCL_OFFSET:
 976     case ARM::LDCL_PRE:
 977     case ARM::LDCL_POST:
 978     case ARM::LDCL_OPTION:
 979     case ARM::STC_OFFSET:
 980     case ARM::STC_PRE:
 981     case ARM::STC_POST:
 982     case ARM::STC_OPTION:
 983     case ARM::STCL_OFFSET:
 984     case ARM::STCL_PRE:
 985     case ARM::STCL_POST:
 986     case ARM::STCL_OPTION:
 987       CHECK(S, DecodePredicateOperand(Inst, pred, Address, Decoder));
 988       break;
 989     default:
 990       break;
 991   }
 992
 993   return S;
 994 }
 995
 996 static DecodeStatus
 997 DecodeAddrMode2IdxInstruction(llvm::MCInst &Inst, unsigned Insn,
 998                               uint64_t Address, const void *Decoder) {
 999   DecodeStatus S = Success;
1000
1001   unsigned Rn = fieldFromInstruction32(Insn, 16, 4);
1002   unsigned Rt = fieldFromInstruction32(Insn, 12, 4);
1003   unsigned Rm = fieldFromInstruction32(Insn, 0, 4);
1004   unsigned imm = fieldFromInstruction32(Insn, 0, 12);
1005   unsigned pred = fieldFromInstruction32(Insn, 28, 4);
1006   unsigned reg = fieldFromInstruction32(Insn, 25, 1);
1007   unsigned P = fieldFromInstruction32(Insn, 24, 1);
1008   unsigned W = fieldFromInstruction32(Insn, 21, 1);
1009
1010   // On stores, the writeback operand precedes Rt.
1011   switch (Inst.getOpcode()) {
1012     case ARM::STR_POST_IMM:
1013     case ARM::STR_POST_REG:
1014     case ARM::STRB_POST_IMM:
1015     case ARM::STRB_POST_REG:
1016     case ARM::STRT_POST_REG:
1017     case ARM::STRT_POST_IMM:
1018     case ARM::STRBT_POST_REG:
1019     case ARM::STRBT_POST_IMM:
1020       CHECK(S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder));
1021       break;
1022     default:
1023       break;
1024   }
1025
1026   CHECK(S, DecodeGPRRegisterClass(Inst, Rt, Address, Decoder));
1027
1028   // On loads, the writeback operand comes after Rt.
1029   switch (Inst.getOpcode()) {
1030     case ARM::LDR_POST_IMM:
1031     case ARM::LDR_POST_REG:
1032     case ARM::LDRB_POST_IMM:
1033     case ARM::LDRB_POST_REG:
1034     case ARM::LDR_PRE:
1035     case ARM::LDRB_PRE:
1036     case ARM::LDRBT_POST_REG:
1037     case ARM::LDRBT_POST_IMM:
1038     case ARM::LDRT_POST_REG:
1039     case ARM::LDRT_POST_IMM:
1040       CHECK(S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder));
1041       break;
1042     default:
1043       break;
1044   }
1045
1046   CHECK(S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder));
1047
1048   ARM_AM::AddrOpc Op = ARM_AM::add;
1049   if (!fieldFromInstruction32(Insn, 23, 1))
1050     Op = ARM_AM::sub;
1051
1052   bool writeback = (P == 0) || (W == 1);
1053   unsigned idx_mode = 0;
1054   if (P && writeback)
1055     idx_mode = ARMII::IndexModePre;
1056   else if (!P && writeback)
1057     idx_mode = ARMII::IndexModePost;
1058
1059   if (writeback && (Rn == 15 || Rn == Rt)) S = Unpredictable; // UNPREDICTABLE
1060
1061   if (reg) {
1062     CHECK(S, DecodeGPRnopcRegisterClass(Inst, Rm, Address, Decoder));
1063     ARM_AM::ShiftOpc Opc = ARM_AM::lsl;
1064     switch( fieldFromInstruction32(Insn, 5, 2)) {
1065       case 0:
1066         Opc = ARM_AM::lsl;
1067         break;
1068       case 1:
1069         Opc = ARM_AM::lsr;
1070         break;
1071       case 2:
1072         Opc = ARM_AM::asr;
1073         break;
1074       case 3:
1075         Opc = ARM_AM::ror;
1076         break;
1077       default:
1078         return Fail;
1079     }
1080     unsigned amt = fieldFromInstruction32(Insn, 7, 5);
1081     unsigned imm = ARM_AM::getAM2Opc(Op, amt, Opc, idx_mode);
1082
1083     Inst.addOperand(MCOperand::CreateImm(imm));
1084   } else {
1085     Inst.addOperand(MCOperand::CreateReg(0));
1086     unsigned tmp = ARM_AM::getAM2Opc(Op, imm, ARM_AM::lsl, idx_mode);
1087     Inst.addOperand(MCOperand::CreateImm(tmp));
1088   }
1089
1090   CHECK(S, DecodePredicateOperand(Inst, pred, Address, Decoder));
1091
1092   return S;
1093 }
1094
1095 static DecodeStatus DecodeSORegMemOperand(llvm::MCInst &Inst, unsigned Val,
1096                                   uint64_t Address, const void *Decoder) {
1097   DecodeStatus S = Success;
1098
1099   unsigned Rn = fieldFromInstruction32(Val, 13, 4);
1100   unsigned Rm = fieldFromInstruction32(Val,  0, 4);
1101   unsigned type = fieldFromInstruction32(Val, 5, 2);
1102   unsigned imm = fieldFromInstruction32(Val, 7, 5);
1103   unsigned U = fieldFromInstruction32(Val, 12, 1);
1104
1105   ARM_AM::ShiftOpc ShOp = ARM_AM::lsl;
1106   switch (type) {
1107     case 0:
1108       ShOp = ARM_AM::lsl;
1109       break;
1110     case 1:
1111       ShOp = ARM_AM::lsr;
1112       break;
1113     case 2:
1114       ShOp = ARM_AM::asr;
1115       break;
1116     case 3:
1117       ShOp = ARM_AM::ror;
1118       break;
1119   }
1120
1121   CHECK(S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder));
1122   CHECK(S, DecodeGPRRegisterClass(Inst, Rm, Address, Decoder));
1123   unsigned shift;
1124   if (U)
1125     shift = ARM_AM::getAM2Opc(ARM_AM::add, imm, ShOp);
1126   else
1127     shift = ARM_AM::getAM2Opc(ARM_AM::sub, imm, ShOp);
1128   Inst.addOperand(MCOperand::CreateImm(shift));
1129
1130   return S;
1131 }
1132
1133 static DecodeStatus
1134 DecodeAddrMode3Instruction(llvm::MCInst &Inst, unsigned Insn,
1135                            uint64_t Address, const void *Decoder) {
1136   DecodeStatus S = Success;
1137
1138   unsigned Rt = fieldFromInstruction32(Insn, 12, 4);
1139   unsigned Rn = fieldFromInstruction32(Insn, 16, 4);
1140   unsigned Rm = fieldFromInstruction32(Insn, 0, 4);
1141   unsigned type = fieldFromInstruction32(Insn, 22, 1);
1142   unsigned imm = fieldFromInstruction32(Insn, 8, 4);
1143   unsigned U = ((~fieldFromInstruction32(Insn, 23, 1)) & 1) << 8;
1144   unsigned pred = fieldFromInstruction32(Insn, 28, 4);
1145   unsigned W = fieldFromInstruction32(Insn, 21, 1);
1146   unsigned P = fieldFromInstruction32(Insn, 24, 1);
1147
1148   bool writeback = (W == 1) | (P == 0);
1149
1150   // For {LD,ST}RD, Rt must be even, else undefined.
1151   switch (Inst.getOpcode()) {
1152     case ARM::STRD:
1153     case ARM::STRD_PRE:
1154     case ARM::STRD_POST:
1155     case ARM::LDRD:
1156     case ARM::LDRD_PRE:
1157     case ARM::LDRD_POST:
1158       if (Rt & 0x1) return Fail;
1159       break;
1160   default:
1161     break;
1162   }
1163
1164   if (writeback) { // Writeback
1165     if (P)
1166       U |= ARMII::IndexModePre << 9;
1167     else
1168       U |= ARMII::IndexModePost << 9;
1169
1170     // On stores, the writeback operand precedes Rt.
1171     switch (Inst.getOpcode()) {
1172     case ARM::STRD:
1173     case ARM::STRD_PRE:
1174     case ARM::STRD_POST:
1175     case ARM::STRH:
1176     case ARM::STRH_PRE:
1177     case ARM::STRH_POST:
1178       CHECK(S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder));
1179       break;
1180     default:
1181       break;
1182     }
1183   }
1184
1185   CHECK(S, DecodeGPRRegisterClass(Inst, Rt, Address, Decoder));
1186   switch (Inst.getOpcode()) {
1187     case ARM::STRD:
1188     case ARM::STRD_PRE:
1189     case ARM::STRD_POST:
1190     case ARM::LDRD:
1191     case ARM::LDRD_PRE:
1192     case ARM::LDRD_POST:
1193       CHECK(S, DecodeGPRRegisterClass(Inst, Rt+1, Address, Decoder));
1194       break;
1195     default:
1196       break;
1197   }
1198
1199   if (writeback) {
1200     // On loads, the writeback operand comes after Rt.
1201     switch (Inst.getOpcode()) {
1202     case ARM::LDRD:
1203     case ARM::LDRD_PRE:
1204     case ARM::LDRD_POST:
1205     case ARM::LDRH:
1206     case ARM::LDRH_PRE:
1207     case ARM::LDRH_POST:
1208     case ARM::LDRSH:
1209     case ARM::LDRSH_PRE:
1210     case ARM::LDRSH_POST:
1211     case ARM::LDRSB:
1212     case ARM::LDRSB_PRE:
1213     case ARM::LDRSB_POST:
1214     case ARM::LDRHTr:
1215     case ARM::LDRSBTr:
1216       CHECK(S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder));
1217       break;
1218     default:
1219       break;
1220     }
1221   }
1222
1223   CHECK(S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder));
1224
1225   if (type) {
1226     Inst.addOperand(MCOperand::CreateReg(0));
1227     Inst.addOperand(MCOperand::CreateImm(U | (imm << 4) | Rm));
1228   } else {
1229     CHECK(S, DecodeGPRRegisterClass(Inst, Rm, Address, Decoder));
1230     Inst.addOperand(MCOperand::CreateImm(U));
1231   }
1232
1233   CHECK(S, DecodePredicateOperand(Inst, pred, Address, Decoder));
1234
1235   return S;
1236 }
1237
1238 static DecodeStatus DecodeRFEInstruction(llvm::MCInst &Inst, unsigned Insn,
1239                                  uint64_t Address, const void *Decoder) {
1240   DecodeStatus S = Success;
1241
1242   unsigned Rn = fieldFromInstruction32(Insn, 16, 4);
1243   unsigned mode = fieldFromInstruction32(Insn, 23, 2);
1244
1245   switch (mode) {
1246     case 0:
1247       mode = ARM_AM::da;
1248       break;
1249     case 1:
1250       mode = ARM_AM::ia;
1251       break;
1252     case 2:
1253       mode = ARM_AM::db;
1254       break;
1255     case 3:
1256       mode = ARM_AM::ib;
1257       break;
1258   }
1259
1260   Inst.addOperand(MCOperand::CreateImm(mode));
1261   CHECK(S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder));
1262
1263   return S;
1264 }
1265
1266 static DecodeStatus DecodeMemMultipleWritebackInstruction(llvm::MCInst &Inst,
1267                                   unsigned Insn,
1268                                   uint64_t Address, const void *Decoder) {
1269   DecodeStatus S = Success;
1270
1271   unsigned Rn = fieldFromInstruction32(Insn, 16, 4);
1272   unsigned pred = fieldFromInstruction32(Insn, 28, 4);
1273   unsigned reglist = fieldFromInstruction32(Insn, 0, 16);
1274
1275   if (pred == 0xF) {
1276     switch (Inst.getOpcode()) {
1277       case ARM::STMDA:
1278         Inst.setOpcode(ARM::RFEDA);
1279         break;
1280       case ARM::STMDA_UPD:
1281         Inst.setOpcode(ARM::RFEDA_UPD);
1282         break;
1283       case ARM::STMDB:
1284         Inst.setOpcode(ARM::RFEDB);
1285         break;
1286       case ARM::STMDB_UPD:
1287         Inst.setOpcode(ARM::RFEDB_UPD);
1288         break;
1289       case ARM::STMIA:
1290         Inst.setOpcode(ARM::RFEIA);
1291         break;
1292       case ARM::STMIA_UPD:
1293         Inst.setOpcode(ARM::RFEIA_UPD);
1294         break;
1295       case ARM::STMIB:
1296         Inst.setOpcode(ARM::RFEIB);
1297         break;
1298       case ARM::STMIB_UPD:
1299         Inst.setOpcode(ARM::RFEIB_UPD);
1300         break;
1301     }
1302     return DecodeRFEInstruction(Inst, Insn, Address, Decoder);
1303   }
1304
1305   CHECK(S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder));
1306   CHECK(S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder)); // Tied
1307   CHECK(S, DecodePredicateOperand(Inst, pred, Address, Decoder));
1308   CHECK(S, DecodeRegListOperand(Inst, reglist, Address, Decoder));
1309
1310   return S;
1311 }
1312
1313 static DecodeStatus DecodeCPSInstruction(llvm::MCInst &Inst, unsigned Insn,
1314                                  uint64_t Address, const void *Decoder) {
1315   unsigned imod = fieldFromInstruction32(Insn, 18, 2);
1316   unsigned M = fieldFromInstruction32(Insn, 17, 1);
1317   unsigned iflags = fieldFromInstruction32(Insn, 6, 3);
1318   unsigned mode = fieldFromInstruction32(Insn, 0, 5);
1319
1320   DecodeStatus S = Success;
1321
1322   // imod == '01' --> UNPREDICTABLE
1323   // NOTE: Even though this is technically UNPREDICTABLE, we choose to
1324   // return failure here.  The '01' imod value is unprintable, so there's
1325   // nothing useful we could do even if we returned UNPREDICTABLE.
1326
1327   if (imod == 1) CHECK(S, Fail);
1328
1329   if (imod && M) {
1330     Inst.setOpcode(ARM::CPS3p);
1331     Inst.addOperand(MCOperand::CreateImm(imod));
1332     Inst.addOperand(MCOperand::CreateImm(iflags));
1333     Inst.addOperand(MCOperand::CreateImm(mode));
1334   } else if (imod && !M) {
1335     Inst.setOpcode(ARM::CPS2p);
1336     Inst.addOperand(MCOperand::CreateImm(imod));
1337     Inst.addOperand(MCOperand::CreateImm(iflags));
1338     if (mode) CHECK(S, Unpredictable);
1339   } else if (!imod && M) {
1340     Inst.setOpcode(ARM::CPS1p);
1341     Inst.addOperand(MCOperand::CreateImm(mode));
1342     if (iflags) CHECK(S, Unpredictable);
1343   } else {
1344     // imod == '00' && M == '0' --> UNPREDICTABLE
1345     Inst.setOpcode(ARM::CPS1p);
1346     Inst.addOperand(MCOperand::CreateImm(mode));
1347     CHECK(S, Unpredictable);
1348   }
1349
1350   return S;
1351 }
1352
1353 static DecodeStatus DecodeSMLAInstruction(llvm::MCInst &Inst, unsigned Insn,
1354                                  uint64_t Address, const void *Decoder) {
1355   DecodeStatus S = Success;
1356
1357   unsigned Rd = fieldFromInstruction32(Insn, 16, 4);
1358   unsigned Rn = fieldFromInstruction32(Insn, 0, 4);
1359   unsigned Rm = fieldFromInstruction32(Insn, 8, 4);
1360   unsigned Ra = fieldFromInstruction32(Insn, 12, 4);
1361   unsigned pred = fieldFromInstruction32(Insn, 28, 4);
1362
1363   if (pred == 0xF)
1364     return DecodeCPSInstruction(Inst, Insn, Address, Decoder);
1365
1366   CHECK(S, DecodeGPRnopcRegisterClass(Inst, Rd, Address, Decoder));
1367   CHECK(S, DecodeGPRnopcRegisterClass(Inst, Rn, Address, Decoder));
1368   CHECK(S, DecodeGPRnopcRegisterClass(Inst, Rm, Address, Decoder));
1369   CHECK(S, DecodeGPRnopcRegisterClass(Inst, Ra, Address, Decoder));
1370
1371   CHECK(S, DecodePredicateOperand(Inst, pred, Address, Decoder));
1372
1373   return S;
1374 }
1375
1376 static DecodeStatus DecodeAddrModeImm12Operand(llvm::MCInst &Inst, unsigned Val,
1377                            uint64_t Address, const void *Decoder) {
1378   DecodeStatus S = Success;
1379
1380   unsigned add = fieldFromInstruction32(Val, 12, 1);
1381   unsigned imm = fieldFromInstruction32(Val, 0, 12);
1382   unsigned Rn = fieldFromInstruction32(Val, 13, 4);
1383
1384   CHECK(S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder));
1385
1386   if (!add) imm *= -1;
1387   if (imm == 0 && !add) imm = INT32_MIN;
1388   Inst.addOperand(MCOperand::CreateImm(imm));
1389
1390   return S;
1391 }
1392
1393 static DecodeStatus DecodeAddrMode5Operand(llvm::MCInst &Inst, unsigned Val,
1394                                    uint64_t Address, const void *Decoder) {
1395   DecodeStatus S = Success;
1396
1397   unsigned Rn = fieldFromInstruction32(Val, 9, 4);
1398   unsigned U = fieldFromInstruction32(Val, 8, 1);
1399   unsigned imm = fieldFromInstruction32(Val, 0, 8);
1400
1401   CHECK(S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder));
1402
1403   if (U)
1404     Inst.addOperand(MCOperand::CreateImm(ARM_AM::getAM5Opc(ARM_AM::add, imm)));
1405   else
1406     Inst.addOperand(MCOperand::CreateImm(ARM_AM::getAM5Opc(ARM_AM::sub, imm)));
1407
1408   return S;
1409 }
1410
1411 static DecodeStatus DecodeAddrMode7Operand(llvm::MCInst &Inst, unsigned Val,
1412                                    uint64_t Address, const void *Decoder) {
1413   return DecodeGPRRegisterClass(Inst, Val, Address, Decoder);
1414 }
1415
1416 static DecodeStatus
1417 DecodeBranchImmInstruction(llvm::MCInst &Inst, unsigned Insn,
1418                            uint64_t Address, const void *Decoder) {
1419   DecodeStatus S = Success;
1420
1421   unsigned pred = fieldFromInstruction32(Insn, 28, 4);
1422   unsigned imm = fieldFromInstruction32(Insn, 0, 24) << 2;
1423
1424   if (pred == 0xF) {
1425     Inst.setOpcode(ARM::BLXi);
1426     imm |= fieldFromInstruction32(Insn, 24, 1) << 1;
1427     Inst.addOperand(MCOperand::CreateImm(SignExtend32<26>(imm)));
1428     return S;
1429   }
1430
1431   Inst.addOperand(MCOperand::CreateImm(SignExtend32<26>(imm)));
1432   CHECK(S, DecodePredicateOperand(Inst, pred, Address, Decoder));
1433
1434   return S;
1435 }
1436
1437
1438 static DecodeStatus DecodeVCVTImmOperand(llvm::MCInst &Inst, unsigned Val,
1439                                  uint64_t Address, const void *Decoder) {
1440   Inst.addOperand(MCOperand::CreateImm(64 - Val));
1441   return Success;
1442 }
1443
1444 static DecodeStatus DecodeAddrMode6Operand(llvm::MCInst &Inst, unsigned Val,
1445                                    uint64_t Address, const void *Decoder) {
1446   DecodeStatus S = Success;
1447
1448   unsigned Rm = fieldFromInstruction32(Val, 0, 4);
1449   unsigned align = fieldFromInstruction32(Val, 4, 2);
1450
1451   CHECK(S, DecodeGPRRegisterClass(Inst, Rm, Address, Decoder));
1452   if (!align)
1453     Inst.addOperand(MCOperand::CreateImm(0));
1454   else
1455     Inst.addOperand(MCOperand::CreateImm(4 << align));
1456
1457   return S;
1458 }
1459
1460 static DecodeStatus DecodeVLDInstruction(llvm::MCInst &Inst, unsigned Insn,
1461                                    uint64_t Address, const void *Decoder) {
1462   DecodeStatus S = Success;
1463
1464   unsigned Rd = fieldFromInstruction32(Insn, 12, 4);
1465   Rd |= fieldFromInstruction32(Insn, 22, 1) << 4;
1466   unsigned wb = fieldFromInstruction32(Insn, 16, 4);
1467   unsigned Rn = fieldFromInstruction32(Insn, 16, 4);
1468   Rn |= fieldFromInstruction32(Insn, 4, 2) << 4;
1469   unsigned Rm = fieldFromInstruction32(Insn, 0, 4);
1470
1471   // First output register
1472   CHECK(S, DecodeDPRRegisterClass(Inst, Rd, Address, Decoder));
1473
1474   // Second output register
1475   switch (Inst.getOpcode()) {
1476     case ARM::VLD1q8:
1477     case ARM::VLD1q16:
1478     case ARM::VLD1q32:
1479     case ARM::VLD1q64:
1480     case ARM::VLD1q8_UPD:
1481     case ARM::VLD1q16_UPD:
1482     case ARM::VLD1q32_UPD:
1483     case ARM::VLD1q64_UPD:
1484     case ARM::VLD1d8T:
1485     case ARM::VLD1d16T:
1486     case ARM::VLD1d32T:
1487     case ARM::VLD1d64T:
1488     case ARM::VLD1d8T_UPD:
1489     case ARM::VLD1d16T_UPD:
1490     case ARM::VLD1d32T_UPD:
1491     case ARM::VLD1d64T_UPD:
1492     case ARM::VLD1d8Q:
1493     case ARM::VLD1d16Q:
1494     case ARM::VLD1d32Q:
1495     case ARM::VLD1d64Q:
1496     case ARM::VLD1d8Q_UPD:
1497     case ARM::VLD1d16Q_UPD:
1498     case ARM::VLD1d32Q_UPD:
1499     case ARM::VLD1d64Q_UPD:
1500     case ARM::VLD2d8:
1501     case ARM::VLD2d16:
1502     case ARM::VLD2d32:
1503     case ARM::VLD2d8_UPD:
1504     case ARM::VLD2d16_UPD:
1505     case ARM::VLD2d32_UPD:
1506     case ARM::VLD2q8:
1507     case ARM::VLD2q16:
1508     case ARM::VLD2q32:
1509     case ARM::VLD2q8_UPD:
1510     case ARM::VLD2q16_UPD:
1511     case ARM::VLD2q32_UPD:
1512     case ARM::VLD3d8:
1513     case ARM::VLD3d16:
1514     case ARM::VLD3d32:
1515     case ARM::VLD3d8_UPD:
1516     case ARM::VLD3d16_UPD:
1517     case ARM::VLD3d32_UPD:
1518     case ARM::VLD4d8:
1519     case ARM::VLD4d16:
1520     case ARM::VLD4d32:
1521     case ARM::VLD4d8_UPD:
1522     case ARM::VLD4d16_UPD:
1523     case ARM::VLD4d32_UPD:
1524       CHECK(S, DecodeDPRRegisterClass(Inst, (Rd+1)%32, Address, Decoder));
1525       break;
1526     case ARM::VLD2b8:
1527     case ARM::VLD2b16:
1528     case ARM::VLD2b32:
1529     case ARM::VLD2b8_UPD:
1530     case ARM::VLD2b16_UPD:
1531     case ARM::VLD2b32_UPD:
1532     case ARM::VLD3q8:
1533     case ARM::VLD3q16:
1534     case ARM::VLD3q32:
1535     case ARM::VLD3q8_UPD:
1536     case ARM::VLD3q16_UPD:
1537     case ARM::VLD3q32_UPD:
1538     case ARM::VLD4q8:
1539     case ARM::VLD4q16:
1540     case ARM::VLD4q32:
1541     case ARM::VLD4q8_UPD:
1542     case ARM::VLD4q16_UPD:
1543     case ARM::VLD4q32_UPD:
1544       CHECK(S, DecodeDPRRegisterClass(Inst, (Rd+2)%32, Address, Decoder));
1545     default:
1546       break;
1547   }
1548
1549   // Third output register
1550   switch(Inst.getOpcode()) {
1551     case ARM::VLD1d8T:
1552     case ARM::VLD1d16T:
1553     case ARM::VLD1d32T:
1554     case ARM::VLD1d64T:
1555     case ARM::VLD1d8T_UPD:
1556     case ARM::VLD1d16T_UPD:
1557     case ARM::VLD1d32T_UPD:
1558     case ARM::VLD1d64T_UPD:
1559     case ARM::VLD1d8Q:
1560     case ARM::VLD1d16Q:
1561     case ARM::VLD1d32Q:
1562     case ARM::VLD1d64Q:
1563     case ARM::VLD1d8Q_UPD:
1564     case ARM::VLD1d16Q_UPD:
1565     case ARM::VLD1d32Q_UPD:
1566     case ARM::VLD1d64Q_UPD:
1567     case ARM::VLD2q8:
1568     case ARM::VLD2q16:
1569     case ARM::VLD2q32:
1570     case ARM::VLD2q8_UPD:
1571     case ARM::VLD2q16_UPD:
1572     case ARM::VLD2q32_UPD:
1573     case ARM::VLD3d8:
1574     case ARM::VLD3d16:
1575     case ARM::VLD3d32:
1576     case ARM::VLD3d8_UPD:
1577     case ARM::VLD3d16_UPD:
1578     case ARM::VLD3d32_UPD:
1579     case ARM::VLD4d8:
1580     case ARM::VLD4d16:
1581     case ARM::VLD4d32:
1582     case ARM::VLD4d8_UPD:
1583     case ARM::VLD4d16_UPD:
1584     case ARM::VLD4d32_UPD:
1585       CHECK(S, DecodeDPRRegisterClass(Inst, (Rd+2)%32, Address, Decoder));
1586       break;
1587     case ARM::VLD3q8:
1588     case ARM::VLD3q16:
1589     case ARM::VLD3q32:
1590     case ARM::VLD3q8_UPD:
1591     case ARM::VLD3q16_UPD:
1592     case ARM::VLD3q32_UPD:
1593     case ARM::VLD4q8:
1594     case ARM::VLD4q16:
1595     case ARM::VLD4q32:
1596     case ARM::VLD4q8_UPD:
1597     case ARM::VLD4q16_UPD:
1598     case ARM::VLD4q32_UPD:
1599       CHECK(S, DecodeDPRRegisterClass(Inst, (Rd+4)%32, Address, Decoder));
1600       break;
1601     default:
1602       break;
1603   }
1604
1605   // Fourth output register
1606   switch (Inst.getOpcode()) {
1607     case ARM::VLD1d8Q:
1608     case ARM::VLD1d16Q:
1609     case ARM::VLD1d32Q:
1610     case ARM::VLD1d64Q:
1611     case ARM::VLD1d8Q_UPD:
1612     case ARM::VLD1d16Q_UPD:
1613     case ARM::VLD1d32Q_UPD:
1614     case ARM::VLD1d64Q_UPD:
1615     case ARM::VLD2q8:
1616     case ARM::VLD2q16:
1617     case ARM::VLD2q32:
1618     case ARM::VLD2q8_UPD:
1619     case ARM::VLD2q16_UPD:
1620     case ARM::VLD2q32_UPD:
1621     case ARM::VLD4d8:
1622     case ARM::VLD4d16:
1623     case ARM::VLD4d32:
1624     case ARM::VLD4d8_UPD:
1625     case ARM::VLD4d16_UPD:
1626     case ARM::VLD4d32_UPD:
1627       CHECK(S, DecodeDPRRegisterClass(Inst, (Rd+3)%32, Address, Decoder));
1628       break;
1629     case ARM::VLD4q8:
1630     case ARM::VLD4q16:
1631     case ARM::VLD4q32:
1632     case ARM::VLD4q8_UPD:
1633     case ARM::VLD4q16_UPD:
1634     case ARM::VLD4q32_UPD:
1635       CHECK(S, DecodeDPRRegisterClass(Inst, (Rd+6)%32, Address, Decoder));
1636       break;
1637     default:
1638       break;
1639   }
1640
1641   // Writeback operand
1642   switch (Inst.getOpcode()) {
1643     case ARM::VLD1d8_UPD:
1644     case ARM::VLD1d16_UPD:
1645     case ARM::VLD1d32_UPD:
1646     case ARM::VLD1d64_UPD:
1647     case ARM::VLD1q8_UPD:
1648     case ARM::VLD1q16_UPD:
1649     case ARM::VLD1q32_UPD:
1650     case ARM::VLD1q64_UPD:
1651     case ARM::VLD1d8T_UPD:
1652     case ARM::VLD1d16T_UPD:
1653     case ARM::VLD1d32T_UPD:
1654     case ARM::VLD1d64T_UPD:
1655     case ARM::VLD1d8Q_UPD:
1656     case ARM::VLD1d16Q_UPD:
1657     case ARM::VLD1d32Q_UPD:
1658     case ARM::VLD1d64Q_UPD:
1659     case ARM::VLD2d8_UPD:
1660     case ARM::VLD2d16_UPD:
1661     case ARM::VLD2d32_UPD:
1662     case ARM::VLD2q8_UPD:
1663     case ARM::VLD2q16_UPD:
1664     case ARM::VLD2q32_UPD:
1665     case ARM::VLD2b8_UPD:
1666     case ARM::VLD2b16_UPD:
1667     case ARM::VLD2b32_UPD:
1668     case ARM::VLD3d8_UPD:
1669     case ARM::VLD3d16_UPD:
1670     case ARM::VLD3d32_UPD:
1671     case ARM::VLD3q8_UPD:
1672     case ARM::VLD3q16_UPD:
1673     case ARM::VLD3q32_UPD:
1674     case ARM::VLD4d8_UPD:
1675     case ARM::VLD4d16_UPD:
1676     case ARM::VLD4d32_UPD:
1677     case ARM::VLD4q8_UPD:
1678     case ARM::VLD4q16_UPD:
1679     case ARM::VLD4q32_UPD:
1680       CHECK(S, DecodeGPRRegisterClass(Inst, wb, Address, Decoder));
1681       break;
1682     default:
1683       break;
1684   }
1685
1686   // AddrMode6 Base (register+alignment)
1687   CHECK(S, DecodeAddrMode6Operand(Inst, Rn, Address, Decoder));
1688
1689   // AddrMode6 Offset (register)
1690   if (Rm == 0xD)
1691     Inst.addOperand(MCOperand::CreateReg(0));
1692   else if (Rm != 0xF) {
1693     CHECK(S, DecodeGPRRegisterClass(Inst, Rm, Address, Decoder));
1694   }
1695
1696   return S;
1697 }
1698
1699 static DecodeStatus DecodeVSTInstruction(llvm::MCInst &Inst, unsigned Insn,
1700                                  uint64_t Address, const void *Decoder) {
1701   DecodeStatus S = Success;
1702
1703   unsigned Rd = fieldFromInstruction32(Insn, 12, 4);
1704   Rd |= fieldFromInstruction32(Insn, 22, 1) << 4;
1705   unsigned wb = fieldFromInstruction32(Insn, 16, 4);
1706   unsigned Rn = fieldFromInstruction32(Insn, 16, 4);
1707   Rn |= fieldFromInstruction32(Insn, 4, 2) << 4;
1708   unsigned Rm = fieldFromInstruction32(Insn, 0, 4);
1709
1710   // Writeback Operand
1711   switch (Inst.getOpcode()) {
1712     case ARM::VST1d8_UPD:
1713     case ARM::VST1d16_UPD:
1714     case ARM::VST1d32_UPD:
1715     case ARM::VST1d64_UPD:
1716     case ARM::VST1q8_UPD:
1717     case ARM::VST1q16_UPD:
1718     case ARM::VST1q32_UPD:
1719     case ARM::VST1q64_UPD:
1720     case ARM::VST1d8T_UPD:
1721     case ARM::VST1d16T_UPD:
1722     case ARM::VST1d32T_UPD:
1723     case ARM::VST1d64T_UPD:
1724     case ARM::VST1d8Q_UPD:
1725     case ARM::VST1d16Q_UPD:
1726     case ARM::VST1d32Q_UPD:
1727     case ARM::VST1d64Q_UPD:
1728     case ARM::VST2d8_UPD:
1729     case ARM::VST2d16_UPD:
1730     case ARM::VST2d32_UPD:
1731     case ARM::VST2q8_UPD:
1732     case ARM::VST2q16_UPD:
1733     case ARM::VST2q32_UPD:
1734     case ARM::VST2b8_UPD:
1735     case ARM::VST2b16_UPD:
1736     case ARM::VST2b32_UPD:
1737     case ARM::VST3d8_UPD:
1738     case ARM::VST3d16_UPD:
1739     case ARM::VST3d32_UPD:
1740     case ARM::VST3q8_UPD:
1741     case ARM::VST3q16_UPD:
1742     case ARM::VST3q32_UPD:
1743     case ARM::VST4d8_UPD:
1744     case ARM::VST4d16_UPD:
1745     case ARM::VST4d32_UPD:
1746     case ARM::VST4q8_UPD:
1747     case ARM::VST4q16_UPD:
1748     case ARM::VST4q32_UPD:
1749       CHECK(S, DecodeGPRRegisterClass(Inst, wb, Address, Decoder));
1750       break;
1751     default:
1752       break;
1753   }
1754
1755   // AddrMode6 Base (register+alignment)
1756   CHECK(S, DecodeAddrMode6Operand(Inst, Rn, Address, Decoder));
1757
1758   // AddrMode6 Offset (register)
1759   if (Rm == 0xD)
1760     Inst.addOperand(MCOperand::CreateReg(0));
1761   else if (Rm != 0xF) {
1762     CHECK(S, DecodeGPRRegisterClass(Inst, Rm, Address, Decoder));
1763   }
1764
1765   // First input register
1766   CHECK(S, DecodeDPRRegisterClass(Inst, Rd, Address, Decoder));
1767
1768   // Second input register
1769   switch (Inst.getOpcode()) {
1770     case ARM::VST1q8:
1771     case ARM::VST1q16:
1772     case ARM::VST1q32:
1773     case ARM::VST1q64:
1774     case ARM::VST1q8_UPD:
1775     case ARM::VST1q16_UPD:
1776     case ARM::VST1q32_UPD:
1777     case ARM::VST1q64_UPD:
1778     case ARM::VST1d8T:
1779     case ARM::VST1d16T:
1780     case ARM::VST1d32T:
1781     case ARM::VST1d64T:
1782     case ARM::VST1d8T_UPD:
1783     case ARM::VST1d16T_UPD:
1784     case ARM::VST1d32T_UPD:
1785     case ARM::VST1d64T_UPD:
1786     case ARM::VST1d8Q:
1787     case ARM::VST1d16Q:
1788     case ARM::VST1d32Q:
1789     case ARM::VST1d64Q:
1790     case ARM::VST1d8Q_UPD:
1791     case ARM::VST1d16Q_UPD:
1792     case ARM::VST1d32Q_UPD:
1793     case ARM::VST1d64Q_UPD:
1794     case ARM::VST2d8:
1795     case ARM::VST2d16:
1796     case ARM::VST2d32:
1797     case ARM::VST2d8_UPD:
1798     case ARM::VST2d16_UPD:
1799     case ARM::VST2d32_UPD:
1800     case ARM::VST2q8:
1801     case ARM::VST2q16:
1802     case ARM::VST2q32:
1803     case ARM::VST2q8_UPD:
1804     case ARM::VST2q16_UPD:
1805     case ARM::VST2q32_UPD:
1806     case ARM::VST3d8:
1807     case ARM::VST3d16:
1808     case ARM::VST3d32:
1809     case ARM::VST3d8_UPD:
1810     case ARM::VST3d16_UPD:
1811     case ARM::VST3d32_UPD:
1812     case ARM::VST4d8:
1813     case ARM::VST4d16:
1814     case ARM::VST4d32:
1815     case ARM::VST4d8_UPD:
1816     case ARM::VST4d16_UPD:
1817     case ARM::VST4d32_UPD:
1818       CHECK(S, DecodeDPRRegisterClass(Inst, (Rd+1)%32, Address, Decoder));
1819       break;
1820     case ARM::VST2b8:
1821     case ARM::VST2b16:
1822     case ARM::VST2b32:
1823     case ARM::VST2b8_UPD:
1824     case ARM::VST2b16_UPD:
1825     case ARM::VST2b32_UPD:
1826     case ARM::VST3q8:
1827     case ARM::VST3q16:
1828     case ARM::VST3q32:
1829     case ARM::VST3q8_UPD:
1830     case ARM::VST3q16_UPD:
1831     case ARM::VST3q32_UPD:
1832     case ARM::VST4q8:
1833     case ARM::VST4q16:
1834     case ARM::VST4q32:
1835     case ARM::VST4q8_UPD:
1836     case ARM::VST4q16_UPD:
1837     case ARM::VST4q32_UPD:
1838       CHECK(S, DecodeDPRRegisterClass(Inst, (Rd+2)%32, Address, Decoder));
1839       break;
1840     default:
1841       break;
1842   }
1843
1844   // Third input register
1845   switch (Inst.getOpcode()) {
1846     case ARM::VST1d8T:
1847     case ARM::VST1d16T:
1848     case ARM::VST1d32T:
1849     case ARM::VST1d64T:
1850     case ARM::VST1d8T_UPD:
1851     case ARM::VST1d16T_UPD:
1852     case ARM::VST1d32T_UPD:
1853     case ARM::VST1d64T_UPD:
1854     case ARM::VST1d8Q:
1855     case ARM::VST1d16Q:
1856     case ARM::VST1d32Q:
1857     case ARM::VST1d64Q:
1858     case ARM::VST1d8Q_UPD:
1859     case ARM::VST1d16Q_UPD:
1860     case ARM::VST1d32Q_UPD:
1861     case ARM::VST1d64Q_UPD:
1862     case ARM::VST2q8:
1863     case ARM::VST2q16:
1864     case ARM::VST2q32:
1865     case ARM::VST2q8_UPD:
1866     case ARM::VST2q16_UPD:
1867     case ARM::VST2q32_UPD:
1868     case ARM::VST3d8:
1869     case ARM::VST3d16:
1870     case ARM::VST3d32:
1871     case ARM::VST3d8_UPD:
1872     case ARM::VST3d16_UPD:
1873     case ARM::VST3d32_UPD:
1874     case ARM::VST4d8:
1875     case ARM::VST4d16:
1876     case ARM::VST4d32:
1877     case ARM::VST4d8_UPD:
1878     case ARM::VST4d16_UPD:
1879     case ARM::VST4d32_UPD:
1880       CHECK(S, DecodeDPRRegisterClass(Inst, (Rd+2)%32, Address, Decoder));
1881       break;
1882     case ARM::VST3q8:
1883     case ARM::VST3q16:
1884     case ARM::VST3q32:
1885     case ARM::VST3q8_UPD:
1886     case ARM::VST3q16_UPD:
1887     case ARM::VST3q32_UPD:
1888     case ARM::VST4q8:
1889     case ARM::VST4q16:
1890     case ARM::VST4q32:
1891     case ARM::VST4q8_UPD:
1892     case ARM::VST4q16_UPD:
1893     case ARM::VST4q32_UPD:
1894       CHECK(S, DecodeDPRRegisterClass(Inst, (Rd+4)%32, Address, Decoder));
1895       break;
1896     default:
1897       break;
1898   }
1899
1900   // Fourth input register
1901   switch (Inst.getOpcode()) {
1902     case ARM::VST1d8Q:
1903     case ARM::VST1d16Q:
1904     case ARM::VST1d32Q:
1905     case ARM::VST1d64Q:
1906     case ARM::VST1d8Q_UPD:
1907     case ARM::VST1d16Q_UPD:
1908     case ARM::VST1d32Q_UPD:
1909     case ARM::VST1d64Q_UPD:
1910     case ARM::VST2q8:
1911     case ARM::VST2q16:
1912     case ARM::VST2q32:
1913     case ARM::VST2q8_UPD:
1914     case ARM::VST2q16_UPD:
1915     case ARM::VST2q32_UPD:
1916     case ARM::VST4d8:
1917     case ARM::VST4d16:
1918     case ARM::VST4d32:
1919     case ARM::VST4d8_UPD:
1920     case ARM::VST4d16_UPD:
1921     case ARM::VST4d32_UPD:
1922       CHECK(S, DecodeDPRRegisterClass(Inst, (Rd+3)%32, Address, Decoder));
1923       break;
1924     case ARM::VST4q8:
1925     case ARM::VST4q16:
1926     case ARM::VST4q32:
1927     case ARM::VST4q8_UPD:
1928     case ARM::VST4q16_UPD:
1929     case ARM::VST4q32_UPD:
1930       CHECK(S, DecodeDPRRegisterClass(Inst, (Rd+6)%32, Address, Decoder));
1931       break;
1932     default:
1933       break;
1934   }
1935
1936   return S;
1937 }
1938
1939 static DecodeStatus DecodeVLD1DupInstruction(llvm::MCInst &Inst, unsigned Insn,
1940                                     uint64_t Address, const void *Decoder) {
1941   DecodeStatus S = Success;
1942
1943   unsigned Rd = fieldFromInstruction32(Insn, 12, 4);
1944   Rd |= fieldFromInstruction32(Insn, 22, 1) << 4;
1945   unsigned Rn = fieldFromInstruction32(Insn, 16, 4);
1946   unsigned Rm = fieldFromInstruction32(Insn, 0, 4);
1947   unsigned align = fieldFromInstruction32(Insn, 4, 1);
1948   unsigned size = fieldFromInstruction32(Insn, 6, 2);
1949   unsigned regs = fieldFromInstruction32(Insn, 5, 1) + 1;
1950
1951   align *= (1 << size);
1952
1953   CHECK(S, DecodeDPRRegisterClass(Inst, Rd, Address, Decoder));
1954   if (regs == 2) {
1955     CHECK(S, DecodeDPRRegisterClass(Inst, (Rd+1)%32, Address, Decoder));
1956   }
1957   if (Rm == 0xD) {
1958     CHECK(S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder));
1959   }
1960
1961   CHECK(S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder));
1962   Inst.addOperand(MCOperand::CreateImm(align));
1963
1964   if (Rm == 0xD)
1965     Inst.addOperand(MCOperand::CreateReg(0));
1966   else if (Rm != 0xF) {
1967     CHECK(S, DecodeGPRRegisterClass(Inst, Rm, Address, Decoder));
1968   }
1969
1970   return S;
1971 }
1972
1973 static DecodeStatus DecodeVLD2DupInstruction(llvm::MCInst &Inst, unsigned Insn,
1974                                     uint64_t Address, const void *Decoder) {
1975   DecodeStatus S = Success;
1976
1977   unsigned Rd = fieldFromInstruction32(Insn, 12, 4);
1978   Rd |= fieldFromInstruction32(Insn, 22, 1) << 4;
1979   unsigned Rn = fieldFromInstruction32(Insn, 16, 4);
1980   unsigned Rm = fieldFromInstruction32(Insn, 0, 4);
1981   unsigned align = fieldFromInstruction32(Insn, 4, 1);
1982   unsigned size = 1 << fieldFromInstruction32(Insn, 6, 2);
1983   unsigned inc = fieldFromInstruction32(Insn, 5, 1) + 1;
1984   align *= 2*size;
1985
1986   CHECK(S, DecodeDPRRegisterClass(Inst, Rd, Address, Decoder));
1987   CHECK(S, DecodeDPRRegisterClass(Inst, (Rd+inc)%32, Address, Decoder));
1988   if (Rm == 0xD) {
1989     CHECK(S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder));
1990   }
1991
1992   CHECK(S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder));
1993   Inst.addOperand(MCOperand::CreateImm(align));
1994
1995   if (Rm == 0xD)
1996     Inst.addOperand(MCOperand::CreateReg(0));
1997   else if (Rm != 0xF) {
1998     CHECK(S, DecodeGPRRegisterClass(Inst, Rm, Address, Decoder));
1999   }
2000
2001   return S;
2002 }
2003
2004 static DecodeStatus DecodeVLD3DupInstruction(llvm::MCInst &Inst, unsigned Insn,
2005                                     uint64_t Address, const void *Decoder) {
2006   DecodeStatus S = Success;
2007
2008   unsigned Rd = fieldFromInstruction32(Insn, 12, 4);
2009   Rd |= fieldFromInstruction32(Insn, 22, 1) << 4;
2010   unsigned Rn = fieldFromInstruction32(Insn, 16, 4);
2011   unsigned Rm = fieldFromInstruction32(Insn, 0, 4);
2012   unsigned inc = fieldFromInstruction32(Insn, 5, 1) + 1;
2013
2014   CHECK(S, DecodeDPRRegisterClass(Inst, Rd, Address, Decoder));
2015   CHECK(S, DecodeDPRRegisterClass(Inst, (Rd+inc)%32, Address, Decoder));
2016   CHECK(S, DecodeDPRRegisterClass(Inst, (Rd+2*inc)%32, Address, Decoder));
2017   if (Rm == 0xD) {
2018     CHECK(S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder));
2019   }
2020
2021   CHECK(S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder));
2022   Inst.addOperand(MCOperand::CreateImm(0));
2023
2024   if (Rm == 0xD)
2025     Inst.addOperand(MCOperand::CreateReg(0));
2026   else if (Rm != 0xF) {
2027     CHECK(S, DecodeGPRRegisterClass(Inst, Rm, Address, Decoder));
2028   }
2029
2030   return S;
2031 }
2032
2033 static DecodeStatus DecodeVLD4DupInstruction(llvm::MCInst &Inst, unsigned Insn,
2034                                     uint64_t Address, const void *Decoder) {
2035   DecodeStatus S = Success;
2036
2037   unsigned Rd = fieldFromInstruction32(Insn, 12, 4);
2038   Rd |= fieldFromInstruction32(Insn, 22, 1) << 4;
2039   unsigned Rn = fieldFromInstruction32(Insn, 16, 4);
2040   unsigned Rm = fieldFromInstruction32(Insn, 0, 4);
2041   unsigned size = fieldFromInstruction32(Insn, 6, 2);
2042   unsigned inc = fieldFromInstruction32(Insn, 5, 1) + 1;
2043   unsigned align = fieldFromInstruction32(Insn, 4, 1);
2044
2045   if (size == 0x3) {
2046     size = 4;
2047     align = 16;
2048   } else {
2049     if (size == 2) {
2050       size = 1 << size;
2051       align *= 8;
2052     } else {
2053       size = 1 << size;
2054       align *= 4*size;
2055     }
2056   }
2057
2058   CHECK(S, DecodeDPRRegisterClass(Inst, Rd, Address, Decoder));
2059   CHECK(S, DecodeDPRRegisterClass(Inst, (Rd+inc)%32, Address, Decoder));
2060   CHECK(S, DecodeDPRRegisterClass(Inst, (Rd+2*inc)%32, Address, Decoder));
2061   CHECK(S, DecodeDPRRegisterClass(Inst, (Rd+3*inc)%32, Address, Decoder));
2062   if (Rm == 0xD) {
2063     CHECK(S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder));
2064   }
2065
2066   CHECK(S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder));
2067   Inst.addOperand(MCOperand::CreateImm(align));
2068
2069   if (Rm == 0xD)
2070     Inst.addOperand(MCOperand::CreateReg(0));
2071   else if (Rm != 0xF) {
2072     CHECK(S, DecodeGPRRegisterClass(Inst, Rm, Address, Decoder));
2073   }
2074
2075   return S;
2076 }
2077
2078 static DecodeStatus
2079 DecodeNEONModImmInstruction(llvm::MCInst &Inst, unsigned Insn,
2080                             uint64_t Address, const void *Decoder) {
2081   DecodeStatus S = Success;
2082
2083   unsigned Rd = fieldFromInstruction32(Insn, 12, 4);
2084   Rd |= fieldFromInstruction32(Insn, 22, 1) << 4;
2085   unsigned imm = fieldFromInstruction32(Insn, 0, 4);
2086   imm |= fieldFromInstruction32(Insn, 16, 3) << 4;
2087   imm |= fieldFromInstruction32(Insn, 24, 1) << 7;
2088   imm |= fieldFromInstruction32(Insn, 8, 4) << 8;
2089   imm |= fieldFromInstruction32(Insn, 5, 1) << 12;
2090   unsigned Q = fieldFromInstruction32(Insn, 6, 1);
2091
2092   if (Q) {
2093     CHECK(S, DecodeQPRRegisterClass(Inst, Rd, Address, Decoder));
2094   } else {
2095     CHECK(S, DecodeDPRRegisterClass(Inst, Rd, Address, Decoder));
2096   }
2097
2098   Inst.addOperand(MCOperand::CreateImm(imm));
2099
2100   switch (Inst.getOpcode()) {
2101     case ARM::VORRiv4i16:
2102     case ARM::VORRiv2i32:
2103     case ARM::VBICiv4i16:
2104     case ARM::VBICiv2i32:
2105       CHECK(S, DecodeDPRRegisterClass(Inst, Rd, Address, Decoder));
2106       break;
2107     case ARM::VORRiv8i16:
2108     case ARM::VORRiv4i32:
2109     case ARM::VBICiv8i16:
2110     case ARM::VBICiv4i32:
2111       CHECK(S, DecodeQPRRegisterClass(Inst, Rd, Address, Decoder));
2112       break;
2113     default:
2114       break;
2115   }
2116
2117   return S;
2118 }
2119
2120 static DecodeStatus DecodeVSHLMaxInstruction(llvm::MCInst &Inst, unsigned Insn,
2121                                         uint64_t Address, const void *Decoder) {
2122   DecodeStatus S = Success;
2123
2124   unsigned Rd = fieldFromInstruction32(Insn, 12, 4);
2125   Rd |= fieldFromInstruction32(Insn, 22, 1) << 4;
2126   unsigned Rm = fieldFromInstruction32(Insn, 0, 4);
2127   Rm |= fieldFromInstruction32(Insn, 5, 1) << 4;
2128   unsigned size = fieldFromInstruction32(Insn, 18, 2);
2129
2130   CHECK(S, DecodeQPRRegisterClass(Inst, Rd, Address, Decoder));
2131   CHECK(S, DecodeDPRRegisterClass(Inst, Rm, Address, Decoder));
2132   Inst.addOperand(MCOperand::CreateImm(8 << size));
2133
2134   return S;
2135 }
2136
2137 static DecodeStatus DecodeShiftRight8Imm(llvm::MCInst &Inst, unsigned Val,
2138                                uint64_t Address, const void *Decoder) {
2139   Inst.addOperand(MCOperand::CreateImm(8 - Val));
2140   return Success;
2141 }
2142
2143 static DecodeStatus DecodeShiftRight16Imm(llvm::MCInst &Inst, unsigned Val,
2144                                uint64_t Address, const void *Decoder) {
2145   Inst.addOperand(MCOperand::CreateImm(16 - Val));
2146   return Success;
2147 }
2148
2149 static DecodeStatus DecodeShiftRight32Imm(llvm::MCInst &Inst, unsigned Val,
2150                                uint64_t Address, const void *Decoder) {
2151   Inst.addOperand(MCOperand::CreateImm(32 - Val));
2152   return Success;
2153 }
2154
2155 static DecodeStatus DecodeShiftRight64Imm(llvm::MCInst &Inst, unsigned Val,
2156                                uint64_t Address, const void *Decoder) {
2157   Inst.addOperand(MCOperand::CreateImm(64 - Val));
2158   return Success;
2159 }
2160
2161 static DecodeStatus DecodeTBLInstruction(llvm::MCInst &Inst, unsigned Insn,
2162                                uint64_t Address, const void *Decoder) {
2163   DecodeStatus S = Success;
2164
2165   unsigned Rd = fieldFromInstruction32(Insn, 12, 4);
2166   Rd |= fieldFromInstruction32(Insn, 22, 1) << 4;
2167   unsigned Rn = fieldFromInstruction32(Insn, 16, 4);
2168   Rn |= fieldFromInstruction32(Insn, 7, 1) << 4;
2169   unsigned Rm = fieldFromInstruction32(Insn, 0, 4);
2170   Rm |= fieldFromInstruction32(Insn, 5, 1) << 4;
2171   unsigned op = fieldFromInstruction32(Insn, 6, 1);
2172   unsigned length = fieldFromInstruction32(Insn, 8, 2) + 1;
2173
2174   CHECK(S, DecodeDPRRegisterClass(Inst, Rd, Address, Decoder));
2175   if (op) {
2176     CHECK(S, DecodeDPRRegisterClass(Inst, Rd, Address, Decoder)); // Writeback
2177   }
2178
2179   for (unsigned i = 0; i < length; ++i) {
2180     CHECK(S, DecodeDPRRegisterClass(Inst, (Rn+i)%32, Address, Decoder));
2181   }
2182
2183   CHECK(S, DecodeDPRRegisterClass(Inst, Rm, Address, Decoder));
2184
2185   return S;
2186 }
2187
2188 static DecodeStatus DecodeVFPfpImm(llvm::MCInst &Inst, unsigned Val,
2189                             uint64_t Address, const void *Decoder) {
2190   // The immediate needs to be a fully instantiated float.  However, the
2191   // auto-generated decoder is only able to fill in some of the bits
2192   // necessary.  For instance, the 'b' bit is replicated multiple times,
2193   // and is even present in inverted form in one bit.  We do a little
2194   // binary parsing here to fill in those missing bits, and then
2195   // reinterpret it all as a float.
2196   union {
2197     uint32_t integer;
2198     float fp;
2199   } fp_conv;
2200
2201   fp_conv.integer = Val;
2202   uint32_t b = fieldFromInstruction32(Val, 25, 1);
2203   fp_conv.integer |= b << 26;
2204   fp_conv.integer |= b << 27;
2205   fp_conv.integer |= b << 28;
2206   fp_conv.integer |= b << 29;
2207   fp_conv.integer |= (~b & 0x1) << 30;
2208
2209   Inst.addOperand(MCOperand::CreateFPImm(fp_conv.fp));
2210   return Success;
2211 }
2212
2213 static DecodeStatus DecodeThumbAddSpecialReg(llvm::MCInst &Inst, uint16_t Insn,
2214                                      uint64_t Address, const void *Decoder) {
2215   DecodeStatus S = Success;
2216
2217   unsigned dst = fieldFromInstruction16(Insn, 8, 3);
2218   unsigned imm = fieldFromInstruction16(Insn, 0, 8);
2219
2220   CHECK(S, DecodetGPRRegisterClass(Inst, dst, Address, Decoder));
2221
2222   if (Inst.getOpcode() == ARM::tADR)
2223     Inst.addOperand(MCOperand::CreateReg(ARM::PC));
2224   else if (Inst.getOpcode() == ARM::tADDrSPi)
2225     Inst.addOperand(MCOperand::CreateReg(ARM::SP));
2226   else
2227     return Fail;
2228
2229   Inst.addOperand(MCOperand::CreateImm(imm));
2230   return S;
2231 }
2232
2233 static DecodeStatus DecodeThumbBROperand(llvm::MCInst &Inst, unsigned Val,
2234                                  uint64_t Address, const void *Decoder) {
2235   Inst.addOperand(MCOperand::CreateImm(SignExtend32<12>(Val << 1)));
2236   return Success;
2237 }
2238
2239 static DecodeStatus DecodeT2BROperand(llvm::MCInst &Inst, unsigned Val,
2240                                  uint64_t Address, const void *Decoder) {
2241   Inst.addOperand(MCOperand::CreateImm(SignExtend32<21>(Val)));
2242   return Success;
2243 }
2244
2245 static DecodeStatus DecodeThumbCmpBROperand(llvm::MCInst &Inst, unsigned Val,
2246                                  uint64_t Address, const void *Decoder) {
2247   Inst.addOperand(MCOperand::CreateImm(SignExtend32<7>(Val << 1)));
2248   return Success;
2249 }
2250
2251 static DecodeStatus DecodeThumbAddrModeRR(llvm::MCInst &Inst, unsigned Val,
2252                                  uint64_t Address, const void *Decoder) {
2253   DecodeStatus S = Success;
2254
2255   unsigned Rn = fieldFromInstruction32(Val, 0, 3);
2256   unsigned Rm = fieldFromInstruction32(Val, 3, 3);
2257
2258   CHECK(S, DecodetGPRRegisterClass(Inst, Rn, Address, Decoder));
2259   CHECK(S, DecodetGPRRegisterClass(Inst, Rm, Address, Decoder));
2260
2261   return S;
2262 }
2263
2264 static DecodeStatus DecodeThumbAddrModeIS(llvm::MCInst &Inst, unsigned Val,
2265                                   uint64_t Address, const void *Decoder) {
2266   DecodeStatus S = Success;
2267
2268   unsigned Rn = fieldFromInstruction32(Val, 0, 3);
2269   unsigned imm = fieldFromInstruction32(Val, 3, 5);
2270
2271   CHECK(S, DecodetGPRRegisterClass(Inst, Rn, Address, Decoder));
2272   Inst.addOperand(MCOperand::CreateImm(imm));
2273
2274   return S;
2275 }
2276
2277 static DecodeStatus DecodeThumbAddrModePC(llvm::MCInst &Inst, unsigned Val,
2278                                   uint64_t Address, const void *Decoder) {
2279   Inst.addOperand(MCOperand::CreateImm(Val << 2));
2280
2281   return Success;
2282 }
2283
2284 static DecodeStatus DecodeThumbAddrModeSP(llvm::MCInst &Inst, unsigned Val,
2285                                   uint64_t Address, const void *Decoder) {
2286   Inst.addOperand(MCOperand::CreateReg(ARM::SP));
2287   Inst.addOperand(MCOperand::CreateImm(Val << 2));
2288
2289   return Success;
2290 }
2291
2292 static DecodeStatus DecodeT2AddrModeSOReg(llvm::MCInst &Inst, unsigned Val,
2293                                   uint64_t Address, const void *Decoder) {
2294   DecodeStatus S = Success;
2295
2296   unsigned Rn = fieldFromInstruction32(Val, 6, 4);
2297   unsigned Rm = fieldFromInstruction32(Val, 2, 4);
2298   unsigned imm = fieldFromInstruction32(Val, 0, 2);
2299
2300   CHECK(S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder));
2301   CHECK(S, DecoderGPRRegisterClass(Inst, Rm, Address, Decoder));
2302   Inst.addOperand(MCOperand::CreateImm(imm));
2303
2304   return S;
2305 }
2306
2307 static DecodeStatus DecodeT2LoadShift(llvm::MCInst &Inst, unsigned Insn,
2308                               uint64_t Address, const void *Decoder) {
2309   DecodeStatus S = Success;
2310
2311   if (Inst.getOpcode() != ARM::t2PLDs) {
2312     unsigned Rt = fieldFromInstruction32(Insn, 12, 4);
2313     CHECK(S, DecodeGPRRegisterClass(Inst, Rt, Address, Decoder));
2314   }
2315
2316   unsigned Rn = fieldFromInstruction32(Insn, 16, 4);
2317   if (Rn == 0xF) {
2318     switch (Inst.getOpcode()) {
2319       case ARM::t2LDRBs:
2320         Inst.setOpcode(ARM::t2LDRBpci);
2321         break;
2322       case ARM::t2LDRHs:
2323         Inst.setOpcode(ARM::t2LDRHpci);
2324         break;
2325       case ARM::t2LDRSHs:
2326         Inst.setOpcode(ARM::t2LDRSHpci);
2327         break;
2328       case ARM::t2LDRSBs:
2329         Inst.setOpcode(ARM::t2LDRSBpci);
2330         break;
2331       case ARM::t2PLDs:
2332         Inst.setOpcode(ARM::t2PLDi12);
2333         Inst.addOperand(MCOperand::CreateReg(ARM::PC));
2334         break;
2335       default:
2336         return Fail;
2337     }
2338
2339     int imm = fieldFromInstruction32(Insn, 0, 12);
2340     if (!fieldFromInstruction32(Insn, 23, 1)) imm *= -1;
2341     Inst.addOperand(MCOperand::CreateImm(imm));
2342
2343     return S;
2344   }
2345
2346   unsigned addrmode = fieldFromInstruction32(Insn, 4, 2);
2347   addrmode |= fieldFromInstruction32(Insn, 0, 4) << 2;
2348   addrmode |= fieldFromInstruction32(Insn, 16, 4) << 6;
2349   CHECK(S, DecodeT2AddrModeSOReg(Inst, addrmode, Address, Decoder));
2350
2351   return S;
2352 }
2353
2354 static DecodeStatus DecodeT2Imm8S4(llvm::MCInst &Inst, unsigned Val,
2355                            uint64_t Address, const void *Decoder) {
2356   int imm = Val & 0xFF;
2357   if (!(Val & 0x100)) imm *= -1;
2358   Inst.addOperand(MCOperand::CreateImm(imm << 2));
2359
2360   return Success;
2361 }
2362
2363 static DecodeStatus DecodeT2AddrModeImm8s4(llvm::MCInst &Inst, unsigned Val,
2364                                    uint64_t Address, const void *Decoder) {
2365   DecodeStatus S = Success;
2366
2367   unsigned Rn = fieldFromInstruction32(Val, 9, 4);
2368   unsigned imm = fieldFromInstruction32(Val, 0, 9);
2369
2370   CHECK(S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder));
2371   CHECK(S, DecodeT2Imm8S4(Inst, imm, Address, Decoder));
2372
2373   return S;
2374 }
2375
2376 static DecodeStatus DecodeT2Imm8(llvm::MCInst &Inst, unsigned Val,
2377                          uint64_t Address, const void *Decoder) {
2378   int imm = Val & 0xFF;
2379   if (!(Val & 0x100)) imm *= -1;
2380   Inst.addOperand(MCOperand::CreateImm(imm));
2381
2382   return Success;
2383 }
2384
2385
2386 static DecodeStatus DecodeT2AddrModeImm8(llvm::MCInst &Inst, unsigned Val,
2387                                  uint64_t Address, const void *Decoder) {
2388   DecodeStatus S = Success;
2389
2390   unsigned Rn = fieldFromInstruction32(Val, 9, 4);
2391   unsigned imm = fieldFromInstruction32(Val, 0, 9);
2392
2393   // Some instructions always use an additive offset.
2394   switch (Inst.getOpcode()) {
2395     case ARM::t2LDRT:
2396     case ARM::t2LDRBT:
2397     case ARM::t2LDRHT:
2398     case ARM::t2LDRSBT:
2399     case ARM::t2LDRSHT:
2400       imm |= 0x100;
2401       break;
2402     default:
2403       break;
2404   }
2405
2406   CHECK(S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder));
2407   CHECK(S, DecodeT2Imm8(Inst, imm, Address, Decoder));
2408
2409   return S;
2410 }
2411
2412
2413 static DecodeStatus DecodeT2AddrModeImm12(llvm::MCInst &Inst, unsigned Val,
2414                                   uint64_t Address, const void *Decoder) {
2415   DecodeStatus S = Success;
2416
2417   unsigned Rn = fieldFromInstruction32(Val, 13, 4);
2418   unsigned imm = fieldFromInstruction32(Val, 0, 12);
2419
2420   CHECK(S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder));
2421   Inst.addOperand(MCOperand::CreateImm(imm));
2422
2423   return S;
2424 }
2425
2426
2427 static DecodeStatus DecodeThumbAddSPImm(llvm::MCInst &Inst, uint16_t Insn,
2428                                 uint64_t Address, const void *Decoder) {
2429   unsigned imm = fieldFromInstruction16(Insn, 0, 7);
2430
2431   Inst.addOperand(MCOperand::CreateReg(ARM::SP));
2432   Inst.addOperand(MCOperand::CreateReg(ARM::SP));
2433   Inst.addOperand(MCOperand::CreateImm(imm));
2434
2435   return Success;
2436 }
2437
2438 static DecodeStatus DecodeThumbAddSPReg(llvm::MCInst &Inst, uint16_t Insn,
2439                                 uint64_t Address, const void *Decoder) {
2440   DecodeStatus S = Success;
2441
2442   if (Inst.getOpcode() == ARM::tADDrSP) {
2443     unsigned Rdm = fieldFromInstruction16(Insn, 0, 3);
2444     Rdm |= fieldFromInstruction16(Insn, 7, 1) << 3;
2445
2446     CHECK(S, DecodeGPRRegisterClass(Inst, Rdm, Address, Decoder));
2447     Inst.addOperand(MCOperand::CreateReg(ARM::SP));
2448     CHECK(S, DecodeGPRRegisterClass(Inst, Rdm, Address, Decoder));
2449   } else if (Inst.getOpcode() == ARM::tADDspr) {
2450     unsigned Rm = fieldFromInstruction16(Insn, 3, 4);
2451
2452     Inst.addOperand(MCOperand::CreateReg(ARM::SP));
2453     Inst.addOperand(MCOperand::CreateReg(ARM::SP));
2454     CHECK(S, DecodeGPRRegisterClass(Inst, Rm, Address, Decoder));
2455   }
2456
2457   return S;
2458 }
2459
2460 static DecodeStatus DecodeThumbCPS(llvm::MCInst &Inst, uint16_t Insn,
2461                            uint64_t Address, const void *Decoder) {
2462   unsigned imod = fieldFromInstruction16(Insn, 4, 1) | 0x2;
2463   unsigned flags = fieldFromInstruction16(Insn, 0, 3);
2464
2465   Inst.addOperand(MCOperand::CreateImm(imod));
2466   Inst.addOperand(MCOperand::CreateImm(flags));
2467
2468   return Success;
2469 }
2470
2471 static DecodeStatus DecodePostIdxReg(llvm::MCInst &Inst, unsigned Insn,
2472                              uint64_t Address, const void *Decoder) {
2473   DecodeStatus S = Success;
2474   unsigned Rm = fieldFromInstruction32(Insn, 0, 4);
2475   unsigned add = fieldFromInstruction32(Insn, 4, 1);
2476
2477   CHECK(S, DecodeGPRRegisterClass(Inst, Rm, Address, Decoder)) ;
2478   Inst.addOperand(MCOperand::CreateImm(add));
2479
2480   return S;
2481 }
2482
2483 static DecodeStatus DecodeThumbBLXOffset(llvm::MCInst &Inst, unsigned Val,
2484                                  uint64_t Address, const void *Decoder) {
2485   Inst.addOperand(MCOperand::CreateImm(SignExtend32<22>(Val << 1)));
2486   return Success;
2487 }
2488
2489 static DecodeStatus DecodeCoprocessor(llvm::MCInst &Inst, unsigned Val,
2490                               uint64_t Address, const void *Decoder) {
2491   if (Val == 0xA || Val == 0xB)
2492     return Fail;
2493
2494   Inst.addOperand(MCOperand::CreateImm(Val));
2495   return Success;
2496 }
2497
2498 static DecodeStatus
2499 DecodeThumb2BCCInstruction(llvm::MCInst &Inst, unsigned Insn,
2500                            uint64_t Address, const void *Decoder) {
2501   DecodeStatus S = Success;
2502
2503   unsigned pred = fieldFromInstruction32(Insn, 22, 4);
2504   if (pred == 0xE || pred == 0xF) {
2505     unsigned opc = fieldFromInstruction32(Insn, 4, 2);
2506     switch (opc) {
2507       default:
2508         return Fail;
2509       case 0:
2510         Inst.setOpcode(ARM::t2DSB);
2511         break;
2512       case 1:
2513         Inst.setOpcode(ARM::t2DMB);
2514         break;
2515       case 2:
2516         Inst.setOpcode(ARM::t2ISB);
2517         return Success;
2518     }
2519
2520     unsigned imm = fieldFromInstruction32(Insn, 0, 4);
2521     return DecodeMemBarrierOption(Inst, imm, Address, Decoder);
2522   }
2523
2524   unsigned brtarget = fieldFromInstruction32(Insn, 0, 11) << 1;
2525   brtarget |= fieldFromInstruction32(Insn, 11, 1) << 19;
2526   brtarget |= fieldFromInstruction32(Insn, 13, 1) << 18;
2527   brtarget |= fieldFromInstruction32(Insn, 16, 6) << 12;
2528   brtarget |= fieldFromInstruction32(Insn, 26, 1) << 20;
2529
2530   CHECK(S, DecodeT2BROperand(Inst, brtarget, Address, Decoder));
2531   CHECK(S, DecodePredicateOperand(Inst, pred, Address, Decoder));
2532
2533   return S;
2534 }
2535
2536 // Decode a shifted immediate operand.  These basically consist
2537 // of an 8-bit value, and a 4-bit directive that specifies either
2538 // a splat operation or a rotation.
2539 static DecodeStatus DecodeT2SOImm(llvm::MCInst &Inst, unsigned Val,
2540                           uint64_t Address, const void *Decoder) {
2541   unsigned ctrl = fieldFromInstruction32(Val, 10, 2);
2542   if (ctrl == 0) {
2543     unsigned byte = fieldFromInstruction32(Val, 8, 2);
2544     unsigned imm = fieldFromInstruction32(Val, 0, 8);
2545     switch (byte) {
2546       case 0:
2547         Inst.addOperand(MCOperand::CreateImm(imm));
2548         break;
2549       case 1:
2550         Inst.addOperand(MCOperand::CreateImm((imm << 16) | imm));
2551         break;
2552       case 2:
2553         Inst.addOperand(MCOperand::CreateImm((imm << 24) | (imm << 8)));
2554         break;
2555       case 3:
2556         Inst.addOperand(MCOperand::CreateImm((imm << 24) | (imm << 16) |
2557                                              (imm << 8)  |  imm));
2558         break;
2559     }
2560   } else {
2561     unsigned unrot = fieldFromInstruction32(Val, 0, 7) | 0x80;
2562     unsigned rot = fieldFromInstruction32(Val, 7, 5);
2563     unsigned imm = (unrot >> rot) | (unrot << ((32-rot)&31));
2564     Inst.addOperand(MCOperand::CreateImm(imm));
2565   }
2566
2567   return Success;
2568 }
2569
2570 static DecodeStatus
2571 DecodeThumbBCCTargetOperand(llvm::MCInst &Inst, unsigned Val,
2572                             uint64_t Address, const void *Decoder){
2573   Inst.addOperand(MCOperand::CreateImm(Val << 1));
2574   return Success;
2575 }
2576
2577 static DecodeStatus DecodeThumbBLTargetOperand(llvm::MCInst &Inst, unsigned Val,
2578                                        uint64_t Address, const void *Decoder){
2579   Inst.addOperand(MCOperand::CreateImm(SignExtend32<22>(Val << 1)));
2580   return Success;
2581 }
2582
2583 static DecodeStatus DecodeMemBarrierOption(llvm::MCInst &Inst, unsigned Val,
2584                                    uint64_t Address, const void *Decoder) {
2585   switch (Val) {
2586   default:
2587     return Fail;
2588   case 0xF: // SY
2589   case 0xE: // ST
2590   case 0xB: // ISH
2591   case 0xA: // ISHST
2592   case 0x7: // NSH
2593   case 0x6: // NSHST
2594   case 0x3: // OSH
2595   case 0x2: // OSHST
2596     break;
2597   }
2598
2599   Inst.addOperand(MCOperand::CreateImm(Val));
2600   return Success;
2601 }
2602
2603 static DecodeStatus DecodeMSRMask(llvm::MCInst &Inst, unsigned Val,
2604                           uint64_t Address, const void *Decoder) {
2605   if (!Val) return Fail;
2606   Inst.addOperand(MCOperand::CreateImm(Val));
2607   return Success;
2608 }
2609
2610 static DecodeStatus DecodeDoubleRegLoad(llvm::MCInst &Inst, unsigned Insn,
2611                                         uint64_t Address, const void *Decoder) {
2612   DecodeStatus S = Success;
2613
2614   unsigned Rt = fieldFromInstruction32(Insn, 12, 4);
2615   unsigned Rn = fieldFromInstruction32(Insn, 16, 4);
2616   unsigned pred = fieldFromInstruction32(Insn, 28, 4);
2617
2618   if ((Rt & 1) || Rt == 0xE || Rn == 0xF) return Fail;
2619
2620   CHECK(S, DecodeGPRRegisterClass(Inst, Rt, Address, Decoder));
2621   CHECK(S, DecodeGPRRegisterClass(Inst, Rt+1, Address, Decoder));
2622   CHECK(S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder));
2623   CHECK(S, DecodePredicateOperand(Inst, pred, Address, Decoder));
2624
2625   return S;
2626 }
2627
2628
2629 static DecodeStatus DecodeDoubleRegStore(llvm::MCInst &Inst, unsigned Insn,
2630                                          uint64_t Address, const void *Decoder){
2631   DecodeStatus S = Success;
2632
2633   unsigned Rd = fieldFromInstruction32(Insn, 12, 4);
2634   unsigned Rt = fieldFromInstruction32(Insn, 0, 4);
2635   unsigned Rn = fieldFromInstruction32(Insn, 16, 4);
2636   unsigned pred = fieldFromInstruction32(Insn, 28, 4);
2637
2638   CHECK(S, DecoderGPRRegisterClass(Inst, Rd, Address, Decoder));
2639
2640   if ((Rt & 1) || Rt == 0xE || Rn == 0xF) return Fail;
2641   if (Rd == Rn || Rd == Rt || Rd == Rt+1) return Fail;
2642
2643   CHECK(S, DecodeGPRRegisterClass(Inst, Rt, Address, Decoder));
2644   CHECK(S, DecodeGPRRegisterClass(Inst, Rt+1, Address, Decoder));
2645   CHECK(S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder));
2646   CHECK(S, DecodePredicateOperand(Inst, pred, Address, Decoder));
2647
2648   return S;
2649 }
2650
2651 static DecodeStatus DecodeSTRPreImm(llvm::MCInst &Inst, unsigned Insn,
2652                             uint64_t Address, const void *Decoder) {
2653   DecodeStatus S = Success;
2654
2655   unsigned Rn = fieldFromInstruction32(Insn, 16, 4);
2656   unsigned Rt = fieldFromInstruction32(Insn, 12, 4);
2657   unsigned imm = fieldFromInstruction32(Insn, 0, 12);
2658   imm |= fieldFromInstruction32(Insn, 16, 4) << 13;
2659   imm |= fieldFromInstruction32(Insn, 23, 1) << 12;
2660   unsigned pred = fieldFromInstruction32(Insn, 28, 4);
2661
2662   if (Rn == 0xF || Rn == Rt) CHECK(S, Unpredictable);
2663
2664   CHECK(S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder));
2665   CHECK(S, DecodeGPRRegisterClass(Inst, Rt, Address, Decoder));
2666   CHECK(S, DecodeAddrModeImm12Operand(Inst, imm, Address, Decoder));
2667   CHECK(S, DecodePredicateOperand(Inst, pred, Address, Decoder));
2668
2669   return S;
2670 }
2671
2672 static DecodeStatus DecodeSTRPreReg(llvm::MCInst &Inst, unsigned Insn,
2673                             uint64_t Address, const void *Decoder) {
2674   DecodeStatus S = Success;
2675
2676   unsigned Rn = fieldFromInstruction32(Insn, 16, 4);
2677   unsigned Rt = fieldFromInstruction32(Insn, 12, 4);
2678   unsigned imm = fieldFromInstruction32(Insn, 0, 12);
2679   imm |= fieldFromInstruction32(Insn, 16, 4) << 13;
2680   imm |= fieldFromInstruction32(Insn, 23, 1) << 12;
2681   unsigned pred = fieldFromInstruction32(Insn, 28, 4);
2682
2683   if (Rn == 0xF || Rn == Rt) CHECK(S, Unpredictable);
2684
2685   CHECK(S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder));
2686   CHECK(S, DecodeGPRRegisterClass(Inst, Rt, Address, Decoder));
2687   CHECK(S, DecodeSORegMemOperand(Inst, imm, Address, Decoder));
2688   CHECK(S, DecodePredicateOperand(Inst, pred, Address, Decoder));
2689
2690   return S;
2691 }
2692
2693 static DecodeStatus DecodeVLD1LN(llvm::MCInst &Inst, unsigned Insn,
2694                          uint64_t Address, const void *Decoder) {
2695   DecodeStatus S = Success;
2696
2697   unsigned Rn = fieldFromInstruction32(Insn, 16, 4);
2698   unsigned Rm = fieldFromInstruction32(Insn, 0, 4);
2699   unsigned Rd = fieldFromInstruction32(Insn, 12, 4);
2700   Rd |= fieldFromInstruction32(Insn, 22, 1) << 4;
2701   unsigned size = fieldFromInstruction32(Insn, 10, 2);
2702
2703   unsigned align = 0;
2704   unsigned index = 0;
2705   switch (size) {
2706     default:
2707       return Fail;
2708     case 0:
2709       if (fieldFromInstruction32(Insn, 4, 1))
2710         return Fail; // UNDEFINED
2711       index = fieldFromInstruction32(Insn, 5, 3);
2712       break;
2713     case 1:
2714       if (fieldFromInstruction32(Insn, 5, 1))
2715         return Fail; // UNDEFINED
2716       index = fieldFromInstruction32(Insn, 6, 2);
2717       if (fieldFromInstruction32(Insn, 4, 1))
2718         align = 2;
2719       break;
2720     case 2:
2721       if (fieldFromInstruction32(Insn, 6, 1))
2722         return Fail; // UNDEFINED
2723       index = fieldFromInstruction32(Insn, 7, 1);
2724       if (fieldFromInstruction32(Insn, 4, 2) != 0)
2725         align = 4;
2726   }
2727
2728   CHECK(S, DecodeDPRRegisterClass(Inst, Rd, Address, Decoder));
2729   if (Rm != 0xF) { // Writeback
2730     CHECK(S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder));
2731   }
2732   CHECK(S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder));
2733   Inst.addOperand(MCOperand::CreateImm(align));
2734   if (Rm != 0xF && Rm != 0xD) {
2735     CHECK(S, DecodeGPRRegisterClass(Inst, Rm, Address, Decoder));
2736   }
2737
2738   CHECK(S, DecodeDPRRegisterClass(Inst, Rd, Address, Decoder));
2739   Inst.addOperand(MCOperand::CreateImm(index));
2740
2741   return S;
2742 }
2743
2744 static DecodeStatus DecodeVST1LN(llvm::MCInst &Inst, unsigned Insn,
2745                          uint64_t Address, const void *Decoder) {
2746   DecodeStatus S = Success;
2747
2748   unsigned Rn = fieldFromInstruction32(Insn, 16, 4);
2749   unsigned Rm = fieldFromInstruction32(Insn, 0, 4);
2750   unsigned Rd = fieldFromInstruction32(Insn, 12, 4);
2751   Rd |= fieldFromInstruction32(Insn, 22, 1) << 4;
2752   unsigned size = fieldFromInstruction32(Insn, 10, 2);
2753
2754   unsigned align = 0;
2755   unsigned index = 0;
2756   switch (size) {
2757     default:
2758       return Fail;
2759     case 0:
2760       if (fieldFromInstruction32(Insn, 4, 1))
2761         return Fail; // UNDEFINED
2762       index = fieldFromInstruction32(Insn, 5, 3);
2763       break;
2764     case 1:
2765       if (fieldFromInstruction32(Insn, 5, 1))
2766         return Fail; // UNDEFINED
2767       index = fieldFromInstruction32(Insn, 6, 2);
2768       if (fieldFromInstruction32(Insn, 4, 1))
2769         align = 2;
2770       break;
2771     case 2:
2772       if (fieldFromInstruction32(Insn, 6, 1))
2773         return Fail; // UNDEFINED
2774       index = fieldFromInstruction32(Insn, 7, 1);
2775       if (fieldFromInstruction32(Insn, 4, 2) != 0)
2776         align = 4;
2777   }
2778
2779   if (Rm != 0xF) { // Writeback
2780     CHECK(S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder));
2781   }
2782   CHECK(S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder));
2783   Inst.addOperand(MCOperand::CreateImm(align));
2784   if (Rm != 0xF && Rm != 0xD) {
2785     CHECK(S, DecodeGPRRegisterClass(Inst, Rm, Address, Decoder));
2786   }
2787
2788   CHECK(S, DecodeDPRRegisterClass(Inst, Rd, Address, Decoder));
2789   Inst.addOperand(MCOperand::CreateImm(index));
2790
2791   return S;
2792 }
2793
2794
2795 static DecodeStatus DecodeVLD2LN(llvm::MCInst &Inst, unsigned Insn,
2796                          uint64_t Address, const void *Decoder) {
2797   DecodeStatus S = Success;
2798
2799   unsigned Rn = fieldFromInstruction32(Insn, 16, 4);
2800   unsigned Rm = fieldFromInstruction32(Insn, 0, 4);
2801   unsigned Rd = fieldFromInstruction32(Insn, 12, 4);
2802   Rd |= fieldFromInstruction32(Insn, 22, 1) << 4;
2803   unsigned size = fieldFromInstruction32(Insn, 10, 2);
2804
2805   unsigned align = 0;
2806   unsigned index = 0;
2807   unsigned inc = 1;
2808   switch (size) {
2809     default:
2810       return Fail;
2811     case 0:
2812       index = fieldFromInstruction32(Insn, 5, 3);
2813       if (fieldFromInstruction32(Insn, 4, 1))
2814         align = 2;
2815       break;
2816     case 1:
2817       index = fieldFromInstruction32(Insn, 6, 2);
2818       if (fieldFromInstruction32(Insn, 4, 1))
2819         align = 4;
2820       if (fieldFromInstruction32(Insn, 5, 1))
2821         inc = 2;
2822       break;
2823     case 2:
2824       if (fieldFromInstruction32(Insn, 5, 1))
2825         return Fail; // UNDEFINED
2826       index = fieldFromInstruction32(Insn, 7, 1);
2827       if (fieldFromInstruction32(Insn, 4, 1) != 0)
2828         align = 8;
2829       if (fieldFromInstruction32(Insn, 6, 1))
2830         inc = 2;
2831       break;
2832   }
2833
2834   CHECK(S, DecodeDPRRegisterClass(Inst, Rd, Address, Decoder));
2835   CHECK(S, DecodeDPRRegisterClass(Inst, Rd+inc, Address, Decoder));
2836   if (Rm != 0xF) { // Writeback
2837     CHECK(S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder));
2838   }
2839   CHECK(S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder));
2840   Inst.addOperand(MCOperand::CreateImm(align));
2841   if (Rm != 0xF && Rm != 0xD) {
2842     CHECK(S, DecodeGPRRegisterClass(Inst, Rm, Address, Decoder));
2843   }
2844
2845   CHECK(S, DecodeDPRRegisterClass(Inst, Rd, Address, Decoder));
2846   CHECK(S, DecodeDPRRegisterClass(Inst, Rd+inc, Address, Decoder));
2847   Inst.addOperand(MCOperand::CreateImm(index));
2848
2849   return S;
2850 }
2851
2852 static DecodeStatus DecodeVST2LN(llvm::MCInst &Inst, unsigned Insn,
2853                          uint64_t Address, const void *Decoder) {
2854   DecodeStatus S = Success;
2855
2856   unsigned Rn = fieldFromInstruction32(Insn, 16, 4);
2857   unsigned Rm = fieldFromInstruction32(Insn, 0, 4);
2858   unsigned Rd = fieldFromInstruction32(Insn, 12, 4);
2859   Rd |= fieldFromInstruction32(Insn, 22, 1) << 4;
2860   unsigned size = fieldFromInstruction32(Insn, 10, 2);
2861
2862   unsigned align = 0;
2863   unsigned index = 0;
2864   unsigned inc = 1;
2865   switch (size) {
2866     default:
2867       return Fail;
2868     case 0:
2869       index = fieldFromInstruction32(Insn, 5, 3);
2870       if (fieldFromInstruction32(Insn, 4, 1))
2871         align = 2;
2872       break;
2873     case 1:
2874       index = fieldFromInstruction32(Insn, 6, 2);
2875       if (fieldFromInstruction32(Insn, 4, 1))
2876         align = 4;
2877       if (fieldFromInstruction32(Insn, 5, 1))
2878         inc = 2;
2879       break;
2880     case 2:
2881       if (fieldFromInstruction32(Insn, 5, 1))
2882         return Fail; // UNDEFINED
2883       index = fieldFromInstruction32(Insn, 7, 1);
2884       if (fieldFromInstruction32(Insn, 4, 1) != 0)
2885         align = 8;
2886       if (fieldFromInstruction32(Insn, 6, 1))
2887         inc = 2;
2888       break;
2889   }
2890
2891   if (Rm != 0xF) { // Writeback
2892     CHECK(S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder));
2893   }
2894   CHECK(S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder));
2895   Inst.addOperand(MCOperand::CreateImm(align));
2896   if (Rm != 0xF && Rm != 0xD) {
2897     CHECK(S, DecodeGPRRegisterClass(Inst, Rm, Address, Decoder));
2898   }
2899
2900   CHECK(S, DecodeDPRRegisterClass(Inst, Rd, Address, Decoder));
2901   CHECK(S, DecodeDPRRegisterClass(Inst, Rd+inc, Address, Decoder));
2902   Inst.addOperand(MCOperand::CreateImm(index));
2903
2904   return S;
2905 }
2906
2907
2908 static DecodeStatus DecodeVLD3LN(llvm::MCInst &Inst, unsigned Insn,
2909                          uint64_t Address, const void *Decoder) {
2910   DecodeStatus S = Success;
2911
2912   unsigned Rn = fieldFromInstruction32(Insn, 16, 4);
2913   unsigned Rm = fieldFromInstruction32(Insn, 0, 4);
2914   unsigned Rd = fieldFromInstruction32(Insn, 12, 4);
2915   Rd |= fieldFromInstruction32(Insn, 22, 1) << 4;
2916   unsigned size = fieldFromInstruction32(Insn, 10, 2);
2917
2918   unsigned align = 0;
2919   unsigned index = 0;
2920   unsigned inc = 1;
2921   switch (size) {
2922     default:
2923       return Fail;
2924     case 0:
2925       if (fieldFromInstruction32(Insn, 4, 1))
2926         return Fail; // UNDEFINED
2927       index = fieldFromInstruction32(Insn, 5, 3);
2928       break;
2929     case 1:
2930       if (fieldFromInstruction32(Insn, 4, 1))
2931         return Fail; // UNDEFINED
2932       index = fieldFromInstruction32(Insn, 6, 2);
2933       if (fieldFromInstruction32(Insn, 5, 1))
2934         inc = 2;
2935       break;
2936     case 2:
2937       if (fieldFromInstruction32(Insn, 4, 2))
2938         return Fail; // UNDEFINED
2939       index = fieldFromInstruction32(Insn, 7, 1);
2940       if (fieldFromInstruction32(Insn, 6, 1))
2941         inc = 2;
2942       break;
2943   }
2944
2945   CHECK(S, DecodeDPRRegisterClass(Inst, Rd, Address, Decoder));
2946   CHECK(S, DecodeDPRRegisterClass(Inst, Rd+inc, Address, Decoder));
2947   CHECK(S, DecodeDPRRegisterClass(Inst, Rd+2*inc, Address, Decoder));
2948
2949   if (Rm != 0xF) { // Writeback
2950     CHECK(S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder));
2951   }
2952   CHECK(S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder));
2953   Inst.addOperand(MCOperand::CreateImm(align));
2954   if (Rm != 0xF && Rm != 0xD) {
2955     CHECK(S, DecodeGPRRegisterClass(Inst, Rm, Address, Decoder));
2956   }
2957
2958   CHECK(S, DecodeDPRRegisterClass(Inst, Rd, Address, Decoder));
2959   CHECK(S, DecodeDPRRegisterClass(Inst, Rd+inc, Address, Decoder));
2960   CHECK(S, DecodeDPRRegisterClass(Inst, Rd+2*inc, Address, Decoder));
2961   Inst.addOperand(MCOperand::CreateImm(index));
2962
2963   return S;
2964 }
2965
2966 static DecodeStatus DecodeVST3LN(llvm::MCInst &Inst, unsigned Insn,
2967                          uint64_t Address, const void *Decoder) {
2968   DecodeStatus S = Success;
2969
2970   unsigned Rn = fieldFromInstruction32(Insn, 16, 4);
2971   unsigned Rm = fieldFromInstruction32(Insn, 0, 4);
2972   unsigned Rd = fieldFromInstruction32(Insn, 12, 4);
2973   Rd |= fieldFromInstruction32(Insn, 22, 1) << 4;
2974   unsigned size = fieldFromInstruction32(Insn, 10, 2);
2975
2976   unsigned align = 0;
2977   unsigned index = 0;
2978   unsigned inc = 1;
2979   switch (size) {
2980     default:
2981       return Fail;
2982     case 0:
2983       if (fieldFromInstruction32(Insn, 4, 1))
2984         return Fail; // UNDEFINED
2985       index = fieldFromInstruction32(Insn, 5, 3);
2986       break;
2987     case 1:
2988       if (fieldFromInstruction32(Insn, 4, 1))
2989         return Fail; // UNDEFINED
2990       index = fieldFromInstruction32(Insn, 6, 2);
2991       if (fieldFromInstruction32(Insn, 5, 1))
2992         inc = 2;
2993       break;
2994     case 2:
2995       if (fieldFromInstruction32(Insn, 4, 2))
2996         return Fail; // UNDEFINED
2997       index = fieldFromInstruction32(Insn, 7, 1);
2998       if (fieldFromInstruction32(Insn, 6, 1))
2999         inc = 2;
3000       break;
3001   }
3002
3003   if (Rm != 0xF) { // Writeback
3004     CHECK(S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder));
3005   }
3006   CHECK(S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder));
3007   Inst.addOperand(MCOperand::CreateImm(align));
3008   if (Rm != 0xF && Rm != 0xD) {
3009     CHECK(S, DecodeGPRRegisterClass(Inst, Rm, Address, Decoder));
3010   }
3011
3012   CHECK(S, DecodeDPRRegisterClass(Inst, Rd, Address, Decoder));
3013   CHECK(S, DecodeDPRRegisterClass(Inst, Rd+inc, Address, Decoder));
3014   CHECK(S, DecodeDPRRegisterClass(Inst, Rd+2*inc, Address, Decoder));
3015   Inst.addOperand(MCOperand::CreateImm(index));
3016
3017   return S;
3018 }
3019
3020
3021 static DecodeStatus DecodeVLD4LN(llvm::MCInst &Inst, unsigned Insn,
3022                          uint64_t Address, const void *Decoder) {
3023   DecodeStatus S = Success;
3024
3025   unsigned Rn = fieldFromInstruction32(Insn, 16, 4);
3026   unsigned Rm = fieldFromInstruction32(Insn, 0, 4);
3027   unsigned Rd = fieldFromInstruction32(Insn, 12, 4);
3028   Rd |= fieldFromInstruction32(Insn, 22, 1) << 4;
3029   unsigned size = fieldFromInstruction32(Insn, 10, 2);
3030
3031   unsigned align = 0;
3032   unsigned index = 0;
3033   unsigned inc = 1;
3034   switch (size) {
3035     default:
3036       return Fail;
3037     case 0:
3038       if (fieldFromInstruction32(Insn, 4, 1))
3039         align = 4;
3040       index = fieldFromInstruction32(Insn, 5, 3);
3041       break;
3042     case 1:
3043       if (fieldFromInstruction32(Insn, 4, 1))
3044         align = 8;
3045       index = fieldFromInstruction32(Insn, 6, 2);
3046       if (fieldFromInstruction32(Insn, 5, 1))
3047         inc = 2;
3048       break;
3049     case 2:
3050       if (fieldFromInstruction32(Insn, 4, 2))
3051         align = 4 << fieldFromInstruction32(Insn, 4, 2);
3052       index = fieldFromInstruction32(Insn, 7, 1);
3053       if (fieldFromInstruction32(Insn, 6, 1))
3054         inc = 2;
3055       break;
3056   }
3057
3058   CHECK(S, DecodeDPRRegisterClass(Inst, Rd, Address, Decoder));
3059   CHECK(S, DecodeDPRRegisterClass(Inst, Rd+inc, Address, Decoder));
3060   CHECK(S, DecodeDPRRegisterClass(Inst, Rd+2*inc, Address, Decoder));
3061   CHECK(S, DecodeDPRRegisterClass(Inst, Rd+3*inc, Address, Decoder));
3062
3063   if (Rm != 0xF) { // Writeback
3064     CHECK(S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder));
3065   }
3066   CHECK(S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder));
3067   Inst.addOperand(MCOperand::CreateImm(align));
3068   if (Rm != 0xF && Rm != 0xD) {
3069     CHECK(S, DecodeGPRRegisterClass(Inst, Rm, Address, Decoder));
3070   }
3071
3072   CHECK(S, DecodeDPRRegisterClass(Inst, Rd, Address, Decoder));
3073   CHECK(S, DecodeDPRRegisterClass(Inst, Rd+inc, Address, Decoder));
3074   CHECK(S, DecodeDPRRegisterClass(Inst, Rd+2*inc, Address, Decoder));
3075   CHECK(S, DecodeDPRRegisterClass(Inst, Rd+3*inc, Address, Decoder));
3076   Inst.addOperand(MCOperand::CreateImm(index));
3077
3078   return S;
3079 }
3080
3081 static DecodeStatus DecodeVST4LN(llvm::MCInst &Inst, unsigned Insn,
3082                          uint64_t Address, const void *Decoder) {
3083   DecodeStatus S = Success;
3084
3085   unsigned Rn = fieldFromInstruction32(Insn, 16, 4);
3086   unsigned Rm = fieldFromInstruction32(Insn, 0, 4);
3087   unsigned Rd = fieldFromInstruction32(Insn, 12, 4);
3088   Rd |= fieldFromInstruction32(Insn, 22, 1) << 4;
3089   unsigned size = fieldFromInstruction32(Insn, 10, 2);
3090
3091   unsigned align = 0;
3092   unsigned index = 0;
3093   unsigned inc = 1;
3094   switch (size) {
3095     default:
3096       return Fail;
3097     case 0:
3098       if (fieldFromInstruction32(Insn, 4, 1))
3099         align = 4;
3100       index = fieldFromInstruction32(Insn, 5, 3);
3101       break;
3102     case 1:
3103       if (fieldFromInstruction32(Insn, 4, 1))
3104         align = 8;
3105       index = fieldFromInstruction32(Insn, 6, 2);
3106       if (fieldFromInstruction32(Insn, 5, 1))
3107         inc = 2;
3108       break;
3109     case 2:
3110       if (fieldFromInstruction32(Insn, 4, 2))
3111         align = 4 << fieldFromInstruction32(Insn, 4, 2);
3112       index = fieldFromInstruction32(Insn, 7, 1);
3113       if (fieldFromInstruction32(Insn, 6, 1))
3114         inc = 2;
3115       break;
3116   }
3117
3118   if (Rm != 0xF) { // Writeback
3119     CHECK(S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder));
3120   }
3121   CHECK(S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder));
3122   Inst.addOperand(MCOperand::CreateImm(align));
3123   if (Rm != 0xF && Rm != 0xD) {
3124     CHECK(S, DecodeGPRRegisterClass(Inst, Rm, Address, Decoder));
3125   }
3126
3127   CHECK(S, DecodeDPRRegisterClass(Inst, Rd, Address, Decoder));
3128   CHECK(S, DecodeDPRRegisterClass(Inst, Rd+inc, Address, Decoder));
3129   CHECK(S, DecodeDPRRegisterClass(Inst, Rd+2*inc, Address, Decoder));
3130   CHECK(S, DecodeDPRRegisterClass(Inst, Rd+3*inc, Address, Decoder));
3131   Inst.addOperand(MCOperand::CreateImm(index));
3132
3133   return S;
3134 }
3135