contrib/llvm/lib/MC/MCDisassembler/EDDisassembler.cpp

   1 //===-EDDisassembler.cpp - LLVM Enhanced Disassembler ---------------------===//
   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 implements the Enhanced Disassembly library's  disassembler class.
  11 // The disassembler is responsible for vending individual instructions according
  12 // to a given architecture and disassembly syntax.
  13 //
  14 //===----------------------------------------------------------------------===//
  15
  16 #include "EDDisassembler.h"
  17 #include "EDInst.h"
  18 #include "llvm/MC/EDInstInfo.h"
  19 #include "llvm/MC/MCAsmInfo.h"
  20 #include "llvm/MC/MCContext.h"
  21 #include "llvm/MC/MCDisassembler.h"
  22 #include "llvm/MC/MCExpr.h"
  23 #include "llvm/MC/MCInst.h"
  24 #include "llvm/MC/MCInstPrinter.h"
  25 #include "llvm/MC/MCStreamer.h"
  26 #include "llvm/MC/MCSubtargetInfo.h"
  27 #include "llvm/MC/MCParser/AsmLexer.h"
  28 #include "llvm/MC/MCParser/MCAsmParser.h"
  29 #include "llvm/MC/MCParser/MCParsedAsmOperand.h"
  30 #include "llvm/Support/MemoryBuffer.h"
  31 #include "llvm/Support/MemoryObject.h"
  32 #include "llvm/Support/SourceMgr.h"
  33 #include "llvm/Target/TargetAsmLexer.h"
  34 #include "llvm/Target/TargetAsmParser.h"
  35 #include "llvm/Target/TargetRegistry.h"
  36 #include "llvm/Target/TargetMachine.h"
  37 #include "llvm/Target/TargetRegisterInfo.h"
  38 #include "llvm/Target/TargetSelect.h"
  39 using namespace llvm;
  40
  41 bool EDDisassembler::sInitialized = false;
  42 EDDisassembler::DisassemblerMap_t EDDisassembler::sDisassemblers;
  43
  44 struct TripleMap {
  45   Triple::ArchType Arch;
  46   const char *String;
  47 };
  48
  49 static struct TripleMap triplemap[] = {
  50   { Triple::x86,          "i386-unknown-unknown"    },
  51   { Triple::x86_64,       "x86_64-unknown-unknown"  },
  52   { Triple::arm,          "arm-unknown-unknown"     },
  53   { Triple::thumb,        "thumb-unknown-unknown"   },
  54   { Triple::InvalidArch,  NULL,                     }
  55 };
  56
  57 /// infoFromArch - Returns the TripleMap corresponding to a given architecture,
  58 ///   or NULL if there is an error
  59 ///
  60 /// @arg arch - The Triple::ArchType for the desired architecture
  61 static const char *tripleFromArch(Triple::ArchType arch) {
  62   unsigned int infoIndex;
  63
  64   for (infoIndex = 0; triplemap[infoIndex].String != NULL; ++infoIndex) {
  65     if (arch == triplemap[infoIndex].Arch)
  66       return triplemap[infoIndex].String;
  67   }
  68
  69   return NULL;
  70 }
  71
  72 /// getLLVMSyntaxVariant - gets the constant to use to get an assembly printer
  73 ///   for the desired assembly syntax, suitable for passing to
  74 ///   Target::createMCInstPrinter()
  75 ///
  76 /// @arg arch   - The target architecture
  77 /// @arg syntax - The assembly syntax in sd form
  78 static int getLLVMSyntaxVariant(Triple::ArchType arch,
  79                                 EDDisassembler::AssemblySyntax syntax) {
  80   switch (syntax) {
  81   default:
  82     return -1;
  83   // Mappings below from X86AsmPrinter.cpp
  84   case EDDisassembler::kEDAssemblySyntaxX86ATT:
  85     if (arch == Triple::x86 || arch == Triple::x86_64)
  86       return 0;
  87     else
  88       return -1;
  89   case EDDisassembler::kEDAssemblySyntaxX86Intel:
  90     if (arch == Triple::x86 || arch == Triple::x86_64)
  91       return 1;
  92     else
  93       return -1;
  94   case EDDisassembler::kEDAssemblySyntaxARMUAL:
  95     if (arch == Triple::arm || arch == Triple::thumb)
  96       return 0;
  97     else
  98       return -1;
  99   }
 100 }
 101
 102 void EDDisassembler::initialize() {
 103   if (sInitialized)
 104     return;
 105
 106   sInitialized = true;
 107
 108   InitializeAllTargetInfos();
 109   InitializeAllTargets();
 110   InitializeAllMCAsmInfos();
 111   InitializeAllAsmPrinters();
 112   InitializeAllAsmParsers();
 113   InitializeAllDisassemblers();
 114 }
 115
 116 #undef BRINGUP_TARGET
 117
 118 EDDisassembler *EDDisassembler::getDisassembler(Triple::ArchType arch,
 119                                                 AssemblySyntax syntax) {
 120   CPUKey key;
 121   key.Arch = arch;
 122   key.Syntax = syntax;
 123
 124   EDDisassembler::DisassemblerMap_t::iterator i = sDisassemblers.find(key);
 125
 126   if (i != sDisassemblers.end()) {
 127     return i->second;
 128   } else {
 129     EDDisassembler* sdd = new EDDisassembler(key);
 130     if (!sdd->valid()) {
 131       delete sdd;
 132       return NULL;
 133     }
 134
 135     sDisassemblers[key] = sdd;
 136
 137     return sdd;
 138   }
 139
 140   return NULL;
 141 }
 142
 143 EDDisassembler *EDDisassembler::getDisassembler(StringRef str,
 144                                                 AssemblySyntax syntax) {
 145   return getDisassembler(Triple(str).getArch(), syntax);
 146 }
 147
 148 EDDisassembler::EDDisassembler(CPUKey &key) :
 149   Valid(false),
 150   HasSemantics(false),
 151   ErrorStream(nulls()),
 152   Key(key) {
 153   const char *triple = tripleFromArch(key.Arch);
 154
 155   if (!triple)
 156     return;
 157
 158   LLVMSyntaxVariant = getLLVMSyntaxVariant(key.Arch, key.Syntax);
 159
 160   if (LLVMSyntaxVariant < 0)
 161     return;
 162
 163   std::string tripleString(triple);
 164   std::string errorString;
 165
 166   Tgt = TargetRegistry::lookupTarget(tripleString,
 167                                      errorString);
 168
 169   if (!Tgt)
 170     return;
 171
 172   std::string CPU;
 173   std::string featureString;
 174   TargetMachine.reset(Tgt->createTargetMachine(tripleString, CPU,
 175                                                featureString));
 176
 177   const TargetRegisterInfo *registerInfo = TargetMachine->getRegisterInfo();
 178
 179   if (!registerInfo)
 180     return;
 181
 182   initMaps(*registerInfo);
 183
 184   AsmInfo.reset(Tgt->createMCAsmInfo(tripleString));
 185
 186   if (!AsmInfo)
 187     return;
 188
 189   Disassembler.reset(Tgt->createMCDisassembler());
 190
 191   if (!Disassembler)
 192     return;
 193
 194   InstInfos = Disassembler->getEDInfo();
 195
 196   InstString.reset(new std::string);
 197   InstStream.reset(new raw_string_ostream(*InstString));
 198   InstPrinter.reset(Tgt->createMCInstPrinter(LLVMSyntaxVariant, *AsmInfo));
 199
 200   if (!InstPrinter)
 201     return;
 202
 203   GenericAsmLexer.reset(new AsmLexer(*AsmInfo));
 204   SpecificAsmLexer.reset(Tgt->createAsmLexer(*AsmInfo));
 205   SpecificAsmLexer->InstallLexer(*GenericAsmLexer);
 206
 207   initMaps(*TargetMachine->getRegisterInfo());
 208
 209   Valid = true;
 210 }
 211
 212 EDDisassembler::~EDDisassembler() {
 213   if (!valid())
 214     return;
 215 }
 216
 217 namespace {
 218   /// EDMemoryObject - a subclass of MemoryObject that allows use of a callback
 219   ///   as provided by the sd interface.  See MemoryObject.
 220   class EDMemoryObject : public llvm::MemoryObject {
 221   private:
 222     EDByteReaderCallback Callback;
 223     void *Arg;
 224   public:
 225     EDMemoryObject(EDByteReaderCallback callback,
 226                    void *arg) : Callback(callback), Arg(arg) { }
 227     ~EDMemoryObject() { }
 228     uint64_t getBase() const { return 0x0; }
 229     uint64_t getExtent() const { return (uint64_t)-1; }
 230     int readByte(uint64_t address, uint8_t *ptr) const {
 231       if (!Callback)
 232         return -1;
 233
 234       if (Callback(ptr, address, Arg))
 235         return -1;
 236
 237       return 0;
 238     }
 239   };
 240 }
 241
 242 EDInst *EDDisassembler::createInst(EDByteReaderCallback byteReader,
 243                                    uint64_t address,
 244                                    void *arg) {
 245   EDMemoryObject memoryObject(byteReader, arg);
 246
 247   MCInst* inst = new MCInst;
 248   uint64_t byteSize;
 249
 250   if (!Disassembler->getInstruction(*inst,
 251                                     byteSize,
 252                                     memoryObject,
 253                                     address,
 254                                     ErrorStream)) {
 255     delete inst;
 256     return NULL;
 257   } else {
 258     const llvm::EDInstInfo *thisInstInfo = NULL;
 259
 260     if (InstInfos) {
 261       thisInstInfo = &InstInfos[inst->getOpcode()];
 262     }
 263
 264     EDInst* sdInst = new EDInst(inst, byteSize, *this, thisInstInfo);
 265     return sdInst;
 266   }
 267 }
 268
 269 void EDDisassembler::initMaps(const TargetRegisterInfo &registerInfo) {
 270   unsigned numRegisters = registerInfo.getNumRegs();
 271   unsigned registerIndex;
 272
 273   for (registerIndex = 0; registerIndex < numRegisters; ++registerIndex) {
 274     const char* registerName = registerInfo.get(registerIndex).Name;
 275
 276     RegVec.push_back(registerName);
 277     RegRMap[registerName] = registerIndex;
 278   }
 279
 280   switch (Key.Arch) {
 281   default:
 282     break;
 283   case Triple::x86:
 284   case Triple::x86_64:
 285     stackPointers.insert(registerIDWithName("SP"));
 286     stackPointers.insert(registerIDWithName("ESP"));
 287     stackPointers.insert(registerIDWithName("RSP"));
 288
 289     programCounters.insert(registerIDWithName("IP"));
 290     programCounters.insert(registerIDWithName("EIP"));
 291     programCounters.insert(registerIDWithName("RIP"));
 292     break;
 293   case Triple::arm:
 294   case Triple::thumb:
 295     stackPointers.insert(registerIDWithName("SP"));
 296
 297     programCounters.insert(registerIDWithName("PC"));
 298     break;
 299   }
 300 }
 301
 302 const char *EDDisassembler::nameWithRegisterID(unsigned registerID) const {
 303   if (registerID >= RegVec.size())
 304     return NULL;
 305   else
 306     return RegVec[registerID].c_str();
 307 }
 308
 309 unsigned EDDisassembler::registerIDWithName(const char *name) const {
 310   regrmap_t::const_iterator iter = RegRMap.find(std::string(name));
 311   if (iter == RegRMap.end())
 312     return 0;
 313   else
 314     return (*iter).second;
 315 }
 316
 317 bool EDDisassembler::registerIsStackPointer(unsigned registerID) {
 318   return (stackPointers.find(registerID) != stackPointers.end());
 319 }
 320
 321 bool EDDisassembler::registerIsProgramCounter(unsigned registerID) {
 322   return (programCounters.find(registerID) != programCounters.end());
 323 }
 324
 325 int EDDisassembler::printInst(std::string &str, MCInst &inst) {
 326   PrinterMutex.acquire();
 327
 328   InstPrinter->printInst(&inst, *InstStream);
 329   InstStream->flush();
 330   str = *InstString;
 331   InstString->clear();
 332
 333   PrinterMutex.release();
 334
 335   return 0;
 336 }
 337
 338 static void diag_handler(const SMDiagnostic &diag,
 339                          void *context)
 340 {
 341   if (context) {
 342     EDDisassembler *disassembler = static_cast<EDDisassembler*>(context);
 343     diag.Print("", disassembler->ErrorStream);
 344   }
 345 }
 346
 347 int EDDisassembler::parseInst(SmallVectorImpl<MCParsedAsmOperand*> &operands,
 348                               SmallVectorImpl<AsmToken> &tokens,
 349                               const std::string &str) {
 350   int ret = 0;
 351
 352   switch (Key.Arch) {
 353   default:
 354     return -1;
 355   case Triple::x86:
 356   case Triple::x86_64:
 357   case Triple::arm:
 358   case Triple::thumb:
 359     break;
 360   }
 361
 362   const char *cStr = str.c_str();
 363   MemoryBuffer *buf = MemoryBuffer::getMemBuffer(cStr, cStr + strlen(cStr));
 364
 365   StringRef instName;
 366   SMLoc instLoc;
 367
 368   SourceMgr sourceMgr;
 369   sourceMgr.setDiagHandler(diag_handler, static_cast<void*>(this));
 370   sourceMgr.AddNewSourceBuffer(buf, SMLoc()); // ownership of buf handed over
 371   MCContext context(*AsmInfo, NULL);
 372   OwningPtr<MCStreamer> streamer(createNullStreamer(context));
 373   OwningPtr<MCAsmParser> genericParser(createMCAsmParser(*Tgt, sourceMgr,
 374                                                          context, *streamer,
 375                                                          *AsmInfo));
 376
 377   StringRef triple = tripleFromArch(Key.Arch);
 378   OwningPtr<MCSubtargetInfo> STI(Tgt->createMCSubtargetInfo(triple, "", ""));
 379   OwningPtr<TargetAsmParser> TargetParser(Tgt->createAsmParser(*STI,
 380                                                                *genericParser));
 381
 382   AsmToken OpcodeToken = genericParser->Lex();
 383   AsmToken NextToken = genericParser->Lex();  // consume next token, because specificParser expects us to
 384
 385   if (OpcodeToken.is(AsmToken::Identifier)) {
 386     instName = OpcodeToken.getString();
 387     instLoc = OpcodeToken.getLoc();
 388
 389     if (NextToken.isNot(AsmToken::Eof) &&
 390         TargetParser->ParseInstruction(instName, instLoc, operands))
 391       ret = -1;
 392   } else {
 393     ret = -1;
 394   }
 395
 396   ParserMutex.acquire();
 397
 398   if (!ret) {
 399     GenericAsmLexer->setBuffer(buf);
 400
 401     while (SpecificAsmLexer->Lex(),
 402            SpecificAsmLexer->isNot(AsmToken::Eof) &&
 403            SpecificAsmLexer->isNot(AsmToken::EndOfStatement)) {
 404       if (SpecificAsmLexer->is(AsmToken::Error)) {
 405         ret = -1;
 406         break;
 407       }
 408       tokens.push_back(SpecificAsmLexer->getTok());
 409     }
 410   }
 411
 412   ParserMutex.release();
 413
 414   return ret;
 415 }
 416
 417 int EDDisassembler::llvmSyntaxVariant() const {
 418   return LLVMSyntaxVariant;
 419 }