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