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/MCStreamer.h"
26 #include "llvm/MC/MCParser/AsmLexer.h"
27 #include "llvm/MC/MCParser/MCAsmParser.h"
28 #include "llvm/MC/MCParser/MCParsedAsmOperand.h"
29 #include "llvm/Support/MemoryBuffer.h"
30 #include "llvm/Support/MemoryObject.h"
31 #include "llvm/Support/SourceMgr.h"
32 #include "llvm/Target/TargetAsmLexer.h"
33 #include "llvm/Target/TargetAsmParser.h"
34 #include "llvm/Target/TargetRegistry.h"
35 #include "llvm/Target/TargetMachine.h"
36 #include "llvm/Target/TargetRegisterInfo.h"
37 #include "llvm/Target/TargetSelect.h"
40 bool EDDisassembler::sInitialized = false;
41 EDDisassembler::DisassemblerMap_t EDDisassembler::sDisassemblers;
44 Triple::ArchType Arch;
48 static struct TripleMap triplemap[] = {
49 { Triple::x86, "i386-unknown-unknown" },
50 { Triple::x86_64, "x86_64-unknown-unknown" },
51 { Triple::arm, "arm-unknown-unknown" },
52 { Triple::thumb, "thumb-unknown-unknown" },
53 { Triple::InvalidArch, NULL, }
56 /// infoFromArch - Returns the TripleMap corresponding to a given architecture,
57 /// or NULL if there is an error
59 /// @arg arch - The Triple::ArchType for the desired architecture
60 static const char *tripleFromArch(Triple::ArchType arch) {
61 unsigned int infoIndex;
63 for (infoIndex = 0; triplemap[infoIndex].String != NULL; ++infoIndex) {
64 if (arch == triplemap[infoIndex].Arch)
65 return triplemap[infoIndex].String;
71 /// getLLVMSyntaxVariant - gets the constant to use to get an assembly printer
72 /// for the desired assembly syntax, suitable for passing to
73 /// Target::createMCInstPrinter()
75 /// @arg arch - The target architecture
76 /// @arg syntax - The assembly syntax in sd form
77 static int getLLVMSyntaxVariant(Triple::ArchType arch,
78 EDDisassembler::AssemblySyntax syntax) {
82 // Mappings below from X86AsmPrinter.cpp
83 case EDDisassembler::kEDAssemblySyntaxX86ATT:
84 if (arch == Triple::x86 || arch == Triple::x86_64)
88 case EDDisassembler::kEDAssemblySyntaxX86Intel:
89 if (arch == Triple::x86 || arch == Triple::x86_64)
93 case EDDisassembler::kEDAssemblySyntaxARMUAL:
94 if (arch == Triple::arm || arch == Triple::thumb)
101 void EDDisassembler::initialize() {
107 InitializeAllTargetInfos();
108 InitializeAllTargets();
109 InitializeAllAsmPrinters();
110 InitializeAllAsmParsers();
111 InitializeAllDisassemblers();
114 #undef BRINGUP_TARGET
116 EDDisassembler *EDDisassembler::getDisassembler(Triple::ArchType arch,
117 AssemblySyntax syntax) {
122 EDDisassembler::DisassemblerMap_t::iterator i = sDisassemblers.find(key);
124 if (i != sDisassemblers.end()) {
127 EDDisassembler* sdd = new EDDisassembler(key);
133 sDisassemblers[key] = sdd;
141 EDDisassembler *EDDisassembler::getDisassembler(StringRef str,
142 AssemblySyntax syntax) {
143 return getDisassembler(Triple(str).getArch(), syntax);
146 EDDisassembler::EDDisassembler(CPUKey &key) :
149 ErrorStream(nulls()),
151 const char *triple = tripleFromArch(key.Arch);
156 LLVMSyntaxVariant = getLLVMSyntaxVariant(key.Arch, key.Syntax);
158 if (LLVMSyntaxVariant < 0)
161 std::string tripleString(triple);
162 std::string errorString;
164 Tgt = TargetRegistry::lookupTarget(tripleString,
170 std::string featureString;
172 TargetMachine.reset(Tgt->createTargetMachine(tripleString,
175 const TargetRegisterInfo *registerInfo = TargetMachine->getRegisterInfo();
180 initMaps(*registerInfo);
182 AsmInfo.reset(Tgt->createAsmInfo(tripleString));
187 Disassembler.reset(Tgt->createMCDisassembler());
192 InstInfos = Disassembler->getEDInfo();
194 InstString.reset(new std::string);
195 InstStream.reset(new raw_string_ostream(*InstString));
196 InstPrinter.reset(Tgt->createMCInstPrinter(*TargetMachine, LLVMSyntaxVariant,
202 GenericAsmLexer.reset(new AsmLexer(*AsmInfo));
203 SpecificAsmLexer.reset(Tgt->createAsmLexer(*AsmInfo));
204 SpecificAsmLexer->InstallLexer(*GenericAsmLexer);
206 initMaps(*TargetMachine->getRegisterInfo());
211 EDDisassembler::~EDDisassembler() {
217 /// EDMemoryObject - a subclass of MemoryObject that allows use of a callback
218 /// as provided by the sd interface. See MemoryObject.
219 class EDMemoryObject : public llvm::MemoryObject {
221 EDByteReaderCallback Callback;
224 EDMemoryObject(EDByteReaderCallback callback,
225 void *arg) : Callback(callback), Arg(arg) { }
226 ~EDMemoryObject() { }
227 uint64_t getBase() const { return 0x0; }
228 uint64_t getExtent() const { return (uint64_t)-1; }
229 int readByte(uint64_t address, uint8_t *ptr) const {
233 if (Callback(ptr, address, Arg))
241 EDInst *EDDisassembler::createInst(EDByteReaderCallback byteReader,
244 EDMemoryObject memoryObject(byteReader, arg);
246 MCInst* inst = new MCInst;
249 if (!Disassembler->getInstruction(*inst,
257 const llvm::EDInstInfo *thisInstInfo;
259 thisInstInfo = &InstInfos[inst->getOpcode()];
261 EDInst* sdInst = new EDInst(inst, byteSize, *this, thisInstInfo);
266 void EDDisassembler::initMaps(const TargetRegisterInfo ®isterInfo) {
267 unsigned numRegisters = registerInfo.getNumRegs();
268 unsigned registerIndex;
270 for (registerIndex = 0; registerIndex < numRegisters; ++registerIndex) {
271 const char* registerName = registerInfo.get(registerIndex).Name;
273 RegVec.push_back(registerName);
274 RegRMap[registerName] = registerIndex;
282 stackPointers.insert(registerIDWithName("SP"));
283 stackPointers.insert(registerIDWithName("ESP"));
284 stackPointers.insert(registerIDWithName("RSP"));
286 programCounters.insert(registerIDWithName("IP"));
287 programCounters.insert(registerIDWithName("EIP"));
288 programCounters.insert(registerIDWithName("RIP"));
292 stackPointers.insert(registerIDWithName("SP"));
294 programCounters.insert(registerIDWithName("PC"));
299 const char *EDDisassembler::nameWithRegisterID(unsigned registerID) const {
300 if (registerID >= RegVec.size())
303 return RegVec[registerID].c_str();
306 unsigned EDDisassembler::registerIDWithName(const char *name) const {
307 regrmap_t::const_iterator iter = RegRMap.find(std::string(name));
308 if (iter == RegRMap.end())
311 return (*iter).second;
314 bool EDDisassembler::registerIsStackPointer(unsigned registerID) {
315 return (stackPointers.find(registerID) != stackPointers.end());
318 bool EDDisassembler::registerIsProgramCounter(unsigned registerID) {
319 return (programCounters.find(registerID) != programCounters.end());
322 int EDDisassembler::printInst(std::string &str, MCInst &inst) {
323 PrinterMutex.acquire();
325 InstPrinter->printInst(&inst, *InstStream);
330 PrinterMutex.release();
335 int EDDisassembler::parseInst(SmallVectorImpl<MCParsedAsmOperand*> &operands,
336 SmallVectorImpl<AsmToken> &tokens,
337 const std::string &str) {
350 const char *cStr = str.c_str();
351 MemoryBuffer *buf = MemoryBuffer::getMemBuffer(cStr, cStr + strlen(cStr));
357 sourceMgr.AddNewSourceBuffer(buf, SMLoc()); // ownership of buf handed over
358 MCContext context(*AsmInfo, NULL);
359 OwningPtr<MCStreamer> streamer(createNullStreamer(context));
360 OwningPtr<MCAsmParser> genericParser(createMCAsmParser(*Tgt, sourceMgr,
363 OwningPtr<TargetAsmParser> TargetParser(Tgt->createAsmParser(*genericParser,
366 AsmToken OpcodeToken = genericParser->Lex();
367 AsmToken NextToken = genericParser->Lex(); // consume next token, because specificParser expects us to
369 if (OpcodeToken.is(AsmToken::Identifier)) {
370 instName = OpcodeToken.getString();
371 instLoc = OpcodeToken.getLoc();
373 if (NextToken.isNot(AsmToken::Eof) &&
374 TargetParser->ParseInstruction(instName, instLoc, operands))
380 ParserMutex.acquire();
383 GenericAsmLexer->setBuffer(buf);
385 while (SpecificAsmLexer->Lex(),
386 SpecificAsmLexer->isNot(AsmToken::Eof) &&
387 SpecificAsmLexer->isNot(AsmToken::EndOfStatement)) {
388 if (SpecificAsmLexer->is(AsmToken::Error)) {
392 tokens.push_back(SpecificAsmLexer->getTok());
396 ParserMutex.release();
401 int EDDisassembler::llvmSyntaxVariant() const {
402 return LLVMSyntaxVariant;