lib/Target/ARM/Disassembler/ARMDisassemblerCore.cpp

   1 //===- ARMDisassemblerCore.cpp - ARM disassembler helpers -------*- 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 // This file is part of the ARM Disassembler.
  11 // It contains code to represent the core concepts of Builder and DisassembleFP
  12 // to solve the problem of disassembling an ARM instr.
  13 //
  14 //===----------------------------------------------------------------------===//
  15
  16 #define DEBUG_TYPE "arm-disassembler"
  17
  18 #include "ARMDisassemblerCore.h"
  19 #include "ARMAddressingModes.h"
  20 #include "llvm/Support/Debug.h"
  21 #include "llvm/Support/raw_ostream.h"
  22
  23 /// ARMGenInstrInfo.inc - ARMGenInstrInfo.inc contains the static const
  24 /// TargetInstrDesc ARMInsts[] definition and the TargetOperandInfo[]'s
  25 /// describing the operand info for each ARMInsts[i].
  26 ///
  27 /// Together with an instruction's encoding format, we can take advantage of the
  28 /// NumOperands and the OpInfo fields of the target instruction description in
  29 /// the quest to build out the MCOperand list for an MCInst.
  30 ///
  31 /// The general guideline is that with a known format, the number of dst and src
  32 /// operands are well-known.  The dst is built first, followed by the src
  33 /// operand(s).  The operands not yet used at this point are for the Implicit
  34 /// Uses and Defs by this instr.  For the Uses part, the pred:$p operand is
  35 /// defined with two components:
  36 ///
  37 /// def pred { // Operand PredicateOperand
  38 ///   ValueType Type = OtherVT;
  39 ///   string PrintMethod = "printPredicateOperand";
  40 ///   string AsmOperandLowerMethod = ?;
  41 ///   dag MIOperandInfo = (ops i32imm, CCR);
  42 ///   AsmOperandClass ParserMatchClass = ImmAsmOperand;
  43 ///   dag DefaultOps = (ops (i32 14), (i32 zero_reg));
  44 /// }
  45 ///
  46 /// which is manifested by the TargetOperandInfo[] of:
  47 ///
  48 /// { 0, 0|(1<<TOI::Predicate), 0 },
  49 /// { ARM::CCRRegClassID, 0|(1<<TOI::Predicate), 0 }
  50 ///
  51 /// So the first predicate MCOperand corresponds to the immediate part of the
  52 /// ARM condition field (Inst{31-28}), and the second predicate MCOperand
  53 /// corresponds to a register kind of ARM::CPSR.
  54 ///
  55 /// For the Defs part, in the simple case of only cc_out:$s, we have:
  56 ///
  57 /// def cc_out { // Operand OptionalDefOperand
  58 ///   ValueType Type = OtherVT;
  59 ///   string PrintMethod = "printSBitModifierOperand";
  60 ///   string AsmOperandLowerMethod = ?;
  61 ///   dag MIOperandInfo = (ops CCR);
  62 ///   AsmOperandClass ParserMatchClass = ImmAsmOperand;
  63 ///   dag DefaultOps = (ops (i32 zero_reg));
  64 /// }
  65 ///
  66 /// which is manifested by the one TargetOperandInfo of:
  67 ///
  68 /// { ARM::CCRRegClassID, 0|(1<<TOI::OptionalDef), 0 }
  69 ///
  70 /// And this maps to one MCOperand with the regsiter kind of ARM::CPSR.
  71 #include "ARMGenInstrInfo.inc"
  72
  73 using namespace llvm;
  74
  75 const char *ARMUtils::OpcodeName(unsigned Opcode) {
  76   return ARMInsts[Opcode].Name;
  77 }
  78
  79 // Return the register enum Based on RegClass and the raw register number.
  80 // For DRegPair, see comments below.
  81 // FIXME: Auto-gened?
  82 static unsigned getRegisterEnum(BO B, unsigned RegClassID, unsigned RawRegister,
  83                                 bool DRegPair = false) {
  84
  85   if (DRegPair && RegClassID == ARM::QPRRegClassID) {
  86     // LLVM expects { Dd, Dd+1 } to form a super register; this is not specified
  87     // in the ARM Architecture Manual as far as I understand it (A8.6.307).
  88     // Therefore, we morph the RegClassID to be the sub register class and don't
  89     // subsequently transform the RawRegister encoding when calculating RegNum.
  90     //
  91     // See also ARMinstPrinter::printOperand() wrt "dregpair" modifier part
  92     // where this workaround is meant for.
  93     RegClassID = ARM::DPRRegClassID;
  94   }
  95
  96   // For this purpose, we can treat rGPR as if it were GPR.
  97   if (RegClassID == ARM::rGPRRegClassID) RegClassID = ARM::GPRRegClassID;
  98
  99   // See also decodeNEONRd(), decodeNEONRn(), decodeNEONRm().
 100   unsigned RegNum =
 101     RegClassID == ARM::QPRRegClassID ? RawRegister >> 1 : RawRegister;
 102
 103   switch (RegNum) {
 104   default:
 105     break;
 106   case 0:
 107     switch (RegClassID) {
 108     case ARM::GPRRegClassID: case ARM::tGPRRegClassID: return ARM::R0;
 109     case ARM::DPRRegClassID: case ARM::DPR_8RegClassID:
 110     case ARM::DPR_VFP2RegClassID:
 111       return ARM::D0;
 112     case ARM::QPRRegClassID: case ARM::QPR_8RegClassID:
 113     case ARM::QPR_VFP2RegClassID:
 114       return ARM::Q0;
 115     case ARM::SPRRegClassID: case ARM::SPR_8RegClassID: return ARM::S0;
 116     }
 117     break;
 118   case 1:
 119     switch (RegClassID) {
 120     case ARM::GPRRegClassID: case ARM::tGPRRegClassID: return ARM::R1;
 121     case ARM::DPRRegClassID: case ARM::DPR_8RegClassID:
 122     case ARM::DPR_VFP2RegClassID:
 123       return ARM::D1;
 124     case ARM::QPRRegClassID: case ARM::QPR_8RegClassID:
 125     case ARM::QPR_VFP2RegClassID:
 126       return ARM::Q1;
 127     case ARM::SPRRegClassID: case ARM::SPR_8RegClassID: return ARM::S1;
 128     }
 129     break;
 130   case 2:
 131     switch (RegClassID) {
 132     case ARM::GPRRegClassID: case ARM::tGPRRegClassID: return ARM::R2;
 133     case ARM::DPRRegClassID: case ARM::DPR_8RegClassID:
 134     case ARM::DPR_VFP2RegClassID:
 135       return ARM::D2;
 136     case ARM::QPRRegClassID: case ARM::QPR_8RegClassID:
 137     case ARM::QPR_VFP2RegClassID:
 138       return ARM::Q2;
 139     case ARM::SPRRegClassID: case ARM::SPR_8RegClassID: return ARM::S2;
 140     }
 141     break;
 142   case 3:
 143     switch (RegClassID) {
 144     case ARM::GPRRegClassID: case ARM::tGPRRegClassID: return ARM::R3;
 145     case ARM::DPRRegClassID: case ARM::DPR_8RegClassID:
 146     case ARM::DPR_VFP2RegClassID:
 147       return ARM::D3;
 148     case ARM::QPRRegClassID: case ARM::QPR_8RegClassID:
 149     case ARM::QPR_VFP2RegClassID:
 150       return ARM::Q3;
 151     case ARM::SPRRegClassID: case ARM::SPR_8RegClassID: return ARM::S3;
 152     }
 153     break;
 154   case 4:
 155     switch (RegClassID) {
 156     case ARM::GPRRegClassID: case ARM::tGPRRegClassID: return ARM::R4;
 157     case ARM::DPRRegClassID: case ARM::DPR_8RegClassID:
 158     case ARM::DPR_VFP2RegClassID:
 159       return ARM::D4;
 160     case ARM::QPRRegClassID: case ARM::QPR_VFP2RegClassID: return ARM::Q4;
 161     case ARM::SPRRegClassID: case ARM::SPR_8RegClassID: return ARM::S4;
 162     }
 163     break;
 164   case 5:
 165     switch (RegClassID) {
 166     case ARM::GPRRegClassID: case ARM::tGPRRegClassID: return ARM::R5;
 167     case ARM::DPRRegClassID: case ARM::DPR_8RegClassID:
 168     case ARM::DPR_VFP2RegClassID:
 169       return ARM::D5;
 170     case ARM::QPRRegClassID: case ARM::QPR_VFP2RegClassID: return ARM::Q5;
 171     case ARM::SPRRegClassID: case ARM::SPR_8RegClassID: return ARM::S5;
 172     }
 173     break;
 174   case 6:
 175     switch (RegClassID) {
 176     case ARM::GPRRegClassID: case ARM::tGPRRegClassID: return ARM::R6;
 177     case ARM::DPRRegClassID: case ARM::DPR_8RegClassID:
 178     case ARM::DPR_VFP2RegClassID:
 179       return ARM::D6;
 180     case ARM::QPRRegClassID: case ARM::QPR_VFP2RegClassID: return ARM::Q6;
 181     case ARM::SPRRegClassID: case ARM::SPR_8RegClassID: return ARM::S6;
 182     }
 183     break;
 184   case 7:
 185     switch (RegClassID) {
 186     case ARM::GPRRegClassID: case ARM::tGPRRegClassID: return ARM::R7;
 187     case ARM::DPRRegClassID: case ARM::DPR_8RegClassID:
 188     case ARM::DPR_VFP2RegClassID:
 189       return ARM::D7;
 190     case ARM::QPRRegClassID: case ARM::QPR_VFP2RegClassID: return ARM::Q7;
 191     case ARM::SPRRegClassID: case ARM::SPR_8RegClassID: return ARM::S7;
 192     }
 193     break;
 194   case 8:
 195     switch (RegClassID) {
 196     case ARM::GPRRegClassID: return ARM::R8;
 197     case ARM::DPRRegClassID: case ARM::DPR_VFP2RegClassID: return ARM::D8;
 198     case ARM::QPRRegClassID: return ARM::Q8;
 199     case ARM::SPRRegClassID: case ARM::SPR_8RegClassID: return ARM::S8;
 200     }
 201     break;
 202   case 9:
 203     switch (RegClassID) {
 204     case ARM::GPRRegClassID: return ARM::R9;
 205     case ARM::DPRRegClassID: case ARM::DPR_VFP2RegClassID: return ARM::D9;
 206     case ARM::QPRRegClassID: return ARM::Q9;
 207     case ARM::SPRRegClassID: case ARM::SPR_8RegClassID: return ARM::S9;
 208     }
 209     break;
 210   case 10:
 211     switch (RegClassID) {
 212     case ARM::GPRRegClassID: return ARM::R10;
 213     case ARM::DPRRegClassID: case ARM::DPR_VFP2RegClassID: return ARM::D10;
 214     case ARM::QPRRegClassID: return ARM::Q10;
 215     case ARM::SPRRegClassID: case ARM::SPR_8RegClassID: return ARM::S10;
 216     }
 217     break;
 218   case 11:
 219     switch (RegClassID) {
 220     case ARM::GPRRegClassID: return ARM::R11;
 221     case ARM::DPRRegClassID: case ARM::DPR_VFP2RegClassID: return ARM::D11;
 222     case ARM::QPRRegClassID: return ARM::Q11;
 223     case ARM::SPRRegClassID: case ARM::SPR_8RegClassID: return ARM::S11;
 224     }
 225     break;
 226   case 12:
 227     switch (RegClassID) {
 228     case ARM::GPRRegClassID: return ARM::R12;
 229     case ARM::DPRRegClassID: case ARM::DPR_VFP2RegClassID: return ARM::D12;
 230     case ARM::QPRRegClassID: return ARM::Q12;
 231     case ARM::SPRRegClassID: case ARM::SPR_8RegClassID: return ARM::S12;
 232     }
 233     break;
 234   case 13:
 235     switch (RegClassID) {
 236     case ARM::GPRRegClassID: return ARM::SP;
 237     case ARM::DPRRegClassID: case ARM::DPR_VFP2RegClassID: return ARM::D13;
 238     case ARM::QPRRegClassID: return ARM::Q13;
 239     case ARM::SPRRegClassID: case ARM::SPR_8RegClassID: return ARM::S13;
 240     }
 241     break;
 242   case 14:
 243     switch (RegClassID) {
 244     case ARM::GPRRegClassID: return ARM::LR;
 245     case ARM::DPRRegClassID: case ARM::DPR_VFP2RegClassID: return ARM::D14;
 246     case ARM::QPRRegClassID: return ARM::Q14;
 247     case ARM::SPRRegClassID: case ARM::SPR_8RegClassID: return ARM::S14;
 248     }
 249     break;
 250   case 15:
 251     switch (RegClassID) {
 252     case ARM::GPRRegClassID: return ARM::PC;
 253     case ARM::DPRRegClassID: case ARM::DPR_VFP2RegClassID: return ARM::D15;
 254     case ARM::QPRRegClassID: return ARM::Q15;
 255     case ARM::SPRRegClassID: case ARM::SPR_8RegClassID: return ARM::S15;
 256     }
 257     break;
 258   case 16:
 259     switch (RegClassID) {
 260     case ARM::DPRRegClassID: return ARM::D16;
 261     case ARM::SPRRegClassID: return ARM::S16;
 262     }
 263     break;
 264   case 17:
 265     switch (RegClassID) {
 266     case ARM::DPRRegClassID: return ARM::D17;
 267     case ARM::SPRRegClassID: return ARM::S17;
 268     }
 269     break;
 270   case 18:
 271     switch (RegClassID) {
 272     case ARM::DPRRegClassID: return ARM::D18;
 273     case ARM::SPRRegClassID: return ARM::S18;
 274     }
 275     break;
 276   case 19:
 277     switch (RegClassID) {
 278     case ARM::DPRRegClassID: return ARM::D19;
 279     case ARM::SPRRegClassID: return ARM::S19;
 280     }
 281     break;
 282   case 20:
 283     switch (RegClassID) {
 284     case ARM::DPRRegClassID: return ARM::D20;
 285     case ARM::SPRRegClassID: return ARM::S20;
 286     }
 287     break;
 288   case 21:
 289     switch (RegClassID) {
 290     case ARM::DPRRegClassID: return ARM::D21;
 291     case ARM::SPRRegClassID: return ARM::S21;
 292     }
 293     break;
 294   case 22:
 295     switch (RegClassID) {
 296     case ARM::DPRRegClassID: return ARM::D22;
 297     case ARM::SPRRegClassID: return ARM::S22;
 298     }
 299     break;
 300   case 23:
 301     switch (RegClassID) {
 302     case ARM::DPRRegClassID: return ARM::D23;
 303     case ARM::SPRRegClassID: return ARM::S23;
 304     }
 305     break;
 306   case 24:
 307     switch (RegClassID) {
 308     case ARM::DPRRegClassID: return ARM::D24;
 309     case ARM::SPRRegClassID: return ARM::S24;
 310     }
 311     break;
 312   case 25:
 313     switch (RegClassID) {
 314     case ARM::DPRRegClassID: return ARM::D25;
 315     case ARM::SPRRegClassID: return ARM::S25;
 316     }
 317     break;
 318   case 26:
 319     switch (RegClassID) {
 320     case ARM::DPRRegClassID: return ARM::D26;
 321     case ARM::SPRRegClassID: return ARM::S26;
 322     }
 323     break;
 324   case 27:
 325     switch (RegClassID) {
 326     case ARM::DPRRegClassID: return ARM::D27;
 327     case ARM::SPRRegClassID: return ARM::S27;
 328     }
 329     break;
 330   case 28:
 331     switch (RegClassID) {
 332     case ARM::DPRRegClassID: return ARM::D28;
 333     case ARM::SPRRegClassID: return ARM::S28;
 334     }
 335     break;
 336   case 29:
 337     switch (RegClassID) {
 338     case ARM::DPRRegClassID: return ARM::D29;
 339     case ARM::SPRRegClassID: return ARM::S29;
 340     }
 341     break;
 342   case 30:
 343     switch (RegClassID) {
 344     case ARM::DPRRegClassID: return ARM::D30;
 345     case ARM::SPRRegClassID: return ARM::S30;
 346     }
 347     break;
 348   case 31:
 349     switch (RegClassID) {
 350     case ARM::DPRRegClassID: return ARM::D31;
 351     case ARM::SPRRegClassID: return ARM::S31;
 352     }
 353     break;
 354   }
 355   DEBUG(errs() << "Invalid (RegClassID, RawRegister) combination\n");
 356   // Encoding error.  Mark the builder with error code != 0.
 357   B->SetErr(-1);
 358   return 0;
 359 }
 360
 361 ///////////////////////////////
 362 //                           //
 363 //     Utility Functions     //
 364 //                           //
 365 ///////////////////////////////
 366
 367 // Extract/Decode Rd: Inst{15-12}.
 368 static inline unsigned decodeRd(uint32_t insn) {
 369   return (insn >> ARMII::RegRdShift) & ARMII::GPRRegMask;
 370 }
 371
 372 // Extract/Decode Rn: Inst{19-16}.
 373 static inline unsigned decodeRn(uint32_t insn) {
 374   return (insn >> ARMII::RegRnShift) & ARMII::GPRRegMask;
 375 }
 376
 377 // Extract/Decode Rm: Inst{3-0}.
 378 static inline unsigned decodeRm(uint32_t insn) {
 379   return (insn & ARMII::GPRRegMask);
 380 }
 381
 382 // Extract/Decode Rs: Inst{11-8}.
 383 static inline unsigned decodeRs(uint32_t insn) {
 384   return (insn >> ARMII::RegRsShift) & ARMII::GPRRegMask;
 385 }
 386
 387 static inline unsigned getCondField(uint32_t insn) {
 388   return (insn >> ARMII::CondShift);
 389 }
 390
 391 static inline unsigned getIBit(uint32_t insn) {
 392   return (insn >> ARMII::I_BitShift) & 1;
 393 }
 394
 395 static inline unsigned getAM3IBit(uint32_t insn) {
 396   return (insn >> ARMII::AM3_I_BitShift) & 1;
 397 }
 398
 399 static inline unsigned getPBit(uint32_t insn) {
 400   return (insn >> ARMII::P_BitShift) & 1;
 401 }
 402
 403 static inline unsigned getUBit(uint32_t insn) {
 404   return (insn >> ARMII::U_BitShift) & 1;
 405 }
 406
 407 static inline unsigned getPUBits(uint32_t insn) {
 408   return (insn >> ARMII::U_BitShift) & 3;
 409 }
 410
 411 static inline unsigned getSBit(uint32_t insn) {
 412   return (insn >> ARMII::S_BitShift) & 1;
 413 }
 414
 415 static inline unsigned getWBit(uint32_t insn) {
 416   return (insn >> ARMII::W_BitShift) & 1;
 417 }
 418
 419 static inline unsigned getDBit(uint32_t insn) {
 420   return (insn >> ARMII::D_BitShift) & 1;
 421 }
 422
 423 static inline unsigned getNBit(uint32_t insn) {
 424   return (insn >> ARMII::N_BitShift) & 1;
 425 }
 426
 427 static inline unsigned getMBit(uint32_t insn) {
 428   return (insn >> ARMII::M_BitShift) & 1;
 429 }
 430
 431 // See A8.4 Shifts applied to a register.
 432 //     A8.4.2 Register controlled shifts.
 433 //
 434 // getShiftOpcForBits - getShiftOpcForBits translates from the ARM encoding bits
 435 // into llvm enums for shift opcode.  The API clients should pass in the value
 436 // encoded with two bits, so the assert stays to signal a wrong API usage.
 437 //
 438 // A8-12: DecodeRegShift()
 439 static inline ARM_AM::ShiftOpc getShiftOpcForBits(unsigned bits) {
 440   switch (bits) {
 441   default: assert(0 && "No such value"); return ARM_AM::no_shift;
 442   case 0:  return ARM_AM::lsl;
 443   case 1:  return ARM_AM::lsr;
 444   case 2:  return ARM_AM::asr;
 445   case 3:  return ARM_AM::ror;
 446   }
 447 }
 448
 449 // See A8.4 Shifts applied to a register.
 450 //     A8.4.1 Constant shifts.
 451 //
 452 // getImmShiftSE - getImmShiftSE translates from the raw ShiftOpc and raw Imm5
 453 // encodings into the intended ShiftOpc and shift amount.
 454 //
 455 // A8-11: DecodeImmShift()
 456 static inline void getImmShiftSE(ARM_AM::ShiftOpc &ShOp, unsigned &ShImm) {
 457   // If type == 0b11 and imm5 == 0, we have an rrx, instead.
 458   if (ShOp == ARM_AM::ror && ShImm == 0)
 459     ShOp = ARM_AM::rrx;
 460   // If (lsr or asr) and imm5 == 0, shift amount is 32.
 461   if ((ShOp == ARM_AM::lsr || ShOp == ARM_AM::asr) && ShImm == 0)
 462     ShImm = 32;
 463 }
 464
 465 // getAMSubModeForBits - getAMSubModeForBits translates from the ARM encoding
 466 // bits Inst{24-23} (P(24) and U(23)) into llvm enums for AMSubMode.  The API
 467 // clients should pass in the value encoded with two bits, so the assert stays
 468 // to signal a wrong API usage.
 469 static inline ARM_AM::AMSubMode getAMSubModeForBits(unsigned bits) {
 470   switch (bits) {
 471   default: assert(0 && "No such value"); return ARM_AM::bad_am_submode;
 472   case 1:  return ARM_AM::ia;   // P=0 U=1
 473   case 3:  return ARM_AM::ib;   // P=1 U=1
 474   case 0:  return ARM_AM::da;   // P=0 U=0
 475   case 2:  return ARM_AM::db;   // P=1 U=0
 476   }
 477 }
 478
 479 ////////////////////////////////////////////
 480 //                                        //
 481 //    Disassemble function definitions    //
 482 //                                        //
 483 ////////////////////////////////////////////
 484
 485 /// There is a separate Disassemble*Frm function entry for disassembly of an ARM
 486 /// instr into a list of MCOperands in the appropriate order, with possible dst,
 487 /// followed by possible src(s).
 488 ///
 489 /// The processing of the predicate, and the 'S' modifier bit, if MI modifies
 490 /// the CPSR, is factored into ARMBasicMCBuilder's method named
 491 /// TryPredicateAndSBitModifier.
 492
 493 static bool DisassemblePseudo(MCInst &MI, unsigned Opcode, uint32_t insn,
 494     unsigned short NumOps, unsigned &NumOpsAdded, BO) {
 495
 496   if (Opcode == ARM::Int_MemBarrierV7 || Opcode == ARM::Int_SyncBarrierV7)
 497     return true;
 498
 499   assert(0 && "Unexpected pseudo instruction!");
 500   return false;
 501 }
 502
 503 // Multiply Instructions.
 504 // MLA, MLS, SMLABB, SMLABT, SMLATB, SMLATT, SMLAWB, SMLAWT, SMMLA, SMMLS:
 505 //     Rd{19-16} Rn{3-0} Rm{11-8} Ra{15-12}
 506 //
 507 // MUL, SMMUL, SMULBB, SMULBT, SMULTB, SMULTT, SMULWB, SMULWT:
 508 //     Rd{19-16} Rn{3-0} Rm{11-8}
 509 //
 510 // SMLAL, SMULL, UMAAL, UMLAL, UMULL, SMLALBB, SMLALBT, SMLALTB, SMLALTT:
 511 //     RdLo{15-12} RdHi{19-16} Rn{3-0} Rm{11-8}
 512 //
 513 // The mapping of the multiply registers to the "regular" ARM registers, where
 514 // there are convenience decoder functions, is:
 515 //
 516 // Inst{15-12} => Rd
 517 // Inst{19-16} => Rn
 518 // Inst{3-0} => Rm
 519 // Inst{11-8} => Rs
 520 static bool DisassembleMulFrm(MCInst &MI, unsigned Opcode, uint32_t insn,
 521     unsigned short NumOps, unsigned &NumOpsAdded, BO B) {
 522
 523   const TargetInstrDesc &TID = ARMInsts[Opcode];
 524   unsigned short NumDefs = TID.getNumDefs();
 525   const TargetOperandInfo *OpInfo = TID.OpInfo;
 526   unsigned &OpIdx = NumOpsAdded;
 527
 528   OpIdx = 0;
 529
 530   assert(NumDefs > 0 && "NumDefs should be greater than 0 for MulFrm");
 531   assert(NumOps >= 3
 532          && OpInfo[0].RegClass == ARM::GPRRegClassID
 533          && OpInfo[1].RegClass == ARM::GPRRegClassID
 534          && OpInfo[2].RegClass == ARM::GPRRegClassID
 535          && "Expect three register operands");
 536
 537   // Instructions with two destination registers have RdLo{15-12} first.
 538   if (NumDefs == 2) {
 539     assert(NumOps >= 4 && OpInfo[3].RegClass == ARM::GPRRegClassID &&
 540            "Expect 4th register operand");
 541     MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::GPRRegClassID,
 542                                                        decodeRd(insn))));
 543     ++OpIdx;
 544   }
 545
 546   // The destination register: RdHi{19-16} or Rd{19-16}.
 547   MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::GPRRegClassID,
 548                                                      decodeRn(insn))));
 549
 550   // The two src regsiters: Rn{3-0}, then Rm{11-8}.
 551   MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::GPRRegClassID,
 552                                                      decodeRm(insn))));
 553   MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::GPRRegClassID,
 554                                                      decodeRs(insn))));
 555   OpIdx += 3;
 556
 557   // Many multiply instructions (e.g., MLA) have three src registers.
 558   // The third register operand is Ra{15-12}.
 559   if (OpIdx < NumOps && OpInfo[OpIdx].RegClass == ARM::GPRRegClassID) {
 560     MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::GPRRegClassID,
 561                                                        decodeRd(insn))));
 562     ++OpIdx;
 563   }
 564
 565   return true;
 566 }
 567
 568 // Helper routines for disassembly of coprocessor instructions.
 569
 570 static bool LdStCopOpcode(unsigned Opcode) {
 571   if ((Opcode >= ARM::LDC2L_OFFSET && Opcode <= ARM::LDC_PRE) ||
 572       (Opcode >= ARM::STC2L_OFFSET && Opcode <= ARM::STC_PRE))
 573     return true;
 574   return false;
 575 }
 576 static bool CoprocessorOpcode(unsigned Opcode) {
 577   if (LdStCopOpcode(Opcode))
 578     return true;
 579
 580   switch (Opcode) {
 581   default:
 582     return false;
 583   case ARM::CDP:  case ARM::CDP2:
 584   case ARM::MCR:  case ARM::MCR2:  case ARM::MRC:  case ARM::MRC2:
 585   case ARM::MCRR: case ARM::MCRR2: case ARM::MRRC: case ARM::MRRC2:
 586     return true;
 587   }
 588 }
 589 static inline unsigned GetCoprocessor(uint32_t insn) {
 590   return slice(insn, 11, 8);
 591 }
 592 static inline unsigned GetCopOpc1(uint32_t insn, bool CDP) {
 593   return CDP ? slice(insn, 23, 20) : slice(insn, 23, 21);
 594 }
 595 static inline unsigned GetCopOpc2(uint32_t insn) {
 596   return slice(insn, 7, 5);
 597 }
 598 static inline unsigned GetCopOpc(uint32_t insn) {
 599   return slice(insn, 7, 4);
 600 }
 601 // Most of the operands are in immediate forms, except Rd and Rn, which are ARM
 602 // core registers.
 603 //
 604 // CDP, CDP2:                cop opc1 CRd CRn CRm opc2
 605 //
 606 // MCR, MCR2, MRC, MRC2:     cop opc1 Rd CRn CRm opc2
 607 //
 608 // MCRR, MCRR2, MRRC, MRRc2: cop opc Rd Rn CRm
 609 //
 610 // LDC_OFFSET, LDC_PRE, LDC_POST: cop CRd Rn R0 [+/-]imm8:00
 611 // and friends
 612 // STC_OFFSET, STC_PRE, STC_POST: cop CRd Rn R0 [+/-]imm8:00
 613 // and friends
 614 //                                        <-- addrmode2 -->
 615 //
 616 // LDC_OPTION:                    cop CRd Rn imm8
 617 // and friends
 618 // STC_OPTION:                    cop CRd Rn imm8
 619 // and friends
 620 //
 621 static bool DisassembleCoprocessor(MCInst &MI, unsigned Opcode, uint32_t insn,
 622     unsigned short NumOps, unsigned &NumOpsAdded, BO B) {
 623
 624   assert(NumOps >= 5 && "Num of operands >= 5 for coprocessor instr");
 625
 626   unsigned &OpIdx = NumOpsAdded;
 627   bool OneCopOpc = (Opcode == ARM::MCRR || Opcode == ARM::MCRR2 ||
 628                     Opcode == ARM::MRRC || Opcode == ARM::MRRC2);
 629   // CDP/CDP2 has no GPR operand; the opc1 operand is also wider (Inst{23-20}).
 630   bool NoGPR = (Opcode == ARM::CDP || Opcode == ARM::CDP2);
 631   bool LdStCop = LdStCopOpcode(Opcode);
 632
 633   OpIdx = 0;
 634
 635   MI.addOperand(MCOperand::CreateImm(GetCoprocessor(insn)));
 636
 637   if (LdStCop) {
 638     // Unindex if P:W = 0b00 --> _OPTION variant
 639     unsigned PW = getPBit(insn) << 1 | getWBit(insn);
 640
 641     MI.addOperand(MCOperand::CreateImm(decodeRd(insn)));
 642
 643     MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::GPRRegClassID,
 644                                                        decodeRn(insn))));
 645
 646     if (PW) {
 647       MI.addOperand(MCOperand::CreateReg(0));
 648       ARM_AM::AddrOpc AddrOpcode = getUBit(insn) ? ARM_AM::add : ARM_AM::sub;
 649       unsigned Offset = ARM_AM::getAM2Opc(AddrOpcode, slice(insn, 7, 0) << 2,
 650                                           ARM_AM::no_shift);
 651       MI.addOperand(MCOperand::CreateImm(Offset));
 652       OpIdx = 5;
 653     } else {
 654       MI.addOperand(MCOperand::CreateImm(slice(insn, 7, 0)));
 655       OpIdx = 4;
 656     }
 657   } else {
 658     MI.addOperand(MCOperand::CreateImm(OneCopOpc ? GetCopOpc(insn)
 659                                                  : GetCopOpc1(insn, NoGPR)));
 660
 661     MI.addOperand(NoGPR ? MCOperand::CreateImm(decodeRd(insn))
 662                         : MCOperand::CreateReg(
 663                             getRegisterEnum(B, ARM::GPRRegClassID,
 664                                             decodeRd(insn))));
 665
 666     MI.addOperand(OneCopOpc ? MCOperand::CreateReg(
 667                                 getRegisterEnum(B, ARM::GPRRegClassID,
 668                                                 decodeRn(insn)))
 669                             : MCOperand::CreateImm(decodeRn(insn)));
 670
 671     MI.addOperand(MCOperand::CreateImm(decodeRm(insn)));
 672
 673     OpIdx = 5;
 674
 675     if (!OneCopOpc) {
 676       MI.addOperand(MCOperand::CreateImm(GetCopOpc2(insn)));
 677       ++OpIdx;
 678     }
 679   }
 680
 681   return true;
 682 }
 683
 684 // Branch Instructions.
 685 // BLr9: SignExtend(Imm24:'00', 32)
 686 // Bcc, BLr9_pred: SignExtend(Imm24:'00', 32) Pred0 Pred1
 687 // SMC: ZeroExtend(imm4, 32)
 688 // SVC: ZeroExtend(Imm24, 32)
 689 //
 690 // Various coprocessor instructions are assigned BrFrm arbitrarily.
 691 // Delegates to DisassembleCoprocessor() helper function.
 692 //
 693 // MRS/MRSsys: Rd
 694 // MSR/MSRsys: Rm mask=Inst{19-16}
 695 // BXJ:        Rm
 696 // MSRi/MSRsysi: so_imm
 697 // SRSW/SRS: addrmode4:$addr mode_imm
 698 // RFEW/RFE: addrmode4:$addr Rn
 699 static bool DisassembleBrFrm(MCInst &MI, unsigned Opcode, uint32_t insn,
 700     unsigned short NumOps, unsigned &NumOpsAdded, BO B) {
 701
 702   if (CoprocessorOpcode(Opcode))
 703     return DisassembleCoprocessor(MI, Opcode, insn, NumOps, NumOpsAdded, B);
 704
 705   const TargetOperandInfo *OpInfo = ARMInsts[Opcode].OpInfo;
 706   if (!OpInfo) return false;
 707
 708   // MRS and MRSsys take one GPR reg Rd.
 709   if (Opcode == ARM::MRS || Opcode == ARM::MRSsys) {
 710     assert(NumOps >= 1 && OpInfo[0].RegClass == ARM::GPRRegClassID &&
 711            "Reg operand expected");
 712     MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::GPRRegClassID,
 713                                                        decodeRd(insn))));
 714     NumOpsAdded = 1;
 715     return true;
 716   }
 717   // BXJ takes one GPR reg Rm.
 718   if (Opcode == ARM::BXJ) {
 719     assert(NumOps >= 1 && OpInfo[0].RegClass == ARM::GPRRegClassID &&
 720            "Reg operand expected");
 721     MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::GPRRegClassID,
 722                                                        decodeRm(insn))));
 723     NumOpsAdded = 1;
 724     return true;
 725   }
 726   // MSR and MSRsys take one GPR reg Rm, followed by the mask.
 727   if (Opcode == ARM::MSR || Opcode == ARM::MSRsys) {
 728     assert(NumOps >= 1 && OpInfo[0].RegClass == ARM::GPRRegClassID &&
 729            "Reg operand expected");
 730     MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::GPRRegClassID,
 731                                                        decodeRm(insn))));
 732     MI.addOperand(MCOperand::CreateImm(slice(insn, 19, 16)));
 733     NumOpsAdded = 2;
 734     return true;
 735   }
 736   // MSRi and MSRsysi take one so_imm operand, followed by the mask.
 737   if (Opcode == ARM::MSRi || Opcode == ARM::MSRsysi) {
 738     // SOImm is 4-bit rotate amount in bits 11-8 with 8-bit imm in bits 7-0.
 739     // A5.2.4 Rotate amount is twice the numeric value of Inst{11-8}.
 740     // See also ARMAddressingModes.h: getSOImmValImm() and getSOImmValRot().
 741     unsigned Rot = (insn >> ARMII::SoRotImmShift) & 0xF;
 742     unsigned Imm = insn & 0xFF;
 743     MI.addOperand(MCOperand::CreateImm(ARM_AM::rotr32(Imm, 2*Rot)));
 744     MI.addOperand(MCOperand::CreateImm(slice(insn, 19, 16)));
 745     NumOpsAdded = 2;
 746     return true;
 747   }
 748   // SRSW and SRS requires addrmode4:$addr for ${addr:submode}, followed by the
 749   // mode immediate (Inst{4-0}).
 750   if (Opcode == ARM::SRSW || Opcode == ARM::SRS ||
 751       Opcode == ARM::RFEW || Opcode == ARM::RFE) {
 752     // ARMInstPrinter::printAddrMode4Operand() prints special mode string
 753     // if the base register is SP; so don't set ARM::SP.
 754     MI.addOperand(MCOperand::CreateReg(0));
 755     ARM_AM::AMSubMode SubMode = getAMSubModeForBits(getPUBits(insn));
 756     MI.addOperand(MCOperand::CreateImm(ARM_AM::getAM4ModeImm(SubMode)));
 757
 758     if (Opcode == ARM::SRSW || Opcode == ARM::SRS)
 759       MI.addOperand(MCOperand::CreateImm(slice(insn, 4, 0)));
 760     else
 761       MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::GPRRegClassID,
 762                                                          decodeRn(insn))));
 763     NumOpsAdded = 3;
 764     return true;
 765   }
 766
 767   assert((Opcode == ARM::Bcc || Opcode == ARM::BLr9 || Opcode == ARM::BLr9_pred
 768           || Opcode == ARM::SMC || Opcode == ARM::SVC) &&
 769          "Unexpected Opcode");
 770
 771   assert(NumOps >= 1 && OpInfo[0].RegClass < 0 && "Reg operand expected");
 772
 773   int Imm32 = 0;
 774   if (Opcode == ARM::SMC) {
 775     // ZeroExtend(imm4, 32) where imm24 = Inst{3-0}.
 776     Imm32 = slice(insn, 3, 0);
 777   } else if (Opcode == ARM::SVC) {
 778     // ZeroExtend(imm24, 32) where imm24 = Inst{23-0}.
 779     Imm32 = slice(insn, 23, 0);
 780   } else {
 781     // SignExtend(imm24:'00', 32) where imm24 = Inst{23-0}.
 782     unsigned Imm26 = slice(insn, 23, 0) << 2;
 783     //Imm32 = signextend<signed int, 26>(Imm26);
 784     Imm32 = SignExtend32<26>(Imm26);
 785
 786     // When executing an ARM instruction, PC reads as the address of the current
 787     // instruction plus 8.  The assembler subtracts 8 from the difference
 788     // between the branch instruction and the target address, disassembler has
 789     // to add 8 to compensate.
 790     Imm32 += 8;
 791   }
 792
 793   MI.addOperand(MCOperand::CreateImm(Imm32));
 794   NumOpsAdded = 1;
 795
 796   return true;
 797 }
 798
 799 // Misc. Branch Instructions.
 800 // BR_JTadd, BR_JTr, BR_JTm
 801 // BLXr9, BXr9
 802 // BRIND, BX_RET
 803 static bool DisassembleBrMiscFrm(MCInst &MI, unsigned Opcode, uint32_t insn,
 804     unsigned short NumOps, unsigned &NumOpsAdded, BO B) {
 805
 806   const TargetOperandInfo *OpInfo = ARMInsts[Opcode].OpInfo;
 807   if (!OpInfo) return false;
 808
 809   unsigned &OpIdx = NumOpsAdded;
 810
 811   OpIdx = 0;
 812
 813   // BX_RET has only two predicate operands, do an early return.
 814   if (Opcode == ARM::BX_RET)
 815     return true;
 816
 817   // BLXr9 and BRIND take one GPR reg.
 818   if (Opcode == ARM::BLXr9 || Opcode == ARM::BRIND) {
 819     assert(NumOps >= 1 && OpInfo[OpIdx].RegClass == ARM::GPRRegClassID &&
 820            "Reg operand expected");
 821     MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::GPRRegClassID,
 822                                                        decodeRm(insn))));
 823     OpIdx = 1;
 824     return true;
 825   }
 826
 827   // BR_JTadd is an ADD with Rd = PC, (Rn, Rm) as the target and index regs.
 828   if (Opcode == ARM::BR_JTadd) {
 829     // InOperandList with GPR:$target and GPR:$idx regs.
 830
 831     assert(NumOps == 4 && "Expect 4 operands");
 832     MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::GPRRegClassID,
 833                                                        decodeRn(insn))));
 834     MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::GPRRegClassID,
 835                                                        decodeRm(insn))));
 836
 837     // Fill in the two remaining imm operands to signify build completion.
 838     MI.addOperand(MCOperand::CreateImm(0));
 839     MI.addOperand(MCOperand::CreateImm(0));
 840
 841     OpIdx = 4;
 842     return true;
 843   }
 844
 845   // BR_JTr is a MOV with Rd = PC, and Rm as the source register.
 846   if (Opcode == ARM::BR_JTr) {
 847     // InOperandList with GPR::$target reg.
 848
 849     assert(NumOps == 3 && "Expect 3 operands");
 850     MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::GPRRegClassID,
 851                                                        decodeRm(insn))));
 852
 853     // Fill in the two remaining imm operands to signify build completion.
 854     MI.addOperand(MCOperand::CreateImm(0));
 855     MI.addOperand(MCOperand::CreateImm(0));
 856
 857     OpIdx = 3;
 858     return true;
 859   }
 860
 861   // BR_JTm is an LDR with Rt = PC.
 862   if (Opcode == ARM::BR_JTm) {
 863     // This is the reg/reg form, with base reg followed by +/- reg shop imm.
 864     // See also ARMAddressingModes.h (Addressing Mode #2).
 865
 866     assert(NumOps == 5 && getIBit(insn) == 1 && "Expect 5 operands && I-bit=1");
 867     MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::GPRRegClassID,
 868                                                        decodeRn(insn))));
 869
 870     ARM_AM::AddrOpc AddrOpcode = getUBit(insn) ? ARM_AM::add : ARM_AM::sub;
 871
 872     // Disassemble the offset reg (Rm), shift type, and immediate shift length.
 873     MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::GPRRegClassID,
 874                                                        decodeRm(insn))));
 875     // Inst{6-5} encodes the shift opcode.
 876     ARM_AM::ShiftOpc ShOp = getShiftOpcForBits(slice(insn, 6, 5));
 877     // Inst{11-7} encodes the imm5 shift amount.
 878     unsigned ShImm = slice(insn, 11, 7);
 879
 880     // A8.4.1.  Possible rrx or shift amount of 32...
 881     getImmShiftSE(ShOp, ShImm);
 882     MI.addOperand(MCOperand::CreateImm(
 883                     ARM_AM::getAM2Opc(AddrOpcode, ShImm, ShOp)));
 884
 885     // Fill in the two remaining imm operands to signify build completion.
 886     MI.addOperand(MCOperand::CreateImm(0));
 887     MI.addOperand(MCOperand::CreateImm(0));
 888
 889     OpIdx = 5;
 890     return true;
 891   }
 892
 893   return false;
 894 }
 895
 896 static inline bool getBFCInvMask(uint32_t insn, uint32_t &mask) {
 897   uint32_t lsb = slice(insn, 11, 7);
 898   uint32_t msb = slice(insn, 20, 16);
 899   uint32_t Val = 0;
 900   if (msb < lsb) {
 901     DEBUG(errs() << "Encoding error: msb < lsb\n");
 902     return false;
 903   }
 904
 905   for (uint32_t i = lsb; i <= msb; ++i)
 906     Val |= (1 << i);
 907   mask = ~Val;
 908   return true;
 909 }
 910
 911 static inline bool SaturateOpcode(unsigned Opcode) {
 912   switch (Opcode) {
 913   case ARM::SSATlsl: case ARM::SSATasr: case ARM::SSAT16:
 914   case ARM::USATlsl: case ARM::USATasr: case ARM::USAT16:
 915     return true;
 916   default:
 917     return false;
 918   }
 919 }
 920
 921 static inline unsigned decodeSaturatePos(unsigned Opcode, uint32_t insn) {
 922   switch (Opcode) {
 923   case ARM::SSATlsl:
 924   case ARM::SSATasr:
 925     return slice(insn, 20, 16) + 1;
 926   case ARM::SSAT16:
 927     return slice(insn, 19, 16) + 1;
 928   case ARM::USATlsl:
 929   case ARM::USATasr:
 930     return slice(insn, 20, 16);
 931   case ARM::USAT16:
 932     return slice(insn, 19, 16);
 933   default:
 934     assert(0 && "Invalid opcode passed in");
 935     return 0;
 936   }
 937 }
 938
 939 // A major complication is the fact that some of the saturating add/subtract
 940 // operations have Rd Rm Rn, instead of the "normal" Rd Rn Rm.
 941 // They are QADD, QDADD, QDSUB, and QSUB.
 942 static bool DisassembleDPFrm(MCInst &MI, unsigned Opcode, uint32_t insn,
 943     unsigned short NumOps, unsigned &NumOpsAdded, BO B) {
 944
 945   const TargetInstrDesc &TID = ARMInsts[Opcode];
 946   unsigned short NumDefs = TID.getNumDefs();
 947   bool isUnary = isUnaryDP(TID.TSFlags);
 948   const TargetOperandInfo *OpInfo = TID.OpInfo;
 949   unsigned &OpIdx = NumOpsAdded;
 950
 951   OpIdx = 0;
 952
 953   // Disassemble register def if there is one.
 954   if (NumDefs && (OpInfo[OpIdx].RegClass == ARM::GPRRegClassID)) {
 955     MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::GPRRegClassID,
 956                                                        decodeRd(insn))));
 957     ++OpIdx;
 958   }
 959
 960   // Now disassemble the src operands.
 961   if (OpIdx >= NumOps)
 962     return false;
 963
 964   // SSAT/SSAT16/USAT/USAT16 has imm operand after Rd.
 965   if (SaturateOpcode(Opcode)) {
 966     MI.addOperand(MCOperand::CreateImm(decodeSaturatePos(Opcode, insn)));
 967
 968     MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::GPRRegClassID,
 969                                                        decodeRm(insn))));
 970
 971     if (Opcode == ARM::SSAT16 || Opcode == ARM::USAT16) {
 972       OpIdx += 2;
 973       return true;
 974     }
 975
 976     // For SSAT operand reg (Rm) has been disassembled above.
 977     // Now disassemble the shift amount.
 978
 979     // Inst{11-7} encodes the imm5 shift amount.
 980     unsigned ShAmt = slice(insn, 11, 7);
 981
 982     // A8.6.183.  Possible ASR shift amount of 32...
 983     if (Opcode == ARM::SSATasr && ShAmt == 0)
 984       ShAmt = 32;
 985
 986     MI.addOperand(MCOperand::CreateImm(ShAmt));
 987
 988     OpIdx += 3;
 989     return true;
 990   }
 991
 992   // Special-case handling of BFC/BFI/SBFX/UBFX.
 993   if (Opcode == ARM::BFC || Opcode == ARM::BFI) {
 994     MI.addOperand(MCOperand::CreateReg(0));
 995     if (Opcode == ARM::BFI) {
 996       MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::GPRRegClassID,
 997                                                          decodeRm(insn))));
 998       ++OpIdx;
 999     }
1000     uint32_t mask = 0;
1001     if (!getBFCInvMask(insn, mask))
1002       return false;
1003
1004     MI.addOperand(MCOperand::CreateImm(mask));
1005     OpIdx += 2;
1006     return true;
1007   }
1008   if (Opcode == ARM::SBFX || Opcode == ARM::UBFX) {
1009     MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::GPRRegClassID,
1010                                                        decodeRm(insn))));
1011     MI.addOperand(MCOperand::CreateImm(slice(insn, 11, 7)));
1012     MI.addOperand(MCOperand::CreateImm(slice(insn, 20, 16) + 1));
1013     OpIdx += 3;
1014     return true;
1015   }
1016
1017   bool RmRn = (Opcode == ARM::QADD || Opcode == ARM::QDADD ||
1018                Opcode == ARM::QDSUB || Opcode == ARM::QSUB);
1019
1020   // BinaryDP has an Rn operand.
1021   if (!isUnary) {
1022     assert(OpInfo[OpIdx].RegClass == ARM::GPRRegClassID &&
1023            "Reg operand expected");
1024     MI.addOperand(MCOperand::CreateReg(
1025                     getRegisterEnum(B, ARM::GPRRegClassID,
1026                                     RmRn ? decodeRm(insn) : decodeRn(insn))));
1027     ++OpIdx;
1028   }
1029
1030   // If this is a two-address operand, skip it, e.g., MOVCCr operand 1.
1031   if (isUnary && (TID.getOperandConstraint(OpIdx, TOI::TIED_TO) != -1)) {
1032     MI.addOperand(MCOperand::CreateReg(0));
1033     ++OpIdx;
1034   }
1035
1036   // Now disassemble operand 2.
1037   if (OpIdx >= NumOps)
1038     return false;
1039
1040   if (OpInfo[OpIdx].RegClass == ARM::GPRRegClassID) {
1041     // We have a reg/reg form.
1042     // Assert disabled because saturating operations, e.g., A8.6.127 QASX, are
1043     // routed here as well.
1044     // assert(getIBit(insn) == 0 && "I_Bit != '0' reg/reg form");
1045     MI.addOperand(MCOperand::CreateReg(
1046                     getRegisterEnum(B, ARM::GPRRegClassID,
1047                                     RmRn? decodeRn(insn) : decodeRm(insn))));
1048     ++OpIdx;
1049   } else if (Opcode == ARM::MOVi16 || Opcode == ARM::MOVTi16) {
1050     // We have an imm16 = imm4:imm12 (imm4=Inst{19:16}, imm12 = Inst{11:0}).
1051     assert(getIBit(insn) == 1 && "I_Bit != '1' reg/imm form");
1052     unsigned Imm16 = slice(insn, 19, 16) << 12 | slice(insn, 11, 0);
1053     MI.addOperand(MCOperand::CreateImm(Imm16));
1054     ++OpIdx;
1055   } else {
1056     // We have a reg/imm form.
1057     // SOImm is 4-bit rotate amount in bits 11-8 with 8-bit imm in bits 7-0.
1058     // A5.2.4 Rotate amount is twice the numeric value of Inst{11-8}.
1059     // See also ARMAddressingModes.h: getSOImmValImm() and getSOImmValRot().
1060     assert(getIBit(insn) == 1 && "I_Bit != '1' reg/imm form");
1061     unsigned Rot = (insn >> ARMII::SoRotImmShift) & 0xF;
1062     unsigned Imm = insn & 0xFF;
1063     MI.addOperand(MCOperand::CreateImm(ARM_AM::rotr32(Imm, 2*Rot)));
1064     ++OpIdx;
1065   }
1066
1067   return true;
1068 }
1069
1070 static bool DisassembleDPSoRegFrm(MCInst &MI, unsigned Opcode, uint32_t insn,
1071     unsigned short NumOps, unsigned &NumOpsAdded, BO B) {
1072
1073   const TargetInstrDesc &TID = ARMInsts[Opcode];
1074   unsigned short NumDefs = TID.getNumDefs();
1075   bool isUnary = isUnaryDP(TID.TSFlags);
1076   const TargetOperandInfo *OpInfo = TID.OpInfo;
1077   unsigned &OpIdx = NumOpsAdded;
1078
1079   OpIdx = 0;
1080
1081   // Disassemble register def if there is one.
1082   if (NumDefs && (OpInfo[OpIdx].RegClass == ARM::GPRRegClassID)) {
1083     MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::GPRRegClassID,
1084                                                        decodeRd(insn))));
1085     ++OpIdx;
1086   }
1087
1088   // Disassemble the src operands.
1089   if (OpIdx >= NumOps)
1090     return false;
1091
1092   // BinaryDP has an Rn operand.
1093   if (!isUnary) {
1094     assert(OpInfo[OpIdx].RegClass == ARM::GPRRegClassID &&
1095            "Reg operand expected");
1096     MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::GPRRegClassID,
1097                                                        decodeRn(insn))));
1098     ++OpIdx;
1099   }
1100
1101   // If this is a two-address operand, skip it, e.g., MOVCCs operand 1.
1102   if (isUnary && (TID.getOperandConstraint(OpIdx, TOI::TIED_TO) != -1)) {
1103     MI.addOperand(MCOperand::CreateReg(0));
1104     ++OpIdx;
1105   }
1106
1107   // Disassemble operand 2, which consists of three components.
1108   if (OpIdx + 2 >= NumOps)
1109     return false;
1110
1111   assert((OpInfo[OpIdx].RegClass == ARM::GPRRegClassID) &&
1112          (OpInfo[OpIdx+1].RegClass == ARM::GPRRegClassID) &&
1113          (OpInfo[OpIdx+2].RegClass < 0) &&
1114          "Expect 3 reg operands");
1115
1116   // Register-controlled shifts have Inst{7} = 0 and Inst{4} = 1.
1117   unsigned Rs = slice(insn, 4, 4);
1118
1119   MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::GPRRegClassID,
1120                                                      decodeRm(insn))));
1121   if (Rs) {
1122     // Register-controlled shifts: [Rm, Rs, shift].
1123     MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::GPRRegClassID,
1124                                                        decodeRs(insn))));
1125     // Inst{6-5} encodes the shift opcode.
1126     ARM_AM::ShiftOpc ShOp = getShiftOpcForBits(slice(insn, 6, 5));
1127     MI.addOperand(MCOperand::CreateImm(ARM_AM::getSORegOpc(ShOp, 0)));
1128   } else {
1129     // Constant shifts: [Rm, reg0, shift_imm].
1130     MI.addOperand(MCOperand::CreateReg(0)); // NoRegister
1131     // Inst{6-5} encodes the shift opcode.
1132     ARM_AM::ShiftOpc ShOp = getShiftOpcForBits(slice(insn, 6, 5));
1133     // Inst{11-7} encodes the imm5 shift amount.
1134     unsigned ShImm = slice(insn, 11, 7);
1135
1136     // A8.4.1.  Possible rrx or shift amount of 32...
1137     getImmShiftSE(ShOp, ShImm);
1138     MI.addOperand(MCOperand::CreateImm(ARM_AM::getSORegOpc(ShOp, ShImm)));
1139   }
1140   OpIdx += 3;
1141
1142   return true;
1143 }
1144
1145 static bool DisassembleLdStFrm(MCInst &MI, unsigned Opcode, uint32_t insn,
1146     unsigned short NumOps, unsigned &NumOpsAdded, bool isStore, BO B) {
1147
1148   const TargetInstrDesc &TID = ARMInsts[Opcode];
1149   bool isPrePost = isPrePostLdSt(TID.TSFlags);
1150   const TargetOperandInfo *OpInfo = TID.OpInfo;
1151   if (!OpInfo) return false;
1152
1153   unsigned &OpIdx = NumOpsAdded;
1154
1155   OpIdx = 0;
1156
1157   assert(((!isStore && TID.getNumDefs() > 0) ||
1158           (isStore && (TID.getNumDefs() == 0 || isPrePost)))
1159          && "Invalid arguments");
1160
1161   // Operand 0 of a pre- and post-indexed store is the address base writeback.
1162   if (isPrePost && isStore) {
1163     assert(OpInfo[OpIdx].RegClass == ARM::GPRRegClassID &&
1164            "Reg operand expected");
1165     MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::GPRRegClassID,
1166                                                        decodeRn(insn))));
1167     ++OpIdx;
1168   }
1169
1170   // Disassemble the dst/src operand.
1171   if (OpIdx >= NumOps)
1172     return false;
1173
1174   assert(OpInfo[OpIdx].RegClass == ARM::GPRRegClassID &&
1175          "Reg operand expected");
1176   MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::GPRRegClassID,
1177                                                      decodeRd(insn))));
1178   ++OpIdx;
1179
1180   // After dst of a pre- and post-indexed load is the address base writeback.
1181   if (isPrePost && !isStore) {
1182     assert(OpInfo[OpIdx].RegClass == ARM::GPRRegClassID &&
1183            "Reg operand expected");
1184     MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::GPRRegClassID,
1185                                                        decodeRn(insn))));
1186     ++OpIdx;
1187   }
1188
1189   // Disassemble the base operand.
1190   if (OpIdx >= NumOps)
1191     return false;
1192
1193   assert(OpInfo[OpIdx].RegClass == ARM::GPRRegClassID &&
1194          "Reg operand expected");
1195   assert((!isPrePost || (TID.getOperandConstraint(OpIdx, TOI::TIED_TO) != -1))
1196          && "Index mode or tied_to operand expected");
1197   MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::GPRRegClassID,
1198                                                      decodeRn(insn))));
1199   ++OpIdx;
1200
1201   // For reg/reg form, base reg is followed by +/- reg shop imm.
1202   // For immediate form, it is followed by +/- imm12.
1203   // See also ARMAddressingModes.h (Addressing Mode #2).
1204   if (OpIdx + 1 >= NumOps)
1205     return false;
1206
1207   assert((OpInfo[OpIdx].RegClass == ARM::GPRRegClassID) &&
1208          (OpInfo[OpIdx+1].RegClass < 0) &&
1209          "Expect 1 reg operand followed by 1 imm operand");
1210
1211   ARM_AM::AddrOpc AddrOpcode = getUBit(insn) ? ARM_AM::add : ARM_AM::sub;
1212   if (getIBit(insn) == 0) {
1213     MI.addOperand(MCOperand::CreateReg(0));
1214
1215     // Disassemble the 12-bit immediate offset.
1216     unsigned Imm12 = slice(insn, 11, 0);
1217     unsigned Offset = ARM_AM::getAM2Opc(AddrOpcode, Imm12, ARM_AM::no_shift);
1218     MI.addOperand(MCOperand::CreateImm(Offset));
1219   } else {
1220     // Disassemble the offset reg (Rm), shift type, and immediate shift length.
1221     MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::GPRRegClassID,
1222                                                        decodeRm(insn))));
1223     // Inst{6-5} encodes the shift opcode.
1224     ARM_AM::ShiftOpc ShOp = getShiftOpcForBits(slice(insn, 6, 5));
1225     // Inst{11-7} encodes the imm5 shift amount.
1226     unsigned ShImm = slice(insn, 11, 7);
1227
1228     // A8.4.1.  Possible rrx or shift amount of 32...
1229     getImmShiftSE(ShOp, ShImm);
1230     MI.addOperand(MCOperand::CreateImm(
1231                     ARM_AM::getAM2Opc(AddrOpcode, ShImm, ShOp)));
1232   }
1233   OpIdx += 2;
1234
1235   return true;
1236 }
1237
1238 static bool DisassembleLdFrm(MCInst &MI, unsigned Opcode, uint32_t insn,
1239     unsigned short NumOps, unsigned &NumOpsAdded, BO B) {
1240   return DisassembleLdStFrm(MI, Opcode, insn, NumOps, NumOpsAdded, false, B);
1241 }
1242
1243 static bool DisassembleStFrm(MCInst &MI, unsigned Opcode, uint32_t insn,
1244     unsigned short NumOps, unsigned &NumOpsAdded, BO B) {
1245   return DisassembleLdStFrm(MI, Opcode, insn, NumOps, NumOpsAdded, true, B);
1246 }
1247
1248 static bool HasDualReg(unsigned Opcode) {
1249   switch (Opcode) {
1250   default:
1251     return false;
1252   case ARM::LDRD: case ARM::LDRD_PRE: case ARM::LDRD_POST:
1253   case ARM::STRD: case ARM::STRD_PRE: case ARM::STRD_POST:
1254     return true;
1255   }
1256 }
1257
1258 static bool DisassembleLdStMiscFrm(MCInst &MI, unsigned Opcode, uint32_t insn,
1259     unsigned short NumOps, unsigned &NumOpsAdded, bool isStore, BO B) {
1260
1261   const TargetInstrDesc &TID = ARMInsts[Opcode];
1262   bool isPrePost = isPrePostLdSt(TID.TSFlags);
1263   const TargetOperandInfo *OpInfo = TID.OpInfo;
1264   if (!OpInfo) return false;
1265
1266   unsigned &OpIdx = NumOpsAdded;
1267
1268   OpIdx = 0;
1269
1270   assert(((!isStore && TID.getNumDefs() > 0) ||
1271           (isStore && (TID.getNumDefs() == 0 || isPrePost)))
1272          && "Invalid arguments");
1273
1274   // Operand 0 of a pre- and post-indexed store is the address base writeback.
1275   if (isPrePost && isStore) {
1276     assert(OpInfo[OpIdx].RegClass == ARM::GPRRegClassID &&
1277            "Reg operand expected");
1278     MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::GPRRegClassID,
1279                                                        decodeRn(insn))));
1280     ++OpIdx;
1281   }
1282
1283   bool DualReg = HasDualReg(Opcode);
1284
1285   // Disassemble the dst/src operand.
1286   if (OpIdx >= NumOps)
1287     return false;
1288
1289   assert(OpInfo[OpIdx].RegClass == ARM::GPRRegClassID &&
1290          "Reg operand expected");
1291   MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::GPRRegClassID,
1292                                                      decodeRd(insn))));
1293   ++OpIdx;
1294
1295   // Fill in LDRD and STRD's second operand.
1296   if (DualReg) {
1297     MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::GPRRegClassID,
1298                                                        decodeRd(insn) + 1)));
1299     ++OpIdx;
1300   }
1301
1302   // After dst of a pre- and post-indexed load is the address base writeback.
1303   if (isPrePost && !isStore) {
1304     assert(OpInfo[OpIdx].RegClass == ARM::GPRRegClassID &&
1305            "Reg operand expected");
1306     MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::GPRRegClassID,
1307                                                        decodeRn(insn))));
1308     ++OpIdx;
1309   }
1310
1311   // Disassemble the base operand.
1312   if (OpIdx >= NumOps)
1313     return false;
1314
1315   assert(OpInfo[OpIdx].RegClass == ARM::GPRRegClassID &&
1316          "Reg operand expected");
1317   assert((!isPrePost || (TID.getOperandConstraint(OpIdx, TOI::TIED_TO) != -1))
1318          && "Index mode or tied_to operand expected");
1319   MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::GPRRegClassID,
1320                                                      decodeRn(insn))));
1321   ++OpIdx;
1322
1323   // For reg/reg form, base reg is followed by +/- reg.
1324   // For immediate form, it is followed by +/- imm8.
1325   // See also ARMAddressingModes.h (Addressing Mode #3).
1326   if (OpIdx + 1 >= NumOps)
1327     return false;
1328
1329   assert((OpInfo[OpIdx].RegClass == ARM::GPRRegClassID) &&
1330          (OpInfo[OpIdx+1].RegClass < 0) &&
1331          "Expect 1 reg operand followed by 1 imm operand");
1332
1333   ARM_AM::AddrOpc AddrOpcode = getUBit(insn) ? ARM_AM::add : ARM_AM::sub;
1334   if (getAM3IBit(insn) == 1) {
1335     MI.addOperand(MCOperand::CreateReg(0));
1336
1337     // Disassemble the 8-bit immediate offset.
1338     unsigned Imm4H = (insn >> ARMII::ImmHiShift) & 0xF;
1339     unsigned Imm4L = insn & 0xF;
1340     unsigned Offset = ARM_AM::getAM3Opc(AddrOpcode, (Imm4H << 4) | Imm4L);
1341     MI.addOperand(MCOperand::CreateImm(Offset));
1342   } else {
1343     // Disassemble the offset reg (Rm).
1344     MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::GPRRegClassID,
1345                                                        decodeRm(insn))));
1346     unsigned Offset = ARM_AM::getAM3Opc(AddrOpcode, 0);
1347     MI.addOperand(MCOperand::CreateImm(Offset));
1348   }
1349   OpIdx += 2;
1350
1351   return true;
1352 }
1353
1354 static bool DisassembleLdMiscFrm(MCInst &MI, unsigned Opcode, uint32_t insn,
1355     unsigned short NumOps, unsigned &NumOpsAdded, BO B) {
1356   return DisassembleLdStMiscFrm(MI, Opcode, insn, NumOps, NumOpsAdded, false,
1357                                 B);
1358 }
1359
1360 static bool DisassembleStMiscFrm(MCInst &MI, unsigned Opcode, uint32_t insn,
1361     unsigned short NumOps, unsigned &NumOpsAdded, BO B) {
1362   return DisassembleLdStMiscFrm(MI, Opcode, insn, NumOps, NumOpsAdded, true, B);
1363 }
1364
1365 // The algorithm for disassembly of LdStMulFrm is different from others because
1366 // it explicitly populates the two predicate operands after operand 0 (the base)
1367 // and operand 1 (the AM4 mode imm).  After operand 3, we need to populate the
1368 // reglist with each affected register encoded as an MCOperand.
1369 static bool DisassembleLdStMulFrm(MCInst &MI, unsigned Opcode, uint32_t insn,
1370     unsigned short NumOps, unsigned &NumOpsAdded, BO B) {
1371
1372   assert(NumOps >= 5 && "LdStMulFrm expects NumOps >= 5");
1373
1374   unsigned &OpIdx = NumOpsAdded;
1375
1376   OpIdx = 0;
1377
1378   unsigned Base = getRegisterEnum(B, ARM::GPRRegClassID, decodeRn(insn));
1379
1380   // Writeback to base, if necessary.
1381   if (Opcode == ARM::LDM_UPD || Opcode == ARM::STM_UPD) {
1382     MI.addOperand(MCOperand::CreateReg(Base));
1383     ++OpIdx;
1384   }
1385
1386   MI.addOperand(MCOperand::CreateReg(Base));
1387
1388   ARM_AM::AMSubMode SubMode = getAMSubModeForBits(getPUBits(insn));
1389   MI.addOperand(MCOperand::CreateImm(ARM_AM::getAM4ModeImm(SubMode)));
1390
1391   // Handling the two predicate operands before the reglist.
1392   int64_t CondVal = insn >> ARMII::CondShift;
1393   MI.addOperand(MCOperand::CreateImm(CondVal == 0xF ? 0xE : CondVal));
1394   MI.addOperand(MCOperand::CreateReg(ARM::CPSR));
1395
1396   OpIdx += 4;
1397
1398   // Fill the variadic part of reglist.
1399   unsigned RegListBits = insn & ((1 << 16) - 1);
1400   for (unsigned i = 0; i < 16; ++i) {
1401     if ((RegListBits >> i) & 1) {
1402       MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::GPRRegClassID,
1403                                                          i)));
1404       ++OpIdx;
1405     }
1406   }
1407
1408   return true;
1409 }
1410
1411 // LDREX, LDREXB, LDREXH: Rd Rn
1412 // LDREXD:                Rd Rd+1 Rn
1413 // STREX, STREXB, STREXH: Rd Rm Rn
1414 // STREXD:                Rd Rm Rm+1 Rn
1415 //
1416 // SWP, SWPB:             Rd Rm Rn
1417 static bool DisassembleLdStExFrm(MCInst &MI, unsigned Opcode, uint32_t insn,
1418     unsigned short NumOps, unsigned &NumOpsAdded, BO B) {
1419
1420   const TargetOperandInfo *OpInfo = ARMInsts[Opcode].OpInfo;
1421   if (!OpInfo) return false;
1422
1423   unsigned &OpIdx = NumOpsAdded;
1424
1425   OpIdx = 0;
1426
1427   assert(NumOps >= 2
1428          && OpInfo[0].RegClass == ARM::GPRRegClassID
1429          && OpInfo[1].RegClass == ARM::GPRRegClassID
1430          && "Expect 2 reg operands");
1431
1432   bool isStore = slice(insn, 20, 20) == 0;
1433   bool isDW = (Opcode == ARM::LDREXD || Opcode == ARM::STREXD);
1434
1435   // Add the destination operand.
1436   MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::GPRRegClassID,
1437                                                      decodeRd(insn))));
1438   ++OpIdx;
1439
1440   // Store register Exclusive needs a source operand.
1441   if (isStore) {
1442     MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::GPRRegClassID,
1443                                                        decodeRm(insn))));
1444     ++OpIdx;
1445
1446     if (isDW) {
1447       MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::GPRRegClassID,
1448                                                          decodeRm(insn)+1)));
1449       ++OpIdx;
1450     }
1451   } else if (isDW) {
1452     MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::GPRRegClassID,
1453                                                        decodeRd(insn)+1)));
1454     ++OpIdx;
1455   }
1456
1457   // Finally add the pointer operand.
1458   MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::GPRRegClassID,
1459                                                      decodeRn(insn))));
1460   ++OpIdx;
1461
1462   return true;
1463 }
1464
1465 // Misc. Arithmetic Instructions.
1466 // CLZ: Rd Rm
1467 // PKHBT, PKHTB: Rd Rn Rm , LSL/ASR #imm5
1468 // RBIT, REV, REV16, REVSH: Rd Rm
1469 static bool DisassembleArithMiscFrm(MCInst &MI, unsigned Opcode, uint32_t insn,
1470     unsigned short NumOps, unsigned &NumOpsAdded, BO B) {
1471
1472   const TargetOperandInfo *OpInfo = ARMInsts[Opcode].OpInfo;
1473   unsigned &OpIdx = NumOpsAdded;
1474
1475   OpIdx = 0;
1476
1477   assert(NumOps >= 2
1478          && OpInfo[0].RegClass == ARM::GPRRegClassID
1479          && OpInfo[1].RegClass == ARM::GPRRegClassID
1480          && "Expect 2 reg operands");
1481
1482   bool ThreeReg = NumOps > 2 && OpInfo[2].RegClass == ARM::GPRRegClassID;
1483
1484   MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::GPRRegClassID,
1485                                                      decodeRd(insn))));
1486   ++OpIdx;
1487
1488   if (ThreeReg) {
1489     assert(NumOps >= 4 && "Expect >= 4 operands");
1490     MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::GPRRegClassID,
1491                                                        decodeRn(insn))));
1492     ++OpIdx;
1493   }
1494
1495   MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::GPRRegClassID,
1496                                                      decodeRm(insn))));
1497   ++OpIdx;
1498
1499   // If there is still an operand info left which is an immediate operand, add
1500   // an additional imm5 LSL/ASR operand.
1501   if (ThreeReg && OpInfo[OpIdx].RegClass < 0
1502       && !OpInfo[OpIdx].isPredicate() && !OpInfo[OpIdx].isOptionalDef()) {
1503     // Extract the 5-bit immediate field Inst{11-7}.
1504     unsigned ShiftAmt = (insn >> ARMII::ShiftShift) & 0x1F;
1505     MI.addOperand(MCOperand::CreateImm(ShiftAmt));
1506     ++OpIdx;
1507   }
1508
1509   return true;
1510 }
1511
1512 // Extend instructions.
1513 // SXT* and UXT*: Rd [Rn] Rm [rot_imm].
1514 // The 2nd operand register is Rn and the 3rd operand regsiter is Rm for the
1515 // three register operand form.  Otherwise, Rn=0b1111 and only Rm is used.
1516 static bool DisassembleExtFrm(MCInst &MI, unsigned Opcode, uint32_t insn,
1517     unsigned short NumOps, unsigned &NumOpsAdded, BO B) {
1518
1519   const TargetOperandInfo *OpInfo = ARMInsts[Opcode].OpInfo;
1520   unsigned &OpIdx = NumOpsAdded;
1521
1522   OpIdx = 0;
1523
1524   assert(NumOps >= 2
1525          && OpInfo[0].RegClass == ARM::GPRRegClassID
1526          && OpInfo[1].RegClass == ARM::GPRRegClassID
1527          && "Expect 2 reg operands");
1528
1529   bool ThreeReg = NumOps > 2 && OpInfo[2].RegClass == ARM::GPRRegClassID;
1530
1531   MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::GPRRegClassID,
1532                                                      decodeRd(insn))));
1533   ++OpIdx;
1534
1535   if (ThreeReg) {
1536     MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::GPRRegClassID,
1537                                                        decodeRn(insn))));
1538     ++OpIdx;
1539   }
1540
1541   MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::GPRRegClassID,
1542                                                      decodeRm(insn))));
1543   ++OpIdx;
1544
1545   // If there is still an operand info left which is an immediate operand, add
1546   // an additional rotate immediate operand.
1547   if (OpIdx < NumOps && OpInfo[OpIdx].RegClass < 0
1548       && !OpInfo[OpIdx].isPredicate() && !OpInfo[OpIdx].isOptionalDef()) {
1549     // Extract the 2-bit rotate field Inst{11-10}.
1550     unsigned rot = (insn >> ARMII::ExtRotImmShift) & 3;
1551     // Rotation by 8, 16, or 24 bits.
1552     MI.addOperand(MCOperand::CreateImm(rot << 3));
1553     ++OpIdx;
1554   }
1555
1556   return true;
1557 }
1558
1559 /////////////////////////////////////
1560 //                                 //
1561 //    Utility Functions For VFP    //
1562 //                                 //
1563 /////////////////////////////////////
1564
1565 // Extract/Decode Dd/Sd:
1566 //
1567 // SP => d = UInt(Vd:D)
1568 // DP => d = UInt(D:Vd)
1569 static unsigned decodeVFPRd(uint32_t insn, bool isSPVFP) {
1570   return isSPVFP ? (decodeRd(insn) << 1 | getDBit(insn))
1571                  : (decodeRd(insn) | getDBit(insn) << 4);
1572 }
1573
1574 // Extract/Decode Dn/Sn:
1575 //
1576 // SP => n = UInt(Vn:N)
1577 // DP => n = UInt(N:Vn)
1578 static unsigned decodeVFPRn(uint32_t insn, bool isSPVFP) {
1579   return isSPVFP ? (decodeRn(insn) << 1 | getNBit(insn))
1580                  : (decodeRn(insn) | getNBit(insn) << 4);
1581 }
1582
1583 // Extract/Decode Dm/Sm:
1584 //
1585 // SP => m = UInt(Vm:M)
1586 // DP => m = UInt(M:Vm)
1587 static unsigned decodeVFPRm(uint32_t insn, bool isSPVFP) {
1588   return isSPVFP ? (decodeRm(insn) << 1 | getMBit(insn))
1589                  : (decodeRm(insn) | getMBit(insn) << 4);
1590 }
1591
1592 // A7.5.1
1593 #if 0
1594 static uint64_t VFPExpandImm(unsigned char byte, unsigned N) {
1595   assert(N == 32 || N == 64);
1596
1597   uint64_t Result;
1598   unsigned bit6 = slice(byte, 6, 6);
1599   if (N == 32) {
1600     Result = slice(byte, 7, 7) << 31 | slice(byte, 5, 0) << 19;
1601     if (bit6)
1602       Result |= 0x1f << 25;
1603     else
1604       Result |= 0x1 << 30;
1605   } else {
1606     Result = (uint64_t)slice(byte, 7, 7) << 63 |
1607              (uint64_t)slice(byte, 5, 0) << 48;
1608     if (bit6)
1609       Result |= 0xffL << 54;
1610     else
1611       Result |= 0x1L << 62;
1612   }
1613   return Result;
1614 }
1615 #endif
1616
1617 // VFP Unary Format Instructions:
1618 //
1619 // VCMP[E]ZD, VCMP[E]ZS: compares one floating-point register with zero
1620 // VCVTDS, VCVTSD: converts between double-precision and single-precision
1621 // The rest of the instructions have homogeneous [VFP]Rd and [VFP]Rm registers.
1622 static bool DisassembleVFPUnaryFrm(MCInst &MI, unsigned Opcode, uint32_t insn,
1623     unsigned short NumOps, unsigned &NumOpsAdded, BO B) {
1624
1625   assert(NumOps >= 1 && "VFPUnaryFrm expects NumOps >= 1");
1626
1627   const TargetOperandInfo *OpInfo = ARMInsts[Opcode].OpInfo;
1628   unsigned &OpIdx = NumOpsAdded;
1629
1630   OpIdx = 0;
1631
1632   unsigned RegClass = OpInfo[OpIdx].RegClass;
1633   assert((RegClass == ARM::SPRRegClassID || RegClass == ARM::DPRRegClassID) &&
1634          "Reg operand expected");
1635   bool isSP = (RegClass == ARM::SPRRegClassID);
1636
1637   MI.addOperand(MCOperand::CreateReg(
1638                   getRegisterEnum(B, RegClass, decodeVFPRd(insn, isSP))));
1639   ++OpIdx;
1640
1641   // Early return for compare with zero instructions.
1642   if (Opcode == ARM::VCMPEZD || Opcode == ARM::VCMPEZS
1643       || Opcode == ARM::VCMPZD || Opcode == ARM::VCMPZS)
1644     return true;
1645
1646   RegClass = OpInfo[OpIdx].RegClass;
1647   assert((RegClass == ARM::SPRRegClassID || RegClass == ARM::DPRRegClassID) &&
1648          "Reg operand expected");
1649   isSP = (RegClass == ARM::SPRRegClassID);
1650
1651   MI.addOperand(MCOperand::CreateReg(
1652                   getRegisterEnum(B, RegClass, decodeVFPRm(insn, isSP))));
1653   ++OpIdx;
1654
1655   return true;
1656 }
1657
1658 // All the instructions have homogeneous [VFP]Rd, [VFP]Rn, and [VFP]Rm regs.
1659 // Some of them have operand constraints which tie the first operand in the
1660 // InOperandList to that of the dst.  As far as asm printing is concerned, this
1661 // tied_to operand is simply skipped.
1662 static bool DisassembleVFPBinaryFrm(MCInst &MI, unsigned Opcode, uint32_t insn,
1663     unsigned short NumOps, unsigned &NumOpsAdded, BO B) {
1664
1665   assert(NumOps >= 3 && "VFPBinaryFrm expects NumOps >= 3");
1666
1667   const TargetInstrDesc &TID = ARMInsts[Opcode];
1668   const TargetOperandInfo *OpInfo = TID.OpInfo;
1669   unsigned &OpIdx = NumOpsAdded;
1670
1671   OpIdx = 0;
1672
1673   unsigned RegClass = OpInfo[OpIdx].RegClass;
1674   assert((RegClass == ARM::SPRRegClassID || RegClass == ARM::DPRRegClassID) &&
1675          "Reg operand expected");
1676   bool isSP = (RegClass == ARM::SPRRegClassID);
1677
1678   MI.addOperand(MCOperand::CreateReg(
1679                   getRegisterEnum(B, RegClass, decodeVFPRd(insn, isSP))));
1680   ++OpIdx;
1681
1682   // Skip tied_to operand constraint.
1683   if (TID.getOperandConstraint(OpIdx, TOI::TIED_TO) != -1) {
1684     assert(NumOps >= 4 && "Expect >=4 operands");
1685     MI.addOperand(MCOperand::CreateReg(0));
1686     ++OpIdx;
1687   }
1688
1689   MI.addOperand(MCOperand::CreateReg(
1690                   getRegisterEnum(B, RegClass, decodeVFPRn(insn, isSP))));
1691   ++OpIdx;
1692
1693   MI.addOperand(MCOperand::CreateReg(
1694                   getRegisterEnum(B, RegClass, decodeVFPRm(insn, isSP))));
1695   ++OpIdx;
1696
1697   return true;
1698 }
1699
1700 // A8.6.295 vcvt (floating-point <-> integer)
1701 // Int to FP: VSITOD, VSITOS, VUITOD, VUITOS
1702 // FP to Int: VTOSI[Z|R]D, VTOSI[Z|R]S, VTOUI[Z|R]D, VTOUI[Z|R]S
1703 //
1704 // A8.6.297 vcvt (floating-point and fixed-point)
1705 // Dd|Sd Dd|Sd(TIED_TO) #fbits(= 16|32 - UInt(imm4:i))
1706 static bool DisassembleVFPConv1Frm(MCInst &MI, unsigned Opcode, uint32_t insn,
1707     unsigned short NumOps, unsigned &NumOpsAdded, BO B) {
1708
1709   assert(NumOps >= 2 && "VFPConv1Frm expects NumOps >= 2");
1710
1711   const TargetInstrDesc &TID = ARMInsts[Opcode];
1712   const TargetOperandInfo *OpInfo = TID.OpInfo;
1713   if (!OpInfo) return false;
1714
1715   bool SP = slice(insn, 8, 8) == 0; // A8.6.295 & A8.6.297
1716   bool fixed_point = slice(insn, 17, 17) == 1; // A8.6.297
1717   unsigned RegClassID = SP ? ARM::SPRRegClassID : ARM::DPRRegClassID;
1718
1719   if (fixed_point) {
1720     // A8.6.297
1721     assert(NumOps >= 3 && "Expect >= 3 operands");
1722     int size = slice(insn, 7, 7) == 0 ? 16 : 32;
1723     int fbits = size - (slice(insn,3,0) << 1 | slice(insn,5,5));
1724     MI.addOperand(MCOperand::CreateReg(
1725                     getRegisterEnum(B, RegClassID,
1726                                     decodeVFPRd(insn, SP))));
1727
1728     assert(TID.getOperandConstraint(1, TOI::TIED_TO) != -1 &&
1729            "Tied to operand expected");
1730     MI.addOperand(MI.getOperand(0));
1731
1732     assert(OpInfo[2].RegClass < 0 && !OpInfo[2].isPredicate() &&
1733            !OpInfo[2].isOptionalDef() && "Imm operand expected");
1734     MI.addOperand(MCOperand::CreateImm(fbits));
1735
1736     NumOpsAdded = 3;
1737   } else {
1738     // A8.6.295
1739     // The Rd (destination) and Rm (source) bits have different interpretations
1740     // depending on their single-precisonness.
1741     unsigned d, m;
1742     if (slice(insn, 18, 18) == 1) { // to_integer operation
1743       d = decodeVFPRd(insn, true /* Is Single Precision */);
1744       MI.addOperand(MCOperand::CreateReg(
1745                       getRegisterEnum(B, ARM::SPRRegClassID, d)));
1746       m = decodeVFPRm(insn, SP);
1747       MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, RegClassID, m)));
1748     } else {
1749       d = decodeVFPRd(insn, SP);
1750       MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, RegClassID, d)));
1751       m = decodeVFPRm(insn, true /* Is Single Precision */);
1752       MI.addOperand(MCOperand::CreateReg(
1753                       getRegisterEnum(B, ARM::SPRRegClassID, m)));
1754     }
1755     NumOpsAdded = 2;
1756   }
1757
1758   return true;
1759 }
1760
1761 // VMOVRS - A8.6.330
1762 // Rt => Rd; Sn => UInt(Vn:N)
1763 static bool DisassembleVFPConv2Frm(MCInst &MI, unsigned Opcode, uint32_t insn,
1764     unsigned short NumOps, unsigned &NumOpsAdded, BO B) {
1765
1766   assert(NumOps >= 2 && "VFPConv2Frm expects NumOps >= 2");
1767
1768   MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::GPRRegClassID,
1769                                                      decodeRd(insn))));
1770   MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::SPRRegClassID,
1771                                                      decodeVFPRn(insn, true))));
1772   NumOpsAdded = 2;
1773   return true;
1774 }
1775
1776 // VMOVRRD - A8.6.332
1777 // Rt => Rd; Rt2 => Rn; Dm => UInt(M:Vm)
1778 //
1779 // VMOVRRS - A8.6.331
1780 // Rt => Rd; Rt2 => Rn; Sm => UInt(Vm:M); Sm1 = Sm+1
1781 static bool DisassembleVFPConv3Frm(MCInst &MI, unsigned Opcode, uint32_t insn,
1782     unsigned short NumOps, unsigned &NumOpsAdded, BO B) {
1783
1784   assert(NumOps >= 3 && "VFPConv3Frm expects NumOps >= 3");
1785
1786   const TargetOperandInfo *OpInfo = ARMInsts[Opcode].OpInfo;
1787   unsigned &OpIdx = NumOpsAdded;
1788
1789   MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::GPRRegClassID,
1790                                                      decodeRd(insn))));
1791   MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::GPRRegClassID,
1792                                                      decodeRn(insn))));
1793   OpIdx = 2;
1794
1795   if (OpInfo[OpIdx].RegClass == ARM::SPRRegClassID) {
1796     unsigned Sm = decodeVFPRm(insn, true);
1797     MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::SPRRegClassID,
1798                                                        Sm)));
1799     MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::SPRRegClassID,
1800                                                        Sm+1)));
1801     OpIdx += 2;
1802   } else {
1803     MI.addOperand(MCOperand::CreateReg(
1804                     getRegisterEnum(B, ARM::DPRRegClassID,
1805                                     decodeVFPRm(insn, false))));
1806     ++OpIdx;
1807   }
1808   return true;
1809 }
1810
1811 // VMOVSR - A8.6.330
1812 // Rt => Rd; Sn => UInt(Vn:N)
1813 static bool DisassembleVFPConv4Frm(MCInst &MI, unsigned Opcode, uint32_t insn,
1814     unsigned short NumOps, unsigned &NumOpsAdded, BO B) {
1815
1816   assert(NumOps >= 2 && "VFPConv4Frm expects NumOps >= 2");
1817
1818   MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::SPRRegClassID,
1819                                                      decodeVFPRn(insn, true))));
1820   MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::GPRRegClassID,
1821                                                      decodeRd(insn))));
1822   NumOpsAdded = 2;
1823   return true;
1824 }
1825
1826 // VMOVDRR - A8.6.332
1827 // Rt => Rd; Rt2 => Rn; Dm => UInt(M:Vm)
1828 //
1829 // VMOVRRS - A8.6.331
1830 // Rt => Rd; Rt2 => Rn; Sm => UInt(Vm:M); Sm1 = Sm+1
1831 static bool DisassembleVFPConv5Frm(MCInst &MI, unsigned Opcode, uint32_t insn,
1832     unsigned short NumOps, unsigned &NumOpsAdded, BO B) {
1833
1834   assert(NumOps >= 3 && "VFPConv5Frm expects NumOps >= 3");
1835
1836   const TargetOperandInfo *OpInfo = ARMInsts[Opcode].OpInfo;
1837   unsigned &OpIdx = NumOpsAdded;
1838
1839   OpIdx = 0;
1840
1841   if (OpInfo[OpIdx].RegClass == ARM::SPRRegClassID) {
1842     unsigned Sm = decodeVFPRm(insn, true);
1843     MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::SPRRegClassID,
1844                                                        Sm)));
1845     MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::SPRRegClassID,
1846                                                        Sm+1)));
1847     OpIdx += 2;
1848   } else {
1849     MI.addOperand(MCOperand::CreateReg(
1850                     getRegisterEnum(B, ARM::DPRRegClassID,
1851                                     decodeVFPRm(insn, false))));
1852     ++OpIdx;
1853   }
1854
1855   MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::GPRRegClassID,
1856                                                      decodeRd(insn))));
1857   MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::GPRRegClassID,
1858                                                      decodeRn(insn))));
1859   OpIdx += 2;
1860   return true;
1861 }
1862
1863 // VFP Load/Store Instructions.
1864 // VLDRD, VLDRS, VSTRD, VSTRS
1865 static bool DisassembleVFPLdStFrm(MCInst &MI, unsigned Opcode, uint32_t insn,
1866     unsigned short NumOps, unsigned &NumOpsAdded, BO B) {
1867
1868   assert(NumOps >= 3 && "VFPLdStFrm expects NumOps >= 3");
1869
1870   bool isSPVFP = (Opcode == ARM::VLDRS || Opcode == ARM::VSTRS) ? true : false;
1871   unsigned RegClassID = isSPVFP ? ARM::SPRRegClassID : ARM::DPRRegClassID;
1872
1873   // Extract Dd/Sd for operand 0.
1874   unsigned RegD = decodeVFPRd(insn, isSPVFP);
1875
1876   MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, RegClassID, RegD)));
1877
1878   unsigned Base = getRegisterEnum(B, ARM::GPRRegClassID, decodeRn(insn));
1879   MI.addOperand(MCOperand::CreateReg(Base));
1880
1881   // Next comes the AM5 Opcode.
1882   ARM_AM::AddrOpc AddrOpcode = getUBit(insn) ? ARM_AM::add : ARM_AM::sub;
1883   unsigned char Imm8 = insn & 0xFF;
1884   MI.addOperand(MCOperand::CreateImm(ARM_AM::getAM5Opc(AddrOpcode, Imm8)));
1885
1886   NumOpsAdded = 3;
1887
1888   return true;
1889 }
1890
1891 // VFP Load/Store Multiple Instructions.
1892 // This is similar to the algorithm for LDM/STM in that operand 0 (the base) and
1893 // operand 1 (the AM5 mode imm) is followed by two predicate operands.  It is
1894 // followed by a reglist of either DPR(s) or SPR(s).
1895 //
1896 // VLDMD[_UPD], VLDMS[_UPD], VSTMD[_UPD], VSTMS[_UPD]
1897 static bool DisassembleVFPLdStMulFrm(MCInst &MI, unsigned Opcode, uint32_t insn,
1898     unsigned short NumOps, unsigned &NumOpsAdded, BO B) {
1899
1900   assert(NumOps >= 5 && "VFPLdStMulFrm expects NumOps >= 5");
1901
1902   unsigned &OpIdx = NumOpsAdded;
1903
1904   OpIdx = 0;
1905
1906   unsigned Base = getRegisterEnum(B, ARM::GPRRegClassID, decodeRn(insn));
1907
1908   // Writeback to base, if necessary.
1909   if (Opcode == ARM::VLDMD_UPD || Opcode == ARM::VLDMS_UPD ||
1910       Opcode == ARM::VSTMD_UPD || Opcode == ARM::VSTMS_UPD) {
1911     MI.addOperand(MCOperand::CreateReg(Base));
1912     ++OpIdx;
1913   }
1914
1915   MI.addOperand(MCOperand::CreateReg(Base));
1916
1917   // Next comes the AM5 Opcode.
1918   ARM_AM::AMSubMode SubMode = getAMSubModeForBits(getPUBits(insn));
1919   // Must be either "ia" or "db" submode.
1920   if (SubMode != ARM_AM::ia && SubMode != ARM_AM::db) {
1921     DEBUG(errs() << "Illegal addressing mode 5 sub-mode!\n");
1922     return false;
1923   }
1924
1925   unsigned char Imm8 = insn & 0xFF;
1926   MI.addOperand(MCOperand::CreateImm(ARM_AM::getAM5Opc(SubMode, Imm8)));
1927
1928   // Handling the two predicate operands before the reglist.
1929   int64_t CondVal = insn >> ARMII::CondShift;
1930   MI.addOperand(MCOperand::CreateImm(CondVal == 0xF ? 0xE : CondVal));
1931   MI.addOperand(MCOperand::CreateReg(ARM::CPSR));
1932
1933   OpIdx += 4;
1934
1935   bool isSPVFP = (Opcode == ARM::VLDMS || Opcode == ARM::VLDMS_UPD ||
1936      Opcode == ARM::VSTMS || Opcode == ARM::VSTMS_UPD) ? true : false;
1937   unsigned RegClassID = isSPVFP ? ARM::SPRRegClassID : ARM::DPRRegClassID;
1938
1939   // Extract Dd/Sd.
1940   unsigned RegD = decodeVFPRd(insn, isSPVFP);
1941
1942   // Fill the variadic part of reglist.
1943   unsigned Regs = isSPVFP ? Imm8 : Imm8/2;
1944   for (unsigned i = 0; i < Regs; ++i) {
1945     MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, RegClassID,
1946                                                        RegD + i)));
1947     ++OpIdx;
1948   }
1949
1950   return true;
1951 }
1952
1953 // Misc. VFP Instructions.
1954 // FMSTAT (vmrs with Rt=0b1111, i.e., to apsr_nzcv and no register operand)
1955 // FCONSTD (DPR and a VFPf64Imm operand)
1956 // FCONSTS (SPR and a VFPf32Imm operand)
1957 // VMRS/VMSR (GPR operand)
1958 static bool DisassembleVFPMiscFrm(MCInst &MI, unsigned Opcode, uint32_t insn,
1959     unsigned short NumOps, unsigned &NumOpsAdded, BO B) {
1960
1961   const TargetOperandInfo *OpInfo = ARMInsts[Opcode].OpInfo;
1962   unsigned &OpIdx = NumOpsAdded;
1963
1964   OpIdx = 0;
1965
1966   if (Opcode == ARM::FMSTAT)
1967     return true;
1968
1969   assert(NumOps >= 2 && "VFPMiscFrm expects >=2 operands");
1970
1971   unsigned RegEnum = 0;
1972   switch (OpInfo[0].RegClass) {
1973   case ARM::DPRRegClassID:
1974     RegEnum = getRegisterEnum(B, ARM::DPRRegClassID, decodeVFPRd(insn, false));
1975     break;
1976   case ARM::SPRRegClassID:
1977     RegEnum = getRegisterEnum(B, ARM::SPRRegClassID, decodeVFPRd(insn, true));
1978     break;
1979   case ARM::GPRRegClassID:
1980     RegEnum = getRegisterEnum(B, ARM::GPRRegClassID, decodeRd(insn));
1981     break;
1982   default:
1983     assert(0 && "Invalid reg class id");
1984     return false;
1985   }
1986
1987   MI.addOperand(MCOperand::CreateReg(RegEnum));
1988   ++OpIdx;
1989
1990   // Extract/decode the f64/f32 immediate.
1991   if (OpIdx < NumOps && OpInfo[OpIdx].RegClass < 0
1992         && !OpInfo[OpIdx].isPredicate() && !OpInfo[OpIdx].isOptionalDef()) {
1993     // The asm syntax specifies the before-expanded <imm>.
1994     // Not VFPExpandImm(slice(insn,19,16) << 4 | slice(insn, 3, 0),
1995     //                  Opcode == ARM::FCONSTD ? 64 : 32)
1996     MI.addOperand(MCOperand::CreateImm(slice(insn,19,16)<<4 | slice(insn,3,0)));
1997     ++OpIdx;
1998   }
1999
2000   return true;
2001 }
2002
2003 // DisassembleThumbFrm() is defined in ThumbDisassemblerCore.h file.
2004 #include "ThumbDisassemblerCore.h"
2005
2006 /////////////////////////////////////////////////////
2007 //                                                 //
2008 //     Utility Functions For ARM Advanced SIMD     //
2009 //                                                 //
2010 /////////////////////////////////////////////////////
2011
2012 // The following NEON namings are based on A8.6.266 VABA, VABAL.  Notice that
2013 // A8.6.303 VDUP (ARM core register)'s D/Vd pair is the N/Vn pair of VABA/VABAL.
2014
2015 // A7.3 Register encoding
2016
2017 // Extract/Decode NEON D/Vd:
2018 //
2019 // Note that for quadword, Qd = UInt(D:Vd<3:1>) = Inst{22:15-13}, whereas for
2020 // doubleword, Dd = UInt(D:Vd).  We compensate for this difference by
2021 // handling it in the getRegisterEnum() utility function.
2022 // D = Inst{22}, Vd = Inst{15-12}
2023 static unsigned decodeNEONRd(uint32_t insn) {
2024   return ((insn >> ARMII::NEON_D_BitShift) & 1) << 4
2025     | ((insn >> ARMII::NEON_RegRdShift) & ARMII::NEONRegMask);
2026 }
2027
2028 // Extract/Decode NEON N/Vn:
2029 //
2030 // Note that for quadword, Qn = UInt(N:Vn<3:1>) = Inst{7:19-17}, whereas for
2031 // doubleword, Dn = UInt(N:Vn).  We compensate for this difference by
2032 // handling it in the getRegisterEnum() utility function.
2033 // N = Inst{7}, Vn = Inst{19-16}
2034 static unsigned decodeNEONRn(uint32_t insn) {
2035   return ((insn >> ARMII::NEON_N_BitShift) & 1) << 4
2036     | ((insn >> ARMII::NEON_RegRnShift) & ARMII::NEONRegMask);
2037 }
2038
2039 // Extract/Decode NEON M/Vm:
2040 //
2041 // Note that for quadword, Qm = UInt(M:Vm<3:1>) = Inst{5:3-1}, whereas for
2042 // doubleword, Dm = UInt(M:Vm).  We compensate for this difference by
2043 // handling it in the getRegisterEnum() utility function.
2044 // M = Inst{5}, Vm = Inst{3-0}
2045 static unsigned decodeNEONRm(uint32_t insn) {
2046   return ((insn >> ARMII::NEON_M_BitShift) & 1) << 4
2047     | ((insn >> ARMII::NEON_RegRmShift) & ARMII::NEONRegMask);
2048 }
2049
2050 namespace {
2051 enum ElemSize {
2052   ESizeNA = 0,
2053   ESize8 = 8,
2054   ESize16 = 16,
2055   ESize32 = 32,
2056   ESize64 = 64
2057 };
2058 } // End of unnamed namespace
2059
2060 // size        field -> Inst{11-10}
2061 // index_align field -> Inst{7-4}
2062 //
2063 // The Lane Index interpretation depends on the Data Size:
2064 //   8  (encoded as size = 0b00) -> Index = index_align[3:1]
2065 //   16 (encoded as size = 0b01) -> Index = index_align[3:2]
2066 //   32 (encoded as size = 0b10) -> Index = index_align[3]
2067 //
2068 // Ref: A8.6.317 VLD4 (single 4-element structure to one lane).
2069 static unsigned decodeLaneIndex(uint32_t insn) {
2070   unsigned size = insn >> 10 & 3;
2071   assert((size == 0 || size == 1 || size == 2) &&
2072          "Encoding error: size should be either 0, 1, or 2");
2073
2074   unsigned index_align = insn >> 4 & 0xF;
2075   return (index_align >> 1) >> size;
2076 }
2077
2078 // imm64 = AdvSIMDExpandImm(op, cmode, i:imm3:imm4)
2079 // op = Inst{5}, cmode = Inst{11-8}
2080 // i = Inst{24} (ARM architecture)
2081 // imm3 = Inst{18-16}, imm4 = Inst{3-0}
2082 // Ref: Table A7-15 Modified immediate values for Advanced SIMD instructions.
2083 static uint64_t decodeN1VImm(uint32_t insn, ElemSize esize) {
2084   unsigned char op = (insn >> 5) & 1;
2085   unsigned char cmode = (insn >> 8) & 0xF;
2086   unsigned char Imm8 = ((insn >> 24) & 1) << 7 |
2087                        ((insn >> 16) & 7) << 4 |
2088                        (insn & 0xF);
2089   return (op << 12) | (cmode << 8) | Imm8;
2090 }
2091
2092 // A8.6.339 VMUL, VMULL (by scalar)
2093 // ESize16 => m = Inst{2-0} (Vm<2:0>) D0-D7
2094 // ESize32 => m = Inst{3-0} (Vm<3:0>) D0-D15
2095 static unsigned decodeRestrictedDm(uint32_t insn, ElemSize esize) {
2096   switch (esize) {
2097   case ESize16:
2098     return insn & 7;
2099   case ESize32:
2100     return insn & 0xF;
2101   default:
2102     assert(0 && "Unreachable code!");
2103     return 0;
2104   }
2105 }
2106
2107 // A8.6.339 VMUL, VMULL (by scalar)
2108 // ESize16 => index = Inst{5:3} (M:Vm<3>) D0-D7
2109 // ESize32 => index = Inst{5}   (M)       D0-D15
2110 static unsigned decodeRestrictedDmIndex(uint32_t insn, ElemSize esize) {
2111   switch (esize) {
2112   case ESize16:
2113     return (((insn >> 5) & 1) << 1) | ((insn >> 3) & 1);
2114   case ESize32:
2115     return (insn >> 5) & 1;
2116   default:
2117     assert(0 && "Unreachable code!");
2118     return 0;
2119   }
2120 }
2121
2122 // A8.6.296 VCVT (between floating-point and fixed-point, Advanced SIMD)
2123 // (64 - <fbits>) is encoded as imm6, i.e., Inst{21-16}.
2124 static unsigned decodeVCVTFractionBits(uint32_t insn) {
2125   return 64 - ((insn >> 16) & 0x3F);
2126 }
2127
2128 // A8.6.302 VDUP (scalar)
2129 // ESize8  => index = Inst{19-17}
2130 // ESize16 => index = Inst{19-18}
2131 // ESize32 => index = Inst{19}
2132 static unsigned decodeNVLaneDupIndex(uint32_t insn, ElemSize esize) {
2133   switch (esize) {
2134   case ESize8:
2135     return (insn >> 17) & 7;
2136   case ESize16:
2137     return (insn >> 18) & 3;
2138   case ESize32:
2139     return (insn >> 19) & 1;
2140   default:
2141     assert(0 && "Unspecified element size!");
2142     return 0;
2143   }
2144 }
2145
2146 // A8.6.328 VMOV (ARM core register to scalar)
2147 // A8.6.329 VMOV (scalar to ARM core register)
2148 // ESize8  => index = Inst{21:6-5}
2149 // ESize16 => index = Inst{21:6}
2150 // ESize32 => index = Inst{21}
2151 static unsigned decodeNVLaneOpIndex(uint32_t insn, ElemSize esize) {
2152   switch (esize) {
2153   case ESize8:
2154     return ((insn >> 21) & 1) << 2 | ((insn >> 5) & 3);
2155   case ESize16:
2156     return ((insn >> 21) & 1) << 1 | ((insn >> 6) & 1);
2157   case ESize32:
2158     return ((insn >> 21) & 1);
2159   default:
2160     assert(0 && "Unspecified element size!");
2161     return 0;
2162   }
2163 }
2164
2165 // Imm6 = Inst{21-16}, L = Inst{7}
2166 //
2167 // LeftShift == true (A8.6.367 VQSHL, A8.6.387 VSLI):
2168 // case L:imm6 of
2169 //   '0001xxx' => esize = 8; shift_amount = imm6 - 8
2170 //   '001xxxx' => esize = 16; shift_amount = imm6 - 16
2171 //   '01xxxxx' => esize = 32; shift_amount = imm6 - 32
2172 //   '1xxxxxx' => esize = 64; shift_amount = imm6
2173 //
2174 // LeftShift == false (A8.6.376 VRSHR, A8.6.368 VQSHRN):
2175 // case L:imm6 of
2176 //   '0001xxx' => esize = 8; shift_amount = 16 - imm6
2177 //   '001xxxx' => esize = 16; shift_amount = 32 - imm6
2178 //   '01xxxxx' => esize = 32; shift_amount = 64 - imm6
2179 //   '1xxxxxx' => esize = 64; shift_amount = 64 - imm6
2180 //
2181 static unsigned decodeNVSAmt(uint32_t insn, bool LeftShift) {
2182   ElemSize esize = ESizeNA;
2183   unsigned L = (insn >> 7) & 1;
2184   unsigned imm6 = (insn >> 16) & 0x3F;
2185   if (L == 0) {
2186     if (imm6 >> 3 == 1)
2187       esize = ESize8;
2188     else if (imm6 >> 4 == 1)
2189       esize = ESize16;
2190     else if (imm6 >> 5 == 1)
2191       esize = ESize32;
2192     else
2193       assert(0 && "Wrong encoding of Inst{7:21-16}!");
2194   } else
2195     esize = ESize64;
2196
2197   if (LeftShift)
2198     return esize == ESize64 ? imm6 : (imm6 - esize);
2199   else
2200     return esize == ESize64 ? (esize - imm6) : (2*esize - imm6);
2201 }
2202
2203 // A8.6.305 VEXT
2204 // Imm4 = Inst{11-8}
2205 static unsigned decodeN3VImm(uint32_t insn) {
2206   return (insn >> 8) & 0xF;
2207 }
2208
2209 static bool UseDRegPair(unsigned Opcode) {
2210   switch (Opcode) {
2211   default:
2212     return false;
2213   case ARM::VLD1q8_UPD:
2214   case ARM::VLD1q16_UPD:
2215   case ARM::VLD1q32_UPD:
2216   case ARM::VLD1q64_UPD:
2217   case ARM::VST1q8_UPD:
2218   case ARM::VST1q16_UPD:
2219   case ARM::VST1q32_UPD:
2220   case ARM::VST1q64_UPD:
2221     return true;
2222   }
2223 }
2224
2225 // VLD*
2226 //   D[d] D[d2] ... Rn [TIED_TO Rn] align [Rm]
2227 // VLD*LN*
2228 //   D[d] D[d2] ... Rn [TIED_TO Rn] align [Rm] TIED_TO ... imm(idx)
2229 // VST*
2230 //   Rn [TIED_TO Rn] align [Rm] D[d] D[d2] ...
2231 // VST*LN*
2232 //   Rn [TIED_TO Rn] align [Rm] D[d] D[d2] ... [imm(idx)]
2233 //
2234 // Correctly set VLD*/VST*'s TIED_TO GPR, as the asm printer needs it.
2235 static bool DisassembleNLdSt0(MCInst &MI, unsigned Opcode, uint32_t insn,
2236     unsigned short NumOps, unsigned &NumOpsAdded, bool Store, bool DblSpaced,
2237     BO B) {
2238
2239   const TargetInstrDesc &TID = ARMInsts[Opcode];
2240   const TargetOperandInfo *OpInfo = TID.OpInfo;
2241
2242   // At least one DPR register plus addressing mode #6.
2243   assert(NumOps >= 3 && "Expect >= 3 operands");
2244
2245   unsigned &OpIdx = NumOpsAdded;
2246
2247   OpIdx = 0;
2248
2249   // We have homogeneous NEON registers for Load/Store.
2250   unsigned RegClass = 0;
2251
2252   // Double-spaced registers have increments of 2.
2253   unsigned Inc = DblSpaced ? 2 : 1;
2254
2255   unsigned Rn = decodeRn(insn);
2256   unsigned Rm = decodeRm(insn);
2257   unsigned Rd = decodeNEONRd(insn);
2258
2259   // A7.7.1 Advanced SIMD addressing mode.
2260   bool WB = Rm != 15;
2261
2262   // LLVM Addressing Mode #6.
2263   unsigned RmEnum = 0;
2264   if (WB && Rm != 13)
2265     RmEnum = getRegisterEnum(B, ARM::GPRRegClassID, Rm);
2266
2267   if (Store) {
2268     // Consume possible WB, AddrMode6, possible increment reg, the DPR/QPR's,
2269     // then possible lane index.
2270     assert(OpIdx < NumOps && OpInfo[0].RegClass == ARM::GPRRegClassID &&
2271            "Reg operand expected");
2272
2273     if (WB) {
2274       MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::GPRRegClassID,
2275                                                          Rn)));
2276       ++OpIdx;
2277     }
2278
2279     assert((OpIdx+1) < NumOps && OpInfo[OpIdx].RegClass == ARM::GPRRegClassID &&
2280            OpInfo[OpIdx + 1].RegClass < 0 && "Addrmode #6 Operands expected");
2281     MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::GPRRegClassID,
2282                                                        Rn)));
2283     MI.addOperand(MCOperand::CreateImm(0)); // Alignment ignored?
2284     OpIdx += 2;
2285
2286     if (WB) {
2287       MI.addOperand(MCOperand::CreateReg(RmEnum));
2288       ++OpIdx;
2289     }
2290
2291     assert(OpIdx < NumOps &&
2292            (OpInfo[OpIdx].RegClass == ARM::DPRRegClassID ||
2293             OpInfo[OpIdx].RegClass == ARM::QPRRegClassID) &&
2294            "Reg operand expected");
2295
2296     RegClass = OpInfo[OpIdx].RegClass;
2297     while (OpIdx < NumOps && (unsigned)OpInfo[OpIdx].RegClass == RegClass) {
2298       MI.addOperand(MCOperand::CreateReg(
2299                       getRegisterEnum(B, RegClass, Rd,
2300                                       UseDRegPair(Opcode))));
2301       Rd += Inc;
2302       ++OpIdx;
2303     }
2304
2305     // Handle possible lane index.
2306     if (OpIdx < NumOps && OpInfo[OpIdx].RegClass < 0
2307         && !OpInfo[OpIdx].isPredicate() && !OpInfo[OpIdx].isOptionalDef()) {
2308       MI.addOperand(MCOperand::CreateImm(decodeLaneIndex(insn)));
2309       ++OpIdx;
2310     }
2311
2312   } else {
2313     // Consume the DPR/QPR's, possible WB, AddrMode6, possible incrment reg,
2314     // possible TIED_TO DPR/QPR's (ignored), then possible lane index.
2315     RegClass = OpInfo[0].RegClass;
2316
2317     while (OpIdx < NumOps && (unsigned)OpInfo[OpIdx].RegClass == RegClass) {
2318       MI.addOperand(MCOperand::CreateReg(
2319                       getRegisterEnum(B, RegClass, Rd,
2320                                       UseDRegPair(Opcode))));
2321       Rd += Inc;
2322       ++OpIdx;
2323     }
2324
2325     if (WB) {
2326       MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::GPRRegClassID,
2327                                                          Rn)));
2328       ++OpIdx;
2329     }
2330
2331     assert((OpIdx+1) < NumOps && OpInfo[OpIdx].RegClass == ARM::GPRRegClassID &&
2332            OpInfo[OpIdx + 1].RegClass < 0 && "Addrmode #6 Operands expected");
2333     MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::GPRRegClassID,
2334                                                        Rn)));
2335     MI.addOperand(MCOperand::CreateImm(0)); // Alignment ignored?
2336     OpIdx += 2;
2337
2338     if (WB) {
2339       MI.addOperand(MCOperand::CreateReg(RmEnum));
2340       ++OpIdx;
2341     }
2342
2343     while (OpIdx < NumOps && (unsigned)OpInfo[OpIdx].RegClass == RegClass) {
2344       assert(TID.getOperandConstraint(OpIdx, TOI::TIED_TO) != -1 &&
2345              "Tied to operand expected");
2346       MI.addOperand(MCOperand::CreateReg(0));
2347       ++OpIdx;
2348     }
2349
2350     // Handle possible lane index.
2351     if (OpIdx < NumOps && OpInfo[OpIdx].RegClass < 0
2352         && !OpInfo[OpIdx].isPredicate() && !OpInfo[OpIdx].isOptionalDef()) {
2353       MI.addOperand(MCOperand::CreateImm(decodeLaneIndex(insn)));
2354       ++OpIdx;
2355     }
2356   }
2357
2358   return true;
2359 }
2360
2361 // A7.7
2362 // If L (Inst{21}) == 0, store instructions.
2363 // Find out about double-spaced-ness of the Opcode and pass it on to
2364 // DisassembleNLdSt0().
2365 static bool DisassembleNLdSt(MCInst &MI, unsigned Opcode, uint32_t insn,
2366     unsigned short NumOps, unsigned &NumOpsAdded, BO B) {
2367
2368   const StringRef Name = ARMInsts[Opcode].Name;
2369   bool DblSpaced = false;
2370
2371   if (Name.find("LN") != std::string::npos) {
2372     // To one lane instructions.
2373     // See, for example, 8.6.317 VLD4 (single 4-element structure to one lane).
2374
2375     // <size> == 16 && Inst{5} == 1 --> DblSpaced = true
2376     if (Name.endswith("16") || Name.endswith("16_UPD"))
2377       DblSpaced = slice(insn, 5, 5) == 1;
2378
2379     // <size> == 32 && Inst{6} == 1 --> DblSpaced = true
2380     if (Name.endswith("32") || Name.endswith("32_UPD"))
2381       DblSpaced = slice(insn, 6, 6) == 1;
2382
2383   } else {
2384     // Multiple n-element structures with type encoded as Inst{11-8}.
2385     // See, for example, A8.6.316 VLD4 (multiple 4-element structures).
2386
2387     // n == 2 && type == 0b1001 -> DblSpaced = true
2388     if (Name.startswith("VST2") || Name.startswith("VLD2"))
2389       DblSpaced = slice(insn, 11, 8) == 9;
2390
2391     // n == 3 && type == 0b0101 -> DblSpaced = true
2392     if (Name.startswith("VST3") || Name.startswith("VLD3"))
2393       DblSpaced = slice(insn, 11, 8) == 5;
2394
2395     // n == 4 && type == 0b0001 -> DblSpaced = true
2396     if (Name.startswith("VST4") || Name.startswith("VLD4"))
2397       DblSpaced = slice(insn, 11, 8) == 1;
2398
2399   }
2400   return DisassembleNLdSt0(MI, Opcode, insn, NumOps, NumOpsAdded,
2401                            slice(insn, 21, 21) == 0, DblSpaced, B);
2402 }
2403
2404 // VMOV (immediate)
2405 //   Qd/Dd imm
2406 static bool DisassembleN1RegModImmFrm(MCInst &MI, unsigned Opcode,
2407     uint32_t insn, unsigned short NumOps, unsigned &NumOpsAdded, BO B) {
2408
2409   const TargetInstrDesc &TID = ARMInsts[Opcode];
2410   const TargetOperandInfo *OpInfo = TID.OpInfo;
2411
2412   assert(NumOps >= 2 &&
2413          (OpInfo[0].RegClass == ARM::DPRRegClassID ||
2414           OpInfo[0].RegClass == ARM::QPRRegClassID) &&
2415          (OpInfo[1].RegClass < 0) &&
2416          "Expect 1 reg operand followed by 1 imm operand");
2417
2418   // Qd/Dd = Inst{22:15-12} => NEON Rd
2419   MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, OpInfo[0].RegClass,
2420                                                      decodeNEONRd(insn))));
2421
2422   ElemSize esize = ESizeNA;
2423   switch (Opcode) {
2424   case ARM::VMOVv8i8:
2425   case ARM::VMOVv16i8:
2426     esize = ESize8;
2427     break;
2428   case ARM::VMOVv4i16:
2429   case ARM::VMOVv8i16:
2430     esize = ESize16;
2431     break;
2432   case ARM::VMOVv2i32:
2433   case ARM::VMOVv4i32:
2434     esize = ESize32;
2435     break;
2436   case ARM::VMOVv1i64:
2437   case ARM::VMOVv2i64:
2438     esize = ESize64;
2439     break;
2440   default:
2441     assert(0 && "Unreachable code!");
2442     return false;
2443   }
2444
2445   // One register and a modified immediate value.
2446   // Add the imm operand.
2447   MI.addOperand(MCOperand::CreateImm(decodeN1VImm(insn, esize)));
2448
2449   NumOpsAdded = 2;
2450   return true;
2451 }
2452
2453 namespace {
2454 enum N2VFlag {
2455   N2V_None,
2456   N2V_VectorDupLane,
2457   N2V_VectorConvert_Between_Float_Fixed
2458 };
2459 } // End of unnamed namespace
2460
2461 // Vector Convert [between floating-point and fixed-point]
2462 //   Qd/Dd Qm/Dm [fbits]
2463 //
2464 // Vector Duplicate Lane (from scalar to all elements) Instructions.
2465 // VDUPLN16d, VDUPLN16q, VDUPLN32d, VDUPLN32q, VDUPLN8d, VDUPLN8q:
2466 //   Qd/Dd Dm index
2467 //
2468 // Vector Move Long:
2469 //   Qd Dm
2470 //
2471 // Vector Move Narrow:
2472 //   Dd Qm
2473 //
2474 // Others
2475 static bool DisassembleNVdVmOptImm(MCInst &MI, unsigned Opc, uint32_t insn,
2476     unsigned short NumOps, unsigned &NumOpsAdded, N2VFlag Flag, BO B) {
2477
2478   const TargetInstrDesc &TID = ARMInsts[Opc];
2479   const TargetOperandInfo *OpInfo = TID.OpInfo;
2480
2481   assert(NumOps >= 2 &&
2482          (OpInfo[0].RegClass == ARM::DPRRegClassID ||
2483           OpInfo[0].RegClass == ARM::QPRRegClassID) &&
2484          (OpInfo[1].RegClass == ARM::DPRRegClassID ||
2485           OpInfo[1].RegClass == ARM::QPRRegClassID) &&
2486          "Expect >= 2 operands and first 2 as reg operands");
2487
2488   unsigned &OpIdx = NumOpsAdded;
2489
2490   OpIdx = 0;
2491
2492   ElemSize esize = ESizeNA;
2493   if (Flag == N2V_VectorDupLane) {
2494     // VDUPLN has its index embedded.  Its size can be inferred from the Opcode.
2495     assert(Opc >= ARM::VDUPLN16d && Opc <= ARM::VDUPLN8q &&
2496            "Unexpected Opcode");
2497     esize = (Opc == ARM::VDUPLN8d || Opc == ARM::VDUPLN8q) ? ESize8
2498        : ((Opc == ARM::VDUPLN16d || Opc == ARM::VDUPLN16q) ? ESize16
2499                                                            : ESize32);
2500   }
2501
2502   // Qd/Dd = Inst{22:15-12} => NEON Rd
2503   MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, OpInfo[OpIdx].RegClass,
2504                                                      decodeNEONRd(insn))));
2505   ++OpIdx;
2506
2507   // VPADAL...
2508   if (TID.getOperandConstraint(OpIdx, TOI::TIED_TO) != -1) {
2509     // TIED_TO operand.
2510     MI.addOperand(MCOperand::CreateReg(0));
2511     ++OpIdx;
2512   }
2513
2514   // Dm = Inst{5:3-0} => NEON Rm
2515   MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, OpInfo[OpIdx].RegClass,
2516                                                      decodeNEONRm(insn))));
2517   ++OpIdx;
2518
2519   // VZIP and others have two TIED_TO reg operands.
2520   int Idx;
2521   while (OpIdx < NumOps &&
2522          (Idx = TID.getOperandConstraint(OpIdx, TOI::TIED_TO)) != -1) {
2523     // Add TIED_TO operand.
2524     MI.addOperand(MI.getOperand(Idx));
2525     ++OpIdx;
2526   }
2527
2528   // Add the imm operand, if required.
2529   if (OpIdx < NumOps && OpInfo[OpIdx].RegClass < 0
2530       && !OpInfo[OpIdx].isPredicate() && !OpInfo[OpIdx].isOptionalDef()) {
2531
2532     unsigned imm = 0xFFFFFFFF;
2533
2534     if (Flag == N2V_VectorDupLane)
2535       imm = decodeNVLaneDupIndex(insn, esize);
2536     if (Flag == N2V_VectorConvert_Between_Float_Fixed)
2537       imm = decodeVCVTFractionBits(insn);
2538
2539     assert(imm != 0xFFFFFFFF && "Internal error");
2540     MI.addOperand(MCOperand::CreateImm(imm));
2541     ++OpIdx;
2542   }
2543
2544   return true;
2545 }
2546
2547 static bool DisassembleN2RegFrm(MCInst &MI, unsigned Opc, uint32_t insn,
2548     unsigned short NumOps, unsigned &NumOpsAdded, BO B) {
2549
2550   return DisassembleNVdVmOptImm(MI, Opc, insn, NumOps, NumOpsAdded,
2551                                 N2V_None, B);
2552 }
2553 static bool DisassembleNVCVTFrm(MCInst &MI, unsigned Opc, uint32_t insn,
2554     unsigned short NumOps, unsigned &NumOpsAdded, BO B) {
2555
2556   return DisassembleNVdVmOptImm(MI, Opc, insn, NumOps, NumOpsAdded,
2557                                 N2V_VectorConvert_Between_Float_Fixed, B);
2558 }
2559 static bool DisassembleNVecDupLnFrm(MCInst &MI, unsigned Opc, uint32_t insn,
2560     unsigned short NumOps, unsigned &NumOpsAdded, BO B) {
2561
2562   return DisassembleNVdVmOptImm(MI, Opc, insn, NumOps, NumOpsAdded,
2563                                 N2V_VectorDupLane, B);
2564 }
2565
2566 // Vector Shift [Accumulate] Instructions.
2567 // Qd/Dd [Qd/Dd (TIED_TO)] Qm/Dm ShiftAmt
2568 //
2569 // Vector Shift Left Long (with maximum shift count) Instructions.
2570 // VSHLLi16, VSHLLi32, VSHLLi8: Qd Dm imm (== size)
2571 //
2572 static bool DisassembleNVectorShift(MCInst &MI, unsigned Opcode, uint32_t insn,
2573     unsigned short NumOps, unsigned &NumOpsAdded, bool LeftShift, BO B) {
2574
2575   const TargetInstrDesc &TID = ARMInsts[Opcode];
2576   const TargetOperandInfo *OpInfo = TID.OpInfo;
2577
2578   assert(NumOps >= 3 &&
2579          (OpInfo[0].RegClass == ARM::DPRRegClassID ||
2580           OpInfo[0].RegClass == ARM::QPRRegClassID) &&
2581          (OpInfo[1].RegClass == ARM::DPRRegClassID ||
2582           OpInfo[1].RegClass == ARM::QPRRegClassID) &&
2583          "Expect >= 3 operands and first 2 as reg operands");
2584
2585   unsigned &OpIdx = NumOpsAdded;
2586
2587   OpIdx = 0;
2588
2589   // Qd/Dd = Inst{22:15-12} => NEON Rd
2590   MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, OpInfo[OpIdx].RegClass,
2591                                                      decodeNEONRd(insn))));
2592   ++OpIdx;
2593
2594   if (TID.getOperandConstraint(OpIdx, TOI::TIED_TO) != -1) {
2595     // TIED_TO operand.
2596     MI.addOperand(MCOperand::CreateReg(0));
2597     ++OpIdx;
2598   }
2599
2600   assert((OpInfo[OpIdx].RegClass == ARM::DPRRegClassID ||
2601           OpInfo[OpIdx].RegClass == ARM::QPRRegClassID) &&
2602          "Reg operand expected");
2603
2604   // Qm/Dm = Inst{5:3-0} => NEON Rm
2605   MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, OpInfo[OpIdx].RegClass,
2606                                                      decodeNEONRm(insn))));
2607   ++OpIdx;
2608
2609   assert(OpInfo[OpIdx].RegClass < 0 && "Imm operand expected");
2610
2611   // Add the imm operand.
2612
2613   // VSHLL has maximum shift count as the imm, inferred from its size.
2614   unsigned Imm;
2615   switch (Opcode) {
2616   default:
2617     Imm = decodeNVSAmt(insn, LeftShift);
2618     break;
2619   case ARM::VSHLLi8:
2620     Imm = 8;
2621     break;
2622   case ARM::VSHLLi16:
2623     Imm = 16;
2624     break;
2625   case ARM::VSHLLi32:
2626     Imm = 32;
2627     break;
2628   }
2629   MI.addOperand(MCOperand::CreateImm(Imm));
2630   ++OpIdx;
2631
2632   return true;
2633 }
2634
2635 // Left shift instructions.
2636 static bool DisassembleN2RegVecShLFrm(MCInst &MI, unsigned Opcode,
2637     uint32_t insn, unsigned short NumOps, unsigned &NumOpsAdded, BO B) {
2638
2639   return DisassembleNVectorShift(MI, Opcode, insn, NumOps, NumOpsAdded, true,
2640                                  B);
2641 }
2642 // Right shift instructions have different shift amount interpretation.
2643 static bool DisassembleN2RegVecShRFrm(MCInst &MI, unsigned Opcode,
2644     uint32_t insn, unsigned short NumOps, unsigned &NumOpsAdded, BO B) {
2645
2646   return DisassembleNVectorShift(MI, Opcode, insn, NumOps, NumOpsAdded, false,
2647                                  B);
2648 }
2649
2650 namespace {
2651 enum N3VFlag {
2652   N3V_None,
2653   N3V_VectorExtract,
2654   N3V_VectorShift,
2655   N3V_Multiply_By_Scalar
2656 };
2657 } // End of unnamed namespace
2658
2659 // NEON Three Register Instructions with Optional Immediate Operand
2660 //
2661 // Vector Extract Instructions.
2662 // Qd/Dd Qn/Dn Qm/Dm imm4
2663 //
2664 // Vector Shift (Register) Instructions.
2665 // Qd/Dd Qm/Dm Qn/Dn (notice the order of m, n)
2666 //
2667 // Vector Multiply [Accumulate/Subtract] [Long] By Scalar Instructions.
2668 // Qd/Dd Qn/Dn RestrictedDm index
2669 //
2670 // Others
2671 static bool DisassembleNVdVnVmOptImm(MCInst &MI, unsigned Opcode, uint32_t insn,
2672     unsigned short NumOps, unsigned &NumOpsAdded, N3VFlag Flag, BO B) {
2673
2674   const TargetInstrDesc &TID = ARMInsts[Opcode];
2675   const TargetOperandInfo *OpInfo = TID.OpInfo;
2676
2677   // No checking for OpInfo[2] because of MOVDneon/MOVQ with only two regs.
2678   assert(NumOps >= 3 &&
2679          (OpInfo[0].RegClass == ARM::DPRRegClassID ||
2680           OpInfo[0].RegClass == ARM::QPRRegClassID) &&
2681          (OpInfo[1].RegClass == ARM::DPRRegClassID ||
2682           OpInfo[1].RegClass == ARM::QPRRegClassID) &&
2683          "Expect >= 3 operands and first 2 as reg operands");
2684
2685   unsigned &OpIdx = NumOpsAdded;
2686
2687   OpIdx = 0;
2688
2689   bool VdVnVm = Flag == N3V_VectorShift ? false : true;
2690   bool IsImm4 = Flag == N3V_VectorExtract ? true : false;
2691   bool IsDmRestricted = Flag == N3V_Multiply_By_Scalar ? true : false;
2692   ElemSize esize = ESizeNA;
2693   if (Flag == N3V_Multiply_By_Scalar) {
2694     unsigned size = (insn >> 20) & 3;
2695     if (size == 1) esize = ESize16;
2696     if (size == 2) esize = ESize32;
2697     assert (esize == ESize16 || esize == ESize32);
2698   }
2699
2700   // Qd/Dd = Inst{22:15-12} => NEON Rd
2701   MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, OpInfo[OpIdx].RegClass,
2702                                                      decodeNEONRd(insn))));
2703   ++OpIdx;
2704
2705   // VABA, VABAL, VBSLd, VBSLq, ...
2706   if (TID.getOperandConstraint(OpIdx, TOI::TIED_TO) != -1) {
2707     // TIED_TO operand.
2708     MI.addOperand(MCOperand::CreateReg(0));
2709     ++OpIdx;
2710   }
2711
2712   // Dn = Inst{7:19-16} => NEON Rn
2713   // or
2714   // Dm = Inst{5:3-0} => NEON Rm
2715   MI.addOperand(MCOperand::CreateReg(
2716                   getRegisterEnum(B, OpInfo[OpIdx].RegClass,
2717                                   VdVnVm ? decodeNEONRn(insn)
2718                                          : decodeNEONRm(insn))));
2719   ++OpIdx;
2720
2721   // Special case handling for VMOVDneon and VMOVQ because they are marked as
2722   // N3RegFrm.
2723   if (Opcode == ARM::VMOVDneon || Opcode == ARM::VMOVQ)
2724     return true;
2725
2726   // Dm = Inst{5:3-0} => NEON Rm
2727   // or
2728   // Dm is restricted to D0-D7 if size is 16, D0-D15 otherwise
2729   // or
2730   // Dn = Inst{7:19-16} => NEON Rn
2731   unsigned m = VdVnVm ? (IsDmRestricted ? decodeRestrictedDm(insn, esize)
2732                                         : decodeNEONRm(insn))
2733                       : decodeNEONRn(insn);
2734
2735   MI.addOperand(MCOperand::CreateReg(
2736                   getRegisterEnum(B, OpInfo[OpIdx].RegClass, m)));
2737   ++OpIdx;
2738
2739   if (OpIdx < NumOps && OpInfo[OpIdx].RegClass < 0
2740       && !OpInfo[OpIdx].isPredicate() && !OpInfo[OpIdx].isOptionalDef()) {
2741     // Add the imm operand.
2742     unsigned Imm = 0;
2743     if (IsImm4)
2744       Imm = decodeN3VImm(insn);
2745     else if (IsDmRestricted)
2746       Imm = decodeRestrictedDmIndex(insn, esize);
2747     else {
2748       assert(0 && "Internal error: unreachable code!");
2749       return false;
2750     }
2751
2752     MI.addOperand(MCOperand::CreateImm(Imm));
2753     ++OpIdx;
2754   }
2755
2756   return true;
2757 }
2758
2759 static bool DisassembleN3RegFrm(MCInst &MI, unsigned Opcode, uint32_t insn,
2760     unsigned short NumOps, unsigned &NumOpsAdded, BO B) {
2761
2762   return DisassembleNVdVnVmOptImm(MI, Opcode, insn, NumOps, NumOpsAdded,
2763                                   N3V_None, B);
2764 }
2765 static bool DisassembleN3RegVecShFrm(MCInst &MI, unsigned Opcode,
2766     uint32_t insn, unsigned short NumOps, unsigned &NumOpsAdded, BO B) {
2767
2768   return DisassembleNVdVnVmOptImm(MI, Opcode, insn, NumOps, NumOpsAdded,
2769                                   N3V_VectorShift, B);
2770 }
2771 static bool DisassembleNVecExtractFrm(MCInst &MI, unsigned Opcode, uint32_t insn,
2772     unsigned short NumOps, unsigned &NumOpsAdded, BO B) {
2773
2774   return DisassembleNVdVnVmOptImm(MI, Opcode, insn, NumOps, NumOpsAdded,
2775                                   N3V_VectorExtract, B);
2776 }
2777 static bool DisassembleNVecMulScalarFrm(MCInst &MI, unsigned Opcode,
2778     uint32_t insn, unsigned short NumOps, unsigned &NumOpsAdded, BO B) {
2779
2780   return DisassembleNVdVnVmOptImm(MI, Opcode, insn, NumOps, NumOpsAdded,
2781                                   N3V_Multiply_By_Scalar, B);
2782 }
2783
2784 // Vector Table Lookup
2785 //
2786 // VTBL1, VTBX1: Dd [Dd(TIED_TO)] Dn Dm
2787 // VTBL2, VTBX2: Dd [Dd(TIED_TO)] Dn Dn+1 Dm
2788 // VTBL3, VTBX3: Dd [Dd(TIED_TO)] Dn Dn+1 Dn+2 Dm
2789 // VTBL4, VTBX4: Dd [Dd(TIED_TO)] Dn Dn+1 Dn+2 Dn+3 Dm
2790 static bool DisassembleNVTBLFrm(MCInst &MI, unsigned Opcode, uint32_t insn,
2791     unsigned short NumOps, unsigned &NumOpsAdded, BO B) {
2792
2793   const TargetInstrDesc &TID = ARMInsts[Opcode];
2794   const TargetOperandInfo *OpInfo = TID.OpInfo;
2795   if (!OpInfo) return false;
2796
2797   assert(NumOps >= 3 &&
2798          OpInfo[0].RegClass == ARM::DPRRegClassID &&
2799          OpInfo[1].RegClass == ARM::DPRRegClassID &&
2800          OpInfo[2].RegClass == ARM::DPRRegClassID &&
2801          "Expect >= 3 operands and first 3 as reg operands");
2802
2803   unsigned &OpIdx = NumOpsAdded;
2804
2805   OpIdx = 0;
2806
2807   unsigned Rn = decodeNEONRn(insn);
2808
2809   // {Dn} encoded as len = 0b00
2810   // {Dn Dn+1} encoded as len = 0b01
2811   // {Dn Dn+1 Dn+2 } encoded as len = 0b10
2812   // {Dn Dn+1 Dn+2 Dn+3} encoded as len = 0b11
2813   unsigned Len = slice(insn, 9, 8) + 1;
2814
2815   // Dd (the destination vector)
2816   MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::DPRRegClassID,
2817                                                      decodeNEONRd(insn))));
2818   ++OpIdx;
2819
2820   // Process tied_to operand constraint.
2821   int Idx;
2822   if ((Idx = TID.getOperandConstraint(OpIdx, TOI::TIED_TO)) != -1) {
2823     MI.addOperand(MI.getOperand(Idx));
2824     ++OpIdx;
2825   }
2826
2827   // Do the <list> now.
2828   for (unsigned i = 0; i < Len; ++i) {
2829     assert(OpIdx < NumOps && OpInfo[OpIdx].RegClass == ARM::DPRRegClassID &&
2830            "Reg operand expected");
2831     MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::DPRRegClassID,
2832                                                        Rn + i)));
2833     ++OpIdx;
2834   }
2835
2836   // Dm (the index vector)
2837   assert(OpIdx < NumOps && OpInfo[OpIdx].RegClass == ARM::DPRRegClassID &&
2838          "Reg operand (index vector) expected");
2839   MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::DPRRegClassID,
2840                                                      decodeNEONRm(insn))));
2841   ++OpIdx;
2842
2843   return true;
2844 }
2845
2846 // Vector Get Lane (move scalar to ARM core register) Instructions.
2847 // VGETLNi32, VGETLNs16, VGETLNs8, VGETLNu16, VGETLNu8: Rt Dn index
2848 static bool DisassembleNGetLnFrm(MCInst &MI, unsigned Opcode, uint32_t insn,
2849     unsigned short NumOps, unsigned &NumOpsAdded, BO B) {
2850
2851   const TargetInstrDesc &TID = ARMInsts[Opcode];
2852   const TargetOperandInfo *OpInfo = TID.OpInfo;
2853   if (!OpInfo) return false;
2854
2855   assert(TID.getNumDefs() == 1 && NumOps >= 3 &&
2856          OpInfo[0].RegClass == ARM::GPRRegClassID &&
2857          OpInfo[1].RegClass == ARM::DPRRegClassID &&
2858          OpInfo[2].RegClass < 0 &&
2859          "Expect >= 3 operands with one dst operand");
2860
2861   ElemSize esize =
2862     Opcode == ARM::VGETLNi32 ? ESize32
2863       : ((Opcode == ARM::VGETLNs16 || Opcode == ARM::VGETLNu16) ? ESize16
2864                                                                 : ESize32);
2865
2866   // Rt = Inst{15-12} => ARM Rd
2867   MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::GPRRegClassID,
2868                                                      decodeRd(insn))));
2869
2870   // Dn = Inst{7:19-16} => NEON Rn
2871   MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::DPRRegClassID,
2872                                                      decodeNEONRn(insn))));
2873
2874   MI.addOperand(MCOperand::CreateImm(decodeNVLaneOpIndex(insn, esize)));
2875
2876   NumOpsAdded = 3;
2877   return true;
2878 }
2879
2880 // Vector Set Lane (move ARM core register to scalar) Instructions.
2881 // VSETLNi16, VSETLNi32, VSETLNi8: Dd Dd (TIED_TO) Rt index
2882 static bool DisassembleNSetLnFrm(MCInst &MI, unsigned Opcode, uint32_t insn,
2883     unsigned short NumOps, unsigned &NumOpsAdded, BO B) {
2884
2885   const TargetInstrDesc &TID = ARMInsts[Opcode];
2886   const TargetOperandInfo *OpInfo = TID.OpInfo;
2887   if (!OpInfo) return false;
2888
2889   assert(TID.getNumDefs() == 1 && NumOps >= 3 &&
2890          OpInfo[0].RegClass == ARM::DPRRegClassID &&
2891          OpInfo[1].RegClass == ARM::DPRRegClassID &&
2892          TID.getOperandConstraint(1, TOI::TIED_TO) != -1 &&
2893          OpInfo[2].RegClass == ARM::GPRRegClassID &&
2894          OpInfo[3].RegClass < 0 &&
2895          "Expect >= 3 operands with one dst operand");
2896
2897   ElemSize esize =
2898     Opcode == ARM::VSETLNi8 ? ESize8
2899                             : (Opcode == ARM::VSETLNi16 ? ESize16
2900                                                         : ESize32);
2901
2902   // Dd = Inst{7:19-16} => NEON Rn
2903   MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::DPRRegClassID,
2904                                                      decodeNEONRn(insn))));
2905
2906   // TIED_TO operand.
2907   MI.addOperand(MCOperand::CreateReg(0));
2908
2909   // Rt = Inst{15-12} => ARM Rd
2910   MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::GPRRegClassID,
2911                                                      decodeRd(insn))));
2912
2913   MI.addOperand(MCOperand::CreateImm(decodeNVLaneOpIndex(insn, esize)));
2914
2915   NumOpsAdded = 4;
2916   return true;
2917 }
2918
2919 // Vector Duplicate Instructions (from ARM core register to all elements).
2920 // VDUP8d, VDUP16d, VDUP32d, VDUP8q, VDUP16q, VDUP32q: Qd/Dd Rt
2921 static bool DisassembleNDupFrm(MCInst &MI, unsigned Opcode, uint32_t insn,
2922     unsigned short NumOps, unsigned &NumOpsAdded, BO B) {
2923
2924   const TargetOperandInfo *OpInfo = ARMInsts[Opcode].OpInfo;
2925
2926   assert(NumOps >= 2 &&
2927          (OpInfo[0].RegClass == ARM::DPRRegClassID ||
2928           OpInfo[0].RegClass == ARM::QPRRegClassID) &&
2929          OpInfo[1].RegClass == ARM::GPRRegClassID &&
2930          "Expect >= 2 operands and first 2 as reg operand");
2931
2932   unsigned RegClass = OpInfo[0].RegClass;
2933
2934   // Qd/Dd = Inst{7:19-16} => NEON Rn
2935   MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, RegClass,
2936                                                      decodeNEONRn(insn))));
2937
2938   // Rt = Inst{15-12} => ARM Rd
2939   MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::GPRRegClassID,
2940                                                      decodeRd(insn))));
2941
2942   NumOpsAdded = 2;
2943   return true;
2944 }
2945
2946 // A8.6.41 DMB
2947 // A8.6.42 DSB
2948 // A8.6.49 ISB
2949 static inline bool MemBarrierInstr(uint32_t insn) {
2950   unsigned op7_4 = slice(insn, 7, 4);
2951   if (slice(insn, 31, 20) == 0xf57 && (op7_4 >= 4 && op7_4 <= 6))
2952     return true;
2953
2954   return false;
2955 }
2956
2957 static inline bool PreLoadOpcode(unsigned Opcode) {
2958   switch(Opcode) {
2959   case ARM::PLDi:  case ARM::PLDr:
2960   case ARM::PLDWi: case ARM::PLDWr:
2961   case ARM::PLIi:  case ARM::PLIr:
2962     return true;
2963   default:
2964     return false;
2965   }
2966 }
2967
2968 static bool DisassemblePreLoadFrm(MCInst &MI, unsigned Opcode, uint32_t insn,
2969     unsigned short NumOps, unsigned &NumOpsAdded, BO B) {
2970
2971   // Preload Data/Instruction requires either 2 or 4 operands.
2972   // PLDi, PLDWi, PLIi:                Rn [+/-]imm12 add = (U == '1')
2973   // PLDr[a|m], PLDWr[a|m], PLIr[a|m]: Rn Rm addrmode2_opc
2974
2975   MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::GPRRegClassID,
2976                                                      decodeRn(insn))));
2977
2978   if (Opcode == ARM::PLDi || Opcode == ARM::PLDWi || Opcode == ARM::PLIi) {
2979     unsigned Imm12 = slice(insn, 11, 0);
2980     bool Negative = getUBit(insn) == 0;
2981     int Offset = Negative ? -1 - Imm12 : 1 * Imm12;
2982     MI.addOperand(MCOperand::CreateImm(Offset));
2983     NumOpsAdded = 2;
2984   } else {
2985     MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::GPRRegClassID,
2986                                                        decodeRm(insn))));
2987
2988     ARM_AM::AddrOpc AddrOpcode = getUBit(insn) ? ARM_AM::add : ARM_AM::sub;
2989
2990     // Inst{6-5} encodes the shift opcode.
2991     ARM_AM::ShiftOpc ShOp = getShiftOpcForBits(slice(insn, 6, 5));
2992     // Inst{11-7} encodes the imm5 shift amount.
2993     unsigned ShImm = slice(insn, 11, 7);
2994
2995     // A8.4.1.  Possible rrx or shift amount of 32...
2996     getImmShiftSE(ShOp, ShImm);
2997     MI.addOperand(MCOperand::CreateImm(
2998                     ARM_AM::getAM2Opc(AddrOpcode, ShImm, ShOp)));
2999     NumOpsAdded = 3;
3000   }
3001
3002   return true;
3003 }
3004
3005 static bool DisassembleMiscFrm(MCInst &MI, unsigned Opcode, uint32_t insn,
3006     unsigned short NumOps, unsigned &NumOpsAdded, BO B) {
3007
3008   if (MemBarrierInstr(insn))
3009     return true;
3010
3011   switch (Opcode) {
3012   case ARM::CLREX:
3013   case ARM::NOP:
3014   case ARM::TRAP:
3015   case ARM::YIELD:
3016   case ARM::WFE:
3017   case ARM::WFI:
3018   case ARM::SEV:
3019   case ARM::SETENDBE:
3020   case ARM::SETENDLE:
3021     return true;
3022   default:
3023     break;
3024   }
3025
3026   // CPS has a singleton $opt operand that contains the following information:
3027   // opt{4-0} = mode from Inst{4-0}
3028   // opt{5} = changemode from Inst{17}
3029   // opt{8-6} = AIF from Inst{8-6}
3030   // opt{10-9} = imod from Inst{19-18} with 0b10 as enable and 0b11 as disable
3031   if (Opcode == ARM::CPS) {
3032     unsigned Option = slice(insn, 4, 0) | slice(insn, 17, 17) << 5 |
3033       slice(insn, 8, 6) << 6 | slice(insn, 19, 18) << 9;
3034     MI.addOperand(MCOperand::CreateImm(Option));
3035     NumOpsAdded = 1;
3036     return true;
3037   }
3038
3039   // DBG has its option specified in Inst{3-0}.
3040   if (Opcode == ARM::DBG) {
3041     MI.addOperand(MCOperand::CreateImm(slice(insn, 3, 0)));
3042     NumOpsAdded = 1;
3043     return true;
3044   }
3045
3046   // BKPT takes an imm32 val equal to ZeroExtend(Inst{19-8:3-0}).
3047   if (Opcode == ARM::BKPT) {
3048     MI.addOperand(MCOperand::CreateImm(slice(insn, 19, 8) << 4 |
3049                                        slice(insn, 3, 0)));
3050     NumOpsAdded = 1;
3051     return true;
3052   }
3053
3054   if (PreLoadOpcode(Opcode))
3055     return DisassemblePreLoadFrm(MI, Opcode, insn, NumOps, NumOpsAdded, B);
3056
3057   assert(0 && "Unexpected misc instruction!");
3058   return false;
3059 }
3060
3061 /// FuncPtrs - FuncPtrs maps ARMFormat to its corresponding DisassembleFP.
3062 /// We divide the disassembly task into different categories, with each one
3063 /// corresponding to a specific instruction encoding format.  There could be
3064 /// exceptions when handling a specific format, and that is why the Opcode is
3065 /// also present in the function prototype.
3066 static const DisassembleFP FuncPtrs[] = {
3067   &DisassemblePseudo,
3068   &DisassembleMulFrm,
3069   &DisassembleBrFrm,
3070   &DisassembleBrMiscFrm,
3071   &DisassembleDPFrm,
3072   &DisassembleDPSoRegFrm,
3073   &DisassembleLdFrm,
3074   &DisassembleStFrm,
3075   &DisassembleLdMiscFrm,
3076   &DisassembleStMiscFrm,
3077   &DisassembleLdStMulFrm,
3078   &DisassembleLdStExFrm,
3079   &DisassembleArithMiscFrm,
3080   &DisassembleExtFrm,
3081   &DisassembleVFPUnaryFrm,
3082   &DisassembleVFPBinaryFrm,
3083   &DisassembleVFPConv1Frm,
3084   &DisassembleVFPConv2Frm,
3085   &DisassembleVFPConv3Frm,
3086   &DisassembleVFPConv4Frm,
3087   &DisassembleVFPConv5Frm,
3088   &DisassembleVFPLdStFrm,
3089   &DisassembleVFPLdStMulFrm,
3090   &DisassembleVFPMiscFrm,
3091   &DisassembleThumbFrm,
3092   &DisassembleMiscFrm,
3093   &DisassembleNGetLnFrm,
3094   &DisassembleNSetLnFrm,
3095   &DisassembleNDupFrm,
3096
3097   // VLD and VST (including one lane) Instructions.
3098   &DisassembleNLdSt,
3099
3100   // A7.4.6 One register and a modified immediate value
3101   // 1-Register Instructions with imm.
3102   // LLVM only defines VMOVv instructions.
3103   &DisassembleN1RegModImmFrm,
3104
3105   // 2-Register Instructions with no imm.
3106   &DisassembleN2RegFrm,
3107
3108   // 2-Register Instructions with imm (vector convert float/fixed point).
3109   &DisassembleNVCVTFrm,
3110
3111   // 2-Register Instructions with imm (vector dup lane).
3112   &DisassembleNVecDupLnFrm,
3113
3114   // Vector Shift Left Instructions.
3115   &DisassembleN2RegVecShLFrm,
3116
3117   // Vector Shift Righ Instructions, which has different interpretation of the
3118   // shift amount from the imm6 field.
3119   &DisassembleN2RegVecShRFrm,
3120
3121   // 3-Register Data-Processing Instructions.
3122   &DisassembleN3RegFrm,
3123
3124   // Vector Shift (Register) Instructions.
3125   // D:Vd M:Vm N:Vn (notice that M:Vm is the first operand)
3126   &DisassembleN3RegVecShFrm,
3127
3128   // Vector Extract Instructions.
3129   &DisassembleNVecExtractFrm,
3130
3131   // Vector [Saturating Rounding Doubling] Multiply [Accumulate/Subtract] [Long]
3132   // By Scalar Instructions.
3133   &DisassembleNVecMulScalarFrm,
3134
3135   // Vector Table Lookup uses byte indexes in a control vector to look up byte
3136   // values in a table and generate a new vector.
3137   &DisassembleNVTBLFrm,
3138
3139   NULL
3140 };
3141
3142 /// BuildIt - BuildIt performs the build step for this ARM Basic MC Builder.
3143 /// The general idea is to set the Opcode for the MCInst, followed by adding
3144 /// the appropriate MCOperands to the MCInst.  ARM Basic MC Builder delegates
3145 /// to the Format-specific disassemble function for disassembly, followed by
3146 /// TryPredicateAndSBitModifier() to do PredicateOperand and OptionalDefOperand
3147 /// which follow the Dst/Src Operands.
3148 bool ARMBasicMCBuilder::BuildIt(MCInst &MI, uint32_t insn) {
3149   // Stage 1 sets the Opcode.
3150   MI.setOpcode(Opcode);
3151   // If the number of operands is zero, we're done!
3152   if (NumOps == 0)
3153     return true;
3154
3155   // Stage 2 calls the format-specific disassemble function to build the operand
3156   // list.
3157   if (Disasm == NULL)
3158     return false;
3159   unsigned NumOpsAdded = 0;
3160   bool OK = (*Disasm)(MI, Opcode, insn, NumOps, NumOpsAdded, this);
3161
3162   if (!OK || this->Err != 0) return false;
3163   if (NumOpsAdded >= NumOps)
3164     return true;
3165
3166   // Stage 3 deals with operands unaccounted for after stage 2 is finished.
3167   // FIXME: Should this be done selectively?
3168   return TryPredicateAndSBitModifier(MI, Opcode, insn, NumOps - NumOpsAdded);
3169 }
3170
3171 // A8.3 Conditional execution
3172 // A8.3.1 Pseudocode details of conditional execution
3173 // Condition bits '111x' indicate the instruction is always executed.
3174 static uint32_t CondCode(uint32_t CondField) {
3175   if (CondField == 0xF)
3176     return ARMCC::AL;
3177   return CondField;
3178 }
3179
3180 /// DoPredicateOperands - DoPredicateOperands process the predicate operands
3181 /// of some Thumb instructions which come before the reglist operands.  It
3182 /// returns true if the two predicate operands have been processed.
3183 bool ARMBasicMCBuilder::DoPredicateOperands(MCInst& MI, unsigned Opcode,
3184     uint32_t /* insn */, unsigned short NumOpsRemaining) {
3185
3186   assert(NumOpsRemaining > 0 && "Invalid argument");
3187
3188   const TargetOperandInfo *OpInfo = ARMInsts[Opcode].OpInfo;
3189   unsigned Idx = MI.getNumOperands();
3190
3191   // First, we check whether this instr specifies the PredicateOperand through
3192   // a pair of TargetOperandInfos with isPredicate() property.
3193   if (NumOpsRemaining >= 2 &&
3194       OpInfo[Idx].isPredicate() && OpInfo[Idx+1].isPredicate() &&
3195       OpInfo[Idx].RegClass < 0 &&
3196       OpInfo[Idx+1].RegClass == ARM::CCRRegClassID)
3197   {
3198     // If we are inside an IT block, get the IT condition bits maintained via
3199     // ARMBasicMCBuilder::ITState[7:0], through ARMBasicMCBuilder::GetITCond().
3200     // See also A2.5.2.
3201     if (InITBlock())
3202       MI.addOperand(MCOperand::CreateImm(GetITCond()));
3203     else
3204       MI.addOperand(MCOperand::CreateImm(ARMCC::AL));
3205     MI.addOperand(MCOperand::CreateReg(ARM::CPSR));
3206     return true;
3207   }
3208
3209   return false;
3210 }
3211
3212 /// TryPredicateAndSBitModifier - TryPredicateAndSBitModifier tries to process
3213 /// the possible Predicate and SBitModifier, to build the remaining MCOperand
3214 /// constituents.
3215 bool ARMBasicMCBuilder::TryPredicateAndSBitModifier(MCInst& MI, unsigned Opcode,
3216     uint32_t insn, unsigned short NumOpsRemaining) {
3217
3218   assert(NumOpsRemaining > 0 && "Invalid argument");
3219
3220   const TargetOperandInfo *OpInfo = ARMInsts[Opcode].OpInfo;
3221   const std::string &Name = ARMInsts[Opcode].Name;
3222   unsigned Idx = MI.getNumOperands();
3223
3224   // First, we check whether this instr specifies the PredicateOperand through
3225   // a pair of TargetOperandInfos with isPredicate() property.
3226   if (NumOpsRemaining >= 2 &&
3227       OpInfo[Idx].isPredicate() && OpInfo[Idx+1].isPredicate() &&
3228       OpInfo[Idx].RegClass < 0 &&
3229       OpInfo[Idx+1].RegClass == ARM::CCRRegClassID)
3230   {
3231     // If we are inside an IT block, get the IT condition bits maintained via
3232     // ARMBasicMCBuilder::ITState[7:0], through ARMBasicMCBuilder::GetITCond().
3233     // See also A2.5.2.
3234     if (InITBlock())
3235       MI.addOperand(MCOperand::CreateImm(GetITCond()));
3236     else {
3237       if (Name.length() > 1 && Name[0] == 't') {
3238         // Thumb conditional branch instructions have their cond field embedded,
3239         // like ARM.
3240         //
3241         // A8.6.16 B
3242         if (Name == "t2Bcc")
3243           MI.addOperand(MCOperand::CreateImm(CondCode(slice(insn, 25, 22))));
3244         else if (Name == "tBcc")
3245           MI.addOperand(MCOperand::CreateImm(CondCode(slice(insn, 11, 8))));
3246         else
3247           MI.addOperand(MCOperand::CreateImm(ARMCC::AL));
3248       } else {
3249         // ARM instructions get their condition field from Inst{31-28}.
3250         MI.addOperand(MCOperand::CreateImm(CondCode(getCondField(insn))));
3251       }
3252     }
3253     MI.addOperand(MCOperand::CreateReg(ARM::CPSR));
3254     Idx += 2;
3255     NumOpsRemaining -= 2;
3256   }
3257
3258   if (NumOpsRemaining == 0)
3259     return true;
3260
3261   // Next, if OptionalDefOperand exists, we check whether the 'S' bit is set.
3262   if (OpInfo[Idx].isOptionalDef() && OpInfo[Idx].RegClass==ARM::CCRRegClassID) {
3263     MI.addOperand(MCOperand::CreateReg(getSBit(insn) == 1 ? ARM::CPSR : 0));
3264     --NumOpsRemaining;
3265   }
3266
3267   if (NumOpsRemaining == 0)
3268     return true;
3269   else
3270     return false;
3271 }
3272
3273 /// RunBuildAfterHook - RunBuildAfterHook performs operations deemed necessary
3274 /// after BuildIt is finished.
3275 bool ARMBasicMCBuilder::RunBuildAfterHook(bool Status, MCInst &MI,
3276     uint32_t insn) {
3277
3278   if (!SP) return Status;
3279
3280   if (Opcode == ARM::t2IT)
3281     Status = SP->InitIT(slice(insn, 7, 0)) ? Status : false;
3282   else if (InITBlock())
3283     SP->UpdateIT();
3284
3285   return Status;
3286 }
3287
3288 /// Opcode, Format, and NumOperands make up an ARM Basic MCBuilder.
3289 ARMBasicMCBuilder::ARMBasicMCBuilder(unsigned opc, ARMFormat format,
3290                                      unsigned short num)
3291   : Opcode(opc), Format(format), NumOps(num), SP(0), Err(0) {
3292   unsigned Idx = (unsigned)format;
3293   assert(Idx < (array_lengthof(FuncPtrs) - 1) && "Unknown format");
3294   Disasm = FuncPtrs[Idx];
3295 }
3296
3297 /// CreateMCBuilder - Return an ARMBasicMCBuilder that can build up the MC
3298 /// infrastructure of an MCInst given the Opcode and Format of the instr.
3299 /// Return NULL if it fails to create/return a proper builder.  API clients
3300 /// are responsible for freeing up of the allocated memory.  Cacheing can be
3301 /// performed by the API clients to improve performance.
3302 ARMBasicMCBuilder *llvm::CreateMCBuilder(unsigned Opcode, ARMFormat Format) {
3303   // For "Unknown format", fail by returning a NULL pointer.
3304   if ((unsigned)Format >= (array_lengthof(FuncPtrs) - 1)) {
3305     DEBUG(errs() << "Unknown format\n");
3306     return 0;
3307   }
3308
3309   return new ARMBasicMCBuilder(Opcode, Format,
3310                                ARMInsts[Opcode].getNumOperands());
3311 }