Always add following blocks even if it is already created
[frida/frida.git] / src / disassembler / llvm / LLVMDisassembler.cxx
1 #include "disassembler/llvm/LLVMDisassembler.hxx"
2 #include "disassembler/llvm/LLVMBasicBlock.hxx"
3 #include "disassembler/llvm/LLVMFunction.hxx"
4
5 #include <stack>
6 #include <algorithm>
7
8 using namespace llvm;
9 using namespace llvm::object;
10
11 /*
12 * TODO: fallback code falls die Datei kein ELF/PE/COFF/MacO/.. binary
13 * ist sondern z.B. einfach nur Instruktionen oder ein Bootsektor oder
14 * foo
15 */
16 LLVMDisassembler::LLVMDisassembler(const std::string& filename)
17 : Disassembler(filename)
18 , logger(log4cxx::Logger::getLogger("LLVMDisassembler"))
19 , triple("unknown-unknown-unknown")
20 {
21 LOG4CXX_DEBUG(logger, "Handling file" << filename);
22 auto result = createBinary(filename);
23
24 error_code ec;
25 if ((ec = result.getError())) {
26 LOG4CXX_ERROR(logger, "Failed to load Binary" << ec.message());
27 binary = NULL;
28 return;
29 }
30
31 binary.reset(result.get());
32
33 o = dyn_cast<ObjectFile>(binary.get());
34
35 triple.setArch(Triple::ArchType(o->getArch()));
36 std::string tripleName(triple.getTriple());
37
38 LOG4CXX_INFO(logger, "Architecture " << tripleName);
39
40
41 std::string es;
42 target = TargetRegistry::lookupTarget("", triple, es);
43 if (!target) {
44 LOG4CXX_ERROR(logger, es);
45 return;
46 }
47
48 LOG4CXX_INFO(logger, "Target " << target->getName());
49
50 MRI.reset(target->createMCRegInfo(tripleName));
51 if (!MRI) {
52 LOG4CXX_ERROR(logger, "no register info for target " << tripleName);
53 return;
54 }
55
56 // Set up disassembler.
57 AsmInfo.reset(target->createMCAsmInfo(*MRI, tripleName));
58 if (!AsmInfo) {
59 LOG4CXX_ERROR(logger, "no assembly info for target " << tripleName);
60 return;
61 }
62
63 STI.reset(target->createMCSubtargetInfo(tripleName, "", ""));
64 if (!STI) {
65 LOG4CXX_ERROR(logger, "no subtarget info for target " << tripleName);
66 return;
67 }
68
69 MII.reset(target->createMCInstrInfo());
70 if (!MII) {
71 LOG4CXX_ERROR(logger, "no instruction info for target " << tripleName);
72 return;
73 }
74
75 DisAsm.reset(target->createMCDisassembler(*STI));
76 if (!DisAsm) {
77 LOG4CXX_ERROR(logger, "no disassembler for target " << tripleName);
78 return;
79 }
80
81 MOFI.reset(new MCObjectFileInfo);
82 Ctx.reset(new MCContext(AsmInfo.get(), MRI.get(), MOFI.get()));
83 RelInfo.reset(
84 target->createMCRelocationInfo(tripleName, *Ctx.get()));
85 if (RelInfo) {
86 Symzer.reset(
87 MCObjectSymbolizer::createObjectSymbolizer(*Ctx.get(), RelInfo, o));
88 if (Symzer)
89 DisAsm->setSymbolizer(Symzer);
90 }
91
92 MIA.reset(target->createMCInstrAnalysis(MII.get()));
93
94 int AsmPrinterVariant = AsmInfo->getAssemblerDialect();
95 IP.reset(target->createMCInstPrinter(AsmPrinterVariant, *AsmInfo, *MII, *MRI, *STI));
96 if (!IP) {
97 LOG4CXX_ERROR(logger, "no instruction printer for target " << tripleName);
98 return;
99 }
100
101 IP->setPrintImmHex(llvm::HexStyle::C);
102 IP->setPrintImmHex(true);
103
104 OwningPtr<MCObjectDisassembler> OD(
105 new MCObjectDisassembler(*o, *DisAsm, *MIA));
106 Mod.reset(OD->buildModule(false));
107
108 readSymbols();
109 readSections();
110 disassemble();
111 }
112
113 LLVMDisassembler::~LLVMDisassembler() {
114 std::for_each(functions.begin(), functions.end(),
115 [](std::pair<uint64_t,LLVMFunction*> it) {
116 delete it.second;
117 });
118 std::for_each(blocks.begin(), blocks.end(),
119 [](std::pair<uint64_t, LLVMBasicBlock*> it) {
120 delete it.second;
121 });
122 }
123
124 void LLVMDisassembler::disassemble() {
125 std::stack<LLVMFunction*> remaining_functions;
126 std::stack<LLVMBasicBlock*> remaining_blocks;
127 SectionRef text_section = sections[".text"];
128
129 // Assume all function symbols actually start a real function
130 for (auto x = symbols.begin(); x != symbols.end(); ++x) {
131 uint64_t result;
132 bool contains;
133 SymbolRef::Type symbol_type;
134
135
136 if (text_section.containsSymbol(x->second, contains) || !contains)
137 continue;
138
139 if (x->second.getType(symbol_type)
140 || SymbolRef::ST_Function != symbol_type)
141 continue;
142
143 if (!x->second.getAddress(result)) {
144 LLVMFunction * fun = new LLVMFunction(x->first, result);
145 remaining_functions.push(fun);
146 functions.insert(std::make_pair(result, fun));
147 LOG4CXX_DEBUG(logger, "Disasembling " << x->first);
148 }
149 }
150
151 StringRef bytes;
152 text_section.getContents(bytes);
153 StringRefMemoryObject ref(bytes);
154
155 while (remaining_functions.size()) {
156 LLVMFunction * current_function = remaining_functions.top();
157 remaining_functions.pop();
158
159 LOG4CXX_DEBUG(logger, "Handling function " << current_function->getName());
160
161 LLVMBasicBlock * block = new LLVMBasicBlock(current_function->getStartAddress(), this);
162 remaining_blocks.push(block);
163 blocks.insert(std::make_pair(block->getStartAddress(), block));
164
165 while (remaining_blocks.size()) {
166 LLVMBasicBlock * current_block = remaining_blocks.top();
167 remaining_blocks.pop();
168
169 LOG4CXX_DEBUG(logger, "Handling Block starting at " << std::hex << current_block->getStartAddress());
170
171 uint64_t inst_size;
172 uint64_t base_address;
173 text_section.getAddress(base_address);
174 uint64_t current_address = current_block->getStartAddress() - base_address;
175 while(true) {
176 MCInst inst;
177 std::string buf;
178 llvm::raw_string_ostream s(buf);
179
180 if(llvm::MCDisassembler::Success ==
181 DisAsm->getInstruction(inst, inst_size, ref, current_address, nulls(), nulls())) {
182
183 uint64_t jmptarget;
184 if (MIA->evaluateBranch(inst, current_address, inst_size, jmptarget)) {
185 jmptarget += base_address;
186 if (!MIA->isIndirectBranch(inst)) {
187 if (MIA->isCall(inst)) {
188 if (functions.find(jmptarget) == functions.end()) {
189 std::stringstream s;
190 s << "<Unnamed 0x" << std::hex << jmptarget << ">";
191 LLVMFunction * fun = new LLVMFunction(s.str(), jmptarget);
192 functions.insert(std::make_pair(jmptarget, fun));
193 remaining_functions.push(fun);
194 }
195 } else {
196 current_block->setNextBlock(0, jmptarget);
197 if (blocks.find(jmptarget) == blocks.end()) {
198 LLVMBasicBlock * block = new LLVMBasicBlock(jmptarget, this);
199 blocks.insert(std::make_pair(block->getStartAddress(), block));
200 remaining_blocks.push(block);
201 }
202 if (MIA->isConditionalBranch(inst)) {
203 jmptarget = base_address + current_address + inst_size;
204 current_block->setNextBlock(1, jmptarget);
205 if (blocks.find(jmptarget) == blocks.end()) {
206 LLVMBasicBlock * block = new LLVMBasicBlock(jmptarget, this);
207 blocks.insert(std::make_pair(block->getStartAddress(), block));
208 remaining_blocks.push(block);
209 }
210 }
211 }
212 }
213 }
214 } else {
215 inst_size = 0;
216 }
217
218
219 if (inst_size == 0 || MIA->isTerminator(inst) || MIA->isBranch(inst)) {
220 current_block->setEndAddress(current_address + base_address + inst_size);
221 LOG4CXX_DEBUG(logger, "Finished Block at " << std::hex <<
222 current_block->getEndAddress());
223 break;
224 }
225 current_address += inst_size;
226 }
227 }
228 LOG4CXX_DEBUG(logger, "Finished function " << current_function->getName());
229 }
230
231 // Split blocks where jumps are going inside the block
232 for (auto it = blocks.begin(); it != blocks.end(); ++it) {
233 LLVMBasicBlock * current_block = it->second;
234 uint64_t inst_size;
235 uint64_t base_address;
236 text_section.getAddress(base_address);
237 uint64_t current_address = current_block->getStartAddress() - base_address;
238 while(current_block->getEndAddress() - base_address != current_address) {
239 MCInst inst;
240 std::string buf;
241 llvm::raw_string_ostream s(buf);
242
243 if(llvm::MCDisassembler::Success ==
244 DisAsm->getInstruction(inst, inst_size, ref, current_address, nulls(), nulls())) {
245 auto other = blocks.find(current_address + inst_size + base_address);
246
247 if (other != blocks.end()) {
248 LOG4CXX_DEBUG(logger, "Shortening block starting at "
249 << std::hex
250 << current_block->getStartAddress()
251 << " now ending at "
252 << other->first);
253 current_block->setEndAddress(current_address + inst_size + base_address);
254 current_block->setNextBlock(0, other->first);
255 current_block->setNextBlock(1, 0);
256 }
257 } else {
258 inst_size = 1;
259 }
260 current_address += inst_size;
261 }
262 }
263 }
264
265 void LLVMDisassembler::readSymbols() {
266 error_code ec;
267 symbol_iterator si(o->symbol_begin()), se(o->symbol_end());
268 for (; si != se; ++si) {
269 StringRef name;
270 if ((ec = si->getName(name))) {
271 LOG4CXX_ERROR(logger, ec.message());
272 break;
273 }
274 LOG4CXX_DEBUG(logger, "Added symbol " << name.str());
275 symbols.insert(make_pair(name.str(), *si));
276 }
277 }
278
279 void LLVMDisassembler::readSections() {
280 error_code ec;
281 section_iterator i(o->section_begin()), e(o->section_end());
282 for (; i != e; ++i) {
283 StringRef name;
284 if ((ec = i->getName(name))) {
285 LOG4CXX_ERROR(logger, ec.message());
286 break;
287 }
288 LOG4CXX_DEBUG(logger, "Added section " << name.str());
289 sections.insert(make_pair(name.str(), *i));
290 }
291
292 }
293
294 void LLVMDisassembler::forEachFunction(std::function<void (uint64_t, Function*)> callback) {
295 std::for_each(functions.begin(), functions.end(),
296 [&](std::pair<uint64_t, LLVMFunction*> x) {
297 callback(x.first, x.second);
298 });
299 }
300
301 void LLVMDisassembler::printEachInstruction(uint64_t start, uint64_t end,
302 std::function<void (uint8_t*, size_t, const std::string&)> fun) {
303 SectionRef text_section = sections[".text"];
304 uint64_t base_address;
305 text_section.getAddress(base_address);
306 uint64_t current_address = start - base_address;
307
308 StringRef bytes;
309 text_section.getContents(bytes);
310 StringRefMemoryObject ref(bytes);
311
312 while (current_address < end - base_address) {
313 uint64_t inst_size;
314 MCInst inst;
315 std::string buf;
316 llvm::raw_string_ostream s(buf);
317
318 if(llvm::MCDisassembler::Success ==
319 DisAsm->getInstruction(inst, inst_size, ref, current_address, nulls(), nulls())) {
320
321 uint8_t bytes[inst_size+2];
322 ref.readBytes(current_address, inst_size, bytes);
323
324 IP->printInst(&inst, s, "");
325 fun(bytes, inst_size, s.str());
326 } else {
327 LOG4CXX_WARN(logger, "Invalid byte at" << std::hex << current_address + base_address);
328 fun(NULL, 0, "Invalid Byte");
329 inst_size = 1;
330 }
331
332 current_address += inst_size;
333 }
334 }