lib/Target/ARM/Disassembler/ARMDisassembler.cpp

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