1 //===-EDDisassembler.cpp - LLVM Enhanced Disassembler ---------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
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.
14 //===----------------------------------------------------------------------===//
16 #include "EDDisassembler.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/MCRegisterInfo.h"
26 #include "llvm/MC/MCStreamer.h"
27 #include "llvm/MC/MCSubtargetInfo.h"
28 #include "llvm/MC/MCParser/AsmLexer.h"
29 #include "llvm/MC/MCParser/MCAsmParser.h"
30 #include "llvm/MC/MCParser/MCParsedAsmOperand.h"
31 #include "llvm/MC/MCTargetAsmLexer.h"
32 #include "llvm/MC/MCTargetAsmParser.h"
33 #include "llvm/Support/MemoryBuffer.h"
34 #include "llvm/Support/MemoryObject.h"
35 #include "llvm/Support/SourceMgr.h"
36 #include "llvm/Support/TargetRegistry.h"
39 EDDisassembler::DisassemblerMap_t EDDisassembler::sDisassemblers;
42 Triple::ArchType Arch;
46 static struct TripleMap triplemap[] = {
47 { Triple::x86, "i386-unknown-unknown" },
48 { Triple::x86_64, "x86_64-unknown-unknown" },
49 { Triple::arm, "arm-unknown-unknown" },
50 { Triple::thumb, "thumb-unknown-unknown" },
51 { Triple::InvalidArch, NULL, }
54 /// infoFromArch - Returns the TripleMap corresponding to a given architecture,
55 /// or NULL if there is an error
57 /// @arg arch - The Triple::ArchType for the desired architecture
58 static const char *tripleFromArch(Triple::ArchType arch) {
59 unsigned int infoIndex;
61 for (infoIndex = 0; triplemap[infoIndex].String != NULL; ++infoIndex) {
62 if (arch == triplemap[infoIndex].Arch)
63 return triplemap[infoIndex].String;
69 /// getLLVMSyntaxVariant - gets the constant to use to get an assembly printer
70 /// for the desired assembly syntax, suitable for passing to
71 /// Target::createMCInstPrinter()
73 /// @arg arch - The target architecture
74 /// @arg syntax - The assembly syntax in sd form
75 static int getLLVMSyntaxVariant(Triple::ArchType arch,
76 EDDisassembler::AssemblySyntax syntax) {
78 // Mappings below from X86AsmPrinter.cpp
79 case EDDisassembler::kEDAssemblySyntaxX86ATT:
80 if (arch == Triple::x86 || arch == Triple::x86_64)
83 case EDDisassembler::kEDAssemblySyntaxX86Intel:
84 if (arch == Triple::x86 || arch == Triple::x86_64)
87 case EDDisassembler::kEDAssemblySyntaxARMUAL:
88 if (arch == Triple::arm || arch == Triple::thumb)
96 EDDisassembler *EDDisassembler::getDisassembler(Triple::ArchType arch,
97 AssemblySyntax syntax) {
98 const char *triple = tripleFromArch(arch);
99 return getDisassembler(StringRef(triple), syntax);
102 EDDisassembler *EDDisassembler::getDisassembler(StringRef str,
103 AssemblySyntax syntax) {
105 key.Triple = str.str();
108 EDDisassembler::DisassemblerMap_t::iterator i = sDisassemblers.find(key);
110 if (i != sDisassemblers.end()) {
114 EDDisassembler *sdd = new EDDisassembler(key);
120 sDisassemblers[key] = sdd;
127 return getDisassembler(Triple(str).getArch(), syntax);
130 EDDisassembler::EDDisassembler(CPUKey &key) :
133 ErrorStream(nulls()),
135 TgtTriple(key.Triple.c_str()) {
136 if (TgtTriple.getArch() == Triple::InvalidArch)
139 LLVMSyntaxVariant = getLLVMSyntaxVariant(TgtTriple.getArch(), key.Syntax);
141 if (LLVMSyntaxVariant < 0)
144 std::string tripleString(key.Triple);
145 std::string errorString;
147 Tgt = TargetRegistry::lookupTarget(key.Triple,
153 MRI.reset(Tgt->createMCRegInfo(tripleString));
160 AsmInfo.reset(Tgt->createMCAsmInfo(tripleString));
165 STI.reset(Tgt->createMCSubtargetInfo(tripleString, "", ""));
170 Disassembler.reset(Tgt->createMCDisassembler(*STI));
175 InstInfos = Disassembler->getEDInfo();
177 InstString.reset(new std::string);
178 InstStream.reset(new raw_string_ostream(*InstString));
179 InstPrinter.reset(Tgt->createMCInstPrinter(LLVMSyntaxVariant, *AsmInfo, *STI));
184 GenericAsmLexer.reset(new AsmLexer(*AsmInfo));
185 SpecificAsmLexer.reset(Tgt->createMCAsmLexer(*MRI, *AsmInfo));
186 SpecificAsmLexer->InstallLexer(*GenericAsmLexer);
193 EDDisassembler::~EDDisassembler() {
199 /// EDMemoryObject - a subclass of MemoryObject that allows use of a callback
200 /// as provided by the sd interface. See MemoryObject.
201 class EDMemoryObject : public llvm::MemoryObject {
203 EDByteReaderCallback Callback;
206 EDMemoryObject(EDByteReaderCallback callback,
207 void *arg) : Callback(callback), Arg(arg) { }
208 ~EDMemoryObject() { }
209 uint64_t getBase() const { return 0x0; }
210 uint64_t getExtent() const { return (uint64_t)-1; }
211 int readByte(uint64_t address, uint8_t *ptr) const {
215 if (Callback(ptr, address, Arg))
223 EDInst *EDDisassembler::createInst(EDByteReaderCallback byteReader,
226 EDMemoryObject memoryObject(byteReader, arg);
228 MCInst* inst = new MCInst;
231 MCDisassembler::DecodeStatus S;
232 S = Disassembler->getInstruction(*inst, byteSize, memoryObject, address,
233 ErrorStream, nulls());
235 case MCDisassembler::Fail:
236 case MCDisassembler::SoftFail:
237 // FIXME: Do something different on soft failure mode?
241 case MCDisassembler::Success: {
242 const llvm::EDInstInfo *thisInstInfo = NULL;
245 thisInstInfo = &InstInfos[inst->getOpcode()];
248 EDInst* sdInst = new EDInst(inst, byteSize, *this, thisInstInfo);
255 void EDDisassembler::initMaps(const MCRegisterInfo ®isterInfo) {
256 unsigned numRegisters = registerInfo.getNumRegs();
257 unsigned registerIndex;
259 for (registerIndex = 0; registerIndex < numRegisters; ++registerIndex) {
260 const char* registerName = registerInfo.get(registerIndex).Name;
262 RegVec.push_back(registerName);
263 RegRMap[registerName] = registerIndex;
266 switch (TgtTriple.getArch()) {
271 stackPointers.insert(registerIDWithName("SP"));
272 stackPointers.insert(registerIDWithName("ESP"));
273 stackPointers.insert(registerIDWithName("RSP"));
275 programCounters.insert(registerIDWithName("IP"));
276 programCounters.insert(registerIDWithName("EIP"));
277 programCounters.insert(registerIDWithName("RIP"));
281 stackPointers.insert(registerIDWithName("SP"));
283 programCounters.insert(registerIDWithName("PC"));
288 const char *EDDisassembler::nameWithRegisterID(unsigned registerID) const {
289 if (registerID >= RegVec.size())
292 return RegVec[registerID].c_str();
295 unsigned EDDisassembler::registerIDWithName(const char *name) const {
296 regrmap_t::const_iterator iter = RegRMap.find(std::string(name));
297 if (iter == RegRMap.end())
300 return (*iter).second;
303 bool EDDisassembler::registerIsStackPointer(unsigned registerID) {
304 return (stackPointers.find(registerID) != stackPointers.end());
307 bool EDDisassembler::registerIsProgramCounter(unsigned registerID) {
308 return (programCounters.find(registerID) != programCounters.end());
311 int EDDisassembler::printInst(std::string &str, MCInst &inst) {
312 PrinterMutex.acquire();
314 InstPrinter->printInst(&inst, *InstStream, "");
319 PrinterMutex.release();
324 static void diag_handler(const SMDiagnostic &diag, void *context) {
326 diag.print("", static_cast<EDDisassembler*>(context)->ErrorStream);
329 int EDDisassembler::parseInst(SmallVectorImpl<MCParsedAsmOperand*> &operands,
330 SmallVectorImpl<AsmToken> &tokens,
331 const std::string &str) {
334 switch (TgtTriple.getArch()) {
344 const char *cStr = str.c_str();
345 MemoryBuffer *buf = MemoryBuffer::getMemBuffer(cStr, cStr + strlen(cStr));
351 sourceMgr.setDiagHandler(diag_handler, static_cast<void*>(this));
352 sourceMgr.AddNewSourceBuffer(buf, SMLoc()); // ownership of buf handed over
353 MCContext context(*AsmInfo, *MRI, NULL);
354 OwningPtr<MCStreamer> streamer(createNullStreamer(context));
355 OwningPtr<MCAsmParser> genericParser(createMCAsmParser(sourceMgr,
359 OwningPtr<MCSubtargetInfo> STI(Tgt->createMCSubtargetInfo(Key.Triple.c_str(), "", ""));
360 OwningPtr<MCTargetAsmParser>
361 TargetParser(Tgt->createMCAsmParser(*STI, *genericParser));
363 AsmToken OpcodeToken = genericParser->Lex();
364 AsmToken NextToken = genericParser->Lex(); // consume next token, because specificParser expects us to
366 if (OpcodeToken.is(AsmToken::Identifier)) {
367 instName = OpcodeToken.getString();
368 instLoc = OpcodeToken.getLoc();
370 if (NextToken.isNot(AsmToken::Eof) &&
371 TargetParser->ParseInstruction(instName, instLoc, operands))
377 ParserMutex.acquire();
380 GenericAsmLexer->setBuffer(buf);
382 while (SpecificAsmLexer->Lex(),
383 SpecificAsmLexer->isNot(AsmToken::Eof) &&
384 SpecificAsmLexer->isNot(AsmToken::EndOfStatement)) {
385 if (SpecificAsmLexer->is(AsmToken::Error)) {
389 tokens.push_back(SpecificAsmLexer->getTok());
393 ParserMutex.release();
398 int EDDisassembler::llvmSyntaxVariant() const {
399 return LLVMSyntaxVariant;