LLD: Remove duplciate code.

[ruiu]

Summary

Remove duplciate code.

[atanasyan]

Do you plan to remove all xxxDynamicFile target specific descendants of DynamicFile class? Now all of them are "empty" and after this change it is not possible to create their instances.

[ruiu]

• Remove subclasses of DynamicFile that are not instantiated

[ruiu]

Thanks for pointing that out. I thought about that, but I forgot to do that when I was writing this patch. Updated.

[atanasyan]

LGTM. Good code cleanup.

lib/ReaderWriter/ELF/AArch64/AArch64ELFFile.h

public:
 
   static ErrorOr<std::unique_ptr<AArch64ELFFile>>
   create(std::unique_ptr<MemoryBuffer> mb, AArch64LinkingContext &ctx) {
     return std::unique_ptr<AArch64ELFFile<ELFT>>(
         new AArch64ELFFile<ELFT>(std::move(mb), ctx));
   }
 };
 
-template <class ELFT> class AArch64DynamicFile : public DynamicFile<ELFT> {
-public:
-  AArch64DynamicFile(const AArch64LinkingContext &context, StringRef name)
-      : DynamicFile<ELFT>(context, name) {}
-};
-
 } // elf
 } // lld
 
 #endif // LLD_READER_WRITER_ELF_AARCH64_AARCH64_ELF_FILE_H

lib/ReaderWriter/ELF/AArch64/AArch64ELFReader.h

 #include "AArch64ELFFile.h"
 #include "ELFReader.h"
 
 namespace lld {
 namespace elf {
 
 typedef llvm::object::ELFType<llvm::support::little, 2, true> AArch64ELFType;
 
-struct AArch64DynamicFileCreateELFTraits {
-  typedef llvm::ErrorOr<std::unique_ptr<lld::SharedLibraryFile>> result_type;
-
-  template <class ELFT>
-  static result_type create(std::unique_ptr<llvm::MemoryBuffer> mb,
-                            AArch64LinkingContext &ctx) {
-    return lld::elf::AArch64DynamicFile<ELFT>::create(std::move(mb), ctx);
-  }
-};
-
 struct AArch64ELFFileCreateELFTraits {
   typedef llvm::ErrorOr<std::unique_ptr<lld::File>> result_type;
 
   template <class ELFT>
   static result_type create(std::unique_ptr<llvm::MemoryBuffer> mb,
                             AArch64LinkingContext &ctx) {
     return lld::elf::AArch64ELFFile<ELFT>::create(std::move(mb), ctx);
   }
 };
 
 class AArch64ELFObjectReader
     : public ELFObjectReader<AArch64ELFType, AArch64ELFFileCreateELFTraits,
                              AArch64LinkingContext> {
 public:
   AArch64ELFObjectReader(AArch64LinkingContext &ctx)
       : ELFObjectReader<AArch64ELFType, AArch64ELFFileCreateELFTraits,
                         AArch64LinkingContext>(ctx, llvm::ELF::EM_AARCH64) {}
 };
 
 class AArch64ELFDSOReader
-    : public ELFDSOReader<AArch64ELFType, AArch64DynamicFileCreateELFTraits,
-                          AArch64LinkingContext> {
+    : public ELFDSOReader<AArch64ELFType, AArch64LinkingContext> {
 public:
   AArch64ELFDSOReader(AArch64LinkingContext &ctx)
-      : ELFDSOReader<AArch64ELFType, AArch64DynamicFileCreateELFTraits,
+      : ELFDSOReader<AArch64ELFType,
                      AArch64LinkingContext>(ctx, llvm::ELF::EM_AARCH64) {}
 };
 
 } // namespace elf
 } // namespace lld
 
 #endif // LLD_READER_WRITER_AARCH64_AARCH64_ELF_READER_H

lib/ReaderWriter/ELF/ARM/ARMELFFile.h

if (symName.size() >= 2 && symName[0] == '$') {
       }
     }
     return new (this->_readerStorage) ARMELFDefinedAtom<ELFT>(
         *this, symName, sectionName, sym, sectionHdr, contentData,
         referenceStart, referenceEnd, referenceList);
   }
 };
 
-template <class ELFT> class ARMDynamicFile : public DynamicFile<ELFT> {
-public:
-  ARMDynamicFile(const ARMLinkingContext &context, StringRef name)
-      : DynamicFile<ELFT>(context, name) {}
-};
-
 } // elf
 } // lld
 
 #endif // LLD_READER_WRITER_ELF_ARM_ARM_ELF_FILE_H

lib/ReaderWriter/ELF/ARM/ARMELFReader.h

 #include "ARMELFFile.h"
 #include "ELFReader.h"
 
 namespace lld {
 namespace elf {
 
 typedef llvm::object::ELFType<llvm::support::little, 2, false> ARMELFType;
 
-struct ARMDynamicFileCreateELFTraits {
-  typedef llvm::ErrorOr<std::unique_ptr<lld::SharedLibraryFile>> result_type;
-
-  template <class ELFT>
-  static result_type create(std::unique_ptr<llvm::MemoryBuffer> mb,
-                            ARMLinkingContext &ctx) {
-    return lld::elf::ARMDynamicFile<ELFT>::create(std::move(mb), ctx);
-  }
-};
-
 struct ARMELFFileCreateELFTraits {
   typedef llvm::ErrorOr<std::unique_ptr<lld::File>> result_type;
 
   template <class ELFT>
   static result_type create(std::unique_ptr<llvm::MemoryBuffer> mb,
                             ARMLinkingContext &ctx) {
     return lld::elf::ARMELFFile<ELFT>::create(std::move(mb), ctx);
   }
 };
 
 class ARMELFObjectReader
     : public ELFObjectReader<ARMELFType, ARMELFFileCreateELFTraits,
                              ARMLinkingContext> {
 public:
   ARMELFObjectReader(ARMLinkingContext &ctx)
       : ELFObjectReader<ARMELFType, ARMELFFileCreateELFTraits,
                         ARMLinkingContext>(ctx, llvm::ELF::EM_ARM) {}
 };
 
 class ARMELFDSOReader
-    : public ELFDSOReader<ARMELFType, ARMDynamicFileCreateELFTraits,
-                          ARMLinkingContext> {
+    : public ELFDSOReader<ARMELFType, ARMLinkingContext> {
 public:
   ARMELFDSOReader(ARMLinkingContext &ctx)
-      : ELFDSOReader<ARMELFType, ARMDynamicFileCreateELFTraits,
-                     ARMLinkingContext>(ctx, llvm::ELF::EM_ARM) {}
+      : ELFDSOReader<ARMELFType, ARMLinkingContext>(ctx, llvm::ELF::EM_ARM) {}
 };
 
 } // namespace elf
 } // namespace lld
 
 #endif // LLD_READER_WRITER_ARM_ARM_ELF_READER_H

lib/ReaderWriter/ELF/ELFReader.h

const Elf_Ehdr *elfHeader(const MemoryBuffer &buf) const {
     return (reinterpret_cast<const Elf_Ehdr *>(data));
   }
 
 protected:
   ContextT &_ctx;
   uint64_t _machine;
 };
 
-template <typename ELFT, typename ELFTraitsT, typename ContextT>
+struct DynamicFileCreateELFTraits {
+  typedef llvm::ErrorOr<std::unique_ptr<lld::SharedLibraryFile>> result_type;
+
+  template<typename ELFT, typename ContextT>
+  static result_type create(std::unique_ptr<llvm::MemoryBuffer> mb,
+                            ContextT &ctx) {
+    return DynamicFile<ELFT>::create(std::move(mb), ctx);
+  }
+};
+
+template <typename ELFT, typename ContextT>
 class ELFDSOReader : public Reader {
 public:
   typedef llvm::object::Elf_Ehdr_Impl<ELFT> Elf_Ehdr;
 
   ELFDSOReader(ContextT &ctx, uint64_t machine)
       : _ctx(ctx), _machine(machine) {}
 
   bool canParse(file_magic magic, StringRef,
                 const MemoryBuffer &buf) const override {
     return (magic == llvm::sys::fs::file_magic::elf_shared_object &&
             elfHeader(buf)->e_machine == _machine);
   }
 
   std::error_code
   loadFile(std::unique_ptr<MemoryBuffer> mb, const class Registry &,
            std::vector<std::unique_ptr<File>> &result) const override {
     std::size_t maxAlignment =
         1ULL << llvm::countTrailingZeros(uintptr_t(mb->getBufferStart()));
-    auto f =
-        createELF<ELFTraitsT>(llvm::object::getElfArchType(mb->getBuffer()),
-                              maxAlignment, std::move(mb), _ctx);
+    auto f = createELF<DynamicFileCreateELFTraits>(
+        llvm::object::getElfArchType(mb->getBuffer()),
     if (std::error_code ec = f.getError())
       return ec;
     result.push_back(std::move(*f));
     return std::error_code();
   }
 
   const Elf_Ehdr *elfHeader(const MemoryBuffer &buf) const {
     const uint8_t *data =

lib/ReaderWriter/ELF/Hexagon/HexagonELFFile.h

public:
   /// Process the Common symbol and create an atom for it.
   ErrorOr<ELFCommonAtom<ELFT> *>
   handleCommonSymbol(StringRef symName, const Elf_Sym *sym) override {
     return new (this->_readerStorage)
         HexagonELFCommonAtom<ELFT>(*this, symName, sym);
   }
 };
 
-template <class ELFT> class HexagonDynamicFile : public DynamicFile<ELFT> {
-public:
-  HexagonDynamicFile(const HexagonLinkingContext &context, StringRef name)
-      : DynamicFile<ELFT>(context, name) {}
-};
-
 } // elf
 } // lld
 
 #endif // LLD_READER_WRITER_ELF_HEXAGON_ELF_FILE_H

lib/ReaderWriter/ELF/Hexagon/HexagonELFReader.h

 #include "ELFReader.h"
 #include "HexagonELFFile.h"
 
 namespace lld {
 namespace elf {
 
 typedef llvm::object::ELFType<llvm::support::little, 2, false> HexagonELFType;
 
-struct HexagonDynamicFileCreateELFTraits {
-  typedef llvm::ErrorOr<std::unique_ptr<lld::SharedLibraryFile>> result_type;
-
-  template <class ELFT>
-  static result_type create(std::unique_ptr<llvm::MemoryBuffer> mb,
-                            HexagonLinkingContext &ctx) {
-    return lld::elf::HexagonDynamicFile<ELFT>::create(std::move(mb), ctx);
-  }
-};
-
 struct HexagonELFFileCreateELFTraits {
   typedef llvm::ErrorOr<std::unique_ptr<lld::File>> result_type;
 
   template <class ELFT>
   static result_type create(std::unique_ptr<llvm::MemoryBuffer> mb,
                             HexagonLinkingContext &ctx) {
     return lld::elf::HexagonELFFile<ELFT>::create(std::move(mb), ctx);
   }
 };
 
 class HexagonELFObjectReader
     : public ELFObjectReader<HexagonELFType, HexagonELFFileCreateELFTraits,
                              HexagonLinkingContext> {
 public:
   HexagonELFObjectReader(HexagonLinkingContext &ctx)
       : ELFObjectReader<HexagonELFType, HexagonELFFileCreateELFTraits,
                         HexagonLinkingContext>(ctx, llvm::ELF::EM_HEXAGON) {}
 };
 
 class HexagonELFDSOReader
-    : public ELFDSOReader<HexagonELFType, HexagonDynamicFileCreateELFTraits,
-                          HexagonLinkingContext> {
+    : public ELFDSOReader<HexagonELFType, HexagonLinkingContext> {
 public:
   HexagonELFDSOReader(HexagonLinkingContext &ctx)
-      : ELFDSOReader<HexagonELFType, HexagonDynamicFileCreateELFTraits,
+      : ELFDSOReader<HexagonELFType,
                      HexagonLinkingContext>(ctx, llvm::ELF::EM_HEXAGON) {}
 };
 
 } // namespace elf
 } // namespace lld
 
 #endif // LLD_READER_WRITER_ELF_READER_H

lib/ReaderWriter/ELF/Mips/MipsELFFile.h

static uint8_t getPrimaryType(const Elf_Rel &rel) {
     return rel.getType(_isMips64EL) & 0xff;
   }
   bool isLocalBinding(const Elf_Rel &rel) const {
     return this->_objFile->getSymbol(rel.getSymbol(_isMips64EL))
                ->getBinding() == llvm::ELF::STB_LOCAL;
   }
 };
 
-template <class ELFT> class MipsDynamicFile : public DynamicFile<ELFT> {
-public:
-  MipsDynamicFile(const MipsLinkingContext &context, StringRef name)
-      : DynamicFile<ELFT>(context, name) {}
-};
-
 } // elf
 } // lld
 
 #endif

lib/ReaderWriter/ELF/Mips/MipsELFReader.h

struct MipsELFFileCreateTraits {
 
   template <class ELFT>
   static result_type create(std::unique_ptr<llvm::MemoryBuffer> mb,
                             MipsLinkingContext &ctx) {
     return lld::elf::MipsELFFile<ELFT>::create(std::move(mb), ctx);
   }
 };
 
-struct MipsDynamicFileCreateELFTraits {
-  typedef llvm::ErrorOr<std::unique_ptr<lld::SharedLibraryFile>> result_type;
-
-  template <class ELFT>
-  static result_type create(std::unique_ptr<llvm::MemoryBuffer> mb,
-                            MipsLinkingContext &ctx) {
-    return lld::elf::MipsDynamicFile<ELFT>::create(std::move(mb), ctx);
-  }
-};
-
 template <class ELFT>
 class MipsELFObjectReader
     : public ELFObjectReader<ELFT, MipsELFFileCreateTraits,
                              MipsLinkingContext> {
   typedef ELFObjectReader<ELFT, MipsELFFileCreateTraits, MipsLinkingContext>
       BaseReaderType;
 
 public:
loadFile(std::unique_ptr<MemoryBuffer> mb, const Registry &registry,
     return BaseReaderType::loadFile(std::move(mb), registry, result);
   }
 
 private:
   MipsELFFlagsMerger &_flagMerger;
 };
 
 template <class ELFT>
-class MipsELFDSOReader
-    : public ELFDSOReader<ELFT, MipsDynamicFileCreateELFTraits,
-                          MipsLinkingContext> {
-  typedef ELFDSOReader<ELFT, MipsDynamicFileCreateELFTraits, MipsLinkingContext>
-      BaseReaderType;
+class MipsELFDSOReader : public ELFDSOReader<ELFT, MipsLinkingContext> {
+  typedef ELFDSOReader<ELFT, MipsLinkingContext> BaseReaderType;
 
 public:
   MipsELFDSOReader(MipsLinkingContext &ctx)
       : BaseReaderType(ctx, llvm::ELF::EM_MIPS),
         _flagMerger(ctx.getELFFlagsMerger()) {}
 
   std::error_code
   loadFile(std::unique_ptr<MemoryBuffer> mb, const Registry &registry,

lib/ReaderWriter/ELF/X86/X86ELFFile.h

public:
 
   static ErrorOr<std::unique_ptr<X86ELFFile>>
   create(std::unique_ptr<MemoryBuffer> mb, X86LinkingContext &ctx) {
     return std::unique_ptr<X86ELFFile<ELFT>>(
         new X86ELFFile<ELFT>(std::move(mb), ctx));
   }
 };
 
-template <class ELFT> class X86DynamicFile : public DynamicFile<ELFT> {
-public:
-  X86DynamicFile(const X86LinkingContext &context, StringRef name)
-      : DynamicFile<ELFT>(context, name) {}
-};
-
 } // elf
 } // lld
 
 #endif // LLD_READER_WRITER_ELF_X86_X86_ELF_FILE_H

lib/ReaderWriter/ELF/X86/X86ELFReader.h

 #include "ELFReader.h"
 #include "X86ELFFile.h"
 
 namespace lld {
 namespace elf {
 
 typedef llvm::object::ELFType<llvm::support::little, 2, false> X86ELFType;
 
-struct X86DynamicFileCreateELFTraits {
-  typedef llvm::ErrorOr<std::unique_ptr<lld::SharedLibraryFile>> result_type;
-
-  template <class ELFT>
-  static result_type create(std::unique_ptr<llvm::MemoryBuffer> mb,
-                            X86LinkingContext &ctx) {
-    return lld::elf::X86DynamicFile<ELFT>::create(std::move(mb), ctx);
-  }
-};
-
 struct X86ELFFileCreateELFTraits {
   typedef llvm::ErrorOr<std::unique_ptr<lld::File>> result_type;
 
   template <class ELFT>
   static result_type create(std::unique_ptr<llvm::MemoryBuffer> mb,
                             X86LinkingContext &ctx) {
     return lld::elf::X86ELFFile<ELFT>::create(std::move(mb), ctx);
   }
 };
 
 class X86ELFObjectReader
     : public ELFObjectReader<X86ELFType, X86ELFFileCreateELFTraits,
                              X86LinkingContext> {
 public:
   X86ELFObjectReader(X86LinkingContext &ctx)
       : ELFObjectReader<X86ELFType, X86ELFFileCreateELFTraits,
                         X86LinkingContext>(ctx, llvm::ELF::EM_386) {}
 };
 
 class X86ELFDSOReader
-    : public ELFDSOReader<X86ELFType, X86DynamicFileCreateELFTraits,
-                          X86LinkingContext> {
+    : public ELFDSOReader<X86ELFType, X86LinkingContext> {
 public:
   X86ELFDSOReader(X86LinkingContext &ctx)
-      : ELFDSOReader<X86ELFType, X86DynamicFileCreateELFTraits,
+      : ELFDSOReader<X86ELFType,
                      X86LinkingContext>(ctx, llvm::ELF::EM_386) {}
 };
 
 } // namespace elf
 } // namespace lld
 
 #endif // LLD_READER_WRITER_X86_X86_ELF_READER_H

lib/ReaderWriter/ELF/X86_64/X86_64ELFFile.h

public:
 
   static ErrorOr<std::unique_ptr<X86_64ELFFile>>
   create(std::unique_ptr<MemoryBuffer> mb, X86_64LinkingContext &ctx) {
     return std::unique_ptr<X86_64ELFFile<ELFT>>(
         new X86_64ELFFile<ELFT>(std::move(mb), ctx));
   }
 };
 
-template <class ELFT> class X86_64DynamicFile : public DynamicFile<ELFT> {
-public:
-  X86_64DynamicFile(const X86_64LinkingContext &context, StringRef name)
-      : DynamicFile<ELFT>(context, name) {}
-};
-
 } // elf
 } // lld
 
 #endif // LLD_READER_WRITER_ELF_X86_64_ELF_FILE_H

lib/ReaderWriter/ELF/X86_64/X86_64ELFReader.h

 #include "ELFReader.h"
 #include "X86_64ELFFile.h"
 
 namespace lld {
 namespace elf {
 
 typedef llvm::object::ELFType<llvm::support::little, 2, true> X86_64ELFType;
 
-struct X86_64DynamicFileCreateELFTraits {
-  typedef llvm::ErrorOr<std::unique_ptr<lld::SharedLibraryFile>> result_type;
-
-  template <class ELFT>
-  static result_type create(std::unique_ptr<llvm::MemoryBuffer> mb,
-                            X86_64LinkingContext &ctx) {
-    return lld::elf::X86_64DynamicFile<ELFT>::create(std::move(mb), ctx);
-  }
-};
-
 struct X86_64ELFFileCreateELFTraits {
   typedef llvm::ErrorOr<std::unique_ptr<lld::File>> result_type;
 
   template <class ELFT>
   static result_type create(std::unique_ptr<llvm::MemoryBuffer> mb,
                             X86_64LinkingContext &ctx) {
     return lld::elf::X86_64ELFFile<ELFT>::create(std::move(mb), ctx);
   }
 };
 
 class X86_64ELFObjectReader
     : public ELFObjectReader<X86_64ELFType, X86_64ELFFileCreateELFTraits,
                              X86_64LinkingContext> {
 public:
   X86_64ELFObjectReader(X86_64LinkingContext &ctx)
       : ELFObjectReader<X86_64ELFType, X86_64ELFFileCreateELFTraits,
                         X86_64LinkingContext>(ctx, llvm::ELF::EM_X86_64) {}
 };
 
 class X86_64ELFDSOReader
-    : public ELFDSOReader<X86_64ELFType, X86_64DynamicFileCreateELFTraits,
-                          X86_64LinkingContext> {
+    : public ELFDSOReader<X86_64ELFType, X86_64LinkingContext> {
 public:
   X86_64ELFDSOReader(X86_64LinkingContext &ctx)
-      : ELFDSOReader<X86_64ELFType, X86_64DynamicFileCreateELFTraits,
+      : ELFDSOReader<X86_64ELFType,
                      X86_64LinkingContext>(ctx, llvm::ELF::EM_X86_64) {}
 };
 
 } // namespace elf
 } // namespace lld
 
 #endif // LLD_READER_WRITER_ELF_X86_64_X86_64_READER_H