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