lib/Target/ARM/Disassembler/ThumbDisassemblerCore.h

   1 //===- ThumbDisassemblerCore.h - Thumb 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 for disassembling a Thumb instr.  It is to be included by
  12 // ARMDisassemblerCore.cpp because it contains the static DisassembleThumbFrm()
  13 // function which acts as the dispatcher to disassemble a Thumb instruction.
  14 //
  15 //===----------------------------------------------------------------------===//
  16
  17 ///////////////////////////////
  18 //                           //
  19 //     Utility Functions     //
  20 //                           //
  21 ///////////////////////////////
  22
  23 // Utilities for 16-bit Thumb instructions.
  24 /*
  25 15 14 13 12 11 10  9  8  7  6  5  4  3  2  1  0
  26                [  tRt ]
  27                       [ tRm ]  [ tRn ]  [ tRd ]
  28                          D  [   Rm   ]  [  Rd ]
  29
  30                       [ imm3]
  31                [    imm5    ]
  32                    i     [    imm5   ]
  33                             [       imm7      ]
  34                          [       imm8         ]
  35                [             imm11            ]
  36
  37             [   cond  ]
  38 */
  39
  40 // Extract tRt: Inst{10-8}.
  41 static inline unsigned getT1tRt(uint32_t insn) {
  42   return slice(insn, 10, 8);
  43 }
  44
  45 // Extract tRm: Inst{8-6}.
  46 static inline unsigned getT1tRm(uint32_t insn) {
  47   return slice(insn, 8, 6);
  48 }
  49
  50 // Extract tRn: Inst{5-3}.
  51 static inline unsigned getT1tRn(uint32_t insn) {
  52   return slice(insn, 5, 3);
  53 }
  54
  55 // Extract tRd: Inst{2-0}.
  56 static inline unsigned getT1tRd(uint32_t insn) {
  57   return slice(insn, 2, 0);
  58 }
  59
  60 // Extract [D:Rd]: Inst{7:2-0}.
  61 static inline unsigned getT1Rd(uint32_t insn) {
  62   return slice(insn, 7, 7) << 3 | slice(insn, 2, 0);
  63 }
  64
  65 // Extract Rm: Inst{6-3}.
  66 static inline unsigned getT1Rm(uint32_t insn) {
  67   return slice(insn, 6, 3);
  68 }
  69
  70 // Extract imm3: Inst{8-6}.
  71 static inline unsigned getT1Imm3(uint32_t insn) {
  72   return slice(insn, 8, 6);
  73 }
  74
  75 // Extract imm5: Inst{10-6}.
  76 static inline unsigned getT1Imm5(uint32_t insn) {
  77   return slice(insn, 10, 6);
  78 }
  79
  80 // Extract i:imm5: Inst{9:7-3}.
  81 static inline unsigned getT1Imm6(uint32_t insn) {
  82   return slice(insn, 9, 9) << 5 | slice(insn, 7, 3);
  83 }
  84
  85 // Extract imm7: Inst{6-0}.
  86 static inline unsigned getT1Imm7(uint32_t insn) {
  87   return slice(insn, 6, 0);
  88 }
  89
  90 // Extract imm8: Inst{7-0}.
  91 static inline unsigned getT1Imm8(uint32_t insn) {
  92   return slice(insn, 7, 0);
  93 }
  94
  95 // Extract imm11: Inst{10-0}.
  96 static inline unsigned getT1Imm11(uint32_t insn) {
  97   return slice(insn, 10, 0);
  98 }
  99
 100 // Extract cond: Inst{11-8}.
 101 static inline unsigned getT1Cond(uint32_t insn) {
 102   return slice(insn, 11, 8);
 103 }
 104
 105 static inline bool IsGPR(unsigned RegClass) {
 106   return RegClass == ARM::GPRRegClassID || RegClass == ARM::rGPRRegClassID;
 107 }
 108
 109 // Utilities for 32-bit Thumb instructions.
 110
 111 static inline bool BadReg(uint32_t n) { return n == 13 || n == 15; }
 112
 113 // Extract imm4: Inst{19-16}.
 114 static inline unsigned getImm4(uint32_t insn) {
 115   return slice(insn, 19, 16);
 116 }
 117
 118 // Extract imm3: Inst{14-12}.
 119 static inline unsigned getImm3(uint32_t insn) {
 120   return slice(insn, 14, 12);
 121 }
 122
 123 // Extract imm8: Inst{7-0}.
 124 static inline unsigned getImm8(uint32_t insn) {
 125   return slice(insn, 7, 0);
 126 }
 127
 128 // A8.6.61 LDRB (immediate, Thumb) and friends
 129 // +/-: Inst{9}
 130 // imm8: Inst{7-0}
 131 static inline int decodeImm8(uint32_t insn) {
 132   int Offset = getImm8(insn);
 133   return slice(insn, 9, 9) ? Offset : -Offset;
 134 }
 135
 136 // Extract imm12: Inst{11-0}.
 137 static inline unsigned getImm12(uint32_t insn) {
 138   return slice(insn, 11, 0);
 139 }
 140
 141 // A8.6.63 LDRB (literal) and friends
 142 // +/-: Inst{23}
 143 // imm12: Inst{11-0}
 144 static inline int decodeImm12(uint32_t insn) {
 145   int Offset = getImm12(insn);
 146   return slice(insn, 23, 23) ? Offset : -Offset;
 147 }
 148
 149 // Extract imm2: Inst{7-6}.
 150 static inline unsigned getImm2(uint32_t insn) {
 151   return slice(insn, 7, 6);
 152 }
 153
 154 // For BFI, BFC, t2SBFX, and t2UBFX.
 155 // Extract lsb: Inst{14-12:7-6}.
 156 static inline unsigned getLsb(uint32_t insn) {
 157   return getImm3(insn) << 2 | getImm2(insn);
 158 }
 159
 160 // For BFI and BFC.
 161 // Extract msb: Inst{4-0}.
 162 static inline unsigned getMsb(uint32_t insn) {
 163   return slice(insn, 4, 0);
 164 }
 165
 166 // For t2SBFX and t2UBFX.
 167 // Extract widthminus1: Inst{4-0}.
 168 static inline unsigned getWidthMinus1(uint32_t insn) {
 169   return slice(insn, 4, 0);
 170 }
 171
 172 // For t2ADDri12 and t2SUBri12.
 173 // imm12 = i:imm3:imm8;
 174 static inline unsigned getIImm3Imm8(uint32_t insn) {
 175   return slice(insn, 26, 26) << 11 | getImm3(insn) << 8 | getImm8(insn);
 176 }
 177
 178 // For t2MOVi16 and t2MOVTi16.
 179 // imm16 = imm4:i:imm3:imm8;
 180 static inline unsigned getImm16(uint32_t insn) {
 181   return getImm4(insn) << 12 | slice(insn, 26, 26) << 11 |
 182     getImm3(insn) << 8 | getImm8(insn);
 183 }
 184
 185 // Inst{5-4} encodes the shift type.
 186 static inline unsigned getShiftTypeBits(uint32_t insn) {
 187   return slice(insn, 5, 4);
 188 }
 189
 190 // Inst{14-12}:Inst{7-6} encodes the imm5 shift amount.
 191 static inline unsigned getShiftAmtBits(uint32_t insn) {
 192   return getImm3(insn) << 2 | getImm2(insn);
 193 }
 194
 195 // A8.6.17 BFC
 196 // Encoding T1 ARMv6T2, ARMv7
 197 // LLVM-specific encoding for #<lsb> and #<width>
 198 static inline bool getBitfieldInvMask(uint32_t insn, uint32_t &mask) {
 199   uint32_t lsb = getImm3(insn) << 2 | getImm2(insn);
 200   uint32_t msb = getMsb(insn);
 201   uint32_t Val = 0;
 202   if (msb < lsb) {
 203     DEBUG(errs() << "Encoding error: msb < lsb\n");
 204     return false;
 205   }
 206   for (uint32_t i = lsb; i <= msb; ++i)
 207     Val |= (1 << i);
 208   mask = ~Val;
 209   return true;
 210 }
 211
 212 // A8.4 Shifts applied to a register
 213 // A8.4.1 Constant shifts
 214 // A8.4.3 Pseudocode details of instruction-specified shifts and rotates
 215 //
 216 // decodeImmShift() returns the shift amount and the the shift opcode.
 217 // Note that, as of Jan-06-2010, LLVM does not support rrx shifted operands yet.
 218 static inline unsigned decodeImmShift(unsigned bits2, unsigned imm5,
 219                                       ARM_AM::ShiftOpc &ShOp) {
 220
 221   assert(imm5 < 32 && "Invalid imm5 argument");
 222   switch (bits2) {
 223   default: assert(0 && "No such value");
 224   case 0:
 225     ShOp = (imm5 == 0 ? ARM_AM::no_shift : ARM_AM::lsl);
 226     return imm5;
 227   case 1:
 228     ShOp = ARM_AM::lsr;
 229     return (imm5 == 0 ? 32 : imm5);
 230   case 2:
 231     ShOp = ARM_AM::asr;
 232     return (imm5 == 0 ? 32 : imm5);
 233   case 3:
 234     ShOp = (imm5 == 0 ? ARM_AM::rrx : ARM_AM::ror);
 235     return (imm5 == 0 ? 1 : imm5);
 236   }
 237 }
 238
 239 // A6.3.2 Modified immediate constants in Thumb instructions
 240 //
 241 // ThumbExpandImm() returns the modified immediate constant given an imm12 for
 242 // Thumb data-processing instructions with modified immediate.
 243 // See also A6.3.1 Data-processing (modified immediate).
 244 static inline unsigned ThumbExpandImm(unsigned imm12) {
 245   assert(imm12 <= 0xFFF && "Invalid imm12 argument");
 246
 247   // If the leading two bits is 0b00, the modified immediate constant is
 248   // obtained by splatting the low 8 bits into the first byte, every other byte,
 249   // or every byte of a 32-bit value.
 250   //
 251   // Otherwise, a rotate right of '1':imm12<6:0> by the amount imm12<11:7> is
 252   // performed.
 253
 254   if (slice(imm12, 11, 10) == 0) {
 255     unsigned short control = slice(imm12, 9, 8);
 256     unsigned imm8 = slice(imm12, 7, 0);
 257     switch (control) {
 258     default:
 259       assert(0 && "No such value");
 260       return 0;
 261     case 0:
 262       return imm8;
 263     case 1:
 264       return imm8 << 16 | imm8;
 265     case 2:
 266       return imm8 << 24 | imm8 << 8;
 267     case 3:
 268       return imm8 << 24 | imm8 << 16 | imm8 << 8 | imm8;
 269     }
 270   } else {
 271     // A rotate is required.
 272     unsigned Val = 1 << 7 | slice(imm12, 6, 0);
 273     unsigned Amt = slice(imm12, 11, 7);
 274     return ARM_AM::rotr32(Val, Amt);
 275   }
 276 }
 277
 278 static inline int decodeImm32_B_EncodingT3(uint32_t insn) {
 279   bool S = slice(insn, 26, 26);
 280   bool J1 = slice(insn, 13, 13);
 281   bool J2 = slice(insn, 11, 11);
 282   unsigned Imm21 = slice(insn, 21, 16) << 12 | slice(insn, 10, 0) << 1;
 283   if (S) Imm21 |= 1 << 20;
 284   if (J2) Imm21 |= 1 << 19;
 285   if (J1) Imm21 |= 1 << 18;
 286
 287   return SignExtend32<21>(Imm21);
 288 }
 289
 290 static inline int decodeImm32_B_EncodingT4(uint32_t insn) {
 291   unsigned S = slice(insn, 26, 26);
 292   bool I1 = slice(insn, 13, 13) == S;
 293   bool I2 = slice(insn, 11, 11) == S;
 294   unsigned Imm25 = slice(insn, 25, 16) << 12 | slice(insn, 10, 0) << 1;
 295   if (S) Imm25 |= 1 << 24;
 296   if (I1) Imm25 |= 1 << 23;
 297   if (I2) Imm25 |= 1 << 22;
 298
 299   return SignExtend32<25>(Imm25);
 300 }
 301
 302 static inline int decodeImm32_BL(uint32_t insn) {
 303   unsigned S = slice(insn, 26, 26);
 304   bool I1 = slice(insn, 13, 13) == S;
 305   bool I2 = slice(insn, 11, 11) == S;
 306   unsigned Imm25 = slice(insn, 25, 16) << 12 | slice(insn, 10, 0) << 1;
 307   if (S) Imm25 |= 1 << 24;
 308   if (I1) Imm25 |= 1 << 23;
 309   if (I2) Imm25 |= 1 << 22;
 310
 311   return SignExtend32<25>(Imm25);
 312 }
 313
 314 static inline int decodeImm32_BLX(uint32_t insn) {
 315   unsigned S = slice(insn, 26, 26);
 316   bool I1 = slice(insn, 13, 13) == S;
 317   bool I2 = slice(insn, 11, 11) == S;
 318   unsigned Imm25 = slice(insn, 25, 16) << 12 | slice(insn, 10, 1) << 2;
 319   if (S) Imm25 |= 1 << 24;
 320   if (I1) Imm25 |= 1 << 23;
 321   if (I2) Imm25 |= 1 << 22;
 322
 323   return SignExtend32<25>(Imm25);
 324 }
 325
 326 // See, for example, A8.6.221 SXTAB16.
 327 static inline unsigned decodeRotate(uint32_t insn) {
 328   unsigned rotate = slice(insn, 5, 4);
 329   return rotate << 3;
 330 }
 331
 332 ///////////////////////////////////////////////
 333 //                                           //
 334 // Thumb1 instruction disassembly functions. //
 335 //                                           //
 336 ///////////////////////////////////////////////
 337
 338 // See "Utilities for 16-bit Thumb instructions" for register naming convention.
 339
 340 // A6.2.1 Shift (immediate), add, subtract, move, and compare
 341 //
 342 // shift immediate:         tRd CPSR tRn imm5
 343 // add/sub register:        tRd CPSR tRn tRm
 344 // add/sub 3-bit immediate: tRd CPSR tRn imm3
 345 // add/sub 8-bit immediate: tRt CPSR tRt(TIED_TO) imm8
 346 // mov/cmp immediate:       tRt [CPSR] imm8 (CPSR present for mov)
 347 //
 348 // Special case:
 349 // tMOVSr:                  tRd tRn
 350 static bool DisassembleThumb1General(MCInst &MI, unsigned Opcode, uint32_t insn,
 351     unsigned short NumOps, unsigned &NumOpsAdded, BO B) {
 352
 353   const TargetOperandInfo *OpInfo = ARMInsts[Opcode].OpInfo;
 354   unsigned &OpIdx = NumOpsAdded;
 355
 356   OpIdx = 0;
 357
 358   assert(NumOps >= 2 && OpInfo[0].RegClass == ARM::tGPRRegClassID
 359          && "Invalid arguments");
 360
 361   bool Imm3 = (Opcode == ARM::tADDi3 || Opcode == ARM::tSUBi3);
 362
 363   // Use Rt implies use imm8.
 364   bool UseRt = (Opcode == ARM::tADDi8 || Opcode == ARM::tSUBi8 ||
 365                 Opcode == ARM::tMOVi8 || Opcode == ARM::tCMPi8);
 366
 367   // Add the destination operand.
 368   MI.addOperand(MCOperand::CreateReg(
 369                   getRegisterEnum(B, ARM::tGPRRegClassID,
 370                                   UseRt ? getT1tRt(insn) : getT1tRd(insn))));
 371   ++OpIdx;
 372
 373   // Check whether the next operand to be added is a CCR Register.
 374   if (OpInfo[OpIdx].RegClass == ARM::CCRRegClassID) {
 375     assert(OpInfo[OpIdx].isOptionalDef() && "Optional def operand expected");
 376     MI.addOperand(MCOperand::CreateReg(B->InITBlock() ? 0 : ARM::CPSR));
 377     ++OpIdx;
 378   }
 379
 380   // Check whether the next operand to be added is a Thumb1 Register.
 381   assert(OpIdx < NumOps && "More operands expected");
 382   if (OpInfo[OpIdx].RegClass == ARM::tGPRRegClassID) {
 383     // For UseRt, the reg operand is tied to the first reg operand.
 384     MI.addOperand(MCOperand::CreateReg(
 385                     getRegisterEnum(B, ARM::tGPRRegClassID,
 386                                     UseRt ? getT1tRt(insn) : getT1tRn(insn))));
 387     ++OpIdx;
 388   }
 389
 390   // Special case for tMOVSr.
 391   if (OpIdx == NumOps)
 392     return true;
 393
 394   // The next available operand is either a reg operand or an imm operand.
 395   if (OpInfo[OpIdx].RegClass == ARM::tGPRRegClassID) {
 396     // Three register operand instructions.
 397     MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::tGPRRegClassID,
 398                                                        getT1tRm(insn))));
 399   } else {
 400     assert(OpInfo[OpIdx].RegClass < 0 &&
 401            !OpInfo[OpIdx].isPredicate() && !OpInfo[OpIdx].isOptionalDef()
 402            && "Pure imm operand expected");
 403     unsigned Imm = 0;
 404     if (UseRt)
 405       Imm = getT1Imm8(insn);
 406     else if (Imm3)
 407       Imm = getT1Imm3(insn);
 408     else {
 409       Imm = getT1Imm5(insn);
 410       ARM_AM::ShiftOpc ShOp = getShiftOpcForBits(slice(insn, 12, 11));
 411       getImmShiftSE(ShOp, Imm);
 412     }
 413     MI.addOperand(MCOperand::CreateImm(Imm));
 414   }
 415   ++OpIdx;
 416
 417   return true;
 418 }
 419
 420 // A6.2.2 Data-processing
 421 //
 422 // tCMPr, tTST, tCMN: tRd tRn
 423 // tMVN, tRSB:        tRd CPSR tRn
 424 // Others:            tRd CPSR tRd(TIED_TO) tRn
 425 static bool DisassembleThumb1DP(MCInst &MI, unsigned Opcode, uint32_t insn,
 426     unsigned short NumOps, unsigned &NumOpsAdded, BO B) {
 427
 428   const TargetInstrDesc &TID = ARMInsts[Opcode];
 429   const TargetOperandInfo *OpInfo = TID.OpInfo;
 430   unsigned &OpIdx = NumOpsAdded;
 431
 432   OpIdx = 0;
 433
 434   assert(NumOps >= 2 && OpInfo[0].RegClass == ARM::tGPRRegClassID &&
 435          (OpInfo[1].RegClass == ARM::CCRRegClassID
 436           || OpInfo[1].RegClass == ARM::tGPRRegClassID)
 437          && "Invalid arguments");
 438
 439   // Add the destination operand.
 440   MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::tGPRRegClassID,
 441                                                      getT1tRd(insn))));
 442   ++OpIdx;
 443
 444   // Check whether the next operand to be added is a CCR Register.
 445   if (OpInfo[OpIdx].RegClass == ARM::CCRRegClassID) {
 446     assert(OpInfo[OpIdx].isOptionalDef() && "Optional def operand expected");
 447     MI.addOperand(MCOperand::CreateReg(B->InITBlock() ? 0 : ARM::CPSR));
 448     ++OpIdx;
 449   }
 450
 451   // We have either { tRd(TIED_TO), tRn } or { tRn } remaining.
 452   // Process the TIED_TO operand first.
 453
 454   assert(OpIdx < NumOps && OpInfo[OpIdx].RegClass == ARM::tGPRRegClassID
 455          && "Thumb reg operand expected");
 456   int Idx;
 457   if ((Idx = TID.getOperandConstraint(OpIdx, TOI::TIED_TO)) != -1) {
 458     // The reg operand is tied to the first reg operand.
 459     MI.addOperand(MI.getOperand(Idx));
 460     ++OpIdx;
 461   }
 462
 463   // Process possible next reg operand.
 464   if (OpIdx < NumOps && OpInfo[OpIdx].RegClass == ARM::tGPRRegClassID) {
 465     // Add tRn operand.
 466     MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::tGPRRegClassID,
 467                                                        getT1tRn(insn))));
 468     ++OpIdx;
 469   }
 470
 471   return true;
 472 }
 473
 474 // A6.2.3 Special data instructions and branch and exchange
 475 //
 476 // tADDhirr: Rd Rd(TIED_TO) Rm
 477 // tCMPhir:  Rd Rm
 478 // tMOVr, tMOVgpr2gpr, tMOVgpr2tgpr, tMOVtgpr2gpr: Rd|tRd Rm|tRn
 479 // tBX_RET: 0 operand
 480 // tBX_RET_vararg: Rm
 481 // tBLXr_r9: Rm
 482 static bool DisassembleThumb1Special(MCInst &MI, unsigned Opcode, uint32_t insn,
 483     unsigned short NumOps, unsigned &NumOpsAdded, BO B) {
 484
 485   // tBX_RET has 0 operand.
 486   if (NumOps == 0)
 487     return true;
 488
 489   // BX/BLX has 1 reg operand: Rm.
 490   if (Opcode == ARM::tBLXr_r9 || Opcode == ARM::tBX_Rm) {
 491     // Handling the two predicate operands before the reg operand.
 492     if (!B->DoPredicateOperands(MI, Opcode, insn, NumOps))
 493       return false;
 494     MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::GPRRegClassID,
 495                                                        getT1Rm(insn))));
 496     NumOpsAdded = 3;
 497     return true;
 498   }
 499
 500   const TargetInstrDesc &TID = ARMInsts[Opcode];
 501   const TargetOperandInfo *OpInfo = TID.OpInfo;
 502   unsigned &OpIdx = NumOpsAdded;
 503
 504   OpIdx = 0;
 505
 506   // Add the destination operand.
 507   unsigned RegClass = OpInfo[OpIdx].RegClass;
 508   MI.addOperand(MCOperand::CreateReg(
 509                   getRegisterEnum(B, RegClass,
 510                                   IsGPR(RegClass) ? getT1Rd(insn)
 511                                                   : getT1tRd(insn))));
 512   ++OpIdx;
 513
 514   // We have either { Rd(TIED_TO), Rm } or { Rm|tRn } remaining.
 515   // Process the TIED_TO operand first.
 516
 517   assert(OpIdx < NumOps && "More operands expected");
 518   int Idx;
 519   if ((Idx = TID.getOperandConstraint(OpIdx, TOI::TIED_TO)) != -1) {
 520     // The reg operand is tied to the first reg operand.
 521     MI.addOperand(MI.getOperand(Idx));
 522     ++OpIdx;
 523   }
 524
 525   // The next reg operand is either Rm or tRn.
 526   assert(OpIdx < NumOps && "More operands expected");
 527   RegClass = OpInfo[OpIdx].RegClass;
 528   MI.addOperand(MCOperand::CreateReg(
 529                   getRegisterEnum(B, RegClass,
 530                                   IsGPR(RegClass) ? getT1Rm(insn)
 531                                                   : getT1tRn(insn))));
 532   ++OpIdx;
 533
 534   return true;
 535 }
 536
 537 // A8.6.59 LDR (literal)
 538 //
 539 // tLDRpci: tRt imm8*4
 540 static bool DisassembleThumb1LdPC(MCInst &MI, unsigned Opcode, uint32_t insn,
 541     unsigned short NumOps, unsigned &NumOpsAdded, BO B) {
 542
 543   const TargetOperandInfo *OpInfo = ARMInsts[Opcode].OpInfo;
 544   if (!OpInfo) return false;
 545
 546   assert(NumOps >= 2 && OpInfo[0].RegClass == ARM::tGPRRegClassID &&
 547          (OpInfo[1].RegClass < 0 &&
 548           !OpInfo[1].isPredicate() &&
 549           !OpInfo[1].isOptionalDef())
 550          && "Invalid arguments");
 551
 552   // Add the destination operand.
 553   MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::tGPRRegClassID,
 554                                                      getT1tRt(insn))));
 555
 556   // And the (imm8 << 2) operand.
 557   MI.addOperand(MCOperand::CreateImm(getT1Imm8(insn) << 2));
 558
 559   NumOpsAdded = 2;
 560
 561   return true;
 562 }
 563
 564 // Thumb specific addressing modes (see ARMInstrThumb.td):
 565 //
 566 // t_addrmode_rr := reg + reg
 567 //
 568 // t_addrmode_s4 := reg + reg
 569 //                  reg + imm5 * 4
 570 //
 571 // t_addrmode_s2 := reg + reg
 572 //                  reg + imm5 * 2
 573 //
 574 // t_addrmode_s1 := reg + reg
 575 //                  reg + imm5
 576 //
 577 // t_addrmode_sp := sp + imm8 * 4
 578 //
 579
 580 // A8.6.63 LDRB (literal)
 581 // A8.6.79 LDRSB (literal)
 582 // A8.6.75 LDRH (literal)
 583 // A8.6.83 LDRSH (literal)
 584 // A8.6.59 LDR (literal)
 585 //
 586 // These instrs calculate an address from the PC value and an immediate offset.
 587 // Rd Rn=PC (+/-)imm12 (+ if Inst{23} == 0b1)
 588 static bool DisassembleThumb2Ldpci(MCInst &MI, unsigned Opcode,
 589     uint32_t insn, unsigned short NumOps, unsigned &NumOpsAdded, BO B) {
 590
 591   const TargetOperandInfo *OpInfo = ARMInsts[Opcode].OpInfo;
 592   if (!OpInfo) return false;
 593
 594   assert(NumOps >= 2 &&
 595          OpInfo[0].RegClass == ARM::GPRRegClassID &&
 596          OpInfo[1].RegClass < 0 &&
 597          "Expect >= 2 operands, first as reg, and second as imm operand");
 598
 599   // Build the register operand, followed by the (+/-)imm12 immediate.
 600
 601   MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::GPRRegClassID,
 602                                                      decodeRd(insn))));
 603
 604   MI.addOperand(MCOperand::CreateImm(decodeImm12(insn)));
 605
 606   NumOpsAdded = 2;
 607
 608   return true;
 609 }
 610
 611
 612 // A6.2.4 Load/store single data item
 613 //
 614 // Load/Store Register (reg|imm):      tRd tRn imm5|tRm
 615 // Load Register Signed Byte|Halfword: tRd tRn tRm
 616 static bool DisassembleThumb1LdSt(unsigned opA, MCInst &MI, unsigned Opcode,
 617     uint32_t insn, unsigned short NumOps, unsigned &NumOpsAdded, BO B) {
 618
 619   const TargetInstrDesc &TID = ARMInsts[Opcode];
 620   const TargetOperandInfo *OpInfo = TID.OpInfo;
 621   unsigned &OpIdx = NumOpsAdded;
 622
 623   assert(NumOps >= 2
 624          && OpInfo[0].RegClass == ARM::tGPRRegClassID
 625          && OpInfo[1].RegClass == ARM::tGPRRegClassID
 626          && "Expect >= 2 operands and first two as thumb reg operands");
 627
 628   // Add the destination reg and the base reg.
 629   MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::tGPRRegClassID,
 630                                                      getT1tRd(insn))));
 631   MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::tGPRRegClassID,
 632                                                      getT1tRn(insn))));
 633   OpIdx = 2;
 634
 635   // We have either { imm5 } or { tRm } remaining.
 636   // Note that STR/LDR (register) should skip the imm5 offset operand for
 637   // t_addrmode_s[1|2|4].
 638
 639   assert(OpIdx < NumOps && "More operands expected");
 640
 641   if (OpInfo[OpIdx].RegClass < 0 && !OpInfo[OpIdx].isPredicate() &&
 642       !OpInfo[OpIdx].isOptionalDef()) {
 643     // Table A6-5 16-bit Thumb Load/store instructions
 644     // opA = 0b0101 for STR/LDR (register) and friends.
 645     // Otherwise, we have STR/LDR (immediate) and friends.
 646     assert(opA != 5 && "Immediate operand expected for this opcode");
 647     MI.addOperand(MCOperand::CreateImm(getT1Imm5(insn)));
 648     ++OpIdx;
 649   } else {
 650     // The next reg operand is tRm, the offset.
 651     assert(OpIdx < NumOps && OpInfo[OpIdx].RegClass == ARM::tGPRRegClassID
 652            && "Thumb reg operand expected");
 653     MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::tGPRRegClassID,
 654                                                        getT1tRm(insn))));
 655     ++OpIdx;
 656   }
 657   return true;
 658 }
 659
 660 // A6.2.4 Load/store single data item
 661 //
 662 // Load/Store Register SP relative: tRt ARM::SP imm8
 663 static bool DisassembleThumb1LdStSP(MCInst &MI, unsigned Opcode, uint32_t insn,
 664     unsigned short NumOps, unsigned &NumOpsAdded, BO B) {
 665
 666   assert((Opcode == ARM::tLDRspi || Opcode == ARM::tSTRspi)
 667          && "Unexpected opcode");
 668
 669   const TargetOperandInfo *OpInfo = ARMInsts[Opcode].OpInfo;
 670   if (!OpInfo) return false;
 671
 672   assert(NumOps >= 3 &&
 673          OpInfo[0].RegClass == ARM::tGPRRegClassID &&
 674          OpInfo[1].RegClass == ARM::GPRRegClassID &&
 675          (OpInfo[2].RegClass < 0 &&
 676           !OpInfo[2].isPredicate() &&
 677           !OpInfo[2].isOptionalDef())
 678          && "Invalid arguments");
 679
 680   MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::tGPRRegClassID,
 681                                                      getT1tRt(insn))));
 682   MI.addOperand(MCOperand::CreateReg(ARM::SP));
 683   MI.addOperand(MCOperand::CreateImm(getT1Imm8(insn)));
 684   NumOpsAdded = 3;
 685   return true;
 686 }
 687
 688 // Table A6-1 16-bit Thumb instruction encoding
 689 // A8.6.10 ADR
 690 //
 691 // tADDrPCi: tRt imm8
 692 static bool DisassembleThumb1AddPCi(MCInst &MI, unsigned Opcode, uint32_t insn,
 693     unsigned short NumOps, unsigned &NumOpsAdded, BO B) {
 694
 695   assert(Opcode == ARM::tADDrPCi && "Unexpected opcode");
 696
 697   const TargetOperandInfo *OpInfo = ARMInsts[Opcode].OpInfo;
 698   if (!OpInfo) return false;
 699
 700   assert(NumOps >= 2 && OpInfo[0].RegClass == ARM::tGPRRegClassID &&
 701          (OpInfo[1].RegClass < 0 &&
 702           !OpInfo[1].isPredicate() &&
 703           !OpInfo[1].isOptionalDef())
 704          && "Invalid arguments");
 705
 706   MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::tGPRRegClassID,
 707                                                      getT1tRt(insn))));
 708   MI.addOperand(MCOperand::CreateImm(getT1Imm8(insn)));
 709   NumOpsAdded = 2;
 710   return true;
 711 }
 712
 713 // Table A6-1 16-bit Thumb instruction encoding
 714 // A8.6.8 ADD (SP plus immediate)
 715 //
 716 // tADDrSPi: tRt ARM::SP imm8
 717 static bool DisassembleThumb1AddSPi(MCInst &MI, unsigned Opcode, uint32_t insn,
 718     unsigned short NumOps, unsigned &NumOpsAdded, BO B) {
 719
 720   assert(Opcode == ARM::tADDrSPi && "Unexpected opcode");
 721
 722   const TargetOperandInfo *OpInfo = ARMInsts[Opcode].OpInfo;
 723   if (!OpInfo) return false;
 724
 725   assert(NumOps >= 3 &&
 726          OpInfo[0].RegClass == ARM::tGPRRegClassID &&
 727          OpInfo[1].RegClass == ARM::GPRRegClassID &&
 728          (OpInfo[2].RegClass < 0 &&
 729           !OpInfo[2].isPredicate() &&
 730           !OpInfo[2].isOptionalDef())
 731          && "Invalid arguments");
 732
 733   MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::tGPRRegClassID,
 734                                                      getT1tRt(insn))));
 735   MI.addOperand(MCOperand::CreateReg(ARM::SP));
 736   MI.addOperand(MCOperand::CreateImm(getT1Imm8(insn)));
 737   NumOpsAdded = 3;
 738   return true;
 739 }
 740
 741 // tPUSH, tPOP: Pred-Imm Pred-CCR register_list
 742 //
 743 // where register_list = low registers + [lr] for PUSH or
 744 //                       low registers + [pc] for POP
 745 //
 746 // "low registers" is specified by Inst{7-0}
 747 // lr|pc is specified by Inst{8}
 748 static bool DisassembleThumb1PushPop(MCInst &MI, unsigned Opcode, uint32_t insn,
 749     unsigned short NumOps, unsigned &NumOpsAdded, BO B) {
 750
 751   assert((Opcode == ARM::tPUSH || Opcode == ARM::tPOP) && "Unexpected opcode");
 752
 753   unsigned &OpIdx = NumOpsAdded;
 754
 755   // Handling the two predicate operands before the reglist.
 756   if (B->DoPredicateOperands(MI, Opcode, insn, NumOps))
 757     OpIdx += 2;
 758   else {
 759     DEBUG(errs() << "Expected predicate operands not found.\n");
 760     return false;
 761   }
 762
 763   unsigned RegListBits = slice(insn, 8, 8) << (Opcode == ARM::tPUSH ? 14 : 15)
 764     | slice(insn, 7, 0);
 765
 766   // Fill the variadic part of reglist.
 767   for (unsigned i = 0; i < 16; ++i) {
 768     if ((RegListBits >> i) & 1) {
 769       MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::GPRRegClassID,
 770                                                          i)));
 771       ++OpIdx;
 772     }
 773   }
 774
 775   return true;
 776 }
 777
 778 // A6.2.5 Miscellaneous 16-bit instructions
 779 // Delegate to DisassembleThumb1PushPop() for tPUSH & tPOP.
 780 //
 781 // tADDspi, tSUBspi: ARM::SP ARM::SP(TIED_TO) imm7
 782 // t2IT:             firstcond=Inst{7-4} mask=Inst{3-0}
 783 // tCBNZ, tCBZ:      tRd imm6*2
 784 // tBKPT:            imm8
 785 // tNOP, tSEV, tYIELD, tWFE, tWFI:
 786 //   no operand (except predicate pair)
 787 // tSETENDBE, tSETENDLE, :
 788 //   no operand
 789 // Others:           tRd tRn
 790 static bool DisassembleThumb1Misc(MCInst &MI, unsigned Opcode, uint32_t insn,
 791     unsigned short NumOps, unsigned &NumOpsAdded, BO B) {
 792
 793   if (NumOps == 0)
 794     return true;
 795
 796   if (Opcode == ARM::tPUSH || Opcode == ARM::tPOP)
 797     return DisassembleThumb1PushPop(MI, Opcode, insn, NumOps, NumOpsAdded, B);
 798
 799   const TargetOperandInfo *OpInfo = ARMInsts[Opcode].OpInfo;
 800
 801   // Predicate operands are handled elsewhere.
 802   if (NumOps == 2 &&
 803       OpInfo[0].isPredicate() && OpInfo[1].isPredicate() &&
 804       OpInfo[0].RegClass < 0 && OpInfo[1].RegClass == ARM::CCRRegClassID) {
 805     return true;
 806   }
 807
 808   if (Opcode == ARM::tADDspi || Opcode == ARM::tSUBspi) {
 809     // Special case handling for tADDspi and tSUBspi.
 810     // A8.6.8 ADD (SP plus immediate) & A8.6.215 SUB (SP minus immediate)
 811     MI.addOperand(MCOperand::CreateReg(ARM::SP));
 812     MI.addOperand(MCOperand::CreateReg(ARM::SP));
 813     MI.addOperand(MCOperand::CreateImm(getT1Imm7(insn)));
 814     NumOpsAdded = 3;
 815     return true;
 816   }
 817
 818   if (Opcode == ARM::t2IT) {
 819     // Special case handling for If-Then.
 820     // A8.6.50 IT
 821     // Tag the (firstcond[0] bit << 4) along with mask.
 822
 823     // firstcond
 824     MI.addOperand(MCOperand::CreateImm(slice(insn, 7, 4)));
 825
 826     // firstcond[0] and mask
 827     MI.addOperand(MCOperand::CreateImm(slice(insn, 4, 0)));
 828     NumOpsAdded = 2;
 829     return true;
 830   }
 831
 832   if (Opcode == ARM::tBKPT) {
 833     MI.addOperand(MCOperand::CreateImm(getT1Imm8(insn))); // breakpoint value
 834     NumOpsAdded = 1;
 835     return true;
 836   }
 837
 838   // CPS has a singleton $opt operand that contains the following information:
 839   // The first op would be 0b10 as enable and 0b11 as disable in regular ARM,
 840   // but in Thumb it's is 0 as enable and 1 as disable. So map it to ARM's
 841   // default one. The second get the AIF flags from Inst{2-0}.
 842   if (Opcode == ARM::tCPS) {
 843     MI.addOperand(MCOperand::CreateImm(2 + slice(insn, 4, 4)));
 844     MI.addOperand(MCOperand::CreateImm(slice(insn, 2, 0)));
 845     NumOpsAdded = 2;
 846     return true;
 847   }
 848
 849   assert(NumOps >= 2 && OpInfo[0].RegClass == ARM::tGPRRegClassID &&
 850          (OpInfo[1].RegClass < 0 || OpInfo[1].RegClass==ARM::tGPRRegClassID)
 851          && "Expect >=2 operands");
 852
 853   // Add the destination operand.
 854   MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::tGPRRegClassID,
 855                                                      getT1tRd(insn))));
 856
 857   if (OpInfo[1].RegClass == ARM::tGPRRegClassID) {
 858     // Two register instructions.
 859     MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::tGPRRegClassID,
 860                                                        getT1tRn(insn))));
 861   } else {
 862     // CBNZ, CBZ
 863     assert((Opcode == ARM::tCBNZ || Opcode == ARM::tCBZ) &&"Unexpected opcode");
 864     MI.addOperand(MCOperand::CreateImm(getT1Imm6(insn) * 2));
 865   }
 866
 867   NumOpsAdded = 2;
 868
 869   return true;
 870 }
 871
 872 // A8.6.53  LDM / LDMIA
 873 // A8.6.189 STM / STMIA
 874 //
 875 // tLDMIA_UPD/tSTMIA_UPD: tRt tRt AM4ModeImm Pred-Imm Pred-CCR register_list
 876 // tLDMIA:                tRt AM4ModeImm Pred-Imm Pred-CCR register_list
 877 static bool DisassembleThumb1LdStMul(bool Ld, MCInst &MI, unsigned Opcode,
 878                                      uint32_t insn, unsigned short NumOps,
 879                                      unsigned &NumOpsAdded, BO B) {
 880   assert((Opcode == ARM::tLDMIA || Opcode == ARM::tLDMIA_UPD ||
 881           Opcode == ARM::tSTMIA_UPD) && "Unexpected opcode");
 882
 883   unsigned tRt = getT1tRt(insn);
 884   NumOpsAdded = 0;
 885
 886   // WB register, if necessary.
 887   if (Opcode == ARM::tLDMIA_UPD || Opcode == ARM::tSTMIA_UPD) {
 888     MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::GPRRegClassID,
 889                                                        tRt)));
 890     ++NumOpsAdded;
 891   }
 892
 893   MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::GPRRegClassID,
 894                                                      tRt)));
 895   ++NumOpsAdded;
 896
 897   // Handling the two predicate operands before the reglist.
 898   if (B->DoPredicateOperands(MI, Opcode, insn, NumOps)) {
 899     NumOpsAdded += 2;
 900   } else {
 901     DEBUG(errs() << "Expected predicate operands not found.\n");
 902     return false;
 903   }
 904
 905   unsigned RegListBits = slice(insn, 7, 0);
 906   if (BitCount(RegListBits) < 1) {
 907     DEBUG(errs() << "if BitCount(registers) < 1 then UNPREDICTABLE\n");
 908     return false;
 909   }
 910
 911   // Fill the variadic part of reglist.
 912   for (unsigned i = 0; i < 8; ++i)
 913     if ((RegListBits >> i) & 1) {
 914       MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::tGPRRegClassID,
 915                                                          i)));
 916       ++NumOpsAdded;
 917     }
 918
 919   return true;
 920 }
 921
 922 static bool DisassembleThumb1LdMul(MCInst &MI, unsigned Opcode, uint32_t insn,
 923     unsigned short NumOps, unsigned &NumOpsAdded, BO B) {
 924   return DisassembleThumb1LdStMul(true, MI, Opcode, insn, NumOps, NumOpsAdded,
 925                                   B);
 926 }
 927
 928 static bool DisassembleThumb1StMul(MCInst &MI, unsigned Opcode, uint32_t insn,
 929     unsigned short NumOps, unsigned &NumOpsAdded, BO B) {
 930   return DisassembleThumb1LdStMul(false, MI, Opcode, insn, NumOps, NumOpsAdded,
 931                                   B);
 932 }
 933
 934 // A8.6.16 B Encoding T1
 935 // cond = Inst{11-8} & imm8 = Inst{7-0}
 936 // imm32 = SignExtend(imm8:'0', 32)
 937 //
 938 // tBcc: offset Pred-Imm Pred-CCR
 939 // tSVC: imm8 Pred-Imm Pred-CCR
 940 // tTRAP: 0 operand (early return)
 941 static bool DisassembleThumb1CondBr(MCInst &MI, unsigned Opcode, uint32_t insn,
 942     unsigned short NumOps, unsigned &NumOpsAdded, BO) {
 943
 944   if (Opcode == ARM::tTRAP)
 945     return true;
 946
 947   const TargetOperandInfo *OpInfo = ARMInsts[Opcode].OpInfo;
 948   if (!OpInfo) return false;
 949
 950   assert(NumOps == 3 && OpInfo[0].RegClass < 0 &&
 951          OpInfo[1].isPredicate() && OpInfo[2].RegClass == ARM::CCRRegClassID
 952          && "Exactly 3 operands expected");
 953
 954   unsigned Imm8 = getT1Imm8(insn);
 955   MI.addOperand(MCOperand::CreateImm(
 956                   Opcode == ARM::tBcc ? SignExtend32<9>(Imm8 << 1) + 4
 957                                       : (int)Imm8));
 958
 959   // Predicate operands by ARMBasicMCBuilder::TryPredicateAndSBitModifier().
 960   // But note that for tBcc, if cond = '1110' then UNDEFINED.
 961   if (Opcode == ARM::tBcc && slice(insn, 11, 8) == 14) {
 962     DEBUG(errs() << "if cond = '1110' then UNDEFINED\n");
 963     return false;
 964   }
 965   NumOpsAdded = 1;
 966
 967   return true;
 968 }
 969
 970 // A8.6.16 B Encoding T2
 971 // imm11 = Inst{10-0}
 972 // imm32 = SignExtend(imm11:'0', 32)
 973 //
 974 // tB: offset
 975 static bool DisassembleThumb1Br(MCInst &MI, unsigned Opcode, uint32_t insn,
 976     unsigned short NumOps, unsigned &NumOpsAdded, BO) {
 977
 978   const TargetOperandInfo *OpInfo = ARMInsts[Opcode].OpInfo;
 979   if (!OpInfo) return false;
 980
 981   assert(NumOps == 1 && OpInfo[0].RegClass < 0 && "1 imm operand expected");
 982
 983   unsigned Imm11 = getT1Imm11(insn);
 984
 985   MI.addOperand(MCOperand::CreateImm(SignExtend32<12>(Imm11 << 1)));
 986
 987   NumOpsAdded = 1;
 988
 989   return true;
 990
 991 }
 992
 993 // See A6.2 16-bit Thumb instruction encoding for instruction classes
 994 // corresponding to op.
 995 //
 996 // Table A6-1 16-bit Thumb instruction encoding (abridged)
 997 // op    Instruction or instruction class
 998 // ------  --------------------------------------------------------------------
 999 // 00xxxx  Shift (immediate), add, subtract, move, and compare on page A6-7
1000 // 010000  Data-processing on page A6-8
1001 // 010001  Special data instructions and branch and exchange on page A6-9
1002 // 01001x  Load from Literal Pool, see LDR (literal) on page A8-122
1003 // 0101xx  Load/store single data item on page A6-10
1004 // 011xxx
1005 // 100xxx
1006 // 10100x  Generate PC-relative address, see ADR on page A8-32
1007 // 10101x  Generate SP-relative address, see ADD (SP plus immediate) on
1008 //         page A8-28
1009 // 1011xx  Miscellaneous 16-bit instructions on page A6-11
1010 // 11000x  Store multiple registers, see STM / STMIA / STMEA on page A8-374
1011 // 11001x  Load multiple registers, see LDM / LDMIA / LDMFD on page A8-110 a
1012 // 1101xx  Conditional branch, and Supervisor Call on page A6-13
1013 // 11100x  Unconditional Branch, see B on page A8-44
1014 //
1015 static bool DisassembleThumb1(uint16_t op, MCInst &MI, unsigned Opcode,
1016     uint32_t insn, unsigned short NumOps, unsigned &NumOpsAdded, BO B) {
1017
1018   unsigned op1 = slice(op, 5, 4);
1019   unsigned op2 = slice(op, 3, 2);
1020   unsigned op3 = slice(op, 1, 0);
1021   unsigned opA = slice(op, 5, 2);
1022   switch (op1) {
1023   case 0:
1024     // A6.2.1 Shift (immediate), add, subtract, move, and compare
1025     return DisassembleThumb1General(MI, Opcode, insn, NumOps, NumOpsAdded, B);
1026   case 1:
1027     switch (op2) {
1028     case 0:
1029       switch (op3) {
1030       case 0:
1031         // A6.2.2 Data-processing
1032         return DisassembleThumb1DP(MI, Opcode, insn, NumOps, NumOpsAdded, B);
1033       case 1:
1034         // A6.2.3 Special data instructions and branch and exchange
1035         return DisassembleThumb1Special(MI, Opcode, insn, NumOps, NumOpsAdded,
1036                                         B);
1037       default:
1038         // A8.6.59 LDR (literal)
1039         return DisassembleThumb1LdPC(MI, Opcode, insn, NumOps, NumOpsAdded, B);
1040       }
1041       break;
1042     default:
1043       // A6.2.4 Load/store single data item
1044       return DisassembleThumb1LdSt(opA, MI, Opcode, insn, NumOps, NumOpsAdded,
1045                                    B);
1046       break;
1047     }
1048     break;
1049   case 2:
1050     switch (op2) {
1051     case 0:
1052       // A6.2.4 Load/store single data item
1053       return DisassembleThumb1LdSt(opA, MI, Opcode, insn, NumOps, NumOpsAdded,
1054                                    B);
1055     case 1:
1056       // A6.2.4 Load/store single data item
1057       return DisassembleThumb1LdStSP(MI, Opcode, insn, NumOps, NumOpsAdded, B);
1058     case 2:
1059       if (op3 <= 1) {
1060         // A8.6.10 ADR
1061         return DisassembleThumb1AddPCi(MI, Opcode, insn, NumOps, NumOpsAdded,
1062                                        B);
1063       } else {
1064         // A8.6.8 ADD (SP plus immediate)
1065         return DisassembleThumb1AddSPi(MI, Opcode, insn, NumOps, NumOpsAdded,
1066                                        B);
1067       }
1068     default:
1069       // A6.2.5 Miscellaneous 16-bit instructions
1070       return DisassembleThumb1Misc(MI, Opcode, insn, NumOps, NumOpsAdded, B);
1071     }
1072     break;
1073   case 3:
1074     switch (op2) {
1075     case 0:
1076       if (op3 <= 1) {
1077         // A8.6.189 STM / STMIA / STMEA
1078         return DisassembleThumb1StMul(MI, Opcode, insn, NumOps, NumOpsAdded, B);
1079       } else {
1080         // A8.6.53 LDM / LDMIA / LDMFD
1081         return DisassembleThumb1LdMul(MI, Opcode, insn, NumOps, NumOpsAdded, B);
1082       }
1083     case 1:
1084       // A6.2.6 Conditional branch, and Supervisor Call
1085       return DisassembleThumb1CondBr(MI, Opcode, insn, NumOps, NumOpsAdded, B);
1086     case 2:
1087       // Unconditional Branch, see B on page A8-44
1088       return DisassembleThumb1Br(MI, Opcode, insn, NumOps, NumOpsAdded, B);
1089     default:
1090       assert(0 && "Unreachable code");
1091       break;
1092     }
1093     break;
1094   default:
1095     assert(0 && "Unreachable code");
1096     break;
1097   }
1098
1099   return false;
1100 }
1101
1102 ///////////////////////////////////////////////
1103 //                                           //
1104 // Thumb2 instruction disassembly functions. //
1105 //                                           //
1106 ///////////////////////////////////////////////
1107
1108 ///////////////////////////////////////////////////////////
1109 //                                                       //
1110 // Note: the register naming follows the ARM convention! //
1111 //                                                       //
1112 ///////////////////////////////////////////////////////////
1113
1114 static inline bool Thumb2SRSOpcode(unsigned Opcode) {
1115   switch (Opcode) {
1116   default:
1117     return false;
1118   case ARM::t2SRSDBW: case ARM::t2SRSDB:
1119   case ARM::t2SRSIAW: case ARM::t2SRSIA:
1120     return true;
1121   }
1122 }
1123
1124 static inline bool Thumb2RFEOpcode(unsigned Opcode) {
1125   switch (Opcode) {
1126   default:
1127     return false;
1128   case ARM::t2RFEDBW: case ARM::t2RFEDB:
1129   case ARM::t2RFEIAW: case ARM::t2RFEIA:
1130     return true;
1131   }
1132 }
1133
1134 // t2SRS[IA|DB]W/t2SRS[IA|DB]: mode_imm = Inst{4-0}
1135 static bool DisassembleThumb2SRS(MCInst &MI, unsigned Opcode, uint32_t insn,
1136     unsigned short NumOps, unsigned &NumOpsAdded) {
1137   MI.addOperand(MCOperand::CreateImm(slice(insn, 4, 0)));
1138   NumOpsAdded = 1;
1139   return true;
1140 }
1141
1142 // t2RFE[IA|DB]W/t2RFE[IA|DB]: Rn
1143 static bool DisassembleThumb2RFE(MCInst &MI, unsigned Opcode, uint32_t insn,
1144     unsigned short NumOps, unsigned &NumOpsAdded, BO B) {
1145   unsigned Rn = decodeRn(insn);
1146   if (Rn == 15) {
1147     DEBUG(errs() << "if n == 15 then UNPREDICTABLE\n");
1148     return false;
1149   }
1150   MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B,ARM::GPRRegClassID,Rn)));
1151   NumOpsAdded = 1;
1152   return true;
1153 }
1154
1155 static bool DisassembleThumb2LdStMul(MCInst &MI, unsigned Opcode, uint32_t insn,
1156     unsigned short NumOps, unsigned &NumOpsAdded, BO B) {
1157
1158   if (Thumb2SRSOpcode(Opcode))
1159     return DisassembleThumb2SRS(MI, Opcode, insn, NumOps, NumOpsAdded);
1160
1161   if (Thumb2RFEOpcode(Opcode))
1162     return DisassembleThumb2RFE(MI, Opcode, insn, NumOps, NumOpsAdded, B);
1163
1164   assert((Opcode == ARM::t2LDMIA || Opcode == ARM::t2LDMIA_UPD ||
1165           Opcode == ARM::t2LDMDB || Opcode == ARM::t2LDMDB_UPD ||
1166           Opcode == ARM::t2STMIA || Opcode == ARM::t2STMIA_UPD ||
1167           Opcode == ARM::t2STMDB || Opcode == ARM::t2STMDB_UPD)
1168          && "Unexpected opcode");
1169   assert(NumOps >= 4 && "Thumb2 LdStMul expects NumOps >= 4");
1170
1171   NumOpsAdded = 0;
1172
1173   unsigned Base = getRegisterEnum(B, ARM::GPRRegClassID, decodeRn(insn));
1174
1175   // Writeback to base.
1176   if (Opcode == ARM::t2LDMIA_UPD || Opcode == ARM::t2LDMDB_UPD ||
1177       Opcode == ARM::t2STMIA_UPD || Opcode == ARM::t2STMDB_UPD) {
1178     MI.addOperand(MCOperand::CreateReg(Base));
1179     ++NumOpsAdded;
1180   }
1181
1182   MI.addOperand(MCOperand::CreateReg(Base));
1183   ++NumOpsAdded;
1184
1185   // Handling the two predicate operands before the reglist.
1186   if (B->DoPredicateOperands(MI, Opcode, insn, NumOps)) {
1187     NumOpsAdded += 2;
1188   } else {
1189     DEBUG(errs() << "Expected predicate operands not found.\n");
1190     return false;
1191   }
1192
1193   unsigned RegListBits = insn & ((1 << 16) - 1);
1194
1195   // Fill the variadic part of reglist.
1196   for (unsigned i = 0; i < 16; ++i)
1197     if ((RegListBits >> i) & 1) {
1198       MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::GPRRegClassID,
1199                                                          i)));
1200       ++NumOpsAdded;
1201     }
1202
1203   return true;
1204 }
1205
1206 // t2LDREX: Rd Rn
1207 // t2LDREXD: Rd Rs Rn
1208 // t2LDREXB, t2LDREXH: Rd Rn
1209 // t2STREX: Rs Rd Rn
1210 // t2STREXD: Rm Rd Rs Rn
1211 // t2STREXB, t2STREXH: Rm Rd Rn
1212 static bool DisassembleThumb2LdStEx(MCInst &MI, unsigned Opcode, uint32_t insn,
1213     unsigned short NumOps, unsigned &NumOpsAdded, BO B) {
1214
1215   const TargetOperandInfo *OpInfo = ARMInsts[Opcode].OpInfo;
1216   if (!OpInfo) return false;
1217
1218   unsigned &OpIdx = NumOpsAdded;
1219
1220   OpIdx = 0;
1221
1222   assert(NumOps >= 2
1223          && OpInfo[0].RegClass > 0
1224          && OpInfo[1].RegClass > 0
1225          && "Expect >=2 operands and first two as reg operands");
1226
1227   bool isStore = (ARM::t2STREX <= Opcode && Opcode <= ARM::t2STREXH);
1228   bool isSW = (Opcode == ARM::t2LDREX || Opcode == ARM::t2STREX);
1229   bool isDW = (Opcode == ARM::t2LDREXD || Opcode == ARM::t2STREXD);
1230
1231   // Add the destination operand for store.
1232   if (isStore) {
1233     MI.addOperand(MCOperand::CreateReg(
1234                     getRegisterEnum(B, OpInfo[OpIdx].RegClass,
1235                                     isSW ? decodeRs(insn) : decodeRm(insn))));
1236     ++OpIdx;
1237   }
1238
1239   // Source operand for store and destination operand for load.
1240   MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, OpInfo[OpIdx].RegClass,
1241                                                      decodeRd(insn))));
1242   ++OpIdx;
1243
1244   // Thumb2 doubleword complication: with an extra source/destination operand.
1245   if (isDW) {
1246     MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B,OpInfo[OpIdx].RegClass,
1247                                                        decodeRs(insn))));
1248     ++OpIdx;
1249   }
1250
1251   // Finally add the pointer operand.
1252   MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, OpInfo[OpIdx].RegClass,
1253                                                      decodeRn(insn))));
1254   ++OpIdx;
1255
1256   return true;
1257 }
1258
1259 // t2LDRDi8: Rd Rs Rn imm8s4 (offset mode)
1260 // t2LDRDpci: Rd Rs imm8s4 (Not decoded, prefer the generic t2LDRDi8 version)
1261 // t2STRDi8: Rd Rs Rn imm8s4 (offset mode)
1262 //
1263 // Ditto for t2LDRD_PRE, t2LDRD_POST, t2STRD_PRE, t2STRD_POST, which are for
1264 // disassembly only and do not have a tied_to writeback base register operand.
1265 static bool DisassembleThumb2LdStDual(MCInst &MI, unsigned Opcode,
1266     uint32_t insn, unsigned short NumOps, unsigned &NumOpsAdded, BO B) {
1267
1268   const TargetOperandInfo *OpInfo = ARMInsts[Opcode].OpInfo;
1269   if (!OpInfo) return false;
1270
1271   assert(NumOps >= 4
1272          && OpInfo[0].RegClass > 0
1273          && OpInfo[0].RegClass == OpInfo[1].RegClass
1274          && OpInfo[2].RegClass > 0
1275          && OpInfo[3].RegClass < 0
1276          && "Expect >= 4 operands and first 3 as reg operands");
1277
1278   // Add the <Rt> <Rt2> operands.
1279   unsigned RegClassPair = OpInfo[0].RegClass;
1280   unsigned RegClassBase = OpInfo[2].RegClass;
1281
1282   MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, RegClassPair,
1283                                                      decodeRd(insn))));
1284   MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, RegClassPair,
1285                                                      decodeRs(insn))));
1286   MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, RegClassBase,
1287                                                      decodeRn(insn))));
1288
1289   // Finally add (+/-)imm8*4, depending on the U bit.
1290   int Offset = getImm8(insn) * 4;
1291   if (getUBit(insn) == 0)
1292     Offset = -Offset;
1293   MI.addOperand(MCOperand::CreateImm(Offset));
1294   NumOpsAdded = 4;
1295
1296   return true;
1297 }
1298
1299 // t2TBB, t2TBH: Rn Rm Pred-Imm Pred-CCR
1300 static bool DisassembleThumb2TB(MCInst &MI, unsigned Opcode,
1301     uint32_t insn, unsigned short NumOps, unsigned &NumOpsAdded, BO B) {
1302
1303   assert(NumOps >= 2 && "Expect >= 2 operands");
1304
1305   // The generic version of TBB/TBH needs a base register.
1306   MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::GPRRegClassID,
1307                                                      decodeRn(insn))));
1308   // Add the index register.
1309   MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::GPRRegClassID,
1310                                                      decodeRm(insn))));
1311   NumOpsAdded = 2;
1312
1313   return true;
1314 }
1315
1316 static inline bool Thumb2ShiftOpcode(unsigned Opcode) {
1317   switch (Opcode) {
1318   default:
1319     return false;
1320   case ARM::t2MOVCClsl: case ARM::t2MOVCClsr:
1321   case ARM::t2MOVCCasr: case ARM::t2MOVCCror:
1322   case ARM::t2LSLri:    case ARM::t2LSRri:
1323   case ARM::t2ASRri:    case ARM::t2RORri:
1324     return true;
1325   }
1326 }
1327
1328 // A6.3.11 Data-processing (shifted register)
1329 //
1330 // Two register operands (Rn=0b1111 no 1st operand reg): Rs Rm
1331 // Two register operands (Rs=0b1111 no dst operand reg): Rn Rm
1332 // Three register operands: Rs Rn Rm
1333 // Three register operands: (Rn=0b1111 Conditional Move) Rs Ro(TIED_TO) Rm
1334 //
1335 // Constant shifts t2_so_reg is a 2-operand unit corresponding to the Thumb2
1336 // register with shift forms: (Rm, ConstantShiftSpecifier).
1337 // Constant shift specifier: Imm = (ShOp | ShAmt<<3).
1338 //
1339 // There are special instructions, like t2MOVsra_flag and t2MOVsrl_flag, which
1340 // only require two register operands: Rd, Rm in ARM Reference Manual terms, and
1341 // nothing else, because the shift amount is already specified.
1342 // Similar case holds for t2MOVrx, t2ADDrr, ..., etc.
1343 static bool DisassembleThumb2DPSoReg(MCInst &MI, unsigned Opcode, uint32_t insn,
1344     unsigned short NumOps, unsigned &NumOpsAdded, BO B) {
1345
1346   const TargetInstrDesc &TID = ARMInsts[Opcode];
1347   const TargetOperandInfo *OpInfo = TID.OpInfo;
1348   unsigned &OpIdx = NumOpsAdded;
1349
1350   // Special case handling.
1351   if (Opcode == ARM::t2BR_JT) {
1352     assert(NumOps == 4
1353            && OpInfo[0].RegClass == ARM::GPRRegClassID
1354            && OpInfo[1].RegClass == ARM::GPRRegClassID
1355            && OpInfo[2].RegClass < 0
1356            && OpInfo[3].RegClass < 0
1357            && "Exactly 4 operands expect and first two as reg operands");
1358     // Only need to populate the src reg operand.
1359     MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::GPRRegClassID,
1360                                                        decodeRm(insn))));
1361     MI.addOperand(MCOperand::CreateReg(0));
1362     MI.addOperand(MCOperand::CreateImm(0));
1363     MI.addOperand(MCOperand::CreateImm(0));
1364     NumOpsAdded = 4;
1365     return true;
1366   }
1367
1368   OpIdx = 0;
1369
1370   assert(NumOps >= 2
1371          && (OpInfo[0].RegClass == ARM::GPRRegClassID ||
1372              OpInfo[0].RegClass == ARM::rGPRRegClassID)
1373          && (OpInfo[1].RegClass == ARM::GPRRegClassID ||
1374              OpInfo[1].RegClass == ARM::rGPRRegClassID)
1375          && "Expect >= 2 operands and first two as reg operands");
1376
1377   bool ThreeReg = (NumOps > 2 && (OpInfo[2].RegClass == ARM::GPRRegClassID ||
1378                                   OpInfo[2].RegClass == ARM::rGPRRegClassID));
1379   bool NoDstReg = (decodeRs(insn) == 0xF);
1380
1381   // Build the register operands, followed by the constant shift specifier.
1382
1383   MI.addOperand(MCOperand::CreateReg(
1384                   getRegisterEnum(B, OpInfo[0].RegClass,
1385                                   NoDstReg ? decodeRn(insn) : decodeRs(insn))));
1386   ++OpIdx;
1387
1388   if (ThreeReg) {
1389     int Idx;
1390     if ((Idx = TID.getOperandConstraint(OpIdx, TOI::TIED_TO)) != -1) {
1391       // Process tied_to operand constraint.
1392       MI.addOperand(MI.getOperand(Idx));
1393       ++OpIdx;
1394     } else if (!NoDstReg) {
1395       MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, OpInfo[1].RegClass,
1396                                                          decodeRn(insn))));
1397       ++OpIdx;
1398     } else {
1399       DEBUG(errs() << "Thumb2 encoding error: d==15 for three-reg operands.\n");
1400       return false;
1401     }
1402   }
1403
1404   MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, OpInfo[OpIdx].RegClass,
1405                                                      decodeRm(insn))));
1406   ++OpIdx;
1407
1408   if (NumOps == OpIdx)
1409     return true;
1410
1411   if (OpInfo[OpIdx].RegClass < 0 && !OpInfo[OpIdx].isPredicate()
1412       && !OpInfo[OpIdx].isOptionalDef()) {
1413
1414     if (Thumb2ShiftOpcode(Opcode)) {
1415       unsigned Imm = getShiftAmtBits(insn);
1416       ARM_AM::ShiftOpc ShOp = getShiftOpcForBits(slice(insn, 5, 4));
1417       getImmShiftSE(ShOp, Imm);
1418       MI.addOperand(MCOperand::CreateImm(Imm));
1419     } else {
1420       // Build the constant shift specifier operand.
1421       unsigned bits2 = getShiftTypeBits(insn);
1422       unsigned imm5 = getShiftAmtBits(insn);
1423       ARM_AM::ShiftOpc ShOp = ARM_AM::no_shift;
1424       unsigned ShAmt = decodeImmShift(bits2, imm5, ShOp);
1425       MI.addOperand(MCOperand::CreateImm(ARM_AM::getSORegOpc(ShOp, ShAmt)));
1426     }
1427     ++OpIdx;
1428   }
1429
1430   return true;
1431 }
1432
1433 // A6.3.1 Data-processing (modified immediate)
1434 //
1435 // Two register operands: Rs Rn ModImm
1436 // One register operands (Rs=0b1111 no explicit dest reg): Rn ModImm
1437 // One register operands (Rn=0b1111 no explicit src reg): Rs ModImm -
1438 // {t2MOVi, t2MVNi}
1439 //
1440 // ModImm = ThumbExpandImm(i:imm3:imm8)
1441 static bool DisassembleThumb2DPModImm(MCInst &MI, unsigned Opcode,
1442     uint32_t insn, unsigned short NumOps, unsigned &NumOpsAdded, BO B) {
1443
1444   const TargetOperandInfo *OpInfo = ARMInsts[Opcode].OpInfo;
1445   unsigned &OpIdx = NumOpsAdded;
1446
1447   OpIdx = 0;
1448
1449   unsigned RdRegClassID = OpInfo[0].RegClass;
1450   assert(NumOps >= 2 && (RdRegClassID == ARM::GPRRegClassID ||
1451                          RdRegClassID == ARM::rGPRRegClassID)
1452          && "Expect >= 2 operands and first one as reg operand");
1453
1454   unsigned RnRegClassID = OpInfo[1].RegClass;
1455   bool TwoReg = (RnRegClassID == ARM::GPRRegClassID
1456                  || RnRegClassID == ARM::rGPRRegClassID);
1457   bool NoDstReg = (decodeRs(insn) == 0xF);
1458
1459   // Build the register operands, followed by the modified immediate.
1460
1461   MI.addOperand(MCOperand::CreateReg(
1462                   getRegisterEnum(B, RdRegClassID,
1463                                   NoDstReg ? decodeRn(insn) : decodeRs(insn))));
1464   ++OpIdx;
1465
1466   if (TwoReg) {
1467     if (NoDstReg) {
1468       DEBUG(errs()<<"Thumb2 encoding error: d==15 for DPModImm 2-reg instr.\n");
1469       return false;
1470     }
1471     MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, RnRegClassID,
1472                                                        decodeRn(insn))));
1473     ++OpIdx;
1474   }
1475
1476   // The modified immediate operand should come next.
1477   assert(OpIdx < NumOps && OpInfo[OpIdx].RegClass < 0 &&
1478          !OpInfo[OpIdx].isPredicate() && !OpInfo[OpIdx].isOptionalDef()
1479          && "Pure imm operand expected");
1480
1481   // i:imm3:imm8
1482   // A6.3.2 Modified immediate constants in Thumb instructions
1483   unsigned imm12 = getIImm3Imm8(insn);
1484   MI.addOperand(MCOperand::CreateImm(ThumbExpandImm(imm12)));
1485   ++OpIdx;
1486
1487   return true;
1488 }
1489
1490 static inline bool Thumb2SaturateOpcode(unsigned Opcode) {
1491   switch (Opcode) {
1492   case ARM::t2SSAT: case ARM::t2SSAT16:
1493   case ARM::t2USAT: case ARM::t2USAT16:
1494     return true;
1495   default:
1496     return false;
1497   }
1498 }
1499
1500 /// DisassembleThumb2Sat - Disassemble Thumb2 saturate instructions:
1501 /// o t2SSAT, t2USAT: Rs sat_pos Rn shamt
1502 /// o t2SSAT16, t2USAT16: Rs sat_pos Rn
1503 static bool DisassembleThumb2Sat(MCInst &MI, unsigned Opcode, uint32_t insn,
1504                                  unsigned &NumOpsAdded, BO B) {
1505   const TargetInstrDesc &TID = ARMInsts[Opcode];
1506   NumOpsAdded = TID.getNumOperands() - 2; // ignore predicate operands
1507
1508   // Disassemble the register def.
1509   MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::rGPRRegClassID,
1510                                                      decodeRs(insn))));
1511
1512   unsigned Pos = slice(insn, 4, 0);
1513   if (Opcode == ARM::t2SSAT || Opcode == ARM::t2SSAT16)
1514     Pos += 1;
1515   MI.addOperand(MCOperand::CreateImm(Pos));
1516
1517   MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::rGPRRegClassID,
1518                                                      decodeRn(insn))));
1519
1520   if (NumOpsAdded == 4) {
1521     ARM_AM::ShiftOpc Opc = (slice(insn, 21, 21) != 0 ?
1522                             ARM_AM::asr : ARM_AM::lsl);
1523     // Inst{14-12:7-6} encodes the imm5 shift amount.
1524     unsigned ShAmt = slice(insn, 14, 12) << 2 | slice(insn, 7, 6);
1525     if (ShAmt == 0) {
1526       if (Opc == ARM_AM::asr)
1527         ShAmt = 32;
1528       else
1529         Opc = ARM_AM::no_shift;
1530     }
1531     MI.addOperand(MCOperand::CreateImm(ARM_AM::getSORegOpc(Opc, ShAmt)));
1532   }
1533   return true;
1534 }
1535
1536 // A6.3.3 Data-processing (plain binary immediate)
1537 //
1538 // o t2ADDri12, t2SUBri12: Rs Rn imm12
1539 // o t2LEApcrel (ADR): Rs imm12
1540 // o t2BFC (BFC): Rs Ro(TIED_TO) bf_inv_mask_imm
1541 // o t2BFI (BFI) (Currently not defined in LLVM as of Jan-07-2010)
1542 // o t2MOVi16: Rs imm16
1543 // o t2MOVTi16: Rs imm16
1544 // o t2SBFX (SBFX): Rs Rn lsb width
1545 // o t2UBFX (UBFX): Rs Rn lsb width
1546 // o t2BFI (BFI): Rs Rn lsb width
1547 static bool DisassembleThumb2DPBinImm(MCInst &MI, unsigned Opcode,
1548     uint32_t insn, unsigned short NumOps, unsigned &NumOpsAdded, BO B) {
1549
1550   const TargetInstrDesc &TID = ARMInsts[Opcode];
1551   const TargetOperandInfo *OpInfo = TID.OpInfo;
1552   unsigned &OpIdx = NumOpsAdded;
1553
1554   OpIdx = 0;
1555
1556   unsigned RdRegClassID = OpInfo[0].RegClass;
1557   assert(NumOps >= 2 && (RdRegClassID == ARM::GPRRegClassID ||
1558                          RdRegClassID == ARM::rGPRRegClassID)
1559          && "Expect >= 2 operands and first one as reg operand");
1560
1561   unsigned RnRegClassID = OpInfo[1].RegClass;
1562   bool TwoReg = (RnRegClassID == ARM::GPRRegClassID
1563                  || RnRegClassID == ARM::rGPRRegClassID);
1564
1565   // Build the register operand(s), followed by the immediate(s).
1566
1567   MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, RdRegClassID,
1568                                                      decodeRs(insn))));
1569   ++OpIdx;
1570
1571   if (TwoReg) {
1572     assert(NumOps >= 3 && "Expect >= 3 operands");
1573     int Idx;
1574     if ((Idx = TID.getOperandConstraint(OpIdx, TOI::TIED_TO)) != -1) {
1575       // Process tied_to operand constraint.
1576       MI.addOperand(MI.getOperand(Idx));
1577     } else {
1578       // Add src reg operand.
1579       MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, RnRegClassID,
1580                                                          decodeRn(insn))));
1581     }
1582     ++OpIdx;
1583   }
1584
1585   if (Opcode == ARM::t2BFI) {
1586     // Add val reg operand.
1587     MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, RnRegClassID,
1588                                                        decodeRn(insn))));
1589     ++OpIdx;
1590   }
1591
1592   assert(OpInfo[OpIdx].RegClass < 0 && !OpInfo[OpIdx].isPredicate()
1593          && !OpInfo[OpIdx].isOptionalDef()
1594          && "Pure imm operand expected");
1595
1596   // Pre-increment OpIdx.
1597   ++OpIdx;
1598
1599   if (Opcode == ARM::t2ADDri12 || Opcode == ARM::t2SUBri12
1600       || Opcode == ARM::t2LEApcrel)
1601     MI.addOperand(MCOperand::CreateImm(getIImm3Imm8(insn)));
1602   else if (Opcode == ARM::t2MOVi16 || Opcode == ARM::t2MOVTi16) {
1603     if (!B->tryAddingSymbolicOperand(getImm16(insn), 4, MI))
1604       MI.addOperand(MCOperand::CreateImm(getImm16(insn)));
1605   } else if (Opcode == ARM::t2BFC || Opcode == ARM::t2BFI) {
1606     uint32_t mask = 0;
1607     if (getBitfieldInvMask(insn, mask))
1608       MI.addOperand(MCOperand::CreateImm(mask));
1609     else
1610       return false;
1611   } else {
1612     // Handle the case of: lsb width
1613     assert((Opcode == ARM::t2SBFX || Opcode == ARM::t2UBFX)
1614             && "Unexpected opcode");
1615     MI.addOperand(MCOperand::CreateImm(getLsb(insn)));
1616     MI.addOperand(MCOperand::CreateImm(getWidthMinus1(insn) + 1));
1617
1618     ++OpIdx;
1619   }
1620
1621   return true;
1622 }
1623
1624 // A6.3.4 Table A6-15 Miscellaneous control instructions
1625 // A8.6.41 DMB
1626 // A8.6.42 DSB
1627 // A8.6.49 ISB
1628 static inline bool t2MiscCtrlInstr(uint32_t insn) {
1629   if (slice(insn, 31, 20) == 0xf3b && slice(insn, 15, 14) == 2 &&
1630       slice(insn, 12, 12) == 0)
1631     return true;
1632
1633   return false;
1634 }
1635
1636 // A6.3.4 Branches and miscellaneous control
1637 //
1638 // A8.6.16 B
1639 // Branches: t2B, t2Bcc -> imm operand
1640 //
1641 // Branches: t2TPsoft -> no operand
1642 //
1643 // A8.6.23 BL, BLX (immediate)
1644 // Branches (defined in ARMInstrThumb.td): tBLr9, tBLXi_r9 -> imm operand
1645 //
1646 // A8.6.26
1647 // t2BXJ -> Rn
1648 //
1649 // Miscellaneous control:
1650 //   -> no operand (except pred-imm pred-ccr for CLREX, memory barrier variants)
1651 //
1652 // Hint: t2NOP, t2YIELD, t2WFE, t2WFI, t2SEV
1653 //   -> no operand (except pred-imm pred-ccr)
1654 //
1655 // t2DBG -> imm4 = Inst{3-0}
1656 //
1657 // t2MRS/t2MRSsys -> Rs
1658 // t2MSR/t2MSRsys -> Rn mask=Inst{11-8}
1659 // t2SMC -> imm4 = Inst{19-16}
1660 static bool DisassembleThumb2BrMiscCtrl(MCInst &MI, unsigned Opcode,
1661     uint32_t insn, unsigned short NumOps, unsigned &NumOpsAdded, BO B) {
1662
1663   if (NumOps == 0)
1664     return true;
1665
1666   if (Opcode == ARM::t2DMB || Opcode == ARM::t2DSB) {
1667     // Inst{3-0} encodes the memory barrier option for the variants.
1668     unsigned opt = slice(insn, 3, 0);
1669     switch (opt) {
1670     case ARM_MB::SY:  case ARM_MB::ST:
1671     case ARM_MB::ISH: case ARM_MB::ISHST:
1672     case ARM_MB::NSH: case ARM_MB::NSHST:
1673     case ARM_MB::OSH: case ARM_MB::OSHST:
1674       MI.addOperand(MCOperand::CreateImm(opt));
1675       NumOpsAdded = 1;
1676       return true;
1677     default:
1678       return false;
1679     }
1680   }
1681
1682   if (t2MiscCtrlInstr(insn))
1683     return true;
1684
1685   switch (Opcode) {
1686   case ARM::t2CLREX:
1687   case ARM::t2NOP:
1688   case ARM::t2YIELD:
1689   case ARM::t2WFE:
1690   case ARM::t2WFI:
1691   case ARM::t2SEV:
1692     return true;
1693   default:
1694     break;
1695   }
1696
1697   // FIXME: To enable correct asm parsing and disasm of CPS we need 3 different
1698   // opcodes which match the same real instruction. This is needed since there's
1699   // no current handling of optional arguments. Fix here when a better handling
1700   // of optional arguments is implemented.
1701   if (Opcode == ARM::t2CPS3p) {
1702     MI.addOperand(MCOperand::CreateImm(slice(insn, 10, 9))); // imod
1703     MI.addOperand(MCOperand::CreateImm(slice(insn, 7, 5)));  // iflags
1704     MI.addOperand(MCOperand::CreateImm(slice(insn, 4, 0)));  // mode
1705     NumOpsAdded = 3;
1706     return true;
1707   }
1708   if (Opcode == ARM::t2CPS2p) {
1709     MI.addOperand(MCOperand::CreateImm(slice(insn, 10, 9))); // imod
1710     MI.addOperand(MCOperand::CreateImm(slice(insn, 7, 5)));  // iflags
1711     NumOpsAdded = 2;
1712     return true;
1713   }
1714   if (Opcode == ARM::t2CPS1p) {
1715     MI.addOperand(MCOperand::CreateImm(slice(insn, 4, 0))); // mode
1716     NumOpsAdded = 1;
1717     return true;
1718   }
1719
1720   // DBG has its option specified in Inst{3-0}.
1721   if (Opcode == ARM::t2DBG) {
1722     MI.addOperand(MCOperand::CreateImm(slice(insn, 3, 0)));
1723     NumOpsAdded = 1;
1724     return true;
1725   }
1726
1727   // MRS and MRSsys take one GPR reg Rs.
1728   if (Opcode == ARM::t2MRS || Opcode == ARM::t2MRSsys) {
1729     MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::GPRRegClassID,
1730                                                        decodeRs(insn))));
1731     NumOpsAdded = 1;
1732     return true;
1733   }
1734   // BXJ takes one GPR reg Rn.
1735   if (Opcode == ARM::t2BXJ) {
1736     MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::GPRRegClassID,
1737                                                        decodeRn(insn))));
1738     NumOpsAdded = 1;
1739     return true;
1740   }
1741   // MSR take a mask, followed by one GPR reg Rn. The mask contains the R Bit in
1742   // bit 4, and the special register fields in bits 3-0.
1743   if (Opcode == ARM::t2MSR) {
1744     MI.addOperand(MCOperand::CreateImm(slice(insn, 20, 20) << 4 /* R Bit */ |
1745                                        slice(insn, 11, 8) /* Special Reg */));
1746     MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::GPRRegClassID,
1747                                                        decodeRn(insn))));
1748     NumOpsAdded = 2;
1749     return true;
1750   }
1751   // SMC take imm4.
1752   if (Opcode == ARM::t2SMC) {
1753     MI.addOperand(MCOperand::CreateImm(slice(insn, 19, 16)));
1754     NumOpsAdded = 1;
1755     return true;
1756   }
1757
1758   // Some instructions have predicate operands first before the immediate.
1759   if (Opcode == ARM::tBLXi_r9 || Opcode == ARM::tBLr9) {
1760     // Handling the two predicate operands before the imm operand.
1761     if (B->DoPredicateOperands(MI, Opcode, insn, NumOps))
1762       NumOpsAdded += 2;
1763     else {
1764       DEBUG(errs() << "Expected predicate operands not found.\n");
1765       return false;
1766     }
1767   }
1768
1769   // Add the imm operand.
1770   int Offset = 0;
1771
1772   switch (Opcode) {
1773   default:
1774     assert(0 && "Unexpected opcode");
1775     return false;
1776   case ARM::t2B:
1777     Offset = decodeImm32_B_EncodingT4(insn);
1778     break;
1779   case ARM::t2Bcc:
1780     Offset = decodeImm32_B_EncodingT3(insn);
1781     break;
1782   case ARM::tBLr9:
1783     Offset = decodeImm32_BL(insn);
1784     break;
1785   case ARM::tBLXi_r9:
1786     Offset = decodeImm32_BLX(insn);
1787     break;
1788   }
1789
1790   if (!B->tryAddingSymbolicOperand(Offset + B->getBuilderAddress() + 4, 4, MI))
1791     MI.addOperand(MCOperand::CreateImm(Offset));
1792
1793   // This is an increment as some predicate operands may have been added first.
1794   NumOpsAdded += 1;
1795
1796   return true;
1797 }
1798
1799 static inline bool Thumb2PreloadOpcode(unsigned Opcode) {
1800   switch (Opcode) {
1801   default:
1802     return false;
1803   case ARM::t2PLDi12:   case ARM::t2PLDi8:
1804   case ARM::t2PLDs:
1805   case ARM::t2PLDWi12:  case ARM::t2PLDWi8:
1806   case ARM::t2PLDWs:
1807   case ARM::t2PLIi12:   case ARM::t2PLIi8:
1808   case ARM::t2PLIs:
1809     return true;
1810   }
1811 }
1812
1813 static bool DisassembleThumb2PreLoad(MCInst &MI, unsigned Opcode, uint32_t insn,
1814     unsigned short NumOps, unsigned &NumOpsAdded, BO B) {
1815
1816   // Preload Data/Instruction requires either 2 or 3 operands.
1817   // t2PLDi12, t2PLDi8, t2PLDpci: Rn [+/-]imm12/imm8
1818   // t2PLDr:                      Rn Rm
1819   // t2PLDs:                      Rn Rm imm2=Inst{5-4}
1820   // Same pattern applies for t2PLDW* and t2PLI*.
1821
1822   const TargetInstrDesc &TID = ARMInsts[Opcode];
1823   const TargetOperandInfo *OpInfo = TID.OpInfo;
1824   unsigned &OpIdx = NumOpsAdded;
1825
1826   OpIdx = 0;
1827
1828   assert(NumOps >= 2 &&
1829          OpInfo[0].RegClass == ARM::GPRRegClassID &&
1830          "Expect >= 2 operands and first one as reg operand");
1831
1832   MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::GPRRegClassID,
1833                                                      decodeRn(insn))));
1834   ++OpIdx;
1835
1836   if (OpInfo[OpIdx].RegClass == ARM::rGPRRegClassID) {
1837     MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::GPRRegClassID,
1838                                                        decodeRm(insn))));
1839   } else {
1840     assert(OpInfo[OpIdx].RegClass < 0 && !OpInfo[OpIdx].isPredicate()
1841            && !OpInfo[OpIdx].isOptionalDef()
1842            && "Pure imm operand expected");
1843     int Offset = 0;
1844     if (Opcode == ARM::t2PLDi8 || Opcode == ARM::t2PLDWi8 ||
1845         Opcode == ARM::t2PLIi8) {
1846       // A8.6.117 Encoding T2: add = FALSE
1847       unsigned Imm8 = getImm8(insn);
1848       Offset = -1 * Imm8;
1849     } else {
1850       // The i12 forms.  See, for example, A8.6.117 Encoding T1.
1851       // Note that currently t2PLDi12 also handles the previously named t2PLDpci
1852       // opcode, that's why we use decodeImm12(insn) which returns +/- imm12.
1853       Offset = decodeImm12(insn);
1854     }
1855     MI.addOperand(MCOperand::CreateImm(Offset));
1856   }
1857   ++OpIdx;
1858
1859   if (OpIdx < NumOps && OpInfo[OpIdx].RegClass < 0 &&
1860       !OpInfo[OpIdx].isPredicate() && !OpInfo[OpIdx].isOptionalDef()) {
1861     // Fills in the shift amount for t2PLDs, t2PLDWs, t2PLIs.
1862     MI.addOperand(MCOperand::CreateImm(slice(insn, 5, 4)));
1863     ++OpIdx;
1864   }
1865
1866   return true;
1867 }
1868
1869 static bool BadRegsThumb2LdSt(unsigned Opcode, uint32_t insn, bool Load,
1870       unsigned R0, unsigned R1, unsigned R2, bool UseRm, bool WB) {
1871
1872   // Inst{22-21} encodes the data item transferred for load/store.
1873   // For single word, it is encoded as ob10.
1874   bool Word = (slice(insn, 22, 21) == 2);
1875
1876   if (UseRm && BadReg(R2)) {
1877     DEBUG(errs() << "if BadReg(m) then UNPREDICTABLE\n");
1878     return true;
1879   }
1880
1881   if (Load) {
1882     if (!Word && R0 == 13) {
1883       DEBUG(errs() << "if t == 13 then UNPREDICTABLE\n");
1884       return true;
1885     }
1886   } else {
1887     if (WB && R0 == R1) {
1888       DEBUG(errs() << "if wback && n == t then UNPREDICTABLE\n");
1889       return true;
1890     }
1891     if ((WB && R0 == 15) || (!WB && R1 == 15)) {
1892       DEBUG(errs() << "if Rn == '1111' then UNDEFINED\n");
1893       return true;
1894     }
1895     if (Word) {
1896       if ((WB && R1 == 15) || (!WB && R0 == 15)) {
1897         DEBUG(errs() << "if t == 15 then UNPREDICTABLE\n");
1898         return true;
1899       }
1900     } else {
1901       if ((WB && BadReg(R1)) || (!WB && BadReg(R0))) {
1902         DEBUG(errs() << "if BadReg(t) then UNPREDICTABLE\n");
1903         return true;
1904       }
1905     }
1906   }
1907   return false;
1908 }
1909
1910 // A6.3.10 Store single data item
1911 // A6.3.9 Load byte, memory hints
1912 // A6.3.8 Load halfword, memory hints
1913 // A6.3.7 Load word
1914 //
1915 // For example,
1916 //
1917 // t2LDRi12:   Rd Rn (+)imm12
1918 // t2LDRi8:    Rd Rn (+/-)imm8 (+ if Inst{9} == 0b1)
1919 // t2LDRs:     Rd Rn Rm ConstantShiftSpecifier (see also
1920 //             DisassembleThumb2DPSoReg)
1921 // t2LDR_POST: Rd Rn Rn(TIED_TO) (+/-)imm8 (+ if Inst{9} == 0b1)
1922 // t2LDR_PRE:  Rd Rn Rn(TIED_TO) (+/-)imm8 (+ if Inst{9} == 0b1)
1923 //
1924 // t2STRi12:   Rd Rn (+)imm12
1925 // t2STRi8:    Rd Rn (+/-)imm8 (+ if Inst{9} == 0b1)
1926 // t2STRs:     Rd Rn Rm ConstantShiftSpecifier (see also
1927 //             DisassembleThumb2DPSoReg)
1928 // t2STR_POST: Rn Rd Rn(TIED_TO) (+/-)imm8 (+ if Inst{9} == 0b1)
1929 // t2STR_PRE:  Rn Rd Rn(TIED_TO) (+/-)imm8 (+ if Inst{9} == 0b1)
1930 //
1931 // Note that for indexed modes, the Rn(TIED_TO) operand needs to be populated
1932 // correctly, as LLVM AsmPrinter depends on it.  For indexed stores, the first
1933 // operand is Rn; for all the other instructions, Rd is the first operand.
1934 //
1935 // Delegates to DisassembleThumb2PreLoad() for preload data/instruction.
1936 // Delegates to DisassembleThumb2Ldpci() for load * literal operations.
1937 static bool DisassembleThumb2LdSt(bool Load, MCInst &MI, unsigned Opcode,
1938     uint32_t insn, unsigned short NumOps, unsigned &NumOpsAdded, BO B) {
1939
1940   unsigned Rn = decodeRn(insn);
1941
1942   if (Thumb2PreloadOpcode(Opcode))
1943     return DisassembleThumb2PreLoad(MI, Opcode, insn, NumOps, NumOpsAdded, B);
1944
1945   // See, for example, A6.3.7 Load word: Table A6-18 Load word.
1946   if (Load && Rn == 15)
1947     return DisassembleThumb2Ldpci(MI, Opcode, insn, NumOps, NumOpsAdded, B);
1948   const TargetInstrDesc &TID = ARMInsts[Opcode];
1949   const TargetOperandInfo *OpInfo = TID.OpInfo;
1950   unsigned &OpIdx = NumOpsAdded;
1951
1952   OpIdx = 0;
1953
1954   assert(NumOps >= 3 &&
1955          OpInfo[0].RegClass == ARM::GPRRegClassID &&
1956          OpInfo[1].RegClass == ARM::GPRRegClassID &&
1957          "Expect >= 3 operands and first two as reg operands");
1958
1959   bool ThreeReg = (OpInfo[2].RegClass > 0);
1960   bool TIED_TO = ThreeReg && TID.getOperandConstraint(2, TOI::TIED_TO) != -1;
1961   bool Imm12 = !ThreeReg && slice(insn, 23, 23) == 1; // ARMInstrThumb2.td
1962
1963   // Build the register operands, followed by the immediate.
1964   unsigned R0, R1, R2 = 0;
1965   unsigned Rd = decodeRd(insn);
1966   int Imm = 0;
1967
1968   if (!Load && TIED_TO) {
1969     R0 = Rn;
1970     R1 = Rd;
1971   } else {
1972     R0 = Rd;
1973     R1 = Rn;
1974   }
1975   if (ThreeReg) {
1976     if (TIED_TO) {
1977       R2 = Rn;
1978       Imm = decodeImm8(insn);
1979     } else {
1980       R2 = decodeRm(insn);
1981       // See, for example, A8.6.64 LDRB (register).
1982       // And ARMAsmPrinter::printT2AddrModeSoRegOperand().
1983       // LSL is the default shift opc, and LLVM does not expect it to be encoded
1984       // as part of the immediate operand.
1985       // Imm = ARM_AM::getSORegOpc(ARM_AM::lsl, slice(insn, 5, 4));
1986       Imm = slice(insn, 5, 4);
1987     }
1988   } else {
1989     if (Imm12)
1990       Imm = getImm12(insn);
1991     else
1992       Imm = decodeImm8(insn);
1993   }
1994
1995   MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::GPRRegClassID,
1996                                                      R0)));
1997   ++OpIdx;
1998   MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::GPRRegClassID,
1999                                                      R1)));
2000   ++OpIdx;
2001
2002   if (ThreeReg) {
2003     // This could be an offset register or a TIED_TO register.
2004     MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B,OpInfo[OpIdx].RegClass,
2005                                                        R2)));
2006     ++OpIdx;
2007   }
2008
2009   if (BadRegsThumb2LdSt(Opcode, insn, Load, R0, R1, R2, ThreeReg & !TIED_TO,
2010                         TIED_TO))
2011     return false;
2012
2013   assert(OpInfo[OpIdx].RegClass < 0 && !OpInfo[OpIdx].isPredicate()
2014          && !OpInfo[OpIdx].isOptionalDef()
2015          && "Pure imm operand expected");
2016
2017   MI.addOperand(MCOperand::CreateImm(Imm));
2018   ++OpIdx;
2019
2020   return true;
2021 }
2022
2023 // A6.3.12 Data-processing (register)
2024 //
2025 // Two register operands [rotate]:   Rs Rm [rotation(= (rotate:'000'))]
2026 // Three register operands only:     Rs Rn Rm
2027 // Three register operands [rotate]: Rs Rn Rm [rotation(= (rotate:'000'))]
2028 //
2029 // Parallel addition and subtraction 32-bit Thumb instructions: Rs Rn Rm
2030 //
2031 // Miscellaneous operations: Rs [Rn] Rm
2032 static bool DisassembleThumb2DPReg(MCInst &MI, unsigned Opcode, uint32_t insn,
2033     unsigned short NumOps, unsigned &NumOpsAdded, BO B) {
2034
2035   const TargetInstrDesc &TID = ARMInsts[Opcode];
2036   const TargetOperandInfo *OpInfo = TID.OpInfo;
2037   unsigned &OpIdx = NumOpsAdded;
2038
2039   OpIdx = 0;
2040
2041   assert(NumOps >= 2 &&
2042          OpInfo[0].RegClass > 0 &&
2043          OpInfo[1].RegClass > 0 &&
2044          "Expect >= 2 operands and first two as reg operands");
2045
2046   // Build the register operands, followed by the optional rotation amount.
2047
2048   bool ThreeReg = NumOps > 2 && OpInfo[2].RegClass > 0;
2049
2050   MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, OpInfo[OpIdx].RegClass,
2051                                                      decodeRs(insn))));
2052   ++OpIdx;
2053
2054   if (ThreeReg) {
2055     MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B,OpInfo[OpIdx].RegClass,
2056                                                        decodeRn(insn))));
2057     ++OpIdx;
2058   }
2059
2060   MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, OpInfo[OpIdx].RegClass,
2061                                                      decodeRm(insn))));
2062   ++OpIdx;
2063
2064   if (OpIdx < NumOps && OpInfo[OpIdx].RegClass < 0
2065       && !OpInfo[OpIdx].isPredicate() && !OpInfo[OpIdx].isOptionalDef()) {
2066     // Add the rotation amount immediate.
2067     MI.addOperand(MCOperand::CreateImm(decodeRotate(insn)));
2068     ++OpIdx;
2069   }
2070
2071   return true;
2072 }
2073
2074 // A6.3.16 Multiply, multiply accumulate, and absolute difference
2075 //
2076 // t2MLA, t2MLS, t2SMMLA, t2SMMLS: Rs Rn Rm Ra=Inst{15-12}
2077 // t2MUL, t2SMMUL:                 Rs Rn Rm
2078 // t2SMLA[BB|BT|TB|TT|WB|WT]:      Rs Rn Rm Ra=Inst{15-12}
2079 // t2SMUL[BB|BT|TB|TT|WB|WT]:      Rs Rn Rm
2080 //
2081 // Dual halfword multiply: t2SMUAD[X], t2SMUSD[X], t2SMLAD[X], t2SMLSD[X]:
2082 //   Rs Rn Rm Ra=Inst{15-12}
2083 //
2084 // Unsigned Sum of Absolute Differences [and Accumulate]
2085 //    Rs Rn Rm [Ra=Inst{15-12}]
2086 static bool DisassembleThumb2Mul(MCInst &MI, unsigned Opcode, uint32_t insn,
2087     unsigned short NumOps, unsigned &NumOpsAdded, BO B) {
2088
2089   const TargetOperandInfo *OpInfo = ARMInsts[Opcode].OpInfo;
2090
2091   assert(NumOps >= 3 &&
2092          OpInfo[0].RegClass == ARM::rGPRRegClassID &&
2093          OpInfo[1].RegClass == ARM::rGPRRegClassID &&
2094          OpInfo[2].RegClass == ARM::rGPRRegClassID &&
2095          "Expect >= 3 operands and first three as reg operands");
2096
2097   // Build the register operands.
2098
2099   bool FourReg = NumOps > 3 && OpInfo[3].RegClass == ARM::rGPRRegClassID;
2100
2101   MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::rGPRRegClassID,
2102                                                      decodeRs(insn))));
2103
2104   MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::rGPRRegClassID,
2105                                                      decodeRn(insn))));
2106
2107   MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::rGPRRegClassID,
2108                                                      decodeRm(insn))));
2109
2110   if (FourReg)
2111     MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::rGPRRegClassID,
2112                                                        decodeRd(insn))));
2113
2114   NumOpsAdded = FourReg ? 4 : 3;
2115
2116   return true;
2117 }
2118
2119 // A6.3.17 Long multiply, long multiply accumulate, and divide
2120 //
2121 // t2SMULL, t2UMULL, t2SMLAL, t2UMLAL, t2UMAAL: RdLo RdHi Rn Rm
2122 // where RdLo = Inst{15-12} and RdHi = Inst{11-8}
2123 //
2124 // Halfword multiple accumulate long: t2SMLAL<x><y>: RdLo RdHi Rn Rm
2125 // where RdLo = Inst{15-12} and RdHi = Inst{11-8}
2126 //
2127 // Dual halfword multiple: t2SMLALD[X], t2SMLSLD[X]: RdLo RdHi Rn Rm
2128 // where RdLo = Inst{15-12} and RdHi = Inst{11-8}
2129 //
2130 // Signed/Unsigned divide: t2SDIV, t2UDIV: Rs Rn Rm
2131 static bool DisassembleThumb2LongMul(MCInst &MI, unsigned Opcode, uint32_t insn,
2132     unsigned short NumOps, unsigned &NumOpsAdded, BO B) {
2133
2134   const TargetOperandInfo *OpInfo = ARMInsts[Opcode].OpInfo;
2135
2136   assert(NumOps >= 3 &&
2137          OpInfo[0].RegClass == ARM::rGPRRegClassID &&
2138          OpInfo[1].RegClass == ARM::rGPRRegClassID &&
2139          OpInfo[2].RegClass == ARM::rGPRRegClassID &&
2140          "Expect >= 3 operands and first three as reg operands");
2141
2142   bool FourReg = NumOps > 3 && OpInfo[3].RegClass == ARM::rGPRRegClassID;
2143
2144   // Build the register operands.
2145
2146   if (FourReg)
2147     MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::rGPRRegClassID,
2148                                                        decodeRd(insn))));
2149
2150   MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::rGPRRegClassID,
2151                                                      decodeRs(insn))));
2152
2153   MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::rGPRRegClassID,
2154                                                      decodeRn(insn))));
2155
2156   MI.addOperand(MCOperand::CreateReg(getRegisterEnum(B, ARM::rGPRRegClassID,
2157                                                      decodeRm(insn))));
2158
2159   if (FourReg)
2160     NumOpsAdded = 4;
2161   else
2162     NumOpsAdded = 3;
2163
2164   return true;
2165 }
2166
2167 // See A6.3 32-bit Thumb instruction encoding for instruction classes
2168 // corresponding to (op1, op2, op).
2169 //
2170 // Table A6-9 32-bit Thumb instruction encoding
2171 // op1  op2    op  Instruction class, see
2172 // ---  -------  --  -----------------------------------------------------------
2173 // 01  00xx0xx  -  Load/store multiple on page A6-23
2174 //     00xx1xx  -  Load/store dual, load/store exclusive, table branch on
2175 //                 page A6-24
2176 //     01xxxxx  -  Data-processing (shifted register) on page A6-31
2177 //     1xxxxxx  -  Coprocessor instructions on page A6-40
2178 // 10  x0xxxxx  0  Data-processing (modified immediate) on page A6-15
2179 //     x1xxxxx  0  Data-processing (plain binary immediate) on page A6-19
2180 //         -    1  Branches and miscellaneous control on page A6-20
2181 // 11  000xxx0  -  Store single data item on page A6-30
2182 //     001xxx0  -  Advanced SIMD element or structure load/store instructions
2183 //                 on page A7-27
2184 //     00xx001  - Load byte, memory hints on page A6-28
2185 //     00xx011  -  Load halfword, memory hints on page A6-26
2186 //     00xx101  -  Load word on page A6-25
2187 //     00xx111  -  UNDEFINED
2188 //     010xxxx  -  Data-processing (register) on page A6-33
2189 //     0110xxx  -  Multiply, multiply accumulate, and absolute difference on
2190 //                 page A6-38
2191 //     0111xxx  -  Long multiply, long multiply accumulate, and divide on
2192 //                 page A6-39
2193 //     1xxxxxx  -  Coprocessor instructions on page A6-40
2194 //
2195 static bool DisassembleThumb2(uint16_t op1, uint16_t op2, uint16_t op,
2196     MCInst &MI, unsigned Opcode, uint32_t insn, unsigned short NumOps,
2197     unsigned &NumOpsAdded, BO B) {
2198
2199   switch (op1) {
2200   case 1:
2201     if (slice(op2, 6, 5) == 0) {
2202       if (slice(op2, 2, 2) == 0) {
2203         // Load/store multiple.
2204         return DisassembleThumb2LdStMul(MI, Opcode, insn, NumOps, NumOpsAdded,
2205                                         B);
2206       }
2207
2208       // Load/store dual, load/store exclusive, table branch, otherwise.
2209       assert(slice(op2, 2, 2) == 1 && "Thumb2 encoding error!");
2210       if ((ARM::t2LDREX <= Opcode && Opcode <= ARM::t2LDREXH) ||
2211           (ARM::t2STREX <= Opcode && Opcode <= ARM::t2STREXH)) {
2212         // Load/store exclusive.
2213         return DisassembleThumb2LdStEx(MI, Opcode, insn, NumOps, NumOpsAdded,
2214                                        B);
2215       }
2216       if (Opcode == ARM::t2LDRDi8 ||
2217           Opcode == ARM::t2LDRD_PRE || Opcode == ARM::t2LDRD_POST ||
2218           Opcode == ARM::t2STRDi8 ||
2219           Opcode == ARM::t2STRD_PRE || Opcode == ARM::t2STRD_POST) {
2220         // Load/store dual.
2221         return DisassembleThumb2LdStDual(MI, Opcode, insn, NumOps, NumOpsAdded,
2222                                          B);
2223       }
2224       if (Opcode == ARM::t2TBB || Opcode == ARM::t2TBH) {
2225         // Table branch.
2226         return DisassembleThumb2TB(MI, Opcode, insn, NumOps, NumOpsAdded, B);
2227       }
2228     } else if (slice(op2, 6, 5) == 1) {
2229       // Data-processing (shifted register).
2230       return DisassembleThumb2DPSoReg(MI, Opcode, insn, NumOps, NumOpsAdded, B);
2231     }
2232
2233     // FIXME: A6.3.18 Coprocessor instructions
2234     // But see ThumbDisassembler::getInstruction().
2235
2236     break;
2237   case 2:
2238     if (op == 0) {
2239       if (slice(op2, 5, 5) == 0)
2240         // Data-processing (modified immediate)
2241         return DisassembleThumb2DPModImm(MI, Opcode, insn, NumOps, NumOpsAdded,
2242                                          B);
2243       if (Thumb2SaturateOpcode(Opcode))
2244         return DisassembleThumb2Sat(MI, Opcode, insn, NumOpsAdded, B);
2245
2246       // Data-processing (plain binary immediate)
2247       return DisassembleThumb2DPBinImm(MI, Opcode, insn, NumOps, NumOpsAdded,
2248                                        B);
2249     }
2250     // Branches and miscellaneous control on page A6-20.
2251     return DisassembleThumb2BrMiscCtrl(MI, Opcode, insn, NumOps, NumOpsAdded,
2252                                        B);
2253   case 3:
2254     switch (slice(op2, 6, 5)) {
2255     case 0:
2256       // Load/store instructions...
2257       if (slice(op2, 0, 0) == 0) {
2258         if (slice(op2, 4, 4) == 0) {
2259           // Store single data item on page A6-30
2260           return DisassembleThumb2LdSt(false, MI,Opcode,insn,NumOps,NumOpsAdded,
2261                                        B);
2262         } else {
2263           // FIXME: Advanced SIMD element or structure load/store instructions.
2264           // But see ThumbDisassembler::getInstruction().
2265           ;
2266         }
2267       } else {
2268         // Table A6-9 32-bit Thumb instruction encoding: Load byte|halfword|word
2269         return DisassembleThumb2LdSt(true, MI, Opcode, insn, NumOps,
2270                                      NumOpsAdded, B);
2271       }
2272       break;
2273     case 1:
2274       if (slice(op2, 4, 4) == 0) {
2275         // A6.3.12 Data-processing (register)
2276         return DisassembleThumb2DPReg(MI, Opcode, insn, NumOps, NumOpsAdded, B);
2277       } else if (slice(op2, 3, 3) == 0) {
2278         // A6.3.16 Multiply, multiply accumulate, and absolute difference
2279         return DisassembleThumb2Mul(MI, Opcode, insn, NumOps, NumOpsAdded, B);
2280       } else {
2281         // A6.3.17 Long multiply, long multiply accumulate, and divide
2282         return DisassembleThumb2LongMul(MI, Opcode, insn, NumOps, NumOpsAdded,
2283                                         B);
2284       }
2285       break;
2286     default:
2287       // FIXME: A6.3.18 Coprocessor instructions
2288       // But see ThumbDisassembler::getInstruction().
2289       ;
2290       break;
2291     }
2292
2293     break;
2294   default:
2295     assert(0 && "Thumb2 encoding error!");
2296     break;
2297   }
2298
2299   return false;
2300 }
2301
2302 static bool DisassembleThumbFrm(MCInst &MI, unsigned Opcode, uint32_t insn,
2303     unsigned short NumOps, unsigned &NumOpsAdded, BO Builder) {
2304
2305   uint16_t HalfWord = slice(insn, 31, 16);
2306
2307   if (HalfWord == 0) {
2308     // A6.2 16-bit Thumb instruction encoding
2309     // op = bits[15:10]
2310     uint16_t op = slice(insn, 15, 10);
2311     return DisassembleThumb1(op, MI, Opcode, insn, NumOps, NumOpsAdded,
2312                              Builder);
2313   }
2314
2315   unsigned bits15_11 = slice(HalfWord, 15, 11);
2316
2317   // A6.1 Thumb instruction set encoding
2318   if (!(bits15_11 == 0x1D || bits15_11 == 0x1E || bits15_11 == 0x1F)) {
2319     assert("Bits[15:11] first halfword of Thumb2 instruction is out of range");
2320     return false;
2321   }
2322
2323   // A6.3 32-bit Thumb instruction encoding
2324
2325   uint16_t op1 = slice(HalfWord, 12, 11);
2326   uint16_t op2 = slice(HalfWord, 10, 4);
2327   uint16_t op = slice(insn, 15, 15);
2328
2329   return DisassembleThumb2(op1, op2, op, MI, Opcode, insn, NumOps, NumOpsAdded,
2330                            Builder);
2331 }