Get entry address from llvm

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

diff --git a/src/disassembler/llvm/LLVMDisassembler.cxx b/src/disassembler/llvm/LLVMDisassembler.cxx
index 1f92ab04410624c1a3ede4957234e2ad21cb0671..18cfe8065eefc0fb5e409d7978408e50dd47a1b2 100644 (file)
--- a/src/disassembler/llvm/LLVMDisassembler.cxx
+++ b/src/disassembler/llvm/LLVMDisassembler.cxx
@@ -13,26 +13,25 @@ using std::error_code;
  *
  */
 Disassembler * createLLVMDisassembler(const std::string& filename, InformationManager* manager) {
+       if (filename == "")
+               return NULL;
+
        std::unique_ptr<Binary> o;
        o.reset(createBinary(filename).get());
-       const Binary * op = o.get();
+       Binary * op = o.release();
 
        // ELFType<endian, maxalign, 64bit>
-       if (const ELF32LEObjectFile * _ = dyn_cast<ELF32LEObjectFile>(op)) {
-#pragma unused(_)
-               return new LLVMDisassembler<ELFType<support::little, 2, false>>(filename, manager);
+       if (ELF32LEObjectFile * object = dyn_cast<ELF32LEObjectFile>(op)) {
+               return new LLVMDisassembler<ELFType<support::little, 2, false>>(filename, manager, object);
        }
-       if (const ELF64LEObjectFile * _ = dyn_cast<ELF64LEObjectFile>(op)) {
-#pragma unused(_)
-               return new LLVMDisassembler<ELFType<support::little, 2, true>>(filename, manager);
+       if (ELF64LEObjectFile * object = dyn_cast<ELF64LEObjectFile>(op)) {
+               return new LLVMDisassembler<ELFType<support::little, 2, true>>(filename, manager, object);
        }
-       if (const ELF32BEObjectFile * _ = dyn_cast<ELF32BEObjectFile>(op)) {
-#pragma unused(_)
-               return new LLVMDisassembler<ELFType<support::big, 2, false>>(filename, manager);
+       if (ELF32BEObjectFile * object = dyn_cast<ELF32BEObjectFile>(op)) {
+               return new LLVMDisassembler<ELFType<support::big, 2, false>>(filename, manager, object);
        }
-       if (const ELF64BEObjectFile * _ = dyn_cast<ELF64BEObjectFile>(op)) {
-#pragma unused(_)
-               return new LLVMDisassembler<ELFType<support::big, 2, true>>(filename, manager);
+       if (ELF64BEObjectFile * object = dyn_cast<ELF64BEObjectFile>(op)) {
+               return new LLVMDisassembler<ELFType<support::big, 2, true>>(filename, manager, object);
        }
 
        return NULL;
@@ -45,25 +44,32 @@ Disassembler * createLLVMDisassembler(const std::string& filename, InformationMa
  */
 template <typename ELFT>
 LLVMDisassembler<ELFT>::LLVMDisassembler(const std::string& filename,
-                                   InformationManager* manager)
+                                         InformationManager* manager,
+                                         ELFObjectFile<ELFT>* file)
        : Disassembler(filename, manager)
        , logger(log4cxx::Logger::getLogger("LLVMDisassembler"))
        , triple("unknown-unknown-unknown")
        , manager(manager)
 {
        LOG4CXX_DEBUG(logger, "Handling file" << filename);
-       auto result = createBinary(filename);
 
-       error_code ec;
-       if ((ec = result.getError())) {
-               LOG4CXX_ERROR(logger, "Failed to load Binary" << ec.message());
-               binary = NULL;
-               return;
-       }
+       if (!file) {
+               auto result = createBinary(filename);
 
-       binary.reset(result.get());
+               error_code ec;
+               if ((ec = result.getError())) {
+                       LOG4CXX_ERROR(logger, "Failed to load Binary" << ec.message());
+                       binary = NULL;
+                       return;
+               }
 
-       o = dyn_cast<ObjectFile>(binary.get());
+               binary.reset(result.get());
+
+               o = dyn_cast<ELFObjectFile<ELFT>>(binary.get());
+       } else {
+               o = file;
+               binary.reset(file);
+       }
 
        triple.setArch(Triple::ArchType(o->getArch()));
        std::string tripleName(triple.getTriple());
@@ -314,22 +320,16 @@ void LLVMDisassembler<ELFT>::disassemble() {
        }
 
        if (binary->isELF()) {
-               bool is64bit = (binary->getData()[4] == 0x02);
+               typedef ELFFile<ELFT> ELFO;
+               const ELFO * elffile = o->getELFFile();
+               const typename ELFO::Elf_Ehdr * header = elffile->getHeader();
 
-               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];
-                       }
-               }
-               LOG4CXX_DEBUG(logger, "Adding entry at: " << std::hex << entry);
+               _entryAddress = header->e_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()) {
@@ -430,8 +430,9 @@ void LLVMDisassembler<ELFT>::forEachFunction(std::function<void (uint64_t, Funct
 
 template <typename ELFT>
 void LLVMDisassembler<ELFT>::printEachInstruction(uint64_t start, uint64_t end,
-                                            std::function<void (uint8_t*, size_t,
-                                                                const std::string&)> fun) {
+                                                  std::function<void (uint8_t*, size_t,
+                                                                         const std::string&,
+                                                                         const std::string&)> fun) {
        SectionRef text_section = sections[".text"];
        uint64_t base_address;
        text_section.getAddress(base_address);
@@ -454,17 +455,24 @@ void LLVMDisassembler<ELFT>::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;
                }