lib/Target/ARM64/Disassembler/ARM64Disassembler.cpp

   1 //===- ARM64Disassembler.cpp - Disassembler for ARM64 -----------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 #define DEBUG_TYPE "arm64-disassembler"
  14
  15 #include "ARM64Disassembler.h"
  16 #include "ARM64Subtarget.h"
  17 #include "MCTargetDesc/ARM64BaseInfo.h"
  18 #include "MCTargetDesc/ARM64AddressingModes.h"
  19 #include "llvm/MC/MCInst.h"
  20 #include "llvm/MC/MCExpr.h"
  21 #include "llvm/MC/MCContext.h"
  22 #include "llvm/MC/MCFixedLenDisassembler.h"
  23 #include "llvm/Support/Debug.h"
  24 #include "llvm/Support/MemoryObject.h"
  25 #include "llvm/Support/TargetRegistry.h"
  26 #include "llvm/Support/ErrorHandling.h"
  27 #include "llvm/Support/Format.h"
  28 #include "llvm/Support/raw_ostream.h"
  29
  30 // Pull DecodeStatus and its enum values into the global namespace.
  31 typedef llvm::MCDisassembler::DecodeStatus DecodeStatus;
  32
  33 // Forward declare these because the autogenerated code will reference them.
  34 // Definitions are further down.
  35 static DecodeStatus DecodeFPR128RegisterClass(llvm::MCInst &Inst,
  36                                               unsigned RegNo, uint64_t Address,
  37                                               const void *Decoder);
  38 static DecodeStatus DecodeFPR128_loRegisterClass(llvm::MCInst &Inst,
  39                                                  unsigned RegNo,
  40                                                  uint64_t Address,
  41                                                  const void *Decoder);
  42 static DecodeStatus DecodeFPR64RegisterClass(llvm::MCInst &Inst, unsigned RegNo,
  43                                              uint64_t Address,
  44                                              const void *Decoder);
  45 static DecodeStatus DecodeFPR32RegisterClass(llvm::MCInst &Inst, unsigned RegNo,
  46                                              uint64_t Address,
  47                                              const void *Decoder);
  48 static DecodeStatus DecodeFPR16RegisterClass(llvm::MCInst &Inst, unsigned RegNo,
  49                                              uint64_t Address,
  50                                              const void *Decoder);
  51 static DecodeStatus DecodeFPR8RegisterClass(llvm::MCInst &Inst, unsigned RegNo,
  52                                             uint64_t Address,
  53                                             const void *Decoder);
  54 static DecodeStatus DecodeGPR64RegisterClass(llvm::MCInst &Inst, unsigned RegNo,
  55                                              uint64_t Address,
  56                                              const void *Decoder);
  57 static DecodeStatus DecodeGPR64spRegisterClass(llvm::MCInst &Inst,
  58                                                unsigned RegNo, uint64_t Address,
  59                                                const void *Decoder);
  60 static DecodeStatus DecodeGPR32RegisterClass(llvm::MCInst &Inst, unsigned RegNo,
  61                                              uint64_t Address,
  62                                              const void *Decoder);
  63 static DecodeStatus DecodeGPR32spRegisterClass(llvm::MCInst &Inst,
  64                                                unsigned RegNo, uint64_t Address,
  65                                                const void *Decoder);
  66 static DecodeStatus DecodeQQRegisterClass(llvm::MCInst &Inst, unsigned RegNo,
  67                                           uint64_t Address,
  68                                           const void *Decoder);
  69 static DecodeStatus DecodeQQQRegisterClass(llvm::MCInst &Inst, unsigned RegNo,
  70                                            uint64_t Address,
  71                                            const void *Decoder);
  72 static DecodeStatus DecodeQQQQRegisterClass(llvm::MCInst &Inst, unsigned RegNo,
  73                                             uint64_t Address,
  74                                             const void *Decoder);
  75 static DecodeStatus DecodeDDRegisterClass(llvm::MCInst &Inst, unsigned RegNo,
  76                                           uint64_t Address,
  77                                           const void *Decoder);
  78 static DecodeStatus DecodeDDDRegisterClass(llvm::MCInst &Inst, unsigned RegNo,
  79                                            uint64_t Address,
  80                                            const void *Decoder);
  81 static DecodeStatus DecodeDDDDRegisterClass(llvm::MCInst &Inst, unsigned RegNo,
  82                                             uint64_t Address,
  83                                             const void *Decoder);
  84
  85 static DecodeStatus DecodeFixedPointScaleImm(llvm::MCInst &Inst, unsigned Imm,
  86                                              uint64_t Address,
  87                                              const void *Decoder);
  88 static DecodeStatus DecodeCondBranchTarget(llvm::MCInst &Inst, unsigned Imm,
  89                                            uint64_t Address,
  90                                            const void *Decoder);
  91 static DecodeStatus DecodeSystemRegister(llvm::MCInst &Inst, unsigned Imm,
  92                                          uint64_t Address, const void *Decoder);
  93 static DecodeStatus DecodeThreeAddrSRegInstruction(llvm::MCInst &Inst,
  94                                                    uint32_t insn,
  95                                                    uint64_t Address,
  96                                                    const void *Decoder);
  97 static DecodeStatus DecodeMoveImmInstruction(llvm::MCInst &Inst, uint32_t insn,
  98                                              uint64_t Address,
  99                                              const void *Decoder);
 100 static DecodeStatus DecodeUnsignedLdStInstruction(llvm::MCInst &Inst,
 101                                                   uint32_t insn,
 102                                                   uint64_t Address,
 103                                                   const void *Decoder);
 104 static DecodeStatus DecodeSignedLdStInstruction(llvm::MCInst &Inst,
 105                                                 uint32_t insn, uint64_t Address,
 106                                                 const void *Decoder);
 107 static DecodeStatus DecodeExclusiveLdStInstruction(llvm::MCInst &Inst,
 108                                                    uint32_t insn,
 109                                                    uint64_t Address,
 110                                                    const void *Decoder);
 111 static DecodeStatus DecodePairLdStInstruction(llvm::MCInst &Inst, uint32_t insn,
 112                                               uint64_t Address,
 113                                               const void *Decoder);
 114 static DecodeStatus DecodeRegOffsetLdStInstruction(llvm::MCInst &Inst,
 115                                                    uint32_t insn,
 116                                                    uint64_t Address,
 117                                                    const void *Decoder);
 118 static DecodeStatus DecodeAddSubERegInstruction(llvm::MCInst &Inst,
 119                                                 uint32_t insn, uint64_t Address,
 120                                                 const void *Decoder);
 121 static DecodeStatus DecodeLogicalImmInstruction(llvm::MCInst &Inst,
 122                                                 uint32_t insn, uint64_t Address,
 123                                                 const void *Decoder);
 124 static DecodeStatus DecodeModImmInstruction(llvm::MCInst &Inst, uint32_t insn,
 125                                             uint64_t Address,
 126                                             const void *Decoder);
 127 static DecodeStatus DecodeModImmTiedInstruction(llvm::MCInst &Inst,
 128                                                 uint32_t insn, uint64_t Address,
 129                                                 const void *Decoder);
 130 static DecodeStatus DecodeAdrInstruction(llvm::MCInst &Inst, uint32_t insn,
 131                                          uint64_t Address, const void *Decoder);
 132 static DecodeStatus DecodeBaseAddSubImm(llvm::MCInst &Inst, uint32_t insn,
 133                                         uint64_t Address, const void *Decoder);
 134 static DecodeStatus DecodeUnconditionalBranch(llvm::MCInst &Inst, uint32_t insn,
 135                                               uint64_t Address,
 136                                               const void *Decoder);
 137 static DecodeStatus DecodeSystemCPSRInstruction(llvm::MCInst &Inst,
 138                                                 uint32_t insn, uint64_t Address,
 139                                                 const void *Decoder);
 140 static DecodeStatus DecodeTestAndBranch(llvm::MCInst &Inst, uint32_t insn,
 141                                         uint64_t Address, const void *Decoder);
 142 static DecodeStatus DecodeSIMDLdStPost(llvm::MCInst &Inst, uint32_t insn,
 143                                        uint64_t Addr, const void *Decoder);
 144 static DecodeStatus DecodeSIMDLdStSingle(llvm::MCInst &Inst, uint32_t insn,
 145                                          uint64_t Addr, const void *Decoder);
 146 static DecodeStatus DecodeSIMDLdStSingleTied(llvm::MCInst &Inst, uint32_t insn,
 147                                              uint64_t Addr,
 148                                              const void *Decoder);
 149
 150 static DecodeStatus DecodeVecShiftR64Imm(llvm::MCInst &Inst, unsigned Imm,
 151                                          uint64_t Addr, const void *Decoder);
 152 static DecodeStatus DecodeVecShiftR64ImmNarrow(llvm::MCInst &Inst, unsigned Imm,
 153                                                uint64_t Addr,
 154                                                const void *Decoder);
 155 static DecodeStatus DecodeVecShiftR32Imm(llvm::MCInst &Inst, unsigned Imm,
 156                                          uint64_t Addr, const void *Decoder);
 157 static DecodeStatus DecodeVecShiftR32ImmNarrow(llvm::MCInst &Inst, unsigned Imm,
 158                                                uint64_t Addr,
 159                                                const void *Decoder);
 160 static DecodeStatus DecodeVecShiftR16Imm(llvm::MCInst &Inst, unsigned Imm,
 161                                          uint64_t Addr, const void *Decoder);
 162 static DecodeStatus DecodeVecShiftR16ImmNarrow(llvm::MCInst &Inst, unsigned Imm,
 163                                                uint64_t Addr,
 164                                                const void *Decoder);
 165 static DecodeStatus DecodeVecShiftR8Imm(llvm::MCInst &Inst, unsigned Imm,
 166                                         uint64_t Addr, const void *Decoder);
 167 static DecodeStatus DecodeVecShiftL64Imm(llvm::MCInst &Inst, unsigned Imm,
 168                                          uint64_t Addr, const void *Decoder);
 169 static DecodeStatus DecodeVecShiftL32Imm(llvm::MCInst &Inst, unsigned Imm,
 170                                          uint64_t Addr, const void *Decoder);
 171 static DecodeStatus DecodeVecShiftL16Imm(llvm::MCInst &Inst, unsigned Imm,
 172                                          uint64_t Addr, const void *Decoder);
 173 static DecodeStatus DecodeVecShiftL8Imm(llvm::MCInst &Inst, unsigned Imm,
 174                                         uint64_t Addr, const void *Decoder);
 175
 176 #include "ARM64GenDisassemblerTables.inc"
 177 #include "ARM64GenInstrInfo.inc"
 178
 179 using namespace llvm;
 180
 181 #define Success llvm::MCDisassembler::Success
 182 #define Fail llvm::MCDisassembler::Fail
 183
 184 static MCDisassembler *createARM64Disassembler(const Target &T,
 185                                                const MCSubtargetInfo &STI) {
 186   return new ARM64Disassembler(STI);
 187 }
 188
 189 DecodeStatus ARM64Disassembler::getInstruction(MCInst &MI, uint64_t &Size,
 190                                                const MemoryObject &Region,
 191                                                uint64_t Address,
 192                                                raw_ostream &os,
 193                                                raw_ostream &cs) const {
 194   CommentStream = &cs;
 195
 196   uint8_t bytes[4];
 197
 198   // We want to read exactly 4 bytes of data.
 199   if (Region.readBytes(Address, 4, (uint8_t *)bytes) == -1)
 200     return Fail;
 201
 202   // Encoded as a small-endian 32-bit word in the stream.
 203   uint32_t insn =
 204       (bytes[3] << 24) | (bytes[2] << 16) | (bytes[1] << 8) | (bytes[0] << 0);
 205
 206   // Calling the auto-generated decoder function.
 207   DecodeStatus result =
 208       decodeInstruction(DecoderTable32, MI, insn, Address, this, STI);
 209   if (!result)
 210     return Fail;
 211
 212   Size = 4;
 213
 214   return Success;
 215 }
 216
 217 static MCSymbolRefExpr::VariantKind
 218 getVariant(uint64_t LLVMDisassembler_VariantKind) {
 219   switch (LLVMDisassembler_VariantKind) {
 220   case LLVMDisassembler_VariantKind_None:
 221     return MCSymbolRefExpr::VK_None;
 222   case LLVMDisassembler_VariantKind_ARM64_PAGE:
 223     return MCSymbolRefExpr::VK_PAGE;
 224   case LLVMDisassembler_VariantKind_ARM64_PAGEOFF:
 225     return MCSymbolRefExpr::VK_PAGEOFF;
 226   case LLVMDisassembler_VariantKind_ARM64_GOTPAGE:
 227     return MCSymbolRefExpr::VK_GOTPAGE;
 228   case LLVMDisassembler_VariantKind_ARM64_GOTPAGEOFF:
 229     return MCSymbolRefExpr::VK_GOTPAGEOFF;
 230   case LLVMDisassembler_VariantKind_ARM64_TLVP:
 231   case LLVMDisassembler_VariantKind_ARM64_TLVOFF:
 232   default:
 233     assert("bad LLVMDisassembler_VariantKind");
 234     return MCSymbolRefExpr::VK_None;
 235   }
 236 }
 237
 238 /// tryAddingSymbolicOperand - tryAddingSymbolicOperand trys to add a symbolic
 239 /// operand in place of the immediate Value in the MCInst.  The immediate
 240 /// Value has not had any PC adjustment made by the caller. If the instruction
 241 /// is a branch that adds the PC to the immediate Value then isBranch is
 242 /// Success, else Fail.  If the getOpInfo() function was set as part of the
 243 /// setupForSymbolicDisassembly() call then that function is called to get any
 244 /// symbolic information at the Address for this instrution.  If that returns
 245 /// non-zero then the symbolic information it returns is used to create an
 246 /// MCExpr and that is added as an operand to the MCInst.  If getOpInfo()
 247 /// returns zero and isBranch is Success then a symbol look up for
 248 /// Address + Value is done and if a symbol is found an MCExpr is created with
 249 /// that, else an MCExpr with Address + Value is created.  If getOpInfo()
 250 /// returns zero and isBranch is Fail then the the Opcode of the MCInst is
 251 /// tested and for ADRP an other instructions that help to load of pointers
 252 /// a symbol look up is done to see it is returns a specific reference type
 253 /// to add to the comment stream.  This function returns Success if it adds
 254 /// an operand to the MCInst and Fail otherwise.
 255 bool ARM64Disassembler::tryAddingSymbolicOperand(uint64_t Address, int Value,
 256                                                  bool isBranch,
 257                                                  uint64_t InstSize, MCInst &MI,
 258                                                  uint32_t insn) const {
 259   LLVMOpInfoCallback getOpInfo = getLLVMOpInfoCallback();
 260
 261   struct LLVMOpInfo1 SymbolicOp;
 262   memset(&SymbolicOp, '\0', sizeof(struct LLVMOpInfo1));
 263   SymbolicOp.Value = Value;
 264   void *DisInfo = getDisInfoBlock();
 265   uint64_t ReferenceType;
 266   const char *ReferenceName;
 267   const char *Name;
 268   LLVMSymbolLookupCallback SymbolLookUp = getLLVMSymbolLookupCallback();
 269   if (!getOpInfo ||
 270       !getOpInfo(DisInfo, Address, 0 /* Offset */, InstSize, 1, &SymbolicOp)) {
 271     if (isBranch) {
 272       if (SymbolLookUp) {
 273         ReferenceType = LLVMDisassembler_ReferenceType_In_Branch;
 274         Name = SymbolLookUp(DisInfo, Address + Value, &ReferenceType, Address,
 275                             &ReferenceName);
 276         if (Name) {
 277           SymbolicOp.AddSymbol.Name = Name;
 278           SymbolicOp.AddSymbol.Present = Success;
 279           SymbolicOp.Value = 0;
 280         } else {
 281           SymbolicOp.Value = Address + Value;
 282         }
 283         if (ReferenceType == LLVMDisassembler_ReferenceType_Out_SymbolStub)
 284           (*CommentStream) << "symbol stub for: " << ReferenceName;
 285         else if (ReferenceType ==
 286                  LLVMDisassembler_ReferenceType_Out_Objc_Message)
 287           (*CommentStream) << "Objc message: " << ReferenceName;
 288       } else {
 289         return false;
 290       }
 291     } else if (MI.getOpcode() == ARM64::ADRP) {
 292       if (SymbolLookUp) {
 293         ReferenceType = LLVMDisassembler_ReferenceType_In_ARM64_ADRP;
 294         Name = SymbolLookUp(DisInfo, insn, &ReferenceType, Address,
 295                             &ReferenceName);
 296         (*CommentStream) << format("0x%llx",
 297                                    0xfffffffffffff000LL & (Address + Value));
 298       } else {
 299         return false;
 300       }
 301     } else if (MI.getOpcode() == ARM64::ADDXri ||
 302                MI.getOpcode() == ARM64::LDRXui ||
 303                MI.getOpcode() == ARM64::LDRXl || MI.getOpcode() == ARM64::ADR) {
 304       if (SymbolLookUp) {
 305         if (MI.getOpcode() == ARM64::ADDXri)
 306           ReferenceType = LLVMDisassembler_ReferenceType_In_ARM64_ADDXri;
 307         else if (MI.getOpcode() == ARM64::LDRXui)
 308           ReferenceType = LLVMDisassembler_ReferenceType_In_ARM64_LDRXui;
 309         if (MI.getOpcode() == ARM64::LDRXl) {
 310           ReferenceType = LLVMDisassembler_ReferenceType_In_ARM64_LDRXl;
 311           Name = SymbolLookUp(DisInfo, Address + Value, &ReferenceType, Address,
 312                               &ReferenceName);
 313         } else if (MI.getOpcode() == ARM64::ADR) {
 314           ReferenceType = LLVMDisassembler_ReferenceType_In_ARM64_ADR;
 315           Name = SymbolLookUp(DisInfo, Address + Value, &ReferenceType, Address,
 316                               &ReferenceName);
 317         } else {
 318           Name = SymbolLookUp(DisInfo, insn, &ReferenceType, Address,
 319                               &ReferenceName);
 320         }
 321         if (ReferenceType == LLVMDisassembler_ReferenceType_Out_LitPool_SymAddr)
 322           (*CommentStream) << "literal pool symbol address: " << ReferenceName;
 323         else if (ReferenceType ==
 324                  LLVMDisassembler_ReferenceType_Out_LitPool_CstrAddr)
 325           (*CommentStream) << "literal pool for: \"" << ReferenceName << "\"";
 326         else if (ReferenceType ==
 327                  LLVMDisassembler_ReferenceType_Out_Objc_CFString_Ref)
 328           (*CommentStream) << "Objc cfstring ref: @\"" << ReferenceName << "\"";
 329         else if (ReferenceType ==
 330                  LLVMDisassembler_ReferenceType_Out_Objc_Message)
 331           (*CommentStream) << "Objc message: " << ReferenceName;
 332         else if (ReferenceType ==
 333                  LLVMDisassembler_ReferenceType_Out_Objc_Message_Ref)
 334           (*CommentStream) << "Objc message ref: " << ReferenceName;
 335         else if (ReferenceType ==
 336                  LLVMDisassembler_ReferenceType_Out_Objc_Selector_Ref)
 337           (*CommentStream) << "Objc selector ref: " << ReferenceName;
 338         else if (ReferenceType ==
 339                  LLVMDisassembler_ReferenceType_Out_Objc_Class_Ref)
 340           (*CommentStream) << "Objc class ref: " << ReferenceName;
 341         // For these instructions, the SymbolLookUp() above is just to get the
 342         // ReferenceType and ReferenceName.  We want to make sure not to
 343         // fall through so we don't build an MCExpr to leave the disassembly
 344         // of the immediate values of these instructions to the InstPrinter.
 345         return false;
 346       } else {
 347         return false;
 348       }
 349     } else {
 350       return false;
 351     }
 352   }
 353
 354   MCContext *Ctx = getMCContext();
 355   const MCExpr *Add = NULL;
 356   if (SymbolicOp.AddSymbol.Present) {
 357     if (SymbolicOp.AddSymbol.Name) {
 358       StringRef Name(SymbolicOp.AddSymbol.Name);
 359       MCSymbol *Sym = Ctx->GetOrCreateSymbol(Name);
 360       MCSymbolRefExpr::VariantKind Variant = getVariant(SymbolicOp.VariantKind);
 361       if (Variant != MCSymbolRefExpr::VK_None)
 362         Add = MCSymbolRefExpr::Create(Sym, Variant, *Ctx);
 363       else
 364         Add = MCSymbolRefExpr::Create(Sym, *Ctx);
 365     } else {
 366       Add = MCConstantExpr::Create(SymbolicOp.AddSymbol.Value, *Ctx);
 367     }
 368   }
 369
 370   const MCExpr *Sub = NULL;
 371   if (SymbolicOp.SubtractSymbol.Present) {
 372     if (SymbolicOp.SubtractSymbol.Name) {
 373       StringRef Name(SymbolicOp.SubtractSymbol.Name);
 374       MCSymbol *Sym = Ctx->GetOrCreateSymbol(Name);
 375       Sub = MCSymbolRefExpr::Create(Sym, *Ctx);
 376     } else {
 377       Sub = MCConstantExpr::Create(SymbolicOp.SubtractSymbol.Value, *Ctx);
 378     }
 379   }
 380
 381   const MCExpr *Off = NULL;
 382   if (SymbolicOp.Value != 0)
 383     Off = MCConstantExpr::Create(SymbolicOp.Value, *Ctx);
 384
 385   const MCExpr *Expr;
 386   if (Sub) {
 387     const MCExpr *LHS;
 388     if (Add)
 389       LHS = MCBinaryExpr::CreateSub(Add, Sub, *Ctx);
 390     else
 391       LHS = MCUnaryExpr::CreateMinus(Sub, *Ctx);
 392     if (Off != 0)
 393       Expr = MCBinaryExpr::CreateAdd(LHS, Off, *Ctx);
 394     else
 395       Expr = LHS;
 396   } else if (Add) {
 397     if (Off != 0)
 398       Expr = MCBinaryExpr::CreateAdd(Add, Off, *Ctx);
 399     else
 400       Expr = Add;
 401   } else {
 402     if (Off != 0)
 403       Expr = Off;
 404     else
 405       Expr = MCConstantExpr::Create(0, *Ctx);
 406   }
 407
 408   MI.addOperand(MCOperand::CreateExpr(Expr));
 409
 410   return true;
 411 }
 412
 413 extern "C" void LLVMInitializeARM64Disassembler() {
 414   TargetRegistry::RegisterMCDisassembler(TheARM64Target,
 415                                          createARM64Disassembler);
 416 }
 417
 418 static const unsigned FPR128DecoderTable[] = {
 419   ARM64::Q0,  ARM64::Q1,  ARM64::Q2,  ARM64::Q3,  ARM64::Q4,  ARM64::Q5,
 420   ARM64::Q6,  ARM64::Q7,  ARM64::Q8,  ARM64::Q9,  ARM64::Q10, ARM64::Q11,
 421   ARM64::Q12, ARM64::Q13, ARM64::Q14, ARM64::Q15, ARM64::Q16, ARM64::Q17,
 422   ARM64::Q18, ARM64::Q19, ARM64::Q20, ARM64::Q21, ARM64::Q22, ARM64::Q23,
 423   ARM64::Q24, ARM64::Q25, ARM64::Q26, ARM64::Q27, ARM64::Q28, ARM64::Q29,
 424   ARM64::Q30, ARM64::Q31
 425 };
 426
 427 static DecodeStatus DecodeFPR128RegisterClass(MCInst &Inst, unsigned RegNo,
 428                                               uint64_t Addr,
 429                                               const void *Decoder) {
 430   if (RegNo > 31)
 431     return Fail;
 432
 433   unsigned Register = FPR128DecoderTable[RegNo];
 434   Inst.addOperand(MCOperand::CreateReg(Register));
 435   return Success;
 436 }
 437
 438 static DecodeStatus DecodeFPR128_loRegisterClass(MCInst &Inst, unsigned RegNo,
 439                                                  uint64_t Addr,
 440                                                  const void *Decoder) {
 441   if (RegNo > 15)
 442     return Fail;
 443   return DecodeFPR128RegisterClass(Inst, RegNo, Addr, Decoder);
 444 }
 445
 446 static const unsigned FPR64DecoderTable[] = {
 447   ARM64::D0,  ARM64::D1,  ARM64::D2,  ARM64::D3,  ARM64::D4,  ARM64::D5,
 448   ARM64::D6,  ARM64::D7,  ARM64::D8,  ARM64::D9,  ARM64::D10, ARM64::D11,
 449   ARM64::D12, ARM64::D13, ARM64::D14, ARM64::D15, ARM64::D16, ARM64::D17,
 450   ARM64::D18, ARM64::D19, ARM64::D20, ARM64::D21, ARM64::D22, ARM64::D23,
 451   ARM64::D24, ARM64::D25, ARM64::D26, ARM64::D27, ARM64::D28, ARM64::D29,
 452   ARM64::D30, ARM64::D31
 453 };
 454
 455 static DecodeStatus DecodeFPR64RegisterClass(MCInst &Inst, unsigned RegNo,
 456                                              uint64_t Addr,
 457                                              const void *Decoder) {
 458   if (RegNo > 31)
 459     return Fail;
 460
 461   unsigned Register = FPR64DecoderTable[RegNo];
 462   Inst.addOperand(MCOperand::CreateReg(Register));
 463   return Success;
 464 }
 465
 466 static const unsigned FPR32DecoderTable[] = {
 467   ARM64::S0,  ARM64::S1,  ARM64::S2,  ARM64::S3,  ARM64::S4,  ARM64::S5,
 468   ARM64::S6,  ARM64::S7,  ARM64::S8,  ARM64::S9,  ARM64::S10, ARM64::S11,
 469   ARM64::S12, ARM64::S13, ARM64::S14, ARM64::S15, ARM64::S16, ARM64::S17,
 470   ARM64::S18, ARM64::S19, ARM64::S20, ARM64::S21, ARM64::S22, ARM64::S23,
 471   ARM64::S24, ARM64::S25, ARM64::S26, ARM64::S27, ARM64::S28, ARM64::S29,
 472   ARM64::S30, ARM64::S31
 473 };
 474
 475 static DecodeStatus DecodeFPR32RegisterClass(MCInst &Inst, unsigned RegNo,
 476                                              uint64_t Addr,
 477                                              const void *Decoder) {
 478   if (RegNo > 31)
 479     return Fail;
 480
 481   unsigned Register = FPR32DecoderTable[RegNo];
 482   Inst.addOperand(MCOperand::CreateReg(Register));
 483   return Success;
 484 }
 485
 486 static const unsigned FPR16DecoderTable[] = {
 487   ARM64::H0,  ARM64::H1,  ARM64::H2,  ARM64::H3,  ARM64::H4,  ARM64::H5,
 488   ARM64::H6,  ARM64::H7,  ARM64::H8,  ARM64::H9,  ARM64::H10, ARM64::H11,
 489   ARM64::H12, ARM64::H13, ARM64::H14, ARM64::H15, ARM64::H16, ARM64::H17,
 490   ARM64::H18, ARM64::H19, ARM64::H20, ARM64::H21, ARM64::H22, ARM64::H23,
 491   ARM64::H24, ARM64::H25, ARM64::H26, ARM64::H27, ARM64::H28, ARM64::H29,
 492   ARM64::H30, ARM64::H31
 493 };
 494
 495 static DecodeStatus DecodeFPR16RegisterClass(MCInst &Inst, unsigned RegNo,
 496                                              uint64_t Addr,
 497                                              const void *Decoder) {
 498   if (RegNo > 31)
 499     return Fail;
 500
 501   unsigned Register = FPR16DecoderTable[RegNo];
 502   Inst.addOperand(MCOperand::CreateReg(Register));
 503   return Success;
 504 }
 505
 506 static const unsigned FPR8DecoderTable[] = {
 507   ARM64::B0,  ARM64::B1,  ARM64::B2,  ARM64::B3,  ARM64::B4,  ARM64::B5,
 508   ARM64::B6,  ARM64::B7,  ARM64::B8,  ARM64::B9,  ARM64::B10, ARM64::B11,
 509   ARM64::B12, ARM64::B13, ARM64::B14, ARM64::B15, ARM64::B16, ARM64::B17,
 510   ARM64::B18, ARM64::B19, ARM64::B20, ARM64::B21, ARM64::B22, ARM64::B23,
 511   ARM64::B24, ARM64::B25, ARM64::B26, ARM64::B27, ARM64::B28, ARM64::B29,
 512   ARM64::B30, ARM64::B31
 513 };
 514
 515 static DecodeStatus DecodeFPR8RegisterClass(MCInst &Inst, unsigned RegNo,
 516                                             uint64_t Addr,
 517                                             const void *Decoder) {
 518   if (RegNo > 31)
 519     return Fail;
 520
 521   unsigned Register = FPR8DecoderTable[RegNo];
 522   Inst.addOperand(MCOperand::CreateReg(Register));
 523   return Success;
 524 }
 525
 526 static const unsigned GPR64DecoderTable[] = {
 527   ARM64::X0,  ARM64::X1,  ARM64::X2,  ARM64::X3,  ARM64::X4,  ARM64::X5,
 528   ARM64::X6,  ARM64::X7,  ARM64::X8,  ARM64::X9,  ARM64::X10, ARM64::X11,
 529   ARM64::X12, ARM64::X13, ARM64::X14, ARM64::X15, ARM64::X16, ARM64::X17,
 530   ARM64::X18, ARM64::X19, ARM64::X20, ARM64::X21, ARM64::X22, ARM64::X23,
 531   ARM64::X24, ARM64::X25, ARM64::X26, ARM64::X27, ARM64::X28, ARM64::FP,
 532   ARM64::LR,  ARM64::XZR
 533 };
 534
 535 static DecodeStatus DecodeGPR64RegisterClass(MCInst &Inst, unsigned RegNo,
 536                                              uint64_t Addr,
 537                                              const void *Decoder) {
 538   if (RegNo > 31)
 539     return Fail;
 540
 541   unsigned Register = GPR64DecoderTable[RegNo];
 542   Inst.addOperand(MCOperand::CreateReg(Register));
 543   return Success;
 544 }
 545
 546 static DecodeStatus DecodeGPR64spRegisterClass(MCInst &Inst, unsigned RegNo,
 547                                                uint64_t Addr,
 548                                                const void *Decoder) {
 549   if (RegNo > 31)
 550     return Fail;
 551   unsigned Register = GPR64DecoderTable[RegNo];
 552   if (Register == ARM64::XZR)
 553     Register = ARM64::SP;
 554   Inst.addOperand(MCOperand::CreateReg(Register));
 555   return Success;
 556 }
 557
 558 static const unsigned GPR32DecoderTable[] = {
 559   ARM64::W0,  ARM64::W1,  ARM64::W2,  ARM64::W3,  ARM64::W4,  ARM64::W5,
 560   ARM64::W6,  ARM64::W7,  ARM64::W8,  ARM64::W9,  ARM64::W10, ARM64::W11,
 561   ARM64::W12, ARM64::W13, ARM64::W14, ARM64::W15, ARM64::W16, ARM64::W17,
 562   ARM64::W18, ARM64::W19, ARM64::W20, ARM64::W21, ARM64::W22, ARM64::W23,
 563   ARM64::W24, ARM64::W25, ARM64::W26, ARM64::W27, ARM64::W28, ARM64::W29,
 564   ARM64::W30, ARM64::WZR
 565 };
 566
 567 static DecodeStatus DecodeGPR32RegisterClass(MCInst &Inst, unsigned RegNo,
 568                                              uint64_t Addr,
 569                                              const void *Decoder) {
 570   if (RegNo > 31)
 571     return Fail;
 572
 573   unsigned Register = GPR32DecoderTable[RegNo];
 574   Inst.addOperand(MCOperand::CreateReg(Register));
 575   return Success;
 576 }
 577
 578 static DecodeStatus DecodeGPR32spRegisterClass(MCInst &Inst, unsigned RegNo,
 579                                                uint64_t Addr,
 580                                                const void *Decoder) {
 581   if (RegNo > 31)
 582     return Fail;
 583
 584   unsigned Register = GPR32DecoderTable[RegNo];
 585   if (Register == ARM64::WZR)
 586     Register = ARM64::WSP;
 587   Inst.addOperand(MCOperand::CreateReg(Register));
 588   return Success;
 589 }
 590
 591 static const unsigned VectorDecoderTable[] = {
 592   ARM64::Q0,  ARM64::Q1,  ARM64::Q2,  ARM64::Q3,  ARM64::Q4,  ARM64::Q5,
 593   ARM64::Q6,  ARM64::Q7,  ARM64::Q8,  ARM64::Q9,  ARM64::Q10, ARM64::Q11,
 594   ARM64::Q12, ARM64::Q13, ARM64::Q14, ARM64::Q15, ARM64::Q16, ARM64::Q17,
 595   ARM64::Q18, ARM64::Q19, ARM64::Q20, ARM64::Q21, ARM64::Q22, ARM64::Q23,
 596   ARM64::Q24, ARM64::Q25, ARM64::Q26, ARM64::Q27, ARM64::Q28, ARM64::Q29,
 597   ARM64::Q30, ARM64::Q31
 598 };
 599
 600 static DecodeStatus DecodeVectorRegisterClass(MCInst &Inst, unsigned RegNo,
 601                                               uint64_t Addr,
 602                                               const void *Decoder) {
 603   if (RegNo > 31)
 604     return Fail;
 605
 606   unsigned Register = VectorDecoderTable[RegNo];
 607   Inst.addOperand(MCOperand::CreateReg(Register));
 608   return Success;
 609 }
 610
 611 static const unsigned QQDecoderTable[] = {
 612   ARM64::Q0_Q1,   ARM64::Q1_Q2,   ARM64::Q2_Q3,   ARM64::Q3_Q4,
 613   ARM64::Q4_Q5,   ARM64::Q5_Q6,   ARM64::Q6_Q7,   ARM64::Q7_Q8,
 614   ARM64::Q8_Q9,   ARM64::Q9_Q10,  ARM64::Q10_Q11, ARM64::Q11_Q12,
 615   ARM64::Q12_Q13, ARM64::Q13_Q14, ARM64::Q14_Q15, ARM64::Q15_Q16,
 616   ARM64::Q16_Q17, ARM64::Q17_Q18, ARM64::Q18_Q19, ARM64::Q19_Q20,
 617   ARM64::Q20_Q21, ARM64::Q21_Q22, ARM64::Q22_Q23, ARM64::Q23_Q24,
 618   ARM64::Q24_Q25, ARM64::Q25_Q26, ARM64::Q26_Q27, ARM64::Q27_Q28,
 619   ARM64::Q28_Q29, ARM64::Q29_Q30, ARM64::Q30_Q31, ARM64::Q31_Q0
 620 };
 621
 622 static DecodeStatus DecodeQQRegisterClass(MCInst &Inst, unsigned RegNo,
 623                                           uint64_t Addr, const void *Decoder) {
 624   if (RegNo > 31)
 625     return Fail;
 626   unsigned Register = QQDecoderTable[RegNo];
 627   Inst.addOperand(MCOperand::CreateReg(Register));
 628   return Success;
 629 }
 630
 631 static const unsigned QQQDecoderTable[] = {
 632   ARM64::Q0_Q1_Q2,    ARM64::Q1_Q2_Q3,    ARM64::Q2_Q3_Q4,
 633   ARM64::Q3_Q4_Q5,    ARM64::Q4_Q5_Q6,    ARM64::Q5_Q6_Q7,
 634   ARM64::Q6_Q7_Q8,    ARM64::Q7_Q8_Q9,    ARM64::Q8_Q9_Q10,
 635   ARM64::Q9_Q10_Q11,  ARM64::Q10_Q11_Q12, ARM64::Q11_Q12_Q13,
 636   ARM64::Q12_Q13_Q14, ARM64::Q13_Q14_Q15, ARM64::Q14_Q15_Q16,
 637   ARM64::Q15_Q16_Q17, ARM64::Q16_Q17_Q18, ARM64::Q17_Q18_Q19,
 638   ARM64::Q18_Q19_Q20, ARM64::Q19_Q20_Q21, ARM64::Q20_Q21_Q22,
 639   ARM64::Q21_Q22_Q23, ARM64::Q22_Q23_Q24, ARM64::Q23_Q24_Q25,
 640   ARM64::Q24_Q25_Q26, ARM64::Q25_Q26_Q27, ARM64::Q26_Q27_Q28,
 641   ARM64::Q27_Q28_Q29, ARM64::Q28_Q29_Q30, ARM64::Q29_Q30_Q31,
 642   ARM64::Q30_Q31_Q0,  ARM64::Q31_Q0_Q1
 643 };
 644
 645 static DecodeStatus DecodeQQQRegisterClass(MCInst &Inst, unsigned RegNo,
 646                                            uint64_t Addr, const void *Decoder) {
 647   if (RegNo > 31)
 648     return Fail;
 649   unsigned Register = QQQDecoderTable[RegNo];
 650   Inst.addOperand(MCOperand::CreateReg(Register));
 651   return Success;
 652 }
 653
 654 static const unsigned QQQQDecoderTable[] = {
 655   ARM64::Q0_Q1_Q2_Q3,     ARM64::Q1_Q2_Q3_Q4,     ARM64::Q2_Q3_Q4_Q5,
 656   ARM64::Q3_Q4_Q5_Q6,     ARM64::Q4_Q5_Q6_Q7,     ARM64::Q5_Q6_Q7_Q8,
 657   ARM64::Q6_Q7_Q8_Q9,     ARM64::Q7_Q8_Q9_Q10,    ARM64::Q8_Q9_Q10_Q11,
 658   ARM64::Q9_Q10_Q11_Q12,  ARM64::Q10_Q11_Q12_Q13, ARM64::Q11_Q12_Q13_Q14,
 659   ARM64::Q12_Q13_Q14_Q15, ARM64::Q13_Q14_Q15_Q16, ARM64::Q14_Q15_Q16_Q17,
 660   ARM64::Q15_Q16_Q17_Q18, ARM64::Q16_Q17_Q18_Q19, ARM64::Q17_Q18_Q19_Q20,
 661   ARM64::Q18_Q19_Q20_Q21, ARM64::Q19_Q20_Q21_Q22, ARM64::Q20_Q21_Q22_Q23,
 662   ARM64::Q21_Q22_Q23_Q24, ARM64::Q22_Q23_Q24_Q25, ARM64::Q23_Q24_Q25_Q26,
 663   ARM64::Q24_Q25_Q26_Q27, ARM64::Q25_Q26_Q27_Q28, ARM64::Q26_Q27_Q28_Q29,
 664   ARM64::Q27_Q28_Q29_Q30, ARM64::Q28_Q29_Q30_Q31, ARM64::Q29_Q30_Q31_Q0,
 665   ARM64::Q30_Q31_Q0_Q1,   ARM64::Q31_Q0_Q1_Q2
 666 };
 667
 668 static DecodeStatus DecodeQQQQRegisterClass(MCInst &Inst, unsigned RegNo,
 669                                             uint64_t Addr,
 670                                             const void *Decoder) {
 671   if (RegNo > 31)
 672     return Fail;
 673   unsigned Register = QQQQDecoderTable[RegNo];
 674   Inst.addOperand(MCOperand::CreateReg(Register));
 675   return Success;
 676 }
 677
 678 static const unsigned DDDecoderTable[] = {
 679   ARM64::D0_D1,   ARM64::D1_D2,   ARM64::D2_D3,   ARM64::D3_D4,
 680   ARM64::D4_D5,   ARM64::D5_D6,   ARM64::D6_D7,   ARM64::D7_D8,
 681   ARM64::D8_D9,   ARM64::D9_D10,  ARM64::D10_D11, ARM64::D11_D12,
 682   ARM64::D12_D13, ARM64::D13_D14, ARM64::D14_D15, ARM64::D15_D16,
 683   ARM64::D16_D17, ARM64::D17_D18, ARM64::D18_D19, ARM64::D19_D20,
 684   ARM64::D20_D21, ARM64::D21_D22, ARM64::D22_D23, ARM64::D23_D24,
 685   ARM64::D24_D25, ARM64::D25_D26, ARM64::D26_D27, ARM64::D27_D28,
 686   ARM64::D28_D29, ARM64::D29_D30, ARM64::D30_D31, ARM64::D31_D0
 687 };
 688
 689 static DecodeStatus DecodeDDRegisterClass(MCInst &Inst, unsigned RegNo,
 690                                           uint64_t Addr, const void *Decoder) {
 691   if (RegNo > 31)
 692     return Fail;
 693   unsigned Register = DDDecoderTable[RegNo];
 694   Inst.addOperand(MCOperand::CreateReg(Register));
 695   return Success;
 696 }
 697
 698 static const unsigned DDDDecoderTable[] = {
 699   ARM64::D0_D1_D2,    ARM64::D1_D2_D3,    ARM64::D2_D3_D4,
 700   ARM64::D3_D4_D5,    ARM64::D4_D5_D6,    ARM64::D5_D6_D7,
 701   ARM64::D6_D7_D8,    ARM64::D7_D8_D9,    ARM64::D8_D9_D10,
 702   ARM64::D9_D10_D11,  ARM64::D10_D11_D12, ARM64::D11_D12_D13,
 703   ARM64::D12_D13_D14, ARM64::D13_D14_D15, ARM64::D14_D15_D16,
 704   ARM64::D15_D16_D17, ARM64::D16_D17_D18, ARM64::D17_D18_D19,
 705   ARM64::D18_D19_D20, ARM64::D19_D20_D21, ARM64::D20_D21_D22,
 706   ARM64::D21_D22_D23, ARM64::D22_D23_D24, ARM64::D23_D24_D25,
 707   ARM64::D24_D25_D26, ARM64::D25_D26_D27, ARM64::D26_D27_D28,
 708   ARM64::D27_D28_D29, ARM64::D28_D29_D30, ARM64::D29_D30_D31,
 709   ARM64::D30_D31_D0,  ARM64::D31_D0_D1
 710 };
 711
 712 static DecodeStatus DecodeDDDRegisterClass(MCInst &Inst, unsigned RegNo,
 713                                            uint64_t Addr, const void *Decoder) {
 714   if (RegNo > 31)
 715     return Fail;
 716   unsigned Register = DDDDecoderTable[RegNo];
 717   Inst.addOperand(MCOperand::CreateReg(Register));
 718   return Success;
 719 }
 720
 721 static const unsigned DDDDDecoderTable[] = {
 722   ARM64::D0_D1_D2_D3,     ARM64::D1_D2_D3_D4,     ARM64::D2_D3_D4_D5,
 723   ARM64::D3_D4_D5_D6,     ARM64::D4_D5_D6_D7,     ARM64::D5_D6_D7_D8,
 724   ARM64::D6_D7_D8_D9,     ARM64::D7_D8_D9_D10,    ARM64::D8_D9_D10_D11,
 725   ARM64::D9_D10_D11_D12,  ARM64::D10_D11_D12_D13, ARM64::D11_D12_D13_D14,
 726   ARM64::D12_D13_D14_D15, ARM64::D13_D14_D15_D16, ARM64::D14_D15_D16_D17,
 727   ARM64::D15_D16_D17_D18, ARM64::D16_D17_D18_D19, ARM64::D17_D18_D19_D20,
 728   ARM64::D18_D19_D20_D21, ARM64::D19_D20_D21_D22, ARM64::D20_D21_D22_D23,
 729   ARM64::D21_D22_D23_D24, ARM64::D22_D23_D24_D25, ARM64::D23_D24_D25_D26,
 730   ARM64::D24_D25_D26_D27, ARM64::D25_D26_D27_D28, ARM64::D26_D27_D28_D29,
 731   ARM64::D27_D28_D29_D30, ARM64::D28_D29_D30_D31, ARM64::D29_D30_D31_D0,
 732   ARM64::D30_D31_D0_D1,   ARM64::D31_D0_D1_D2
 733 };
 734
 735 static DecodeStatus DecodeDDDDRegisterClass(MCInst &Inst, unsigned RegNo,
 736                                             uint64_t Addr,
 737                                             const void *Decoder) {
 738   if (RegNo > 31)
 739     return Fail;
 740   unsigned Register = DDDDDecoderTable[RegNo];
 741   Inst.addOperand(MCOperand::CreateReg(Register));
 742   return Success;
 743 }
 744
 745 static DecodeStatus DecodeFixedPointScaleImm(llvm::MCInst &Inst, unsigned Imm,
 746                                              uint64_t Addr,
 747                                              const void *Decoder) {
 748   Inst.addOperand(MCOperand::CreateImm(64 - Imm));
 749   return Success;
 750 }
 751
 752 static DecodeStatus DecodeCondBranchTarget(llvm::MCInst &Inst, unsigned Imm,
 753                                            uint64_t Addr, const void *Decoder) {
 754   int64_t ImmVal = Imm;
 755   const ARM64Disassembler *Dis =
 756       static_cast<const ARM64Disassembler *>(Decoder);
 757
 758   // Sign-extend 19-bit immediate.
 759   if (ImmVal & (1 << (19 - 1)))
 760     ImmVal |= ~((1LL << 19) - 1);
 761
 762   if (!Dis->tryAddingSymbolicOperand(Addr, ImmVal << 2,
 763                                      Inst.getOpcode() != ARM64::LDRXl, 4, Inst))
 764     Inst.addOperand(MCOperand::CreateImm(ImmVal));
 765   return Success;
 766 }
 767
 768 static DecodeStatus DecodeSystemRegister(llvm::MCInst &Inst, unsigned Imm,
 769                                          uint64_t Address,
 770                                          const void *Decoder) {
 771   Inst.addOperand(MCOperand::CreateImm(Imm | 0x8000));
 772   return Success;
 773 }
 774
 775 static DecodeStatus DecodeVecShiftRImm(llvm::MCInst &Inst, unsigned Imm,
 776                                        unsigned Add) {
 777   Inst.addOperand(MCOperand::CreateImm(Add - Imm));
 778   return Success;
 779 }
 780
 781 static DecodeStatus DecodeVecShiftLImm(llvm::MCInst &Inst, unsigned Imm,
 782                                        unsigned Add) {
 783   Inst.addOperand(MCOperand::CreateImm((Imm + Add) & (Add - 1)));
 784   return Success;
 785 }
 786
 787 static DecodeStatus DecodeVecShiftR64Imm(llvm::MCInst &Inst, unsigned Imm,
 788                                          uint64_t Addr, const void *Decoder) {
 789   return DecodeVecShiftRImm(Inst, Imm, 64);
 790 }
 791
 792 static DecodeStatus DecodeVecShiftR64ImmNarrow(llvm::MCInst &Inst, unsigned Imm,
 793                                                uint64_t Addr,
 794                                                const void *Decoder) {
 795   return DecodeVecShiftRImm(Inst, Imm | 0x20, 64);
 796 }
 797
 798 static DecodeStatus DecodeVecShiftR32Imm(llvm::MCInst &Inst, unsigned Imm,
 799                                          uint64_t Addr, const void *Decoder) {
 800   return DecodeVecShiftRImm(Inst, Imm, 32);
 801 }
 802
 803 static DecodeStatus DecodeVecShiftR32ImmNarrow(llvm::MCInst &Inst, unsigned Imm,
 804                                                uint64_t Addr,
 805                                                const void *Decoder) {
 806   return DecodeVecShiftRImm(Inst, Imm | 0x10, 32);
 807 }
 808
 809 static DecodeStatus DecodeVecShiftR16Imm(llvm::MCInst &Inst, unsigned Imm,
 810                                          uint64_t Addr, const void *Decoder) {
 811   return DecodeVecShiftRImm(Inst, Imm, 16);
 812 }
 813
 814 static DecodeStatus DecodeVecShiftR16ImmNarrow(llvm::MCInst &Inst, unsigned Imm,
 815                                                uint64_t Addr,
 816                                                const void *Decoder) {
 817   return DecodeVecShiftRImm(Inst, Imm | 0x8, 16);
 818 }
 819
 820 static DecodeStatus DecodeVecShiftR8Imm(llvm::MCInst &Inst, unsigned Imm,
 821                                         uint64_t Addr, const void *Decoder) {
 822   return DecodeVecShiftRImm(Inst, Imm, 8);
 823 }
 824
 825 static DecodeStatus DecodeVecShiftL64Imm(llvm::MCInst &Inst, unsigned Imm,
 826                                          uint64_t Addr, const void *Decoder) {
 827   return DecodeVecShiftLImm(Inst, Imm, 64);
 828 }
 829
 830 static DecodeStatus DecodeVecShiftL32Imm(llvm::MCInst &Inst, unsigned Imm,
 831                                          uint64_t Addr, const void *Decoder) {
 832   return DecodeVecShiftLImm(Inst, Imm, 32);
 833 }
 834
 835 static DecodeStatus DecodeVecShiftL16Imm(llvm::MCInst &Inst, unsigned Imm,
 836                                          uint64_t Addr, const void *Decoder) {
 837   return DecodeVecShiftLImm(Inst, Imm, 16);
 838 }
 839
 840 static DecodeStatus DecodeVecShiftL8Imm(llvm::MCInst &Inst, unsigned Imm,
 841                                         uint64_t Addr, const void *Decoder) {
 842   return DecodeVecShiftLImm(Inst, Imm, 8);
 843 }
 844
 845 static DecodeStatus DecodeThreeAddrSRegInstruction(llvm::MCInst &Inst,
 846                                                    uint32_t insn, uint64_t Addr,
 847                                                    const void *Decoder) {
 848   unsigned Rd = fieldFromInstruction(insn, 0, 5);
 849   unsigned Rn = fieldFromInstruction(insn, 5, 5);
 850   unsigned Rm = fieldFromInstruction(insn, 16, 5);
 851   unsigned shiftHi = fieldFromInstruction(insn, 22, 2);
 852   unsigned shiftLo = fieldFromInstruction(insn, 10, 6);
 853   unsigned shift = (shiftHi << 6) | shiftLo;
 854   switch (Inst.getOpcode()) {
 855   default:
 856     return Fail;
 857   case ARM64::ANDWrs:
 858   case ARM64::ANDSWrs:
 859   case ARM64::BICWrs:
 860   case ARM64::BICSWrs:
 861   case ARM64::ORRWrs:
 862   case ARM64::ORNWrs:
 863   case ARM64::EORWrs:
 864   case ARM64::EONWrs:
 865   case ARM64::ADDWrs:
 866   case ARM64::ADDSWrs:
 867   case ARM64::SUBWrs:
 868   case ARM64::SUBSWrs: {
 869     DecodeGPR32RegisterClass(Inst, Rd, Addr, Decoder);
 870     DecodeGPR32RegisterClass(Inst, Rn, Addr, Decoder);
 871     DecodeGPR32RegisterClass(Inst, Rm, Addr, Decoder);
 872     break;
 873   }
 874   case ARM64::ANDXrs:
 875   case ARM64::ANDSXrs:
 876   case ARM64::BICXrs:
 877   case ARM64::BICSXrs:
 878   case ARM64::ORRXrs:
 879   case ARM64::ORNXrs:
 880   case ARM64::EORXrs:
 881   case ARM64::EONXrs:
 882   case ARM64::ADDXrs:
 883   case ARM64::ADDSXrs:
 884   case ARM64::SUBXrs:
 885   case ARM64::SUBSXrs:
 886     DecodeGPR64RegisterClass(Inst, Rd, Addr, Decoder);
 887     DecodeGPR64RegisterClass(Inst, Rn, Addr, Decoder);
 888     DecodeGPR64RegisterClass(Inst, Rm, Addr, Decoder);
 889     break;
 890   }
 891
 892   Inst.addOperand(MCOperand::CreateImm(shift));
 893   return Success;
 894 }
 895
 896 static DecodeStatus DecodeMoveImmInstruction(llvm::MCInst &Inst, uint32_t insn,
 897                                              uint64_t Addr,
 898                                              const void *Decoder) {
 899   unsigned Rd = fieldFromInstruction(insn, 0, 5);
 900   unsigned imm = fieldFromInstruction(insn, 5, 16);
 901   unsigned shift = fieldFromInstruction(insn, 21, 2);
 902   shift <<= 4;
 903   switch (Inst.getOpcode()) {
 904   default:
 905     return Fail;
 906   case ARM64::MOVZWi:
 907   case ARM64::MOVNWi:
 908   case ARM64::MOVKWi:
 909     DecodeGPR32RegisterClass(Inst, Rd, Addr, Decoder);
 910     break;
 911   case ARM64::MOVZXi:
 912   case ARM64::MOVNXi:
 913   case ARM64::MOVKXi:
 914     DecodeGPR64RegisterClass(Inst, Rd, Addr, Decoder);
 915     break;
 916   }
 917
 918   if (Inst.getOpcode() == ARM64::MOVKWi || Inst.getOpcode() == ARM64::MOVKXi)
 919     Inst.addOperand(Inst.getOperand(0));
 920
 921   Inst.addOperand(MCOperand::CreateImm(imm));
 922   Inst.addOperand(MCOperand::CreateImm(shift));
 923   return Success;
 924 }
 925
 926 static DecodeStatus DecodeUnsignedLdStInstruction(llvm::MCInst &Inst,
 927                                                   uint32_t insn, uint64_t Addr,
 928                                                   const void *Decoder) {
 929   unsigned Rt = fieldFromInstruction(insn, 0, 5);
 930   unsigned Rn = fieldFromInstruction(insn, 5, 5);
 931   unsigned offset = fieldFromInstruction(insn, 10, 12);
 932   const ARM64Disassembler *Dis =
 933       static_cast<const ARM64Disassembler *>(Decoder);
 934
 935   switch (Inst.getOpcode()) {
 936   default:
 937     return Fail;
 938   case ARM64::PRFMui:
 939     // Rt is an immediate in prefetch.
 940     Inst.addOperand(MCOperand::CreateImm(Rt));
 941     break;
 942   case ARM64::STRBBui:
 943   case ARM64::LDRBBui:
 944   case ARM64::LDRSBWui:
 945   case ARM64::STRHHui:
 946   case ARM64::LDRHHui:
 947   case ARM64::LDRSHWui:
 948   case ARM64::STRWui:
 949   case ARM64::LDRWui:
 950     DecodeGPR32RegisterClass(Inst, Rt, Addr, Decoder);
 951     break;
 952   case ARM64::LDRSBXui:
 953   case ARM64::LDRSHXui:
 954   case ARM64::LDRSWui:
 955   case ARM64::STRXui:
 956   case ARM64::LDRXui:
 957     DecodeGPR64RegisterClass(Inst, Rt, Addr, Decoder);
 958     break;
 959   case ARM64::LDRQui:
 960   case ARM64::STRQui:
 961     DecodeFPR128RegisterClass(Inst, Rt, Addr, Decoder);
 962     break;
 963   case ARM64::LDRDui:
 964   case ARM64::STRDui:
 965     DecodeFPR64RegisterClass(Inst, Rt, Addr, Decoder);
 966     break;
 967   case ARM64::LDRSui:
 968   case ARM64::STRSui:
 969     DecodeFPR32RegisterClass(Inst, Rt, Addr, Decoder);
 970     break;
 971   case ARM64::LDRHui:
 972   case ARM64::STRHui:
 973     DecodeFPR16RegisterClass(Inst, Rt, Addr, Decoder);
 974     break;
 975   case ARM64::LDRBui:
 976   case ARM64::STRBui:
 977     DecodeFPR8RegisterClass(Inst, Rt, Addr, Decoder);
 978     break;
 979   }
 980
 981   DecodeGPR64spRegisterClass(Inst, Rn, Addr, Decoder);
 982   if (!Dis->tryAddingSymbolicOperand(Addr, offset, Fail, 4, Inst, insn))
 983     Inst.addOperand(MCOperand::CreateImm(offset));
 984   return Success;
 985 }
 986
 987 static DecodeStatus DecodeSignedLdStInstruction(llvm::MCInst &Inst,
 988                                                 uint32_t insn, uint64_t Addr,
 989                                                 const void *Decoder) {
 990   unsigned Rt = fieldFromInstruction(insn, 0, 5);
 991   unsigned Rn = fieldFromInstruction(insn, 5, 5);
 992   int64_t offset = fieldFromInstruction(insn, 12, 9);
 993
 994   // offset is a 9-bit signed immediate, so sign extend it to
 995   // fill the unsigned.
 996   if (offset & (1 << (9 - 1)))
 997     offset |= ~((1LL << 9) - 1);
 998
 999   switch (Inst.getOpcode()) {
1000   default:
1001     return Fail;
1002   case ARM64::PRFUMi:
1003     // Rt is an immediate in prefetch.
1004     Inst.addOperand(MCOperand::CreateImm(Rt));
1005     break;
1006   case ARM64::STURBBi:
1007   case ARM64::LDURBBi:
1008   case ARM64::LDURSBWi:
1009   case ARM64::STURHHi:
1010   case ARM64::LDURHHi:
1011   case ARM64::LDURSHWi:
1012   case ARM64::STURWi:
1013   case ARM64::LDURWi:
1014   case ARM64::LDTRSBWi:
1015   case ARM64::LDTRSHWi:
1016   case ARM64::STTRWi:
1017   case ARM64::LDTRWi:
1018   case ARM64::STTRHi:
1019   case ARM64::LDTRHi:
1020   case ARM64::LDTRBi:
1021   case ARM64::STTRBi:
1022   case ARM64::LDRSBWpre:
1023   case ARM64::LDRSHWpre:
1024   case ARM64::STRBBpre:
1025   case ARM64::LDRBBpre:
1026   case ARM64::STRHHpre:
1027   case ARM64::LDRHHpre:
1028   case ARM64::STRWpre:
1029   case ARM64::LDRWpre:
1030   case ARM64::LDRSBWpost:
1031   case ARM64::LDRSHWpost:
1032   case ARM64::STRBBpost:
1033   case ARM64::LDRBBpost:
1034   case ARM64::STRHHpost:
1035   case ARM64::LDRHHpost:
1036   case ARM64::STRWpost:
1037   case ARM64::LDRWpost:
1038     DecodeGPR32RegisterClass(Inst, Rt, Addr, Decoder);
1039     break;
1040   case ARM64::LDURSBXi:
1041   case ARM64::LDURSHXi:
1042   case ARM64::LDURSWi:
1043   case ARM64::STURXi:
1044   case ARM64::LDURXi:
1045   case ARM64::LDTRSBXi:
1046   case ARM64::LDTRSHXi:
1047   case ARM64::LDTRSWi:
1048   case ARM64::STTRXi:
1049   case ARM64::LDTRXi:
1050   case ARM64::LDRSBXpre:
1051   case ARM64::LDRSHXpre:
1052   case ARM64::STRXpre:
1053   case ARM64::LDRSWpre:
1054   case ARM64::LDRXpre:
1055   case ARM64::LDRSBXpost:
1056   case ARM64::LDRSHXpost:
1057   case ARM64::STRXpost:
1058   case ARM64::LDRSWpost:
1059   case ARM64::LDRXpost:
1060     DecodeGPR64RegisterClass(Inst, Rt, Addr, Decoder);
1061     break;
1062   case ARM64::LDURQi:
1063   case ARM64::STURQi:
1064   case ARM64::LDRQpre:
1065   case ARM64::STRQpre:
1066   case ARM64::LDRQpost:
1067   case ARM64::STRQpost:
1068     DecodeFPR128RegisterClass(Inst, Rt, Addr, Decoder);
1069     break;
1070   case ARM64::LDURDi:
1071   case ARM64::STURDi:
1072   case ARM64::LDRDpre:
1073   case ARM64::STRDpre:
1074   case ARM64::LDRDpost:
1075   case ARM64::STRDpost:
1076     DecodeFPR64RegisterClass(Inst, Rt, Addr, Decoder);
1077     break;
1078   case ARM64::LDURSi:
1079   case ARM64::STURSi:
1080   case ARM64::LDRSpre:
1081   case ARM64::STRSpre:
1082   case ARM64::LDRSpost:
1083   case ARM64::STRSpost:
1084     DecodeFPR32RegisterClass(Inst, Rt, Addr, Decoder);
1085     break;
1086   case ARM64::LDURHi:
1087   case ARM64::STURHi:
1088   case ARM64::LDRHpre:
1089   case ARM64::STRHpre:
1090   case ARM64::LDRHpost:
1091   case ARM64::STRHpost:
1092     DecodeFPR16RegisterClass(Inst, Rt, Addr, Decoder);
1093     break;
1094   case ARM64::LDURBi:
1095   case ARM64::STURBi:
1096   case ARM64::LDRBpre:
1097   case ARM64::STRBpre:
1098   case ARM64::LDRBpost:
1099   case ARM64::STRBpost:
1100     DecodeFPR8RegisterClass(Inst, Rt, Addr, Decoder);
1101     break;
1102   }
1103
1104   DecodeGPR64spRegisterClass(Inst, Rn, Addr, Decoder);
1105   Inst.addOperand(MCOperand::CreateImm(offset));
1106   return Success;
1107 }
1108
1109 static DecodeStatus DecodeExclusiveLdStInstruction(llvm::MCInst &Inst,
1110                                                    uint32_t insn, uint64_t Addr,
1111                                                    const void *Decoder) {
1112   unsigned Rt = fieldFromInstruction(insn, 0, 5);
1113   unsigned Rn = fieldFromInstruction(insn, 5, 5);
1114   unsigned Rt2 = fieldFromInstruction(insn, 10, 5);
1115   unsigned Rs = fieldFromInstruction(insn, 16, 5);
1116
1117   switch (Inst.getOpcode()) {
1118   default:
1119     return Fail;
1120   case ARM64::STLXRW:
1121   case ARM64::STLXRB:
1122   case ARM64::STLXRH:
1123   case ARM64::STXRW:
1124   case ARM64::STXRB:
1125   case ARM64::STXRH:
1126     DecodeGPR32RegisterClass(Inst, Rs, Addr, Decoder);
1127   // FALLTHROUGH
1128   case ARM64::LDARW:
1129   case ARM64::LDARB:
1130   case ARM64::LDARH:
1131   case ARM64::LDAXRW:
1132   case ARM64::LDAXRB:
1133   case ARM64::LDAXRH:
1134   case ARM64::LDXRW:
1135   case ARM64::LDXRB:
1136   case ARM64::LDXRH:
1137   case ARM64::STLRW:
1138   case ARM64::STLRB:
1139   case ARM64::STLRH:
1140     DecodeGPR32RegisterClass(Inst, Rt, Addr, Decoder);
1141     break;
1142   case ARM64::STLXRX:
1143   case ARM64::STXRX:
1144     DecodeGPR32RegisterClass(Inst, Rs, Addr, Decoder);
1145   // FALLTHROUGH
1146   case ARM64::LDARX:
1147   case ARM64::LDAXRX:
1148   case ARM64::LDXRX:
1149   case ARM64::STLRX:
1150     DecodeGPR64RegisterClass(Inst, Rt, Addr, Decoder);
1151     break;
1152   case ARM64::STLXPW:
1153   case ARM64::STXPW:
1154     DecodeGPR32RegisterClass(Inst, Rs, Addr, Decoder);
1155   // FALLTHROUGH
1156   case ARM64::LDAXPW:
1157   case ARM64::LDXPW:
1158     DecodeGPR32RegisterClass(Inst, Rt, Addr, Decoder);
1159     DecodeGPR32RegisterClass(Inst, Rt2, Addr, Decoder);
1160     break;
1161   case ARM64::STLXPX:
1162   case ARM64::STXPX:
1163     DecodeGPR32RegisterClass(Inst, Rs, Addr, Decoder);
1164   // FALLTHROUGH
1165   case ARM64::LDAXPX:
1166   case ARM64::LDXPX:
1167     DecodeGPR64RegisterClass(Inst, Rt, Addr, Decoder);
1168     DecodeGPR64RegisterClass(Inst, Rt2, Addr, Decoder);
1169     break;
1170   }
1171
1172   DecodeGPR64spRegisterClass(Inst, Rn, Addr, Decoder);
1173   return Success;
1174 }
1175
1176 static DecodeStatus DecodePairLdStInstruction(llvm::MCInst &Inst, uint32_t insn,
1177                                               uint64_t Addr,
1178                                               const void *Decoder) {
1179   unsigned Rt = fieldFromInstruction(insn, 0, 5);
1180   unsigned Rn = fieldFromInstruction(insn, 5, 5);
1181   unsigned Rt2 = fieldFromInstruction(insn, 10, 5);
1182   int64_t offset = fieldFromInstruction(insn, 15, 7);
1183
1184   // offset is a 7-bit signed immediate, so sign extend it to
1185   // fill the unsigned.
1186   if (offset & (1 << (7 - 1)))
1187     offset |= ~((1LL << 7) - 1);
1188
1189   switch (Inst.getOpcode()) {
1190   default:
1191     return Fail;
1192   case ARM64::LDNPXi:
1193   case ARM64::STNPXi:
1194   case ARM64::LDPXpost:
1195   case ARM64::STPXpost:
1196   case ARM64::LDPSWpost:
1197   case ARM64::LDPXi:
1198   case ARM64::STPXi:
1199   case ARM64::LDPSWi:
1200   case ARM64::LDPXpre:
1201   case ARM64::STPXpre:
1202   case ARM64::LDPSWpre:
1203     DecodeGPR64RegisterClass(Inst, Rt, Addr, Decoder);
1204     DecodeGPR64RegisterClass(Inst, Rt2, Addr, Decoder);
1205     break;
1206   case ARM64::LDNPWi:
1207   case ARM64::STNPWi:
1208   case ARM64::LDPWpost:
1209   case ARM64::STPWpost:
1210   case ARM64::LDPWi:
1211   case ARM64::STPWi:
1212   case ARM64::LDPWpre:
1213   case ARM64::STPWpre:
1214     DecodeGPR32RegisterClass(Inst, Rt, Addr, Decoder);
1215     DecodeGPR32RegisterClass(Inst, Rt2, Addr, Decoder);
1216     break;
1217   case ARM64::LDNPQi:
1218   case ARM64::STNPQi:
1219   case ARM64::LDPQpost:
1220   case ARM64::STPQpost:
1221   case ARM64::LDPQi:
1222   case ARM64::STPQi:
1223   case ARM64::LDPQpre:
1224   case ARM64::STPQpre:
1225     DecodeFPR128RegisterClass(Inst, Rt, Addr, Decoder);
1226     DecodeFPR128RegisterClass(Inst, Rt2, Addr, Decoder);
1227     break;
1228   case ARM64::LDNPDi:
1229   case ARM64::STNPDi:
1230   case ARM64::LDPDpost:
1231   case ARM64::STPDpost:
1232   case ARM64::LDPDi:
1233   case ARM64::STPDi:
1234   case ARM64::LDPDpre:
1235   case ARM64::STPDpre:
1236     DecodeFPR64RegisterClass(Inst, Rt, Addr, Decoder);
1237     DecodeFPR64RegisterClass(Inst, Rt2, Addr, Decoder);
1238     break;
1239   case ARM64::LDNPSi:
1240   case ARM64::STNPSi:
1241   case ARM64::LDPSpost:
1242   case ARM64::STPSpost:
1243   case ARM64::LDPSi:
1244   case ARM64::STPSi:
1245   case ARM64::LDPSpre:
1246   case ARM64::STPSpre:
1247     DecodeFPR32RegisterClass(Inst, Rt, Addr, Decoder);
1248     DecodeFPR32RegisterClass(Inst, Rt2, Addr, Decoder);
1249     break;
1250   }
1251
1252   DecodeGPR64spRegisterClass(Inst, Rn, Addr, Decoder);
1253   Inst.addOperand(MCOperand::CreateImm(offset));
1254   return Success;
1255 }
1256
1257 static DecodeStatus DecodeRegOffsetLdStInstruction(llvm::MCInst &Inst,
1258                                                    uint32_t insn, uint64_t Addr,
1259                                                    const void *Decoder) {
1260   unsigned Rt = fieldFromInstruction(insn, 0, 5);
1261   unsigned Rn = fieldFromInstruction(insn, 5, 5);
1262   unsigned Rm = fieldFromInstruction(insn, 16, 5);
1263   unsigned extendHi = fieldFromInstruction(insn, 13, 3);
1264   unsigned extendLo = fieldFromInstruction(insn, 12, 1);
1265   unsigned extend = 0;
1266
1267   switch (Inst.getOpcode()) {
1268   default:
1269     return Fail;
1270   case ARM64::LDRSWro:
1271     extend = (extendHi << 1) | extendLo;
1272     DecodeGPR64RegisterClass(Inst, Rt, Addr, Decoder);
1273     break;
1274   case ARM64::LDRXro:
1275   case ARM64::STRXro:
1276     extend = (extendHi << 1) | extendLo;
1277     DecodeGPR64RegisterClass(Inst, Rt, Addr, Decoder);
1278     break;
1279   case ARM64::LDRWro:
1280   case ARM64::STRWro:
1281     extend = (extendHi << 1) | extendLo;
1282     DecodeGPR32RegisterClass(Inst, Rt, Addr, Decoder);
1283     break;
1284   case ARM64::LDRQro:
1285   case ARM64::STRQro:
1286     extend = (extendHi << 1) | extendLo;
1287     DecodeFPR128RegisterClass(Inst, Rt, Addr, Decoder);
1288     break;
1289   case ARM64::LDRDro:
1290   case ARM64::STRDro:
1291     extend = (extendHi << 1) | extendLo;
1292     DecodeFPR64RegisterClass(Inst, Rt, Addr, Decoder);
1293     break;
1294   case ARM64::LDRSro:
1295   case ARM64::STRSro:
1296     extend = (extendHi << 1) | extendLo;
1297     DecodeFPR32RegisterClass(Inst, Rt, Addr, Decoder);
1298     break;
1299   case ARM64::LDRHro:
1300     extend = (extendHi << 1) | extendLo;
1301     DecodeFPR16RegisterClass(Inst, Rt, Addr, Decoder);
1302     break;
1303   case ARM64::LDRBro:
1304     extend = (extendHi << 1) | extendLo;
1305     DecodeFPR8RegisterClass(Inst, Rt, Addr, Decoder);
1306     break;
1307   case ARM64::LDRBBro:
1308   case ARM64::STRBBro:
1309   case ARM64::LDRSBWro:
1310     extend = (extendHi << 1) | extendLo;
1311     DecodeGPR32RegisterClass(Inst, Rt, Addr, Decoder);
1312     break;
1313   case ARM64::LDRHHro:
1314   case ARM64::STRHHro:
1315   case ARM64::LDRSHWro:
1316     extend = (extendHi << 1) | extendLo;
1317     DecodeGPR32RegisterClass(Inst, Rt, Addr, Decoder);
1318     break;
1319   case ARM64::LDRSHXro:
1320     extend = (extendHi << 1) | extendLo;
1321     DecodeGPR64RegisterClass(Inst, Rt, Addr, Decoder);
1322     break;
1323   case ARM64::LDRSBXro:
1324     extend = (extendHi << 1) | extendLo;
1325     DecodeGPR64RegisterClass(Inst, Rt, Addr, Decoder);
1326     break;
1327   case ARM64::PRFMro:
1328     extend = (extendHi << 1) | extendLo;
1329     Inst.addOperand(MCOperand::CreateImm(Rt));
1330   }
1331
1332   DecodeGPR64spRegisterClass(Inst, Rn, Addr, Decoder);
1333
1334   if (extendHi == 0x3)
1335     DecodeGPR64RegisterClass(Inst, Rm, Addr, Decoder);
1336   else
1337     DecodeGPR64RegisterClass(Inst, Rm, Addr, Decoder);
1338
1339   Inst.addOperand(MCOperand::CreateImm(extend));
1340   return Success;
1341 }
1342
1343 static DecodeStatus DecodeAddSubERegInstruction(llvm::MCInst &Inst,
1344                                                 uint32_t insn, uint64_t Addr,
1345                                                 const void *Decoder) {
1346   unsigned Rd = fieldFromInstruction(insn, 0, 5);
1347   unsigned Rn = fieldFromInstruction(insn, 5, 5);
1348   unsigned Rm = fieldFromInstruction(insn, 16, 5);
1349   unsigned extend = fieldFromInstruction(insn, 10, 6);
1350
1351   switch (Inst.getOpcode()) {
1352   default:
1353     return Fail;
1354   case ARM64::ADDWrx:
1355   case ARM64::SUBWrx:
1356     DecodeGPR32spRegisterClass(Inst, Rd, Addr, Decoder);
1357     DecodeGPR32spRegisterClass(Inst, Rn, Addr, Decoder);
1358     DecodeGPR32RegisterClass(Inst, Rm, Addr, Decoder);
1359     break;
1360   case ARM64::ADDSWrx:
1361   case ARM64::SUBSWrx:
1362     DecodeGPR32RegisterClass(Inst, Rd, Addr, Decoder);
1363     DecodeGPR32spRegisterClass(Inst, Rn, Addr, Decoder);
1364     DecodeGPR32RegisterClass(Inst, Rm, Addr, Decoder);
1365     break;
1366   case ARM64::ADDXrx:
1367   case ARM64::SUBXrx:
1368     DecodeGPR64spRegisterClass(Inst, Rd, Addr, Decoder);
1369     DecodeGPR64spRegisterClass(Inst, Rn, Addr, Decoder);
1370     DecodeGPR32RegisterClass(Inst, Rm, Addr, Decoder);
1371     break;
1372   case ARM64::ADDSXrx:
1373   case ARM64::SUBSXrx:
1374     DecodeGPR64RegisterClass(Inst, Rd, Addr, Decoder);
1375     DecodeGPR64spRegisterClass(Inst, Rn, Addr, Decoder);
1376     DecodeGPR32RegisterClass(Inst, Rm, Addr, Decoder);
1377     break;
1378   case ARM64::ADDXrx64:
1379   case ARM64::ADDSXrx64:
1380   case ARM64::SUBXrx64:
1381   case ARM64::SUBSXrx64:
1382     DecodeGPR64spRegisterClass(Inst, Rd, Addr, Decoder);
1383     DecodeGPR64spRegisterClass(Inst, Rn, Addr, Decoder);
1384     DecodeGPR64RegisterClass(Inst, Rm, Addr, Decoder);
1385     break;
1386   }
1387
1388   Inst.addOperand(MCOperand::CreateImm(extend));
1389   return Success;
1390 }
1391
1392 static DecodeStatus DecodeLogicalImmInstruction(llvm::MCInst &Inst,
1393                                                 uint32_t insn, uint64_t Addr,
1394                                                 const void *Decoder) {
1395   unsigned Rd = fieldFromInstruction(insn, 0, 5);
1396   unsigned Rn = fieldFromInstruction(insn, 5, 5);
1397   unsigned Datasize = fieldFromInstruction(insn, 31, 1);
1398   unsigned imm;
1399
1400   if (Datasize) {
1401     DecodeGPR64spRegisterClass(Inst, Rd, Addr, Decoder);
1402     DecodeGPR64RegisterClass(Inst, Rn, Addr, Decoder);
1403     imm = fieldFromInstruction(insn, 10, 13);
1404     if (!ARM64_AM::isValidDecodeLogicalImmediate(imm, 64))
1405       return Fail;
1406   } else {
1407     DecodeGPR32RegisterClass(Inst, Rd, Addr, Decoder);
1408     DecodeGPR32RegisterClass(Inst, Rn, Addr, Decoder);
1409     imm = fieldFromInstruction(insn, 10, 12);
1410     if (!ARM64_AM::isValidDecodeLogicalImmediate(imm, 32))
1411       return Fail;
1412   }
1413   Inst.addOperand(MCOperand::CreateImm(imm));
1414   return Success;
1415 }
1416
1417 static DecodeStatus DecodeModImmInstruction(llvm::MCInst &Inst, uint32_t insn,
1418                                             uint64_t Addr,
1419                                             const void *Decoder) {
1420   unsigned Rd = fieldFromInstruction(insn, 0, 5);
1421   unsigned cmode = fieldFromInstruction(insn, 12, 4);
1422   unsigned imm = fieldFromInstruction(insn, 16, 3) << 5;
1423   imm |= fieldFromInstruction(insn, 5, 5);
1424
1425   if (Inst.getOpcode() == ARM64::MOVID)
1426     DecodeFPR64RegisterClass(Inst, Rd, Addr, Decoder);
1427   else
1428     DecodeVectorRegisterClass(Inst, Rd, Addr, Decoder);
1429
1430   Inst.addOperand(MCOperand::CreateImm(imm));
1431
1432   switch (Inst.getOpcode()) {
1433   default:
1434     break;
1435   case ARM64::MOVIv4i16:
1436   case ARM64::MOVIv8i16:
1437   case ARM64::MVNIv4i16:
1438   case ARM64::MVNIv8i16:
1439   case ARM64::MOVIv2i32:
1440   case ARM64::MOVIv4i32:
1441   case ARM64::MVNIv2i32:
1442   case ARM64::MVNIv4i32:
1443     Inst.addOperand(MCOperand::CreateImm((cmode & 6) << 2));
1444     break;
1445   case ARM64::MOVIv2s_msl:
1446   case ARM64::MOVIv4s_msl:
1447   case ARM64::MVNIv2s_msl:
1448   case ARM64::MVNIv4s_msl:
1449     Inst.addOperand(MCOperand::CreateImm(cmode & 1 ? 0x110 : 0x108));
1450     break;
1451   }
1452
1453   return Success;
1454 }
1455
1456 static DecodeStatus DecodeModImmTiedInstruction(llvm::MCInst &Inst,
1457                                                 uint32_t insn, uint64_t Addr,
1458                                                 const void *Decoder) {
1459   unsigned Rd = fieldFromInstruction(insn, 0, 5);
1460   unsigned cmode = fieldFromInstruction(insn, 12, 4);
1461   unsigned imm = fieldFromInstruction(insn, 16, 3) << 5;
1462   imm |= fieldFromInstruction(insn, 5, 5);
1463
1464   // Tied operands added twice.
1465   DecodeVectorRegisterClass(Inst, Rd, Addr, Decoder);
1466   DecodeVectorRegisterClass(Inst, Rd, Addr, Decoder);
1467
1468   Inst.addOperand(MCOperand::CreateImm(imm));
1469   Inst.addOperand(MCOperand::CreateImm((cmode & 6) << 2));
1470
1471   return Success;
1472 }
1473
1474 static DecodeStatus DecodeAdrInstruction(llvm::MCInst &Inst, uint32_t insn,
1475                                          uint64_t Addr, const void *Decoder) {
1476   unsigned Rd = fieldFromInstruction(insn, 0, 5);
1477   int64_t imm = fieldFromInstruction(insn, 5, 19) << 2;
1478   imm |= fieldFromInstruction(insn, 29, 2);
1479   const ARM64Disassembler *Dis =
1480       static_cast<const ARM64Disassembler *>(Decoder);
1481
1482   // Sign-extend the 21-bit immediate.
1483   if (imm & (1 << (21 - 1)))
1484     imm |= ~((1LL << 21) - 1);
1485
1486   DecodeGPR64RegisterClass(Inst, Rd, Addr, Decoder);
1487   if (!Dis->tryAddingSymbolicOperand(Addr, imm, Fail, 4, Inst, insn))
1488     Inst.addOperand(MCOperand::CreateImm(imm));
1489
1490   return Success;
1491 }
1492
1493 static DecodeStatus DecodeBaseAddSubImm(llvm::MCInst &Inst, uint32_t insn,
1494                                         uint64_t Addr, const void *Decoder) {
1495   unsigned Rd = fieldFromInstruction(insn, 0, 5);
1496   unsigned Rn = fieldFromInstruction(insn, 5, 5);
1497   unsigned Imm = fieldFromInstruction(insn, 10, 14);
1498   unsigned S = fieldFromInstruction(insn, 29, 1);
1499   unsigned Datasize = fieldFromInstruction(insn, 31, 1);
1500
1501   unsigned ShifterVal = (Imm >> 12) & 3;
1502   unsigned ImmVal = Imm & 0xFFF;
1503   const ARM64Disassembler *Dis =
1504       static_cast<const ARM64Disassembler *>(Decoder);
1505
1506   if (ShifterVal != 0 && ShifterVal != 1)
1507     return Fail;
1508
1509   if (Datasize) {
1510     if (Rd == 31 && !S)
1511       DecodeGPR64spRegisterClass(Inst, Rd, Addr, Decoder);
1512     else
1513       DecodeGPR64RegisterClass(Inst, Rd, Addr, Decoder);
1514     DecodeGPR64spRegisterClass(Inst, Rn, Addr, Decoder);
1515   } else {
1516     if (Rd == 31 && !S)
1517       DecodeGPR32spRegisterClass(Inst, Rd, Addr, Decoder);
1518     else
1519       DecodeGPR32RegisterClass(Inst, Rd, Addr, Decoder);
1520     DecodeGPR32spRegisterClass(Inst, Rn, Addr, Decoder);
1521   }
1522
1523   if (!Dis->tryAddingSymbolicOperand(Addr, ImmVal, Fail, 4, Inst, insn))
1524     Inst.addOperand(MCOperand::CreateImm(ImmVal));
1525   Inst.addOperand(MCOperand::CreateImm(12 * ShifterVal));
1526   return Success;
1527 }
1528
1529 static DecodeStatus DecodeUnconditionalBranch(llvm::MCInst &Inst, uint32_t insn,
1530                                               uint64_t Addr,
1531                                               const void *Decoder) {
1532   int64_t imm = fieldFromInstruction(insn, 0, 26);
1533   const ARM64Disassembler *Dis =
1534       static_cast<const ARM64Disassembler *>(Decoder);
1535
1536   // Sign-extend the 26-bit immediate.
1537   if (imm & (1 << (26 - 1)))
1538     imm |= ~((1LL << 26) - 1);
1539
1540   if (!Dis->tryAddingSymbolicOperand(Addr, imm << 2, Success, 4, Inst))
1541     Inst.addOperand(MCOperand::CreateImm(imm));
1542
1543   return Success;
1544 }
1545
1546 static DecodeStatus DecodeSystemCPSRInstruction(llvm::MCInst &Inst,
1547                                                 uint32_t insn, uint64_t Addr,
1548                                                 const void *Decoder) {
1549   uint64_t op1 = fieldFromInstruction(insn, 16, 3);
1550   uint64_t op2 = fieldFromInstruction(insn, 5, 3);
1551   uint64_t crm = fieldFromInstruction(insn, 8, 4);
1552
1553   Inst.addOperand(MCOperand::CreateImm((op1 << 3) | op2));
1554   Inst.addOperand(MCOperand::CreateImm(crm));
1555
1556   return Success;
1557 }
1558
1559 static DecodeStatus DecodeTestAndBranch(llvm::MCInst &Inst, uint32_t insn,
1560                                         uint64_t Addr, const void *Decoder) {
1561   uint64_t Rt = fieldFromInstruction(insn, 0, 5);
1562   uint64_t bit = fieldFromInstruction(insn, 31, 1) << 5;
1563   bit |= fieldFromInstruction(insn, 19, 5);
1564   int64_t dst = fieldFromInstruction(insn, 5, 14);
1565   const ARM64Disassembler *Dis =
1566       static_cast<const ARM64Disassembler *>(Decoder);
1567
1568   // Sign-extend 14-bit immediate.
1569   if (dst & (1 << (14 - 1)))
1570     dst |= ~((1LL << 14) - 1);
1571
1572   DecodeGPR64RegisterClass(Inst, Rt, Addr, Decoder);
1573   Inst.addOperand(MCOperand::CreateImm(bit));
1574   if (!Dis->tryAddingSymbolicOperand(Addr, dst << 2, Success, 4, Inst))
1575     Inst.addOperand(MCOperand::CreateImm(dst));
1576
1577   return Success;
1578 }
1579
1580 static DecodeStatus DecodeSIMDLdStPost(llvm::MCInst &Inst, uint32_t insn,
1581                                        uint64_t Addr, const void *Decoder) {
1582   uint64_t Rd = fieldFromInstruction(insn, 0, 5);
1583   uint64_t Rn = fieldFromInstruction(insn, 5, 5);
1584   uint64_t Rm = fieldFromInstruction(insn, 16, 5);
1585
1586   switch (Inst.getOpcode()) {
1587   default:
1588     return Fail;
1589   case ARM64::ST1Onev8b_POST:
1590   case ARM64::ST1Onev4h_POST:
1591   case ARM64::ST1Onev2s_POST:
1592   case ARM64::ST1Onev1d_POST:
1593   case ARM64::LD1Onev8b_POST:
1594   case ARM64::LD1Onev4h_POST:
1595   case ARM64::LD1Onev2s_POST:
1596   case ARM64::LD1Onev1d_POST:
1597     DecodeFPR64RegisterClass(Inst, Rd, Addr, Decoder);
1598     break;
1599   case ARM64::ST1Onev16b_POST:
1600   case ARM64::ST1Onev8h_POST:
1601   case ARM64::ST1Onev4s_POST:
1602   case ARM64::ST1Onev2d_POST:
1603   case ARM64::LD1Onev16b_POST:
1604   case ARM64::LD1Onev8h_POST:
1605   case ARM64::LD1Onev4s_POST:
1606   case ARM64::LD1Onev2d_POST:
1607     DecodeFPR128RegisterClass(Inst, Rd, Addr, Decoder);
1608     break;
1609   case ARM64::ST1Twov8b_POST:
1610   case ARM64::ST1Twov4h_POST:
1611   case ARM64::ST1Twov2s_POST:
1612   case ARM64::ST1Twov1d_POST:
1613   case ARM64::ST2Twov8b_POST:
1614   case ARM64::ST2Twov4h_POST:
1615   case ARM64::ST2Twov2s_POST:
1616   case ARM64::LD1Twov8b_POST:
1617   case ARM64::LD1Twov4h_POST:
1618   case ARM64::LD1Twov2s_POST:
1619   case ARM64::LD1Twov1d_POST:
1620   case ARM64::LD2Twov8b_POST:
1621   case ARM64::LD2Twov4h_POST:
1622   case ARM64::LD2Twov2s_POST:
1623     DecodeDDRegisterClass(Inst, Rd, Addr, Decoder);
1624     break;
1625   case ARM64::ST1Threev8b_POST:
1626   case ARM64::ST1Threev4h_POST:
1627   case ARM64::ST1Threev2s_POST:
1628   case ARM64::ST1Threev1d_POST:
1629   case ARM64::ST3Threev8b_POST:
1630   case ARM64::ST3Threev4h_POST:
1631   case ARM64::ST3Threev2s_POST:
1632   case ARM64::LD1Threev8b_POST:
1633   case ARM64::LD1Threev4h_POST:
1634   case ARM64::LD1Threev2s_POST:
1635   case ARM64::LD1Threev1d_POST:
1636   case ARM64::LD3Threev8b_POST:
1637   case ARM64::LD3Threev4h_POST:
1638   case ARM64::LD3Threev2s_POST:
1639     DecodeDDDRegisterClass(Inst, Rd, Addr, Decoder);
1640     break;
1641   case ARM64::ST1Fourv8b_POST:
1642   case ARM64::ST1Fourv4h_POST:
1643   case ARM64::ST1Fourv2s_POST:
1644   case ARM64::ST1Fourv1d_POST:
1645   case ARM64::ST4Fourv8b_POST:
1646   case ARM64::ST4Fourv4h_POST:
1647   case ARM64::ST4Fourv2s_POST:
1648   case ARM64::LD1Fourv8b_POST:
1649   case ARM64::LD1Fourv4h_POST:
1650   case ARM64::LD1Fourv2s_POST:
1651   case ARM64::LD1Fourv1d_POST:
1652   case ARM64::LD4Fourv8b_POST:
1653   case ARM64::LD4Fourv4h_POST:
1654   case ARM64::LD4Fourv2s_POST:
1655     DecodeDDDDRegisterClass(Inst, Rd, Addr, Decoder);
1656     break;
1657   case ARM64::ST1Twov16b_POST:
1658   case ARM64::ST1Twov8h_POST:
1659   case ARM64::ST1Twov4s_POST:
1660   case ARM64::ST1Twov2d_POST:
1661   case ARM64::ST2Twov16b_POST:
1662   case ARM64::ST2Twov8h_POST:
1663   case ARM64::ST2Twov4s_POST:
1664   case ARM64::ST2Twov2d_POST:
1665   case ARM64::LD1Twov16b_POST:
1666   case ARM64::LD1Twov8h_POST:
1667   case ARM64::LD1Twov4s_POST:
1668   case ARM64::LD1Twov2d_POST:
1669   case ARM64::LD2Twov16b_POST:
1670   case ARM64::LD2Twov8h_POST:
1671   case ARM64::LD2Twov4s_POST:
1672   case ARM64::LD2Twov2d_POST:
1673     DecodeQQRegisterClass(Inst, Rd, Addr, Decoder);
1674     break;
1675   case ARM64::ST1Threev16b_POST:
1676   case ARM64::ST1Threev8h_POST:
1677   case ARM64::ST1Threev4s_POST:
1678   case ARM64::ST1Threev2d_POST:
1679   case ARM64::ST3Threev16b_POST:
1680   case ARM64::ST3Threev8h_POST:
1681   case ARM64::ST3Threev4s_POST:
1682   case ARM64::ST3Threev2d_POST:
1683   case ARM64::LD1Threev16b_POST:
1684   case ARM64::LD1Threev8h_POST:
1685   case ARM64::LD1Threev4s_POST:
1686   case ARM64::LD1Threev2d_POST:
1687   case ARM64::LD3Threev16b_POST:
1688   case ARM64::LD3Threev8h_POST:
1689   case ARM64::LD3Threev4s_POST:
1690   case ARM64::LD3Threev2d_POST:
1691     DecodeQQQRegisterClass(Inst, Rd, Addr, Decoder);
1692     break;
1693   case ARM64::ST1Fourv16b_POST:
1694   case ARM64::ST1Fourv8h_POST:
1695   case ARM64::ST1Fourv4s_POST:
1696   case ARM64::ST1Fourv2d_POST:
1697   case ARM64::ST4Fourv16b_POST:
1698   case ARM64::ST4Fourv8h_POST:
1699   case ARM64::ST4Fourv4s_POST:
1700   case ARM64::ST4Fourv2d_POST:
1701   case ARM64::LD1Fourv16b_POST:
1702   case ARM64::LD1Fourv8h_POST:
1703   case ARM64::LD1Fourv4s_POST:
1704   case ARM64::LD1Fourv2d_POST:
1705   case ARM64::LD4Fourv16b_POST:
1706   case ARM64::LD4Fourv8h_POST:
1707   case ARM64::LD4Fourv4s_POST:
1708   case ARM64::LD4Fourv2d_POST:
1709     DecodeQQQQRegisterClass(Inst, Rd, Addr, Decoder);
1710     break;
1711   }
1712
1713   DecodeGPR64spRegisterClass(Inst, Rn, Addr, Decoder);
1714   DecodeGPR64RegisterClass(Inst, Rm, Addr, Decoder);
1715   return Success;
1716 }
1717
1718 static DecodeStatus DecodeSIMDLdStSingle(llvm::MCInst &Inst, uint32_t insn,
1719                                          uint64_t Addr, const void *Decoder) {
1720   uint64_t Rt = fieldFromInstruction(insn, 0, 5);
1721   uint64_t Rn = fieldFromInstruction(insn, 5, 5);
1722   uint64_t Rm = fieldFromInstruction(insn, 16, 5);
1723   uint64_t size = fieldFromInstruction(insn, 10, 2);
1724   uint64_t S = fieldFromInstruction(insn, 12, 1);
1725   uint64_t Q = fieldFromInstruction(insn, 30, 1);
1726   uint64_t index = 0;
1727
1728   switch (Inst.getOpcode()) {
1729   case ARM64::ST1i8:
1730   case ARM64::ST1i8_POST:
1731   case ARM64::ST2i8:
1732   case ARM64::ST2i8_POST:
1733   case ARM64::ST3i8_POST:
1734   case ARM64::ST3i8:
1735   case ARM64::ST4i8_POST:
1736   case ARM64::ST4i8:
1737     index = (Q << 3) | (S << 2) | size;
1738     break;
1739   case ARM64::ST1i16:
1740   case ARM64::ST1i16_POST:
1741   case ARM64::ST2i16:
1742   case ARM64::ST2i16_POST:
1743   case ARM64::ST3i16_POST:
1744   case ARM64::ST3i16:
1745   case ARM64::ST4i16_POST:
1746   case ARM64::ST4i16:
1747     index = (Q << 2) | (S << 1) | (size >> 1);
1748     break;
1749   case ARM64::ST1i32:
1750   case ARM64::ST1i32_POST:
1751   case ARM64::ST2i32:
1752   case ARM64::ST2i32_POST:
1753   case ARM64::ST3i32_POST:
1754   case ARM64::ST3i32:
1755   case ARM64::ST4i32_POST:
1756   case ARM64::ST4i32:
1757     index = (Q << 1) | S;
1758     break;
1759   case ARM64::ST1i64:
1760   case ARM64::ST1i64_POST:
1761   case ARM64::ST2i64:
1762   case ARM64::ST2i64_POST:
1763   case ARM64::ST3i64_POST:
1764   case ARM64::ST3i64:
1765   case ARM64::ST4i64_POST:
1766   case ARM64::ST4i64:
1767     index = Q;
1768     break;
1769   }
1770
1771   switch (Inst.getOpcode()) {
1772   default:
1773     return Fail;
1774   case ARM64::LD1Rv8b:
1775   case ARM64::LD1Rv8b_POST:
1776   case ARM64::LD1Rv4h:
1777   case ARM64::LD1Rv4h_POST:
1778   case ARM64::LD1Rv2s:
1779   case ARM64::LD1Rv2s_POST:
1780   case ARM64::LD1Rv1d:
1781   case ARM64::LD1Rv1d_POST:
1782     DecodeFPR64RegisterClass(Inst, Rt, Addr, Decoder);
1783     break;
1784   case ARM64::LD1Rv16b:
1785   case ARM64::LD1Rv16b_POST:
1786   case ARM64::LD1Rv8h:
1787   case ARM64::LD1Rv8h_POST:
1788   case ARM64::LD1Rv4s:
1789   case ARM64::LD1Rv4s_POST:
1790   case ARM64::LD1Rv2d:
1791   case ARM64::LD1Rv2d_POST:
1792   case ARM64::ST1i8:
1793   case ARM64::ST1i8_POST:
1794   case ARM64::ST1i16:
1795   case ARM64::ST1i16_POST:
1796   case ARM64::ST1i32:
1797   case ARM64::ST1i32_POST:
1798   case ARM64::ST1i64:
1799   case ARM64::ST1i64_POST:
1800     DecodeFPR128RegisterClass(Inst, Rt, Addr, Decoder);
1801     break;
1802   case ARM64::LD2Rv16b:
1803   case ARM64::LD2Rv16b_POST:
1804   case ARM64::LD2Rv8h:
1805   case ARM64::LD2Rv8h_POST:
1806   case ARM64::LD2Rv4s:
1807   case ARM64::LD2Rv4s_POST:
1808   case ARM64::LD2Rv2d:
1809   case ARM64::LD2Rv2d_POST:
1810   case ARM64::ST2i8:
1811   case ARM64::ST2i8_POST:
1812   case ARM64::ST2i16:
1813   case ARM64::ST2i16_POST:
1814   case ARM64::ST2i32:
1815   case ARM64::ST2i32_POST:
1816   case ARM64::ST2i64:
1817   case ARM64::ST2i64_POST:
1818     DecodeQQRegisterClass(Inst, Rt, Addr, Decoder);
1819     break;
1820   case ARM64::LD2Rv8b:
1821   case ARM64::LD2Rv8b_POST:
1822   case ARM64::LD2Rv4h:
1823   case ARM64::LD2Rv4h_POST:
1824   case ARM64::LD2Rv2s:
1825   case ARM64::LD2Rv2s_POST:
1826   case ARM64::LD2Rv1d:
1827   case ARM64::LD2Rv1d_POST:
1828     DecodeDDRegisterClass(Inst, Rt, Addr, Decoder);
1829     break;
1830   case ARM64::LD3Rv8b:
1831   case ARM64::LD3Rv8b_POST:
1832   case ARM64::LD3Rv4h:
1833   case ARM64::LD3Rv4h_POST:
1834   case ARM64::LD3Rv2s:
1835   case ARM64::LD3Rv2s_POST:
1836   case ARM64::LD3Rv1d:
1837   case ARM64::LD3Rv1d_POST:
1838     DecodeDDDRegisterClass(Inst, Rt, Addr, Decoder);
1839     break;
1840   case ARM64::LD3Rv16b:
1841   case ARM64::LD3Rv16b_POST:
1842   case ARM64::LD3Rv8h:
1843   case ARM64::LD3Rv8h_POST:
1844   case ARM64::LD3Rv4s:
1845   case ARM64::LD3Rv4s_POST:
1846   case ARM64::LD3Rv2d:
1847   case ARM64::LD3Rv2d_POST:
1848   case ARM64::ST3i8:
1849   case ARM64::ST3i8_POST:
1850   case ARM64::ST3i16:
1851   case ARM64::ST3i16_POST:
1852   case ARM64::ST3i32:
1853   case ARM64::ST3i32_POST:
1854   case ARM64::ST3i64:
1855   case ARM64::ST3i64_POST:
1856     DecodeQQQRegisterClass(Inst, Rt, Addr, Decoder);
1857     break;
1858   case ARM64::LD4Rv8b:
1859   case ARM64::LD4Rv8b_POST:
1860   case ARM64::LD4Rv4h:
1861   case ARM64::LD4Rv4h_POST:
1862   case ARM64::LD4Rv2s:
1863   case ARM64::LD4Rv2s_POST:
1864   case ARM64::LD4Rv1d:
1865   case ARM64::LD4Rv1d_POST:
1866     DecodeDDDDRegisterClass(Inst, Rt, Addr, Decoder);
1867     break;
1868   case ARM64::LD4Rv16b:
1869   case ARM64::LD4Rv16b_POST:
1870   case ARM64::LD4Rv8h:
1871   case ARM64::LD4Rv8h_POST:
1872   case ARM64::LD4Rv4s:
1873   case ARM64::LD4Rv4s_POST:
1874   case ARM64::LD4Rv2d:
1875   case ARM64::LD4Rv2d_POST:
1876   case ARM64::ST4i8:
1877   case ARM64::ST4i8_POST:
1878   case ARM64::ST4i16:
1879   case ARM64::ST4i16_POST:
1880   case ARM64::ST4i32:
1881   case ARM64::ST4i32_POST:
1882   case ARM64::ST4i64:
1883   case ARM64::ST4i64_POST:
1884     DecodeQQQQRegisterClass(Inst, Rt, Addr, Decoder);
1885     break;
1886   }
1887
1888   switch (Inst.getOpcode()) {
1889   case ARM64::LD1Rv8b:
1890   case ARM64::LD1Rv8b_POST:
1891   case ARM64::LD1Rv16b:
1892   case ARM64::LD1Rv16b_POST:
1893   case ARM64::LD1Rv4h:
1894   case ARM64::LD1Rv4h_POST:
1895   case ARM64::LD1Rv8h:
1896   case ARM64::LD1Rv8h_POST:
1897   case ARM64::LD1Rv4s:
1898   case ARM64::LD1Rv4s_POST:
1899   case ARM64::LD1Rv2s:
1900   case ARM64::LD1Rv2s_POST:
1901   case ARM64::LD1Rv1d:
1902   case ARM64::LD1Rv1d_POST:
1903   case ARM64::LD1Rv2d:
1904   case ARM64::LD1Rv2d_POST:
1905   case ARM64::LD2Rv8b:
1906   case ARM64::LD2Rv8b_POST:
1907   case ARM64::LD2Rv16b:
1908   case ARM64::LD2Rv16b_POST:
1909   case ARM64::LD2Rv4h:
1910   case ARM64::LD2Rv4h_POST:
1911   case ARM64::LD2Rv8h:
1912   case ARM64::LD2Rv8h_POST:
1913   case ARM64::LD2Rv2s:
1914   case ARM64::LD2Rv2s_POST:
1915   case ARM64::LD2Rv4s:
1916   case ARM64::LD2Rv4s_POST:
1917   case ARM64::LD2Rv2d:
1918   case ARM64::LD2Rv2d_POST:
1919   case ARM64::LD2Rv1d:
1920   case ARM64::LD2Rv1d_POST:
1921   case ARM64::LD3Rv8b:
1922   case ARM64::LD3Rv8b_POST:
1923   case ARM64::LD3Rv16b:
1924   case ARM64::LD3Rv16b_POST:
1925   case ARM64::LD3Rv4h:
1926   case ARM64::LD3Rv4h_POST:
1927   case ARM64::LD3Rv8h:
1928   case ARM64::LD3Rv8h_POST:
1929   case ARM64::LD3Rv2s:
1930   case ARM64::LD3Rv2s_POST:
1931   case ARM64::LD3Rv4s:
1932   case ARM64::LD3Rv4s_POST:
1933   case ARM64::LD3Rv2d:
1934   case ARM64::LD3Rv2d_POST:
1935   case ARM64::LD3Rv1d:
1936   case ARM64::LD3Rv1d_POST:
1937   case ARM64::LD4Rv8b:
1938   case ARM64::LD4Rv8b_POST:
1939   case ARM64::LD4Rv16b:
1940   case ARM64::LD4Rv16b_POST:
1941   case ARM64::LD4Rv4h:
1942   case ARM64::LD4Rv4h_POST:
1943   case ARM64::LD4Rv8h:
1944   case ARM64::LD4Rv8h_POST:
1945   case ARM64::LD4Rv2s:
1946   case ARM64::LD4Rv2s_POST:
1947   case ARM64::LD4Rv4s:
1948   case ARM64::LD4Rv4s_POST:
1949   case ARM64::LD4Rv2d:
1950   case ARM64::LD4Rv2d_POST:
1951   case ARM64::LD4Rv1d:
1952   case ARM64::LD4Rv1d_POST:
1953     break;
1954   default:
1955     Inst.addOperand(MCOperand::CreateImm(index));
1956   }
1957
1958   DecodeGPR64RegisterClass(Inst, Rn, Addr, Decoder);
1959
1960   switch (Inst.getOpcode()) {
1961   case ARM64::ST1i8_POST:
1962   case ARM64::ST1i16_POST:
1963   case ARM64::ST1i32_POST:
1964   case ARM64::ST1i64_POST:
1965   case ARM64::LD1Rv8b_POST:
1966   case ARM64::LD1Rv16b_POST:
1967   case ARM64::LD1Rv4h_POST:
1968   case ARM64::LD1Rv8h_POST:
1969   case ARM64::LD1Rv2s_POST:
1970   case ARM64::LD1Rv4s_POST:
1971   case ARM64::LD1Rv1d_POST:
1972   case ARM64::LD1Rv2d_POST:
1973   case ARM64::ST2i8_POST:
1974   case ARM64::ST2i16_POST:
1975   case ARM64::ST2i32_POST:
1976   case ARM64::ST2i64_POST:
1977   case ARM64::LD2Rv8b_POST:
1978   case ARM64::LD2Rv16b_POST:
1979   case ARM64::LD2Rv4h_POST:
1980   case ARM64::LD2Rv8h_POST:
1981   case ARM64::LD2Rv2s_POST:
1982   case ARM64::LD2Rv4s_POST:
1983   case ARM64::LD2Rv2d_POST:
1984   case ARM64::LD2Rv1d_POST:
1985   case ARM64::ST3i8_POST:
1986   case ARM64::ST3i16_POST:
1987   case ARM64::ST3i32_POST:
1988   case ARM64::ST3i64_POST:
1989   case ARM64::LD3Rv8b_POST:
1990   case ARM64::LD3Rv16b_POST:
1991   case ARM64::LD3Rv4h_POST:
1992   case ARM64::LD3Rv8h_POST:
1993   case ARM64::LD3Rv2s_POST:
1994   case ARM64::LD3Rv4s_POST:
1995   case ARM64::LD3Rv2d_POST:
1996   case ARM64::LD3Rv1d_POST:
1997   case ARM64::ST4i8_POST:
1998   case ARM64::ST4i16_POST:
1999   case ARM64::ST4i32_POST:
2000   case ARM64::ST4i64_POST:
2001   case ARM64::LD4Rv8b_POST:
2002   case ARM64::LD4Rv16b_POST:
2003   case ARM64::LD4Rv4h_POST:
2004   case ARM64::LD4Rv8h_POST:
2005   case ARM64::LD4Rv2s_POST:
2006   case ARM64::LD4Rv4s_POST:
2007   case ARM64::LD4Rv2d_POST:
2008   case ARM64::LD4Rv1d_POST:
2009     DecodeGPR64RegisterClass(Inst, Rm, Addr, Decoder);
2010     break;
2011   }
2012   return Success;
2013 }
2014
2015 static DecodeStatus DecodeSIMDLdStSingleTied(llvm::MCInst &Inst, uint32_t insn,
2016                                              uint64_t Addr,
2017                                              const void *Decoder) {
2018   uint64_t Rt = fieldFromInstruction(insn, 0, 5);
2019   uint64_t Rn = fieldFromInstruction(insn, 5, 5);
2020   uint64_t Rm = fieldFromInstruction(insn, 16, 5);
2021   uint64_t size = fieldFromInstruction(insn, 10, 2);
2022   uint64_t S = fieldFromInstruction(insn, 12, 1);
2023   uint64_t Q = fieldFromInstruction(insn, 30, 1);
2024   uint64_t index = 0;
2025
2026   switch (Inst.getOpcode()) {
2027   case ARM64::LD1i8:
2028   case ARM64::LD1i8_POST:
2029   case ARM64::LD2i8:
2030   case ARM64::LD2i8_POST:
2031   case ARM64::LD3i8_POST:
2032   case ARM64::LD3i8:
2033   case ARM64::LD4i8_POST:
2034   case ARM64::LD4i8:
2035     index = (Q << 3) | (S << 2) | size;
2036     break;
2037   case ARM64::LD1i16:
2038   case ARM64::LD1i16_POST:
2039   case ARM64::LD2i16:
2040   case ARM64::LD2i16_POST:
2041   case ARM64::LD3i16_POST:
2042   case ARM64::LD3i16:
2043   case ARM64::LD4i16_POST:
2044   case ARM64::LD4i16:
2045     index = (Q << 2) | (S << 1) | (size >> 1);
2046     break;
2047   case ARM64::LD1i32:
2048   case ARM64::LD1i32_POST:
2049   case ARM64::LD2i32:
2050   case ARM64::LD2i32_POST:
2051   case ARM64::LD3i32_POST:
2052   case ARM64::LD3i32:
2053   case ARM64::LD4i32_POST:
2054   case ARM64::LD4i32:
2055     index = (Q << 1) | S;
2056     break;
2057   case ARM64::LD1i64:
2058   case ARM64::LD1i64_POST:
2059   case ARM64::LD2i64:
2060   case ARM64::LD2i64_POST:
2061   case ARM64::LD3i64_POST:
2062   case ARM64::LD3i64:
2063   case ARM64::LD4i64_POST:
2064   case ARM64::LD4i64:
2065     index = Q;
2066     break;
2067   }
2068
2069   switch (Inst.getOpcode()) {
2070   default:
2071     return Fail;
2072   case ARM64::LD1i8:
2073   case ARM64::LD1i8_POST:
2074   case ARM64::LD1i16:
2075   case ARM64::LD1i16_POST:
2076   case ARM64::LD1i32:
2077   case ARM64::LD1i32_POST:
2078   case ARM64::LD1i64:
2079   case ARM64::LD1i64_POST:
2080     DecodeFPR128RegisterClass(Inst, Rt, Addr, Decoder);
2081     DecodeFPR128RegisterClass(Inst, Rt, Addr, Decoder);
2082     break;
2083   case ARM64::LD2i8:
2084   case ARM64::LD2i8_POST:
2085   case ARM64::LD2i16:
2086   case ARM64::LD2i16_POST:
2087   case ARM64::LD2i32:
2088   case ARM64::LD2i32_POST:
2089   case ARM64::LD2i64:
2090   case ARM64::LD2i64_POST:
2091     DecodeQQRegisterClass(Inst, Rt, Addr, Decoder);
2092     DecodeQQRegisterClass(Inst, Rt, Addr, Decoder);
2093     break;
2094   case ARM64::LD3i8:
2095   case ARM64::LD3i8_POST:
2096   case ARM64::LD3i16:
2097   case ARM64::LD3i16_POST:
2098   case ARM64::LD3i32:
2099   case ARM64::LD3i32_POST:
2100   case ARM64::LD3i64:
2101   case ARM64::LD3i64_POST:
2102     DecodeQQQRegisterClass(Inst, Rt, Addr, Decoder);
2103     DecodeQQQRegisterClass(Inst, Rt, Addr, Decoder);
2104     break;
2105   case ARM64::LD4i8:
2106   case ARM64::LD4i8_POST:
2107   case ARM64::LD4i16:
2108   case ARM64::LD4i16_POST:
2109   case ARM64::LD4i32:
2110   case ARM64::LD4i32_POST:
2111   case ARM64::LD4i64:
2112   case ARM64::LD4i64_POST:
2113     DecodeQQQQRegisterClass(Inst, Rt, Addr, Decoder);
2114     DecodeQQQQRegisterClass(Inst, Rt, Addr, Decoder);
2115     break;
2116   }
2117
2118   Inst.addOperand(MCOperand::CreateImm(index));
2119   DecodeGPR64RegisterClass(Inst, Rn, Addr, Decoder);
2120
2121   switch (Inst.getOpcode()) {
2122   case ARM64::LD1i8_POST:
2123   case ARM64::LD1i16_POST:
2124   case ARM64::LD1i32_POST:
2125   case ARM64::LD1i64_POST:
2126   case ARM64::LD2i8_POST:
2127   case ARM64::LD2i16_POST:
2128   case ARM64::LD2i32_POST:
2129   case ARM64::LD2i64_POST:
2130   case ARM64::LD3i8_POST:
2131   case ARM64::LD3i16_POST:
2132   case ARM64::LD3i32_POST:
2133   case ARM64::LD3i64_POST:
2134   case ARM64::LD4i8_POST:
2135   case ARM64::LD4i16_POST:
2136   case ARM64::LD4i32_POST:
2137   case ARM64::LD4i64_POST:
2138     DecodeGPR64RegisterClass(Inst, Rm, Addr, Decoder);
2139     break;
2140   }
2141   return Success;
2142 }