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