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