X-Git-Url: https://git.siccegge.de//index.cgi?p=frida%2Ffrida.git;a=blobdiff_plain;f=src%2Fdisassembler%2Fllvm%2FLLVMDisassembler.cxx;h=1ae024a5aea39f9ef6dd786e3933768e8cc6cf5c;hp=25a4ecc25303087bee7c3b3e5265c5aa3bc91257;hb=70d986e452c08aea59d947bfd5700f6c60b3f820;hpb=370dc79ad6da88b8548d9ebd52601271bf279213 diff --git a/src/disassembler/llvm/LLVMDisassembler.cxx b/src/disassembler/llvm/LLVMDisassembler.cxx index 25a4ecc..1ae024a 100644 --- a/src/disassembler/llvm/LLVMDisassembler.cxx +++ b/src/disassembler/llvm/LLVMDisassembler.cxx @@ -7,6 +7,7 @@ using namespace llvm; using namespace llvm::object; +using std::error_code; /* * TODO: fallback code falls die Datei kein ELF/PE/COFF/MacO/.. binary @@ -72,24 +73,30 @@ LLVMDisassembler::LLVMDisassembler(const std::string& filename) return; } - DisAsm.reset(target->createMCDisassembler(*STI)); + MOFI.reset(new MCObjectFileInfo); + MCContext Ctx(AsmInfo.get(), MRI.get(), MOFI.get()); + + DisAsm.reset(target->createMCDisassembler(*STI, Ctx)); if (!DisAsm) { LOG4CXX_ERROR(logger, "no disassembler for target " << tripleName); return; } - - MOFI.reset(new MCObjectFileInfo); - Ctx.reset(new MCContext(AsmInfo.get(), MRI.get(), MOFI.get())); RelInfo.reset( - target->createMCRelocationInfo(tripleName, *Ctx.get())); + target->createMCRelocationInfo(tripleName, Ctx)); if (RelInfo) { Symzer.reset( - MCObjectSymbolizer::createObjectSymbolizer(*Ctx.get(), RelInfo, o)); + MCObjectSymbolizer::createObjectSymbolizer(Ctx, std::move(RelInfo), o)); if (Symzer) - DisAsm->setSymbolizer(Symzer); + DisAsm->setSymbolizer(std::move(Symzer)); } + RelInfo.release(); + Symzer.release(); MIA.reset(target->createMCInstrAnalysis(MII.get())); + if (!MIA) { + LOG4CXX_ERROR(logger, "no instruction analysis for target " << tripleName); + return; + } int AsmPrinterVariant = AsmInfo->getAssemblerDialect(); IP.reset(target->createMCInstPrinter(AsmPrinterVariant, *AsmInfo, *MII, *MRI, *STI)); @@ -101,7 +108,7 @@ LLVMDisassembler::LLVMDisassembler(const std::string& filename) IP->setPrintImmHex(llvm::HexStyle::C); IP->setPrintImmHex(true); - OwningPtr OD( + std::unique_ptr OD( new MCObjectDisassembler(*o, *DisAsm, *MIA)); Mod.reset(OD->buildModule(false)); @@ -126,6 +133,7 @@ void LLVMDisassembler::disassemble() { std::stack remaining_blocks; SectionRef text_section = sections[".text"]; + // Assume all function symbols actually start a real function for (auto x = symbols.begin(); x != symbols.end(); ++x) { uint64_t result; bool contains; @@ -147,6 +155,40 @@ void LLVMDisassembler::disassemble() { } } + if (binary->isELF()) { + bool is64bit = (binary->getData()[4] == 0x02); + + uint64_t entry(0); + for (int i(0); i < (is64bit? 8 : 4); ++i) { + if (binary->isLittleEndian()) { + entry |= (unsigned int)((unsigned char)binary->getData()[0x18 + i]) << 8*i; + } else { + entry = entry << 8; + entry |= (unsigned char)binary->getData()[0x18 + i]; + } + } + if (functions.find(entry) == functions.end()) { + LOG4CXX_DEBUG(logger, "Adding entry at: " << std::hex << entry); + std::stringstream s; + s << "<_start 0x" << std::hex << entry << ">"; + LLVMFunction * fun = new LLVMFunction(s.str(), entry); + functions.insert(std::make_pair(entry, fun)); + remaining_functions.push(fun); + } + } + + if (functions.empty()) { + uint64_t text_entry; + text_section.getAddress(text_entry); + LOG4CXX_INFO(logger, "No Symbols found, starting at the beginning of the text segment"); + + std::stringstream s; + s << ""; + LLVMFunction * fun = new LLVMFunction(s.str(), text_entry); + functions.insert(std::make_pair(text_entry, fun)); + remaining_functions.push(fun); + } + StringRef bytes; text_section.getContents(bytes); StringRefMemoryObject ref(bytes); @@ -157,9 +199,6 @@ void LLVMDisassembler::disassemble() { LOG4CXX_DEBUG(logger, "Handling function " << current_function->getName()); - // if ("_start" != current_function->getName()) - // continue; - LLVMBasicBlock * block = new LLVMBasicBlock(current_function->getStartAddress(), this); remaining_blocks.push(block); blocks.insert(std::make_pair(block->getStartAddress(), block)); @@ -182,19 +221,6 @@ void LLVMDisassembler::disassemble() { if(llvm::MCDisassembler::Success == DisAsm->getInstruction(inst, inst_size, ref, current_address, nulls(), nulls())) { - uint8_t bytes[inst_size+2]; - ref.readBytes(current_address, inst_size, bytes); - s << '\t'; - for(uint8_t* cur = bytes; cur < bytes + inst_size; ++cur) { - s.write_hex(*cur); - s << ' '; - } - s << '\t'; - - IP->printInst(&inst, s, ""); - - LOG4CXX_DEBUG(logger, std::hex << current_address + base_address << s.str()); - uint64_t jmptarget; if (MIA->evaluateBranch(inst, current_address, inst_size, jmptarget)) { jmptarget += base_address; @@ -208,18 +234,18 @@ void LLVMDisassembler::disassemble() { remaining_functions.push(fun); } } else { + current_block->setNextBlock(0, jmptarget); if (blocks.find(jmptarget) == blocks.end()) { LLVMBasicBlock * block = new LLVMBasicBlock(jmptarget, this); blocks.insert(std::make_pair(block->getStartAddress(), block)); - current_block->setNextBlock(0, block->getStartAddress()); remaining_blocks.push(block); } if (MIA->isConditionalBranch(inst)) { jmptarget = base_address + current_address + inst_size; + current_block->setNextBlock(1, jmptarget); if (blocks.find(jmptarget) == blocks.end()) { LLVMBasicBlock * block = new LLVMBasicBlock(jmptarget, this); blocks.insert(std::make_pair(block->getStartAddress(), block)); - current_block->setNextBlock(1, block->getStartAddress()); remaining_blocks.push(block); } } @@ -250,7 +276,7 @@ void LLVMDisassembler::disassemble() { uint64_t base_address; text_section.getAddress(base_address); uint64_t current_address = current_block->getStartAddress() - base_address; - while(current_block->getEndAddress() - base_address != current_address) { + while(current_block->getEndAddress() - base_address > current_address) { MCInst inst; std::string buf; llvm::raw_string_ostream s(buf); @@ -260,14 +286,17 @@ void LLVMDisassembler::disassemble() { auto other = blocks.find(current_address + inst_size + base_address); if (other != blocks.end()) { - LOG4CXX_DEBUG(logger, "Shortening block starting at " - << std::hex - << current_block->getStartAddress() - << " now ending at " - << other->first); - current_block->setEndAddress(current_address + inst_size + base_address); - current_block->setNextBlock(0, other->first); - current_block->setNextBlock(1, 0); + uint64_t endaddress = current_address + inst_size + base_address; + if (endaddress != current_block->getEndAddress()) { + LOG4CXX_DEBUG(logger, "Shortening block starting at " + << std::hex + << current_block->getStartAddress() + << " now ending at " + << other->first); + current_block->setEndAddress(endaddress); + current_block->setNextBlock(0, other->first); + current_block->setNextBlock(1, 0); + } } } else { inst_size = 1; @@ -336,9 +365,17 @@ void LLVMDisassembler::printEachInstruction(uint64_t start, uint64_t end, uint8_t bytes[inst_size+2]; ref.readBytes(current_address, inst_size, bytes); - IP->printInst(&inst, s, ""); + uint64_t jmptarget; + if (MIA->evaluateBranch(inst, current_address, inst_size, jmptarget)) { + std::stringstream stream; + stream << std::hex << (base_address + jmptarget); + IP->printInst(&inst, s, stream.str()); + } else + IP->printInst(&inst, s, ""); + fun(bytes, inst_size, s.str()); } else { + LOG4CXX_WARN(logger, "Invalid byte at" << std::hex << current_address + base_address); fun(NULL, 0, "Invalid Byte"); inst_size = 1; }