1 //===- Disassembler.cpp - Disassembler for hex strings --------------------===//
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 class implements the disassembler of strings of bytes written in
11 // hexadecimal, from standard input or from a file.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #include "Disassembler.h"
16 #include "../../lib/MC/MCDisassembler/EDDisassembler.h"
17 #include "../../lib/MC/MCDisassembler/EDInst.h"
18 #include "../../lib/MC/MCDisassembler/EDOperand.h"
19 #include "../../lib/MC/MCDisassembler/EDToken.h"
20 #include "llvm/MC/MCAsmInfo.h"
21 #include "llvm/MC/MCDisassembler.h"
22 #include "llvm/MC/MCInst.h"
23 #include "llvm/MC/MCInstPrinter.h"
24 #include "llvm/MC/MCInstrInfo.h"
25 #include "llvm/MC/MCRegisterInfo.h"
26 #include "llvm/MC/MCSubtargetInfo.h"
27 #include "llvm/ADT/OwningPtr.h"
28 #include "llvm/ADT/Triple.h"
29 #include "llvm/ADT/Twine.h"
30 #include "llvm/Support/MemoryBuffer.h"
31 #include "llvm/Support/MemoryObject.h"
32 #include "llvm/Support/SourceMgr.h"
33 #include "llvm/Support/TargetRegistry.h"
34 #include "llvm/Support/raw_ostream.h"
35 using namespace llvm;
36 
37 typedef std::vector<std::pair<unsigned char, const char*> > ByteArrayTy;
38 
39 namespace {
40 class VectorMemoryObject : public MemoryObject {
41 private:
42   const ByteArrayTy &Bytes;
43 public:
44   VectorMemoryObject(const ByteArrayTy &bytes) : Bytes(bytes) {}
45 
46   uint64_t getBase() const { return 0; }
47   uint64_t getExtent() const { return Bytes.size(); }
48 
49   int readByte(uint64_t Addr, uint8_t *Byte) const {
50     if (Addr >= getExtent())
51       return -1;
52     *Byte = Bytes[Addr].first;
53     return 0;
54   }
55 };
56 }
57 
58 static bool PrintInsts(const MCDisassembler &DisAsm,
59                        MCInstPrinter &Printer, const ByteArrayTy &Bytes,
60                        SourceMgr &SM, raw_ostream &Out) {
61   // Wrap the vector in a MemoryObject.
62   VectorMemoryObject memoryObject(Bytes);
63 
64   // Disassemble it to strings.
65   uint64_t Size;
66   uint64_t Index;
67 
68   for (Index = 0; Index < Bytes.size(); Index += Size) {
69     MCInst Inst;
70 
71     MCDisassembler::DecodeStatus S;
72     S = DisAsm.getInstruction(Inst, Size, memoryObject, Index,
73                               /*REMOVE*/ nulls(), nulls());
74     switch (S) {
75     case MCDisassembler::Fail:
76       SM.PrintMessage(SMLoc::getFromPointer(Bytes[Index].second),
77                       SourceMgr::DK_Warning,
78                       "invalid instruction encoding");
79       if (Size == 0)
80         Size = 1; // skip illegible bytes
81       break;
82 
83     case MCDisassembler::SoftFail:
84       SM.PrintMessage(SMLoc::getFromPointer(Bytes[Index].second),
85                       SourceMgr::DK_Warning,
86                       "potentially undefined instruction encoding");
87       // Fall through
88 
89     case MCDisassembler::Success:
90       Printer.printInst(&Inst, Out, "");
91       Out << "\n";
92       break;
93     }
94   }
95 
96   return false;
97 }
98 
99 static bool ByteArrayFromString(ByteArrayTy &ByteArray,
100                                 StringRef &Str,
101                                 SourceMgr &SM) {
102   while (!Str.empty()) {
103     // Strip horizontal whitespace.
104     if (size_t Pos = Str.find_first_not_of(" \t\r")) {
105       Str = Str.substr(Pos);
106       continue;
107     }
108 
109     // If this is the end of a line or start of a comment, remove the rest of
110     // the line.
111     if (Str[0] == '\n' || Str[0] == '#') {
112       // Strip to the end of line if we already processed any bytes on this
113       // line.  This strips the comment and/or the \n.
114       if (Str[0] == '\n') {
115         Str = Str.substr(1);
116       } else {
117         Str = Str.substr(Str.find_first_of('\n'));
118         if (!Str.empty())
119           Str = Str.substr(1);
120       }
121       continue;
122     }
123 
124     // Get the current token.
125     size_t Next = Str.find_first_of(" \t\n\r#");
126     StringRef Value = Str.substr(0, Next);
127 
128     // Convert to a byte and add to the byte vector.
129     unsigned ByteVal;
130     if (Value.getAsInteger(0, ByteVal) || ByteVal > 255) {
131       // If we have an error, print it and skip to the end of line.
132       SM.PrintMessage(SMLoc::getFromPointer(Value.data()), SourceMgr::DK_Error,
133                       "invalid input token");
134       Str = Str.substr(Str.find('\n'));
135       ByteArray.clear();
136       continue;
137     }
138 
139     ByteArray.push_back(std::make_pair((unsigned char)ByteVal, Value.data()));
140     Str = Str.substr(Next);
141   }
142 
143   return false;
144 }
145 
146 int Disassembler::disassemble(const Target &T,
147                               const std::string &Triple,
148                               const std::string &Cpu,
149                               const std::string &FeaturesStr,
150                               MemoryBuffer &Buffer,
151                               raw_ostream &Out) {
152   // Set up disassembler.
153   OwningPtr<const MCAsmInfo> AsmInfo(T.createMCAsmInfo(Triple));
154 
155   if (!AsmInfo) {
156     errs() << "error: no assembly info for target " << Triple << "\n";
157     return -1;
158   }
159 
160   OwningPtr<const MCSubtargetInfo> STI(T.createMCSubtargetInfo(Triple, Cpu,
161                                                                FeaturesStr));
162   if (!STI) {
163     errs() << "error: no subtarget info for target " << Triple << "\n";
164     return -1;
165   }
166 
167   OwningPtr<const MCDisassembler> DisAsm(T.createMCDisassembler(*STI));
168   if (!DisAsm) {
169     errs() << "error: no disassembler for target " << Triple << "\n";
170     return -1;
171   }
172 
173   OwningPtr<const MCRegisterInfo> MRI(T.createMCRegInfo(Triple));
174   if (!MRI) {
175     errs() << "error: no register info for target " << Triple << "\n";
176     return -1;
177   }
178 
179   OwningPtr<const MCInstrInfo> MII(T.createMCInstrInfo());
180   if (!MII) {
181     errs() << "error: no instruction info for target " << Triple << "\n";
182     return -1;
183   }
184 
185   int AsmPrinterVariant = AsmInfo->getAssemblerDialect();
186   OwningPtr<MCInstPrinter> IP(T.createMCInstPrinter(AsmPrinterVariant, *AsmInfo,
187                                                     *MII, *MRI, *STI));
188   if (!IP) {
189     errs() << "error: no instruction printer for target " << Triple << '\n';
190     return -1;
191   }
192 
193   bool ErrorOccurred = false;
194 
195   SourceMgr SM;
196   SM.AddNewSourceBuffer(&Buffer, SMLoc());
197 
198   // Convert the input to a vector for disassembly.
199   ByteArrayTy ByteArray;
200   StringRef Str = Buffer.getBuffer();
201 
202   ErrorOccurred |= ByteArrayFromString(ByteArray, Str, SM);
203 
204   if (!ByteArray.empty())
205     ErrorOccurred |= PrintInsts(*DisAsm, *IP, ByteArray, SM, Out);
206 
207   return ErrorOccurred;
208 }
209 
210 static int byteArrayReader(uint8_t *B, uint64_t A, void *Arg) {
211   ByteArrayTy &ByteArray = *((ByteArrayTy*)Arg);
212 
213   if (A >= ByteArray.size())
214     return -1;
215 
216   *B = ByteArray[A].first;
217 
218   return 0;
219 }
220 
221 static int verboseEvaluator(uint64_t *V, unsigned R, void *Arg) {
222   EDDisassembler &disassembler = *(EDDisassembler *)((void **)Arg)[0];
223   raw_ostream &Out = *(raw_ostream *)((void **)Arg)[1];
224 
225   if (const char *regName = disassembler.nameWithRegisterID(R))
226     Out << "[" << regName << "/" << R << "]";
227 
228   if (disassembler.registerIsStackPointer(R))
229     Out << "(sp)";
230   if (disassembler.registerIsProgramCounter(R))
231     Out << "(pc)";
232 
233   *V = 0;
234   return 0;
235 }
236 
237 int Disassembler::disassembleEnhanced(const std::string &TS,
238                                       MemoryBuffer &Buffer,
239                                       raw_ostream &Out) {
240   ByteArrayTy ByteArray;
241   StringRef Str = Buffer.getBuffer();
242   SourceMgr SM;
243 
244   SM.AddNewSourceBuffer(&Buffer, SMLoc());
245 
246   if (ByteArrayFromString(ByteArray, Str, SM)) {
247     return -1;
248   }
249 
250   Triple T(TS);
251   EDDisassembler::AssemblySyntax AS;
252 
253   switch (T.getArch()) {
254   default:
255     errs() << "error: no default assembly syntax for " << TS.c_str() << "\n";
256     return -1;
257   case Triple::arm:
258   case Triple::thumb:
259     AS = EDDisassembler::kEDAssemblySyntaxARMUAL;
260     break;
261   case Triple::x86:
262   case Triple::x86_64:
263     AS = EDDisassembler::kEDAssemblySyntaxX86ATT;
264     break;
265   }
266 
267   OwningPtr<EDDisassembler>
268     disassembler(EDDisassembler::getDisassembler(TS.c_str(), AS));
269 
270   if (disassembler == 0) {
271     errs() << "error: couldn't get disassembler for " << TS << '\n';
272     return -1;
273   }
274 
275   while (ByteArray.size()) {
276     OwningPtr<EDInst>
277       inst(disassembler->createInst(byteArrayReader, 0, &ByteArray));
278 
279     if (inst == 0) {
280       errs() << "error: Didn't get an instruction\n";
281       return -1;
282     }
283 
284     ByteArray.erase (ByteArray.begin(), ByteArray.begin() + inst->byteSize());
285 
286     unsigned numTokens = inst->numTokens();
287     if ((int)numTokens < 0) {
288       errs() << "error: couldn't count the instruction's tokens\n";
289       return -1;
290     }
291 
292     for (unsigned tokenIndex = 0; tokenIndex != numTokens; ++tokenIndex) {
293       EDToken *token;
294 
295       if (inst->getToken(token, tokenIndex)) {
296         errs() << "error: Couldn't get token\n";
297         return -1;
298       }
299 
300       const char *buf;
301       if (token->getString(buf)) {
302         errs() << "error: Couldn't get string for token\n";
303         return -1;
304       }
305 
306       Out << '[';
307       int operandIndex = token->operandID();
308 
309       if (operandIndex >= 0)
310         Out << operandIndex << "-";
311 
312       switch (token->type()) {
313       case EDToken::kTokenWhitespace: Out << "w"; break;
314       case EDToken::kTokenPunctuation: Out << "p"; break;
315       case EDToken::kTokenOpcode: Out << "o"; break;
316       case EDToken::kTokenLiteral: Out << "l"; break;
317       case EDToken::kTokenRegister: Out << "r"; break;
318       }
319 
320       Out << ":" << buf;
321 
322       if (token->type() == EDToken::kTokenLiteral) {
323         Out << "=";
324         if (token->literalSign())
325           Out << "-";
326         uint64_t absoluteValue;
327         if (token->literalAbsoluteValue(absoluteValue)) {
328           errs() << "error: Couldn't get the value of a literal token\n";
329           return -1;
330         }
331         Out << absoluteValue;
332       } else if (token->type() == EDToken::kTokenRegister) {
333         Out << "=";
334         unsigned regID;
335         if (token->registerID(regID)) {
336           errs() << "error: Couldn't get the ID of a register token\n";
337           return -1;
338         }
339         Out << "r" << regID;
340       }
341 
342       Out << "]";
343     }
344 
345     Out << " ";
346 
347     if (inst->isBranch())
348       Out << "<br> ";
349     if (inst->isMove())
350       Out << "<mov> ";
351 
352     unsigned numOperands = inst->numOperands();
353 
354     if ((int)numOperands < 0) {
355       errs() << "error: Couldn't count operands\n";
356       return -1;
357     }
358 
359     for (unsigned operandIndex = 0; operandIndex != numOperands;
360          ++operandIndex) {
361       Out << operandIndex << ":";
362 
363       EDOperand *operand;
364       if (inst->getOperand(operand, operandIndex)) {
365         errs() << "error: couldn't get operand\n";
366         return -1;
367       }
368 
369       uint64_t evaluatedResult;
370       void *Arg[] = { disassembler.get(), &Out };
371       if (operand->evaluate(evaluatedResult, verboseEvaluator, Arg)) {
372         errs() << "error: Couldn't evaluate an operand\n";
373         return -1;
374       }
375       Out << "=" << evaluatedResult << " ";
376     }
377 
378     Out << '\n';
379   }
380 
381   return 0;
382 }
383