Disable symbolizer

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

diff --git a/src/disassembler/llvm/LLVMDisassembler.cxx b/src/disassembler/llvm/LLVMDisassembler.cxx
index abfafa48e61d566de36c3b8879c555de84290561..3d969ef211975fde131ec83514beb561f220d5af 100644 (file)
--- a/src/disassembler/llvm/LLVMDisassembler.cxx
+++ b/src/disassembler/llvm/LLVMDisassembler.cxx
@@ -11,6 +11,12 @@ using namespace llvm;
 using namespace llvm::object;
 using std::error_code;
 
+namespace {
+       class COFFT {
+
+       };
+}
+
 /*
  *
  */
@@ -35,6 +41,9 @@ Disassembler * createLLVMDisassembler(const std::string& filename, InformationMa
        if (ELF64BEObjectFile * object = dyn_cast<ELF64BEObjectFile>(op)) {
                return new LLVMDisassembler<ELFType<support::big, 2, true>>(filename, manager, object);
        }
+       if (COFFObjectFile * object = dyn_cast<COFFObjectFile>(op)) {
+               return new LLVMDisassembler<COFFT>(filename, manager, object);
+       }
 
        return NULL;
 }
@@ -47,13 +56,13 @@ Disassembler * createLLVMDisassembler(const std::string& filename, InformationMa
 template <typename ELFT>
 LLVMDisassembler<ELFT>::LLVMDisassembler(const std::string& filename,
                                          InformationManager* manager,
-                                         ELFObjectFile<ELFT>* file)
+                                         ObjectFile* file)
        : Disassembler()
        , logger(log4cxx::Logger::getLogger("LLVMDisassembler"))
        , triple("unknown-unknown-unknown")
        , manager(manager)
 {
-       LOG4CXX_DEBUG(logger, "Handling file" << filename);
+       LOG4CXX_DEBUG(logger, "Handling file " << filename);
 
        if (!file) {
                auto result = createBinary(filename);
@@ -67,7 +76,7 @@ LLVMDisassembler<ELFT>::LLVMDisassembler(const std::string& filename,
 
                binary.reset(result.get());
 
-               o = dyn_cast<ELFObjectFile<ELFT>>(binary.get());
+               o = dyn_cast<ObjectFile>(binary.get());
        } else {
                o = file;
                binary.reset(file);
@@ -124,10 +133,10 @@ LLVMDisassembler<ELFT>::LLVMDisassembler(const std::string& filename,
        RelInfo.reset(
                target->createMCRelocationInfo(tripleName, Ctx));
        if (RelInfo) {
-               Symzer.reset(
-                       MCObjectSymbolizer::createObjectSymbolizer(Ctx, std::move(RelInfo), o));
-               if (Symzer)
-                       DisAsm->setSymbolizer(std::move(Symzer));
+               // Symzer.reset(
+               //      MCObjectSymbolizer::createObjectSymbolizer(Ctx, std::move(RelInfo), o));
+               // if (Symzer)
+               //      DisAsm->setSymbolizer(std::move(Symzer));
        }
        RelInfo.release();
        Symzer.release();
@@ -151,12 +160,13 @@ LLVMDisassembler<ELFT>::LLVMDisassembler(const std::string& filename,
        std::unique_ptr<MCObjectDisassembler> OD(
                new MCObjectDisassembler(*o, *DisAsm, *MIA));
        Mod.reset(OD->buildModule(false));
+
+       readSections();
 }
 
 template <typename ELFT>
 void LLVMDisassembler<ELFT>::start() {
        readSymbols();
-       readSections();
        disassemble();
        readDynamicSymbols();
 }
@@ -324,10 +334,7 @@ void LLVMDisassembler<ELFT>::disassemble() {
        }
 
        if (binary->isELF()) {
-               const ELFO * elffile = o->getELFFile();
-               const typename ELFO::Elf_Ehdr * header = elffile->getHeader();
-
-               _entryAddress = header->e_entry;
+               uint64_t _entryAddress = entryAddress();
                LOG4CXX_DEBUG(logger, "Adding entryAddress at: " << std::hex << _entryAddress);
                std::stringstream s;
                s << "<_start 0x" << std::hex << _entryAddress << ">";
@@ -343,6 +350,30 @@ void LLVMDisassembler<ELFT>::disassemble() {
        }
 }
 
+template <>
+uint64_t LLVMDisassembler<COFFT>::entryAddress() {
+       const auto coffobject = dyn_cast<COFFObjectFile>(o);
+       const struct pe32_header* pe32_header;
+       const struct pe32plus_header* pe32plus_header;
+
+       coffobject->getPE32PlusHeader(pe32plus_header);
+
+       if (pe32plus_header) {
+               return pe32plus_header->AddressOfEntryPoint;
+       } else {
+               coffobject->getPE32Header(pe32_header);
+               return pe32_header->AddressOfEntryPoint;
+       }
+}
+
+template <typename ELFT>
+uint64_t LLVMDisassembler<ELFT>::entryAddress() {
+       const auto elffile = dyn_cast<ELFObjectFile<ELFT>>(o)->getELFFile();
+       const auto * header = elffile->getHeader();
+
+       return header->e_entry;
+}
+
 template <typename ELFT>
 void LLVMDisassembler<ELFT>::splitBlocks(Function* function) {
        SectionRef text_section = sections[".text"];
@@ -394,11 +425,15 @@ void LLVMDisassembler<ELFT>::splitBlocks(Function* function) {
        }
 }
 
+template<>
+void LLVMDisassembler<COFFT>::readDynamicSymbols() {
+       //TODO
+}
+
 template <typename ELFT>
 void LLVMDisassembler<ELFT>::readDynamicSymbols() {
-       const ELFO * elffile = o->getELFFile();
-       for (typename ELFO::Elf_Sym_Iter
-                    it = elffile->begin_dynamic_symbols(),
+       const auto elffile = dyn_cast<ELFObjectFile<ELFT>>(o)->getELFFile();
+       for (auto it = elffile->begin_dynamic_symbols(),
                     end = elffile->end_dynamic_symbols();
             it != end;
             ++it) {