LLD: Use using to inherit constructors. No functionality change.

[ruiu]

Summary

There are some empty classes that only inherit constructors.
They look dubious, but I'll leave them as they are.

[shankarke]

LGTM. nice to know about this type of usage.

[atanasyan]

LGTM

Just for information - when I tried to use inherit constructor last time at rL233057 some Windows build-bots could not compile the code. I had to revert back to the regular ctor at rL233058. But I did not investigate the real reason of the problem.

[ruiu]

Simon, thanks for the info. I tried to compile this with MSVC 2013 and found that this doesn't compile. Looks like MSVC 2013 doesn't support constructor inheritance at all. https://msdn.microsoft.com/en-us/library/vstudio/hh567368.aspx. Sigh.

Abandoning.

[meadori]

LGTM.

lib/ReaderWriter/ELF/AArch64/AArch64ELFFile.h

 
 namespace lld {
 namespace elf {
 
 class AArch64LinkingContext;
 
 template <class ELFT> class AArch64ELFFile : public ELFFile<ELFT> {
 public:
-  AArch64ELFFile(std::unique_ptr<MemoryBuffer> mb, AArch64LinkingContext &ctx)
-      : ELFFile<ELFT>(std::move(mb), ctx) {}
+  using ELFFile<ELFT>::ELFFile;
 
   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) {}
+  using DynamicFile<ELFT>::DynamicFile;
 };
 
 } // elf
 } // lld
 
 #endif // LLD_READER_WRITER_ELF_AARCH64_AARCH64_ELF_FILE_H

lib/ReaderWriter/ELF/ARM/ARMELFFile.h

 
 class ARMLinkingContext;
 
 template <class ELFT> class ARMELFDefinedAtom : public ELFDefinedAtom<ELFT> {
   typedef llvm::object::Elf_Sym_Impl<ELFT> Elf_Sym;
   typedef llvm::object::Elf_Shdr_Impl<ELFT> Elf_Shdr;
 
 public:
-  ARMELFDefinedAtom(const ELFFile<ELFT> &file, StringRef symbolName,
-                 StringRef sectionName, const Elf_Sym *symbol,
-                 const Elf_Shdr *section, ArrayRef<uint8_t> contentData,
-                 unsigned int referenceStart, unsigned int referenceEnd,
-                 std::vector<ELFReference<ELFT> *> &referenceList)
-      : ELFDefinedAtom<ELFT>(file, symbolName, sectionName, symbol, section,
-                             contentData, referenceStart, referenceEnd,
-                             referenceList) {}
+  using ELFDefinedAtom<ELFT>::ELFDefinedAtom;
 
   bool isThumbFunc(const Elf_Sym *symbol) const {
     return symbol->getType() == llvm::ELF::STT_FUNC &&
         (static_cast<uint64_t>(symbol->st_value) & 0x1);
   }
 
   /// Correct st_value for symbols addressing Thumb instructions
   /// by removing its zero bit.
   uint64_t getSymbolValue(const Elf_Sym *symbol) const override {
     const auto value = static_cast<uint64_t>(symbol->st_value);
     return isThumbFunc(symbol) ? value & ~0x1 : value;
   }
 
   DefinedAtom::CodeModel codeModel() const override {
     if (isThumbFunc(this->_symbol))
       return DefinedAtom::codeARMThumb;
     return DefinedAtom::codeNA;
   }
 };
 
 template <class ELFT> class ARMELFFile : public ELFFile<ELFT> {
 public:
-  ARMELFFile(std::unique_ptr<MemoryBuffer> mb, ARMLinkingContext &ctx)
-      : ELFFile<ELFT>(std::move(mb), ctx) {}
+  using ELFFile<ELFT>::ELFFile;
 
   static ErrorOr<std::unique_ptr<ARMELFFile>>
   create(std::unique_ptr<MemoryBuffer> mb, ARMLinkingContext &ctx) {
     return std::unique_ptr<ARMELFFile<ELFT>>(
         new ARMELFFile<ELFT>(std::move(mb), ctx));
   }
 
 private:
ErrorOr<ELFDefinedAtom<ELFT> *> handleDefinedSymbol(StringRef symName,
     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) {}
+  using DynamicFile<ELFT>::DynamicFile;
 };
 
 } // elf
 } // lld
 
 #endif // LLD_READER_WRITER_ELF_ARM_ARM_ELF_FILE_H

lib/ReaderWriter/ELF/ARM/ARMRelocationPass.cpp

public:
   StringRef name() const override { return _name; }
   std::string _name;
 };
 
 /// \brief Atoms that hold veneer for statically relocated
 /// ARM B/BL instructions.
 class Veneer_ARM_B_BL_StaticAtom : public VeneerAtom {
 public:
-  Veneer_ARM_B_BL_StaticAtom(const File &f, StringRef secName)
-      : VeneerAtom(f, secName) {}
+  using VeneerAtom::VeneerAtom;
 
   ArrayRef<uint8_t> rawContent() const override {
     return llvm::makeArrayRef(Veneer_ARM_B_BL_StaticAtomContent);
   }
 };
 
 /// \brief Atoms that hold veneer for statically relocated
 /// Thumb B/BL instructions.
 class Veneer_THM_B_BL_StaticAtom : public VeneerAtom {
 public:
-  Veneer_THM_B_BL_StaticAtom(const File &f, StringRef secName)
-      : VeneerAtom(f, secName) {}
+  using VeneerAtom::VeneerAtom;
 
   DefinedAtom::CodeModel codeModel() const override {
     return DefinedAtom::codeARMThumb;
   }
 
   ArrayRef<uint8_t> rawContent() const override {
     return llvm::makeArrayRef(Veneer_THM_B_BL_StaticAtomContent);
   }
 };
 
 /// \brief Atoms that are used by ARM dynamic linking
 class ARMGOTAtom : public GOTAtom {
 public:
-  ARMGOTAtom(const File &f, StringRef secName) : GOTAtom(f, secName) {}
+  using GOTAtom::GOTAtom;
 
   ArrayRef<uint8_t> rawContent() const override {
     return llvm::makeArrayRef(ARMGotAtomContent);
   }
 
   Alignment alignment() const override { return Alignment(2); }
 };
 

lib/ReaderWriter/ELF/Hexagon/HexagonELFFile.h

 template <class ELFT> class HexagonELFFile;
 
 template <class ELFT>
 class HexagonELFDefinedAtom : public ELFDefinedAtom<ELFT> {
   typedef llvm::object::Elf_Sym_Impl<ELFT> Elf_Sym;
   typedef llvm::object::Elf_Shdr_Impl<ELFT> Elf_Shdr;
 
 public:
-  HexagonELFDefinedAtom(const HexagonELFFile<ELFT> &file, StringRef symbolName,
-                        StringRef sectionName, const Elf_Sym *symbol,
-                        const Elf_Shdr *section, ArrayRef<uint8_t> contentData,
-                        unsigned int referenceStart, unsigned int referenceEnd,
-                        std::vector<ELFReference<ELFT> *> &referenceList)
-      : ELFDefinedAtom<ELFT>(file, symbolName, sectionName, symbol, section,
-                             contentData, referenceStart, referenceEnd,
-                             referenceList) {}
+  using ELFDefinedAtom<ELFT>::ELFDefinedAtom;
 
   virtual DefinedAtom::ContentType contentType() const {
     if (this->_contentType != DefinedAtom::typeUnknown)
       return this->_contentType;
     else if (this->_section->sh_flags & llvm::ELF::SHF_HEX_GPREL) {
       if (this->_section->sh_type == llvm::ELF::SHT_NOBITS)
         return (this->_contentType = DefinedAtom::typeZeroFillFast);
       else
public:
   }
 };
 
 template <class ELFT> class HexagonELFCommonAtom : public ELFCommonAtom<ELFT> {
   typedef llvm::object::Elf_Sym_Impl<ELFT> Elf_Sym;
   typedef llvm::object::Elf_Shdr_Impl<ELFT> Elf_Shdr;
 
 public:
-  HexagonELFCommonAtom(const HexagonELFFile<ELFT> &file, StringRef symbolName,
-                       const Elf_Sym *symbol)
-      : ELFCommonAtom<ELFT>(file, symbolName, symbol) {}
+  using ELFCommonAtom<ELFT>::ELFCommonAtom;
 
   virtual bool isSmallCommonSymbol() const {
     switch (this->_symbol->st_shndx) {
     // Common symbols
     case llvm::ELF::SHN_HEXAGON_SCOMMON:
     case llvm::ELF::SHN_HEXAGON_SCOMMON_1:
     case llvm::ELF::SHN_HEXAGON_SCOMMON_2:
     case llvm::ELF::SHN_HEXAGON_SCOMMON_4:
public:
   }
 };
 
 template <class ELFT> class HexagonELFFile : public ELFFile<ELFT> {
   typedef llvm::object::Elf_Sym_Impl<ELFT> Elf_Sym;
   typedef llvm::object::Elf_Shdr_Impl<ELFT> Elf_Shdr;
 
 public:
-  HexagonELFFile(std::unique_ptr<MemoryBuffer> mb, HexagonLinkingContext &ctx)
-      : ELFFile<ELFT>(std::move(mb), ctx) {}
+  using ELFFile<ELFT>::ELFFile;
 
   static ErrorOr<std::unique_ptr<HexagonELFFile>>
   create(std::unique_ptr<MemoryBuffer> mb, HexagonLinkingContext &ctx) {
     return std::unique_ptr<HexagonELFFile<ELFT>>(
         new HexagonELFFile<ELFT>(std::move(mb), ctx));
   }
 
   bool isCommonSymbol(const Elf_Sym *symbol) const override {
public:
   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) {}
+  using DynamicFile<ELFT>::DynamicFile;
 };
 
 } // elf
 } // lld
 
 #endif // LLD_READER_WRITER_ELF_HEXAGON_ELF_FILE_H

lib/ReaderWriter/ELF/Mips/MipsELFFile.h

 template <class ELFT> class MipsELFFile;
 
 template <class ELFT>
 class MipsELFDefinedAtom : public ELFDefinedAtom<ELFT> {
   typedef llvm::object::Elf_Sym_Impl<ELFT> Elf_Sym;
   typedef llvm::object::Elf_Shdr_Impl<ELFT> Elf_Shdr;
 
 public:
-  MipsELFDefinedAtom(const MipsELFFile<ELFT> &file, StringRef symbolName,
-                     StringRef sectionName, const Elf_Sym *symbol,
-                     const Elf_Shdr *section, ArrayRef<uint8_t> contentData,
-                     unsigned int referenceStart, unsigned int referenceEnd,
-                     std::vector<ELFReference<ELFT> *> &referenceList)
-      : ELFDefinedAtom<ELFT>(file, symbolName, sectionName, symbol, section,
-                             contentData, referenceStart, referenceEnd,
-                             referenceList) {}
+  using ELFDefinedAtom<ELFT>::ELFDefinedAtom;
 
   const MipsELFFile<ELFT>& file() const override {
     return static_cast<const MipsELFFile<ELFT> &>(this->_owningFile);
   }
 
   DefinedAtom::CodeModel codeModel() const override {
     switch (this->_symbol->st_other & llvm::ELF::STO_MIPS_MIPS16) {
     case llvm::ELF::STO_MIPS_MIPS16:
private:
 
   template <class R> static uint32_t extractTag(const R &rel) {
     return (rel.getType(_isMips64EL) & 0xffffff00) >> 8;
   }
 };
 
 template <class ELFT> class MipsELFFile : public ELFFile<ELFT> {
 public:
-  MipsELFFile(std::unique_ptr<MemoryBuffer> mb, MipsLinkingContext &ctx)
-      : ELFFile<ELFT>(std::move(mb), ctx) {}
+  using ELFFile<ELFT>::ELFFile;
 
   static ErrorOr<std::unique_ptr<MipsELFFile>>
   create(std::unique_ptr<MemoryBuffer> mb, MipsLinkingContext &ctx) {
     return std::unique_ptr<MipsELFFile<ELFT>>(
         new MipsELFFile<ELFT>(std::move(mb), ctx));
   }
 
   bool isPIC() const {
private:
   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) {}
+  using DynamicFile<ELFT>::DynamicFile;
 };
 
 } // elf
 } // lld
 
 #endif

lib/ReaderWriter/ELF/X86/X86ELFFile.h

 
 namespace lld {
 namespace elf {
 
 class X86LinkingContext;
 
 template <class ELFT> class X86ELFFile : public ELFFile<ELFT> {
 public:
-  X86ELFFile(std::unique_ptr<MemoryBuffer> mb, X86LinkingContext &ctx)
-      : ELFFile<ELFT>(std::move(mb), ctx) {}
+  using ELFFile<ELFT>::ELFFile;
 
   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) {}
+  using DynamicFile<ELFT>::DynamicFile;
 };
 
 } // elf
 } // lld
 
 #endif // LLD_READER_WRITER_ELF_X86_X86_ELF_FILE_H

lib/ReaderWriter/ELF/X86_64/X86_64ELFFile.h

 
 namespace lld {
 namespace elf {
 
 class X86_64LinkingContext;
 
 template <class ELFT> class X86_64ELFFile : public ELFFile<ELFT> {
 public:
-  X86_64ELFFile(std::unique_ptr<MemoryBuffer> mb, X86_64LinkingContext &ctx)
-      : ELFFile<ELFT>(std::move(mb), ctx) {}
+  using ELFFile<ELFT>::ELFFile;
 
   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) {}
+  using DynamicFile<ELFT>::DynamicFile;
 };
 
 } // elf
 } // lld
 
 #endif // LLD_READER_WRITER_ELF_X86_64_ELF_FILE_H