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