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