X-Git-Url: https://git.siccegge.de//index.cgi?p=frida%2Ffrida.git;a=blobdiff_plain;f=src%2Fdisassembler%2Fllvm%2FLLVMDisassembler.cxx;h=9ab28440f7f96451ef8fb5cc0e4e4b1c604ab613;hp=79c7a544467fb8f6ce58abf6fae95c800d7bf750;hb=1b95144814ee74e611fd8a3806e54f064b120460;hpb=9e283567ac56a6433e832d0fa38cf534a0cb8f9f diff --git a/src/disassembler/llvm/LLVMDisassembler.cxx b/src/disassembler/llvm/LLVMDisassembler.cxx index 79c7a54..9ab2844 100644 --- a/src/disassembler/llvm/LLVMDisassembler.cxx +++ b/src/disassembler/llvm/LLVMDisassembler.cxx @@ -9,12 +9,42 @@ using namespace llvm; using namespace llvm::object; using std::error_code; +/* + * + */ +Disassembler * createLLVMDisassembler(const std::string& filename, InformationManager* manager) { + std::unique_ptr o; + o.reset(createBinary(filename).get()); + const Binary * op = o.get(); + + // ELFType + if (const ELF32LEObjectFile * _ = dyn_cast(op)) { +#pragma unused(_) + return new LLVMDisassembler>(filename, manager); + } + if (const ELF64LEObjectFile * _ = dyn_cast(op)) { +#pragma unused(_) + return new LLVMDisassembler>(filename, manager); + } + if (const ELF32BEObjectFile * _ = dyn_cast(op)) { +#pragma unused(_) + return new LLVMDisassembler>(filename, manager); + } + if (const ELF64BEObjectFile * _ = dyn_cast(op)) { +#pragma unused(_) + return new LLVMDisassembler>(filename, manager); + } + + return NULL; +} + /* * TODO: fallback code falls die Datei kein ELF/PE/COFF/MacO/.. binary * ist sondern z.B. einfach nur Instruktionen oder ein Bootsektor oder * foo */ -LLVMDisassembler::LLVMDisassembler(const std::string& filename, +template +LLVMDisassembler::LLVMDisassembler(const std::string& filename, InformationManager* manager) : Disassembler(filename, manager) , logger(log4cxx::Logger::getLogger("LLVMDisassembler")) @@ -115,13 +145,15 @@ LLVMDisassembler::LLVMDisassembler(const std::string& filename, Mod.reset(OD->buildModule(false)); } -void LLVMDisassembler::start() { +template +void LLVMDisassembler::start() { readSymbols(); readSections(); disassemble(); } -LLVMDisassembler::~LLVMDisassembler() { +template +LLVMDisassembler::~LLVMDisassembler() { std::for_each(functions.begin(), functions.end(), [](std::pair it) { delete it.second; @@ -132,13 +164,14 @@ LLVMDisassembler::~LLVMDisassembler() { }); } -Function* LLVMDisassembler::disassembleFunctionAt(uint64_t address, const std::string& name) { +template +Function* LLVMDisassembler::disassembleFunctionAt(uint64_t address, const std::string& name) { SectionRef text_section = sections[".text"]; uint64_t base_address, size; text_section.getAddress(base_address); text_section.getSize(size); - if (address < base_address || + if (address < base_address || address >= base_address + size) { return NULL; } @@ -162,7 +195,8 @@ Function* LLVMDisassembler::disassembleFunctionAt(uint64_t address, const std::s return function; } -void LLVMDisassembler::disassembleFunction(LLVMFunction* function) { +template +void LLVMDisassembler::disassembleFunction(LLVMFunction* function) { std::stack remaining_blocks; SectionRef text_section = sections[".text"]; StringRef bytes; @@ -174,6 +208,7 @@ void LLVMDisassembler::disassembleFunction(LLVMFunction* function) { LLVMBasicBlock * block = new LLVMBasicBlock(function->getStartAddress(), this); remaining_blocks.push(block); blocks.insert(std::make_pair(block->getStartAddress(), block)); + function->addBasicBlock(block); while (remaining_blocks.size()) { LLVMBasicBlock * current_block = remaining_blocks.top(); @@ -206,7 +241,11 @@ void LLVMDisassembler::disassembleFunction(LLVMFunction* function) { if (blocks.find(jmptarget) == blocks.end()) { LLVMBasicBlock * block = new LLVMBasicBlock(jmptarget, this); blocks.insert(std::make_pair(block->getStartAddress(), block)); + function->addBasicBlock(block); remaining_blocks.push(block); + } else { + LOG4CXX_DEBUG(logger, "Reusing Block starting at " << std::hex << current_block->getStartAddress()); + function->addBasicBlock(blocks.find(jmptarget)->second); } if (MIA->isConditionalBranch(inst)) { jmptarget = base_address + current_address + inst_size; @@ -214,7 +253,11 @@ void LLVMDisassembler::disassembleFunction(LLVMFunction* function) { if (blocks.find(jmptarget) == blocks.end()) { LLVMBasicBlock * block = new LLVMBasicBlock(jmptarget, this); blocks.insert(std::make_pair(block->getStartAddress(), block)); + function->addBasicBlock(block); remaining_blocks.push(block); + } else { + LOG4CXX_DEBUG(logger, "Reusing Block starting at " << std::hex << current_block->getStartAddress()); + function->addBasicBlock(blocks.find(jmptarget)->second); } } } @@ -234,11 +277,13 @@ void LLVMDisassembler::disassembleFunction(LLVMFunction* function) { current_address += inst_size; } } + splitBlocks(function); LOG4CXX_DEBUG(logger, "Finished function " << function->getName()); manager->signal_new_function(function); } -void LLVMDisassembler::disassemble() { +template +void LLVMDisassembler::disassemble() { SectionRef text_section = sections[".text"]; std::vector remaining_functions; @@ -271,20 +316,19 @@ 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; + _entryAddress |= (unsigned int)((unsigned char)binary->getData()[0x18 + i]) << 8*i; } else { - entry = entry << 8; - entry |= (unsigned char)binary->getData()[0x18 + i]; + _entryAddress = _entryAddress << 8; + _entryAddress |= (unsigned char)binary->getData()[0x18 + i]; } } - LOG4CXX_DEBUG(logger, "Adding entry at: " << std::hex << entry); + LOG4CXX_DEBUG(logger, "Adding entryAddress at: " << std::hex << _entryAddress); std::stringstream s; - s << "<_start 0x" << std::hex << entry << ">"; + s << "<_start 0x" << std::hex << _entryAddress << ">"; - disassembleFunctionAt(entry, s.str()); + disassembleFunctionAt(_entryAddress, s.str()); } if (functions.empty()) { @@ -293,19 +337,20 @@ void LLVMDisassembler::disassemble() { LOG4CXX_INFO(logger, "No Symbols found, starting at the beginning of the text segment"); disassembleFunctionAt(text_entry); } - - splitBlocks(); } -void LLVMDisassembler::splitBlocks() { +template +void LLVMDisassembler::splitBlocks(LLVMFunction* function) { SectionRef text_section = sections[".text"]; StringRef bytes; text_section.getContents(bytes); StringRefMemoryObject ref(bytes); // Split blocks where jumps are going inside the block - for (auto it = blocks.begin(); it != blocks.end(); ++it) { - LLVMBasicBlock * current_block = it->second; + for (auto it = function->blocks().begin(); + it != function->blocks().end(); + ++it) { + BasicBlock * current_block = it->second; uint64_t inst_size; uint64_t base_address; text_section.getAddress(base_address); @@ -317,8 +362,10 @@ void LLVMDisassembler::splitBlocks() { if(llvm::MCDisassembler::Success == DisAsm->getInstruction(inst, inst_size, ref, current_address, nulls(), nulls())) { + // See if some other block starts here auto other = blocks.find(current_address + inst_size + base_address); + // Special case, other block starts here but we are at the end anyway if (other != blocks.end()) { uint64_t endaddress = current_address + inst_size + base_address; if (endaddress != current_block->getEndAddress()) { @@ -327,6 +374,7 @@ void LLVMDisassembler::splitBlocks() { << current_block->getStartAddress() << " now ending at " << other->first); + function->addBasicBlock(other->second); current_block->setEndAddress(endaddress); current_block->setNextBlock(0, other->first); current_block->setNextBlock(1, 0); @@ -340,7 +388,8 @@ void LLVMDisassembler::splitBlocks() { } } -void LLVMDisassembler::readSymbols() { +template +void LLVMDisassembler::readSymbols() { error_code ec; symbol_iterator si(o->symbol_begin()), se(o->symbol_end()); for (; si != se; ++si) { @@ -354,7 +403,8 @@ void LLVMDisassembler::readSymbols() { } } -void LLVMDisassembler::readSections() { +template +void LLVMDisassembler::readSections() { error_code ec; section_iterator i(o->section_begin()), e(o->section_end()); for (; i != e; ++i) { @@ -369,15 +419,19 @@ void LLVMDisassembler::readSections() { } -void LLVMDisassembler::forEachFunction(std::function callback) { +template +void LLVMDisassembler::forEachFunction(std::function callback) { std::for_each(functions.begin(), functions.end(), [&](std::pair x) { callback(x.first, x.second); }); } -void LLVMDisassembler::printEachInstruction(uint64_t start, uint64_t end, - std::function fun) { +template +void LLVMDisassembler::printEachInstruction(uint64_t start, uint64_t end, + std::function fun) { SectionRef text_section = sections[".text"]; uint64_t base_address; text_section.getAddress(base_address); @@ -400,17 +454,24 @@ void LLVMDisassembler::printEachInstruction(uint64_t start, uint64_t end, ref.readBytes(current_address, inst_size, bytes); uint64_t jmptarget; + std::string ref(""); + IP->printInst(&inst, s, ""); if (MIA->evaluateBranch(inst, current_address, inst_size, jmptarget)) { std::stringstream stream; + if (MIA->isCall(inst)) + stream << "function:"; + else + stream << "block:"; + stream << std::hex << (base_address + jmptarget); - IP->printInst(&inst, s, stream.str()); - } else - IP->printInst(&inst, s, ""); + ref = stream.str(); + } + - fun(bytes, inst_size, s.str()); + fun(bytes, inst_size, s.str(), ref); } else { LOG4CXX_WARN(logger, "Invalid byte at" << std::hex << current_address + base_address); - fun(NULL, 0, "Invalid Byte"); + fun(NULL, 0, "Invalid Byte", ""); inst_size = 1; }