Create ObjectFile only once and store it with full type

ObjectFiles was created twice, once to check the type it has and then
again to store and use it in the disassembler. We now create it only
once and store it with full type information for additional use

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());

diff --git a/src/disassembler/llvm/LLVMDisassembler.hxx b/src/disassembler/llvm/LLVMDisassembler.hxx
index 59f73497455162c223fa5c056dea38a23408139c..6c8767aa1a2bc7b55cb116408446504c109ef513 100644 (file)
--- a/src/disassembler/llvm/LLVMDisassembler.hxx
+++ b/src/disassembler/llvm/LLVMDisassembler.hxx
@@ -20,7 +20,8 @@ template <typename ELFT>
 class LLVMDisassembler
        : public Disassembler {
 public:
-       LLVMDisassembler(const std::string& filename, InformationManager* manager);
+       LLVMDisassembler(const std::string& filename, InformationManager* manager,
+                        llvm::object::ELFObjectFile<ELFT>* file = NULL);
        virtual ~LLVMDisassembler();
 
        void start();
@@ -59,7 +60,7 @@ private:
        std::shared_ptr<llvm::object::Binary> binary;
 
        const llvm::Target * target;
-       llvm::object::ObjectFile * o;
+       llvm::object::ELFObjectFile<ELFT> * o;
 
        std::unique_ptr<const llvm::MCRegisterInfo> MRI;
        std::unique_ptr<const llvm::MCAsmInfo> AsmInfo;