Create ObjectFile only once and store it with full type

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

diff --git a/src/disassembler/llvm/LLVMDisassembler.cxx b/src/disassembler/llvm/LLVMDisassembler.cxx
index cf40aaa7ec882fbcd76d09645ca88740a8071231..8dd548332bf4f1f01106cd2020db3b137e13b626 100644 (file)
--- a/src/disassembler/llvm/LLVMDisassembler.cxx
+++ b/src/disassembler/llvm/LLVMDisassembler.cxx
@@ -18,24 +18,20 @@ Disassembler * createLLVMDisassembler(const std::string& filename, InformationMa
 
        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;
@@ -48,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());