Pass the InformationManager inside the BasicBlock and Function classes

[frida/frida.git] / src / disassembler / llvm / LLVMDisassembler.cxx

diff --git a/src/disassembler/llvm/LLVMDisassembler.cxx b/src/disassembler/llvm/LLVMDisassembler.cxx
index 18cfe8065eefc0fb5e409d7978408e50dd47a1b2..b6f8dae75ae2d6cc33b2586bc2b45df68b899eec 100644 (file)
--- a/src/disassembler/llvm/LLVMDisassembler.cxx
+++ b/src/disassembler/llvm/LLVMDisassembler.cxx
@@ -1,6 +1,7 @@
 #include "disassembler/llvm/LLVMDisassembler.hxx"
-#include "disassembler/llvm/LLVMBasicBlock.hxx"
-#include "disassembler/llvm/LLVMFunction.hxx"
+#include "core/InformationManager.hxx"
+#include "core/Function.hxx"
+#include "core/BasicBlock.hxx"
 
 #include <stack>
 #include <algorithm>
@@ -156,18 +157,19 @@ void LLVMDisassembler<ELFT>::start() {
        readSymbols();
        readSections();
        disassemble();
+       readDynamicSymbols();
 }
 
 template <typename ELFT>
 LLVMDisassembler<ELFT>::~LLVMDisassembler() {
-       std::for_each(functions.begin(), functions.end(),
-                     [](std::pair<uint64_t,LLVMFunction*> it) {
-                             delete it.second;
-                     });
-       std::for_each(blocks.begin(), blocks.end(),
-                     [](std::pair<uint64_t, LLVMBasicBlock*> it) {
-                             delete it.second;
-                     });
+       // std::for_each(functions.begin(), functions.end(),
+       //               [](std::pair<uint64_t,LLVMFunction*> it) {
+       //                    delete it.second;
+       //               });
+       // std::for_each(blocks.begin(), blocks.end(),
+       //               [](std::pair<uint64_t, LLVMBasicBlock*> it) {
+       //                    delete it.second;
+       //               });
 }
 
 template <typename ELFT>
@@ -186,13 +188,13 @@ Function* LLVMDisassembler<ELFT>::disassembleFunctionAt(uint64_t address, const
                return functions[address];
        }
 
-       LLVMFunction * function;
+       Function * function;
        if (name == "") {
                std::stringstream s;
                s << "<Unnamed 0x" << std::hex << address << ">";
-               function = new LLVMFunction(s.str(), address);
+               function = new Function(s.str(), address, manager);
        } else {
-               function = new LLVMFunction(name, address);
+               function = new Function(name, address, manager);
        }
        functions.insert(std::make_pair(address, function));
 
@@ -202,8 +204,8 @@ Function* LLVMDisassembler<ELFT>::disassembleFunctionAt(uint64_t address, const
 }
 
 template <typename ELFT>
-void LLVMDisassembler<ELFT>::disassembleFunction(LLVMFunction* function) {
-       std::stack<LLVMBasicBlock*> remaining_blocks;
+void LLVMDisassembler<ELFT>::disassembleFunction(Function* function) {
+       std::stack<BasicBlock*> remaining_blocks;
        SectionRef text_section = sections[".text"];
        StringRef bytes;
        text_section.getContents(bytes);
@@ -211,13 +213,13 @@ void LLVMDisassembler<ELFT>::disassembleFunction(LLVMFunction* function) {
 
        LOG4CXX_DEBUG(logger, "Handling function " << function->getName());
 
-       LLVMBasicBlock * block = new LLVMBasicBlock(function->getStartAddress(), this);
+       BasicBlock * block = new BasicBlock(function->getStartAddress(), this, manager);
        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();
+               BasicBlock * current_block = remaining_blocks.top();
                remaining_blocks.pop();
 
                LOG4CXX_DEBUG(logger, "Handling Block starting at " << std::hex << current_block->getStartAddress());
@@ -245,7 +247,7 @@ void LLVMDisassembler<ELFT>::disassembleFunction(LLVMFunction* function) {
                                                } else {
                                                        current_block->setNextBlock(0, jmptarget);
                                                        if (blocks.find(jmptarget) == blocks.end()) {
-                                                               LLVMBasicBlock * block = new LLVMBasicBlock(jmptarget, this);
+                                                               BasicBlock * block = new BasicBlock(jmptarget, this, manager);
                                                                blocks.insert(std::make_pair(block->getStartAddress(), block));
                                                                function->addBasicBlock(block);
                                                                remaining_blocks.push(block);
@@ -257,7 +259,7 @@ void LLVMDisassembler<ELFT>::disassembleFunction(LLVMFunction* function) {
                                                                jmptarget = base_address + current_address + inst_size;
                                                                current_block->setNextBlock(1, jmptarget);
                                                                if (blocks.find(jmptarget) == blocks.end()) {
-                                                                       LLVMBasicBlock * block = new LLVMBasicBlock(jmptarget, this);
+                                                                       BasicBlock * block = new BasicBlock(jmptarget, this, manager);
                                                                        blocks.insert(std::make_pair(block->getStartAddress(), block));
                                                                        function->addBasicBlock(block);
                                                                        remaining_blocks.push(block);
@@ -291,7 +293,7 @@ void LLVMDisassembler<ELFT>::disassembleFunction(LLVMFunction* function) {
 template <typename ELFT>
 void LLVMDisassembler<ELFT>::disassemble() {
        SectionRef text_section = sections[".text"];
-       std::vector<LLVMFunction*> remaining_functions;
+       std::vector<Function*> remaining_functions;
 
        // Assume all function symbols actually start a real function
        for (auto x = symbols.begin(); x != symbols.end(); ++x) {
@@ -308,19 +310,18 @@ void LLVMDisassembler<ELFT>::disassemble() {
                        continue;
 
                if (!x->second.getAddress(result)) {
-                       LLVMFunction * fun = new LLVMFunction(x->first, result);
+                       Function * fun = new Function(x->first, result, manager);
                        remaining_functions.push_back(fun);
                        functions.insert(std::make_pair(result, fun));
                        LOG4CXX_DEBUG(logger, "Disasembling " << x->first);
                }
        }
 
-       for (LLVMFunction* function : remaining_functions) {
+       for (Function* function : remaining_functions) {
                disassembleFunction(function);
        }
 
        if (binary->isELF()) {
-               typedef ELFFile<ELFT> ELFO;
                const ELFO * elffile = o->getELFFile();
                const typename ELFO::Elf_Ehdr * header = elffile->getHeader();
 
@@ -341,7 +342,7 @@ void LLVMDisassembler<ELFT>::disassemble() {
 }
 
 template <typename ELFT>
-void LLVMDisassembler<ELFT>::splitBlocks(LLVMFunction* function) {
+void LLVMDisassembler<ELFT>::splitBlocks(Function* function) {
        SectionRef text_section = sections[".text"];
        StringRef bytes;
        text_section.getContents(bytes);
@@ -389,6 +390,25 @@ void LLVMDisassembler<ELFT>::splitBlocks(LLVMFunction* function) {
        }
 }
 
+template <typename ELFT>
+void LLVMDisassembler<ELFT>::readDynamicSymbols() {
+       const ELFO * elffile = o->getELFFile();
+       for (typename ELFO::Elf_Sym_Iter
+                    it = elffile->begin_dynamic_symbols(),
+                    end = elffile->end_dynamic_symbols();
+            it != end;
+            ++it) {
+               if (it->getType() == 2) { // Function
+                       bool is_default;
+                       // TODO: Error handling
+                       std::string symbolname = *(elffile->getSymbolName(it));
+                       std::string symbolversion = *(elffile->getSymbolVersion(nullptr, &*it, is_default));
+                       manager->signal_new_dyn_symbol(symbolname + (is_default? "@@" : "@") + symbolversion);
+                       LOG4CXX_DEBUG(logger, "Adding dynamic Symbol " << symbolname << (is_default? "@@" : "@") << symbolversion);
+               }
+       }
+}
+
 template <typename ELFT>
 void LLVMDisassembler<ELFT>::readSymbols() {
        error_code ec;
@@ -423,7 +443,7 @@ void LLVMDisassembler<ELFT>::readSections() {
 template <typename ELFT>
 void LLVMDisassembler<ELFT>::forEachFunction(std::function<void (uint64_t, Function*)> callback) {
        std::for_each(functions.begin(), functions.end(),
-                     [&](std::pair<uint64_t, LLVMFunction*> x) {
+                     [&](std::pair<uint64_t, Function*> x) {
                              callback(x.first, x.second);
                      });
 }