lib/Target/ARM/Disassembler/ARMDisassembler.cpp

   1 //===- ARMDisassembler.cpp - Disassembler for ARM/Thumb ISA -----*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file is part of the ARM Disassembler.
  11 // It contains code to implement the public interfaces of ARMDisassembler and
  12 // ThumbDisassembler, both of which are instances of MCDisassembler.
  13 //
  14 //===----------------------------------------------------------------------===//
  15
  16 #define DEBUG_TYPE "arm-disassembler"
  17
  18 #include "ARMDisassembler.h"
  19 #include "ARMDisassemblerCore.h"
  20
  21 #include "llvm/MC/MCInst.h"
  22 #include "llvm/Target/TargetRegistry.h"
  23 #include "llvm/Support/Debug.h"
  24 #include "llvm/Support/MemoryObject.h"
  25 #include "llvm/Support/ErrorHandling.h"
  26 #include "llvm/Support/raw_ostream.h"
  27
  28 /// ARMGenDecoderTables.inc - ARMDecoderTables.inc is tblgen'ed from
  29 /// ARMDecoderEmitter.cpp TableGen backend.  It contains:
  30 ///
  31 /// o Mappings from opcode to ARM/Thumb instruction format
  32 ///
  33 /// o static uint16_t decodeInstruction(uint32_t insn) - the decoding function
  34 /// for an ARM instruction.
  35 ///
  36 /// o static uint16_t decodeThumbInstruction(field_t insn) - the decoding
  37 /// function for a Thumb instruction.
  38 ///
  39 #include "../ARMGenDecoderTables.inc"
  40
  41 namespace llvm {
  42
  43 /// showBitVector - Use the raw_ostream to log a diagnostic message describing
  44 /// the inidividual bits of the instruction.
  45 ///
  46 static inline void showBitVector(raw_ostream &os, const uint32_t &insn) {
  47   // Split the bit position markers into more than one lines to fit 80 columns.
  48   os << " 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11"
  49      << " 10  9  8  7  6  5  4  3  2  1  0 \n";
  50   os << "---------------------------------------------------------------"
  51      << "----------------------------------\n";
  52   os << '|';
  53   for (unsigned i = 32; i != 0; --i) {
  54     if (insn >> (i - 1) & 0x01)
  55       os << " 1";
  56     else
  57       os << " 0";
  58     os << (i%4 == 1 ? '|' : ':');
  59   }
  60   os << '\n';
  61   // Split the bit position markers into more than one lines to fit 80 columns.
  62   os << "---------------------------------------------------------------"
  63      << "----------------------------------\n";
  64   os << '\n';
  65 }
  66
  67 /// decodeARMInstruction is a decorator function which tries special cases of
  68 /// instruction matching before calling the auto-generated decoder function.
  69 static unsigned decodeARMInstruction(uint32_t &insn) {
  70   if (slice(insn, 31, 28) == 15)
  71     goto AutoGenedDecoder;
  72
  73   // Special case processing, if any, goes here....
  74
  75   // LLVM combines the offset mode of A8.6.197 & A8.6.198 into STRB.
  76   // The insufficient encoding information of the combined instruction confuses
  77   // the decoder wrt BFC/BFI.  Therefore, we try to recover here.
  78   // For BFC, Inst{27-21} = 0b0111110 & Inst{6-0} = 0b0011111.
  79   // For BFI, Inst{27-21} = 0b0111110 & Inst{6-4} = 0b001 & Inst{3-0} =! 0b1111.
  80   if (slice(insn, 27, 21) == 0x3e && slice(insn, 6, 4) == 1) {
  81     if (slice(insn, 3, 0) == 15)
  82       return ARM::BFC;
  83     else
  84       return ARM::BFI;
  85   }
  86
  87   // Ditto for ADDSrs, which is a super-instruction for A8.6.7 & A8.6.8.
  88   // As a result, the decoder fails to decode UMULL properly.
  89   if (slice(insn, 27, 21) == 0x04 && slice(insn, 7, 4) == 9) {
  90     return ARM::UMULL;
  91   }
  92
  93   // Ditto for STR_PRE, which is a super-instruction for A8.6.194 & A8.6.195.
  94   // As a result, the decoder fails to decode SBFX properly.
  95   if (slice(insn, 27, 21) == 0x3d && slice(insn, 6, 4) == 5)
  96     return ARM::SBFX;
  97
  98   // And STRB_PRE, which is a super-instruction for A8.6.197 & A8.6.198.
  99   // As a result, the decoder fails to decode UBFX properly.
 100   if (slice(insn, 27, 21) == 0x3f && slice(insn, 6, 4) == 5)
 101     return ARM::UBFX;
 102
 103   // Ditto for STRT, which is a super-instruction for A8.6.210 Encoding A1 & A2.
 104   // As a result, the decoder fails to deocode SSAT properly.
 105   if (slice(insn, 27, 21) == 0x35 && slice(insn, 5, 4) == 1)
 106     return slice(insn, 6, 6) == 0 ? ARM::SSATlsl : ARM::SSATasr;
 107
 108   // Ditto for RSCrs, which is a super-instruction for A8.6.146 & A8.6.147.
 109   // As a result, the decoder fails to decode STRHT/LDRHT/LDRSHT/LDRSBT.
 110   if (slice(insn, 27, 24) == 0) {
 111     switch (slice(insn, 21, 20)) {
 112     case 2:
 113       switch (slice(insn, 7, 4)) {
 114       case 11:
 115         return ARM::STRHT;
 116       default:
 117         break; // fallthrough
 118       }
 119       break;
 120     case 3:
 121       switch (slice(insn, 7, 4)) {
 122       case 11:
 123         return ARM::LDRHT;
 124       case 13:
 125         return ARM::LDRSBT;
 126       case 15:
 127         return ARM::LDRSHT;
 128       default:
 129         break; // fallthrough
 130       }
 131       break;
 132     default:
 133       break;   // fallthrough
 134     }
 135   }
 136
 137   // Ditto for SBCrs, which is a super-instruction for A8.6.152 & A8.6.153.
 138   // As a result, the decoder fails to decode STRH_Post/LDRD_POST/STRD_POST
 139   // properly.
 140   if (slice(insn, 27, 25) == 0 && slice(insn, 20, 20) == 0) {
 141     unsigned PW = slice(insn, 24, 24) << 1 | slice(insn, 21, 21);
 142     switch (slice(insn, 7, 4)) {
 143     case 11:
 144       switch (PW) {
 145       case 2: // Offset
 146         return ARM::STRH;
 147       case 3: // Pre-indexed
 148         return ARM::STRH_PRE;
 149       case 0: // Post-indexed
 150         return ARM::STRH_POST;
 151       default:
 152         break; // fallthrough
 153       }
 154       break;
 155     case 13:
 156       switch (PW) {
 157       case 2: // Offset
 158         return ARM::LDRD;
 159       case 3: // Pre-indexed
 160         return ARM::LDRD_PRE;
 161       case 0: // Post-indexed
 162         return ARM::LDRD_POST;
 163       default:
 164         break; // fallthrough
 165       }
 166       break;
 167     case 15:
 168       switch (PW) {
 169       case 2: // Offset
 170         return ARM::STRD;
 171       case 3: // Pre-indexed
 172         return ARM::STRD_PRE;
 173       case 0: // Post-indexed
 174         return ARM::STRD_POST;
 175       default:
 176         break; // fallthrough
 177       }
 178       break;
 179     default:
 180       break; // fallthrough
 181     }
 182   }
 183
 184   // Ditto for SBCSSrs, which is a super-instruction for A8.6.152 & A8.6.153.
 185   // As a result, the decoder fails to decode LDRH_POST/LDRSB_POST/LDRSH_POST
 186   // properly.
 187   if (slice(insn, 27, 25) == 0 && slice(insn, 20, 20) == 1) {
 188     unsigned PW = slice(insn, 24, 24) << 1 | slice(insn, 21, 21);
 189     switch (slice(insn, 7, 4)) {
 190     case 11:
 191       switch (PW) {
 192       case 2: // Offset
 193         return ARM::LDRH;
 194       case 3: // Pre-indexed
 195         return ARM::LDRH_PRE;
 196       case 0: // Post-indexed
 197         return ARM::LDRH_POST;
 198       default:
 199         break; // fallthrough
 200       }
 201       break;
 202     case 13:
 203       switch (PW) {
 204       case 2: // Offset
 205         return ARM::LDRSB;
 206       case 3: // Pre-indexed
 207         return ARM::LDRSB_PRE;
 208       case 0: // Post-indexed
 209         return ARM::LDRSB_POST;
 210       default:
 211         break; // fallthrough
 212       }
 213       break;
 214     case 15:
 215       switch (PW) {
 216       case 2: // Offset
 217         return ARM::LDRSH;
 218       case 3: // Pre-indexed
 219         return ARM::LDRSH_PRE;
 220       case 0: // Post-indexed
 221         return ARM::LDRSH_POST;
 222       default:
 223         break; // fallthrough
 224       }
 225       break;
 226     default:
 227       break; // fallthrough
 228     }
 229   }
 230
 231 AutoGenedDecoder:
 232   // Calling the auto-generated decoder function.
 233   return decodeInstruction(insn);
 234 }
 235
 236 // Helper function for special case handling of LDR (literal) and friends.
 237 // See, for example, A6.3.7 Load word: Table A6-18 Load word.
 238 // See A8.6.57 T3, T4 & A8.6.60 T2 and friends for why we morphed the opcode
 239 // before returning it.
 240 static unsigned T2Morph2LoadLiteral(unsigned Opcode) {
 241   switch (Opcode) {
 242   default:
 243     return Opcode; // Return unmorphed opcode.
 244
 245   case ARM::t2LDRDi8:
 246     return ARM::t2LDRDpci;
 247
 248   case ARM::t2LDR_POST:   case ARM::t2LDR_PRE:
 249   case ARM::t2LDRi12:     case ARM::t2LDRi8:
 250   case ARM::t2LDRs:
 251     return ARM::t2LDRpci;
 252
 253   case ARM::t2LDRB_POST:  case ARM::t2LDRB_PRE:
 254   case ARM::t2LDRBi12:    case ARM::t2LDRBi8:
 255   case ARM::t2LDRBs:
 256     return ARM::t2LDRBpci;
 257
 258   case ARM::t2LDRH_POST:  case ARM::t2LDRH_PRE:
 259   case ARM::t2LDRHi12:    case ARM::t2LDRHi8:
 260   case ARM::t2LDRHs:
 261     return ARM::t2LDRHpci;
 262
 263   case ARM::t2LDRSB_POST:  case ARM::t2LDRSB_PRE:
 264   case ARM::t2LDRSBi12:    case ARM::t2LDRSBi8:
 265   case ARM::t2LDRSBs:
 266     return ARM::t2LDRSBpci;
 267
 268   case ARM::t2LDRSH_POST:  case ARM::t2LDRSH_PRE:
 269   case ARM::t2LDRSHi12:    case ARM::t2LDRSHi8:
 270   case ARM::t2LDRSHs:
 271     return ARM::t2LDRSHpci;
 272   }
 273 }
 274
 275 /// decodeThumbSideEffect is a decorator function which can potentially twiddle
 276 /// the instruction or morph the returned opcode under Thumb2.
 277 ///
 278 /// First it checks whether the insn is a NEON or VFP instr; if true, bit
 279 /// twiddling could be performed on insn to turn it into an ARM NEON/VFP
 280 /// equivalent instruction and decodeInstruction is called with the transformed
 281 /// insn.
 282 ///
 283 /// Next, there is special handling for Load byte/halfword/word instruction by
 284 /// checking whether Rn=0b1111 and call T2Morph2LoadLiteral() on the decoded
 285 /// Thumb2 instruction.  See comments below for further details.
 286 ///
 287 /// Finally, one last check is made to see whether the insn is a NEON/VFP and
 288 /// decodeInstruction(insn) is invoked on the original insn.
 289 ///
 290 /// Otherwise, decodeThumbInstruction is called with the original insn.
 291 static unsigned decodeThumbSideEffect(bool IsThumb2, uint32_t &insn) {
 292   if (IsThumb2) {
 293     uint16_t op1 = slice(insn, 28, 27);
 294     uint16_t op2 = slice(insn, 26, 20);
 295
 296     // A6.3 32-bit Thumb instruction encoding
 297     // Table A6-9 32-bit Thumb instruction encoding
 298
 299     // The coprocessor instructions of interest are transformed to their ARM
 300     // equivalents.
 301
 302     // --------- Transform Begin Marker ---------
 303     if ((op1 == 1 || op1 == 3) && slice(op2, 6, 4) == 7) {
 304       // A7.4 Advanced SIMD data-processing instructions
 305       // U bit of Thumb corresponds to Inst{24} of ARM.
 306       uint16_t U = slice(op1, 1, 1);
 307
 308       // Inst{28-24} of ARM = {1,0,0,1,U};
 309       uint16_t bits28_24 = 9 << 1 | U;
 310       DEBUG(showBitVector(errs(), insn));
 311       setSlice(insn, 28, 24, bits28_24);
 312       return decodeInstruction(insn);
 313     }
 314
 315     if (op1 == 3 && slice(op2, 6, 4) == 1 && slice(op2, 0, 0) == 0) {
 316       // A7.7 Advanced SIMD element or structure load/store instructions
 317       // Inst{27-24} of Thumb = 0b1001
 318       // Inst{27-24} of ARM   = 0b0100
 319       DEBUG(showBitVector(errs(), insn));
 320       setSlice(insn, 27, 24, 4);
 321       return decodeInstruction(insn);
 322     }
 323     // --------- Transform End Marker ---------
 324
 325     // See, for example, A6.3.7 Load word: Table A6-18 Load word.
 326     // See A8.6.57 T3, T4 & A8.6.60 T2 and friends for why we morphed the opcode
 327     // before returning it to our caller.
 328     if (op1 == 3 && slice(op2, 6, 5) == 0 && slice(op2, 0, 0) == 1
 329         && slice(insn, 19, 16) == 15)
 330       return T2Morph2LoadLiteral(decodeThumbInstruction(insn));
 331
 332     // One last check for NEON/VFP instructions.
 333     if ((op1 == 1 || op1 == 3) && slice(op2, 6, 6) == 1)
 334       return decodeInstruction(insn);
 335
 336     // Fall through.
 337   }
 338
 339   return decodeThumbInstruction(insn);
 340 }
 341
 342 static inline bool Thumb2PreloadOpcodeNoPCI(unsigned Opcode) {
 343   switch (Opcode) {
 344   default:
 345     return false;
 346   case ARM::t2PLDi12:   case ARM::t2PLDi8:
 347   case ARM::t2PLDr:     case ARM::t2PLDs:
 348   case ARM::t2PLDWi12:  case ARM::t2PLDWi8:
 349   case ARM::t2PLDWr:    case ARM::t2PLDWs:
 350   case ARM::t2PLIi12:   case ARM::t2PLIi8:
 351   case ARM::t2PLIr:     case ARM::t2PLIs:
 352     return true;
 353   }
 354 }
 355
 356 static inline unsigned T2Morph2Preload2PCI(unsigned Opcode) {
 357   switch (Opcode) {
 358   default:
 359     return 0;
 360   case ARM::t2PLDi12:   case ARM::t2PLDi8:
 361   case ARM::t2PLDr:     case ARM::t2PLDs:
 362     return ARM::t2PLDpci;
 363   case ARM::t2PLDWi12:  case ARM::t2PLDWi8:
 364   case ARM::t2PLDWr:    case ARM::t2PLDWs:
 365     return ARM::t2PLDWpci;
 366   case ARM::t2PLIi12:   case ARM::t2PLIi8:
 367   case ARM::t2PLIr:     case ARM::t2PLIs:
 368     return ARM::t2PLIpci;
 369   }
 370 }
 371
 372 //
 373 // Public interface for the disassembler
 374 //
 375
 376 bool ARMDisassembler::getInstruction(MCInst &MI,
 377                                      uint64_t &Size,
 378                                      const MemoryObject &Region,
 379                                      uint64_t Address,
 380                                      raw_ostream &os) const {
 381   // The machine instruction.
 382   uint32_t insn;
 383
 384   // We want to read exactly 4 bytes of data.
 385   if (Region.readBytes(Address, 4, (uint8_t*)&insn, NULL) == -1)
 386     return false;
 387
 388   unsigned Opcode = decodeARMInstruction(insn);
 389   ARMFormat Format = ARMFormats[Opcode];
 390   Size = 4;
 391
 392   DEBUG({
 393       errs() << "Opcode=" << Opcode << " Name=" << ARMUtils::OpcodeName(Opcode)
 394              << " Format=" << stringForARMFormat(Format) << '(' << (int)Format
 395              << ")\n";
 396       showBitVector(errs(), insn);
 397     });
 398
 399   ARMBasicMCBuilder *Builder = CreateMCBuilder(Opcode, Format);
 400
 401   if (!Builder)
 402     return false;
 403
 404   if (!Builder->Build(MI, insn))
 405     return false;
 406
 407   delete Builder;
 408
 409   return true;
 410 }
 411
 412 bool ThumbDisassembler::getInstruction(MCInst &MI,
 413                                        uint64_t &Size,
 414                                        const MemoryObject &Region,
 415                                        uint64_t Address,
 416                                        raw_ostream &os) const {
 417   // The machine instruction.
 418   uint32_t insn = 0;
 419   uint32_t insn1 = 0;
 420
 421   // A6.1 Thumb instruction set encoding
 422   //
 423   // If bits [15:11] of the halfword being decoded take any of the following
 424   // values, the halfword is the first halfword of a 32-bit instruction:
 425   // o 0b11101
 426   // o 0b11110
 427   // o 0b11111.
 428   //
 429   // Otherwise, the halfword is a 16-bit instruction.
 430
 431   // Read 2 bytes of data first.
 432   if (Region.readBytes(Address, 2, (uint8_t*)&insn, NULL) == -1)
 433     return false;
 434
 435   unsigned bits15_11 = slice(insn, 15, 11);
 436   bool IsThumb2 = false;
 437
 438   // 32-bit instructions if the bits [15:11] of the halfword matches
 439   // { 0b11101 /* 0x1D */, 0b11110 /* 0x1E */, ob11111 /* 0x1F */ }.
 440   if (bits15_11 == 0x1D || bits15_11 == 0x1E || bits15_11 == 0x1F) {
 441     IsThumb2 = true;
 442     if (Region.readBytes(Address + 2, 2, (uint8_t*)&insn1, NULL) == -1)
 443       return false;
 444     insn = (insn << 16 | insn1);
 445   }
 446
 447   // The insn could potentially be bit-twiddled in order to be decoded as an ARM
 448   // NEON/VFP opcode.  In such case, the modified insn is later disassembled as
 449   // an ARM NEON/VFP instruction.
 450   //
 451   // This is a short term solution for lack of encoding bits specified for the
 452   // Thumb2 NEON/VFP instructions.  The long term solution could be adding some
 453   // infrastructure to have each instruction support more than one encodings.
 454   // Which encoding is used would be based on which subtarget the compiler/
 455   // disassembler is working with at the time.  This would allow the sharing of
 456   // the NEON patterns between ARM and Thumb2, as well as potential greater
 457   // sharing between the regular ARM instructions and the 32-bit wide Thumb2
 458   // instructions as well.
 459   unsigned Opcode = decodeThumbSideEffect(IsThumb2, insn);
 460
 461   // A8.6.117/119/120/121.
 462   // PLD/PLDW/PLI instructions with Rn==15 is transformed to the pci variant.
 463   if (Thumb2PreloadOpcodeNoPCI(Opcode) && slice(insn, 19, 16) == 15)
 464     Opcode = T2Morph2Preload2PCI(Opcode);
 465
 466   ARMFormat Format = ARMFormats[Opcode];
 467   Size = IsThumb2 ? 4 : 2;
 468
 469   DEBUG({
 470       errs() << "Opcode=" << Opcode << " Name=" << ARMUtils::OpcodeName(Opcode)
 471              << " Format=" << stringForARMFormat(Format) << '(' << (int)Format
 472              << ")\n";
 473       showBitVector(errs(), insn);
 474     });
 475
 476   ARMBasicMCBuilder *Builder = CreateMCBuilder(Opcode, Format);
 477   Builder->setSession(const_cast<Session *>(&SO));
 478
 479   if (!Builder)
 480     return false;
 481
 482   if (!Builder->Build(MI, insn))
 483     return false;
 484
 485   delete Builder;
 486
 487   return true;
 488 }
 489
 490 // A8.6.50
 491 static unsigned short CountITSize(unsigned ITMask) {
 492   // First count the trailing zeros of the IT mask.
 493   unsigned TZ = CountTrailingZeros_32(ITMask);
 494   assert(TZ <= 3 && "Encoding error");
 495   return (4 - TZ);
 496 }
 497
 498 /// Init ITState.
 499 void Session::InitIT(unsigned short bits7_0) {
 500   ITCounter = CountITSize(slice(bits7_0, 3, 0));
 501   ITState = bits7_0;
 502 }
 503
 504 /// Update ITState if necessary.
 505 void Session::UpdateIT() {
 506   assert(ITCounter);
 507   --ITCounter;
 508   if (ITCounter == 0)
 509     ITState = 0;
 510   else {
 511     unsigned short NewITState4_0 = slice(ITState, 4, 0) << 1;
 512     setSlice(ITState, 4, 0, NewITState4_0);
 513   }
 514 }
 515
 516 static MCDisassembler *createARMDisassembler(const Target &T) {
 517   return new ARMDisassembler;
 518 }
 519
 520 static MCDisassembler *createThumbDisassembler(const Target &T) {
 521   return new ThumbDisassembler;
 522 }
 523
 524 extern "C" void LLVMInitializeARMDisassembler() {
 525   // Register the disassembler.
 526   TargetRegistry::RegisterMCDisassembler(TheARMTarget,
 527                                          createARMDisassembler);
 528   TargetRegistry::RegisterMCDisassembler(TheThumbTarget,
 529                                          createThumbDisassembler);
 530 }
 531
 532 } // namespace llvm