LLD: ELF: Do not use multiple inheritance

[ruiu]

Summary

Multiple inheritance is casually used here. Rewriting to not
using multiple inheritance reduces the complexity of the code
and also makes it shorter.

[shankarke]

Thanks for cleaning up.

[Eugene.Zelenko]

Committed in r233718.

lib/ReaderWriter/ELF/Hexagon/HexagonDynamicLibraryWriter.h

 #include "HexagonLinkingContext.h"
 
 namespace lld {
 namespace elf {
 
 template <typename ELFT> class HexagonTargetLayout;
 
 template <class ELFT>
-class HexagonDynamicLibraryWriter : public DynamicLibraryWriter<ELFT>,
-                                    public HexagonELFWriter<ELFT> {
+class HexagonDynamicLibraryWriter : public DynamicLibraryWriter<ELFT> {
 public:
   HexagonDynamicLibraryWriter(HexagonLinkingContext &ctx,
                               HexagonTargetLayout<ELFT> &layout);
 
 protected:
   // Add any runtime files and their atoms to the output
   virtual bool createImplicitFiles(std::vector<std::unique_ptr<File>> &);
 
   virtual void finalizeDefaultAtomValues();
 
   virtual std::error_code setELFHeader() {
     DynamicLibraryWriter<ELFT>::setELFHeader();
-    HexagonELFWriter<ELFT>::setELFHeader(*this->_elfHeader);
+    setHexagonELFHeader(*this->_elfHeader);
     return std::error_code();
   }
 
 private:
   void addDefaultAtoms() {
     _hexagonRuntimeFile->addAbsoluteAtom("_GLOBAL_OFFSET_TABLE_");
     _hexagonRuntimeFile->addAbsoluteAtom("_DYNAMIC");
   }
 
   HexagonLinkingContext &_ctx;
   HexagonTargetLayout<ELFT> &_hexagonTargetLayout;
   std::unique_ptr<HexagonRuntimeFile<ELFT>> _hexagonRuntimeFile;
 };
 
 template <class ELFT>
 HexagonDynamicLibraryWriter<ELFT>::HexagonDynamicLibraryWriter(
     HexagonLinkingContext &ctx, HexagonTargetLayout<ELFT> &layout)
-    : DynamicLibraryWriter<ELFT>(ctx, layout),
-      HexagonELFWriter<ELFT>(ctx, layout), _ctx(ctx),
+    : DynamicLibraryWriter<ELFT>(ctx, layout), _ctx(ctx),
       _hexagonTargetLayout(layout),
       _hexagonRuntimeFile(new HexagonRuntimeFile<ELFT>(ctx)) {}
 
 template <class ELFT>
 bool HexagonDynamicLibraryWriter<ELFT>::createImplicitFiles(
     std::vector<std::unique_ptr<File>> &result) {
   DynamicLibraryWriter<ELFT>::createImplicitFiles(result);
   // Add the default atoms as defined for hexagon
   addDefaultAtoms();
   result.push_back(std::move(_hexagonRuntimeFile));
   return true;
 }
 
 template <class ELFT>
 void HexagonDynamicLibraryWriter<ELFT>::finalizeDefaultAtomValues() {
   // Finalize the atom values that are part of the parent.
   DynamicLibraryWriter<ELFT>::finalizeDefaultAtomValues();
-  HexagonELFWriter<ELFT>::finalizeHexagonRuntimeAtomValues();
+  if (_ctx.isDynamic())
+    finalizeHexagonRuntimeAtomValues(_hexagonTargetLayout);
 }
 
 } // namespace elf
 } // namespace lld
 
 #endif // HEXAGON_DYNAMIC_LIBRARY_WRITER_H

lib/ReaderWriter/ELF/Hexagon/HexagonELFWriters.h

-//===- lib/ReaderWriter/ELF/Hexagon/HexagonELFWriters.h -------------------===//
-//
-//                             The LLVM Linker
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef HEXAGON_ELF_WRITERS_H
-#define HEXAGON_ELF_WRITERS_H
-
-#include "HexagonLinkingContext.h"
-#include "OutputELFWriter.h"
-
-namespace lld {
-namespace elf {
-
-template <class ELFT> class HexagonTargetLayout;
-
-template <typename ELFT> class HexagonELFWriter {
-public:
-  HexagonELFWriter(HexagonLinkingContext &ctx,
-                   HexagonTargetLayout<ELFT> &targetLayout)
-      : _ctx(ctx), _hexagonTargetLayout(targetLayout) {}
-
-protected:
-  bool setELFHeader(ELFHeader<ELFT> &elfHeader) {
-    elfHeader.e_ident(llvm::ELF::EI_VERSION, 1);
-    elfHeader.e_ident(llvm::ELF::EI_OSABI, 0);
-    elfHeader.e_version(1);
-    elfHeader.e_flags(0x3);
-    return true;
-  }
-
-  void finalizeHexagonRuntimeAtomValues() {
-    if (_ctx.isDynamic()) {
-      auto gotAtomIter =
-          _hexagonTargetLayout.findAbsoluteAtom("_GLOBAL_OFFSET_TABLE_");
-      auto gotpltSection = _hexagonTargetLayout.findOutputSection(".got.plt");
-      if (gotpltSection)
-        (*gotAtomIter)->_virtualAddr = gotpltSection->virtualAddr();
-      else
-        (*gotAtomIter)->_virtualAddr = 0;
-      auto dynamicAtomIter = _hexagonTargetLayout.findAbsoluteAtom("_DYNAMIC");
-      auto dynamicSection = _hexagonTargetLayout.findOutputSection(".dynamic");
-      if (dynamicSection)
-        (*dynamicAtomIter)->_virtualAddr = dynamicSection->virtualAddr();
-      else
-        (*dynamicAtomIter)->_virtualAddr = 0;
-    }
-  }
-
-private:
-  HexagonLinkingContext &_ctx;
-  HexagonTargetLayout<ELFT> &_hexagonTargetLayout;
-};
-
-} // elf
-} // lld
-#endif // HEXAGON_ELF_WRITERS_H

lib/ReaderWriter/ELF/Hexagon/HexagonExecutableWriter.h

 //===- lib/ReaderWriter/ELF/Hexagon/HexagonExecutableWriter.h -------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 #ifndef HEXAGON_EXECUTABLE_WRITER_H
 #define HEXAGON_EXECUTABLE_WRITER_H
 
 #include "ExecutableWriter.h"
-#include "HexagonELFWriters.h"
 #include "HexagonExecutableAtoms.h"
 #include "HexagonLinkingContext.h"
 
 namespace lld {
 namespace elf {
 
 template <typename ELFT> class HexagonTargetLayout;
 
 template <class ELFT>
-class HexagonExecutableWriter : public ExecutableWriter<ELFT>,
-                                public HexagonELFWriter<ELFT> {
+class HexagonExecutableWriter : public ExecutableWriter<ELFT> {
 public:
   HexagonExecutableWriter(HexagonLinkingContext &ctx,
                           HexagonTargetLayout<ELFT> &layout);
 
 protected:
   // Add any runtime files and their atoms to the output
   virtual bool createImplicitFiles(std::vector<std::unique_ptr<File>> &);
 
   virtual void finalizeDefaultAtomValues();
 
   virtual std::error_code setELFHeader() {
     ExecutableWriter<ELFT>::setELFHeader();
-    HexagonELFWriter<ELFT>::setELFHeader(*this->_elfHeader);
+    setHexagonELFHeader(*this->_elfHeader);
     return std::error_code();
   }
 
 private:
   void addDefaultAtoms() {
     _hexagonRuntimeFile->addAbsoluteAtom("_SDA_BASE_");
     if (this->_ctx.isDynamic()) {
       _hexagonRuntimeFile->addAbsoluteAtom("_GLOBAL_OFFSET_TABLE_");
       _hexagonRuntimeFile->addAbsoluteAtom("_DYNAMIC");
     }
   }
 
   HexagonLinkingContext &_ctx;
   HexagonTargetLayout<ELFT> &_hexagonTargetLayout;
   std::unique_ptr<HexagonRuntimeFile<ELFT>> _hexagonRuntimeFile;
 };
 
 template <class ELFT>
 HexagonExecutableWriter<ELFT>::HexagonExecutableWriter(
     HexagonLinkingContext &ctx, HexagonTargetLayout<ELFT> &layout)
-    : ExecutableWriter<ELFT>(ctx, layout), HexagonELFWriter<ELFT>(ctx, layout),
-      _ctx(ctx), _hexagonTargetLayout(layout),
+    : ExecutableWriter<ELFT>(ctx, layout), _ctx(ctx),
+      _hexagonTargetLayout(layout),
       _hexagonRuntimeFile(new HexagonRuntimeFile<ELFT>(ctx)) {}
 
 template <class ELFT>
 bool HexagonExecutableWriter<ELFT>::createImplicitFiles(
     std::vector<std::unique_ptr<File>> &result) {
   ExecutableWriter<ELFT>::createImplicitFiles(result);
   // Add the default atoms as defined for hexagon
   addDefaultAtoms();
   result.push_back(std::move(_hexagonRuntimeFile));
   return true;
 }
 
 template <class ELFT>
 void HexagonExecutableWriter<ELFT>::finalizeDefaultAtomValues() {
   // Finalize the atom values that are part of the parent.
   ExecutableWriter<ELFT>::finalizeDefaultAtomValues();
   auto sdabaseAtomIter = _hexagonTargetLayout.findAbsoluteAtom("_SDA_BASE_");
   (*sdabaseAtomIter)->_virtualAddr =
       _hexagonTargetLayout.getSDataSection()->virtualAddr();
-  HexagonELFWriter<ELFT>::finalizeHexagonRuntimeAtomValues();
+  if (_ctx.isDynamic())
+    finalizeHexagonRuntimeAtomValues(_hexagonTargetLayout);
 }
 
 } // namespace elf
 } // namespace lld
 
 #endif // HEXAGON_EXECUTABLE_WRITER_H

lib/ReaderWriter/ELF/Hexagon/HexagonLinkingContext.h

 //===- lib/ReaderWriter/ELF/Hexagon/HexagonLinkingContext.h ---------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_READER_WRITER_ELF_HEXAGON_HEXAGON_LINKING_CONTEXT_H
 #define LLD_READER_WRITER_ELF_HEXAGON_HEXAGON_LINKING_CONTEXT_H
 
+#include "OutputELFWriter.h"
 #include "lld/ReaderWriter/ELFLinkingContext.h"
 #include "llvm/Object/ELF.h"
 #include "llvm/Support/ELF.h"
 
 namespace lld {
 namespace elf {
 
 typedef llvm::object::ELFType<llvm::support::little, 2, false> HexagonELFType;
bool isRelativeReloc(const Reference &r) const override {
     case llvm::ELF::R_HEX_RELATIVE:
       return true;
     default:
       return false;
     }
   }
 };
 
+template <class ELFT> void setHexagonELFHeader(ELFHeader<ELFT> &elfHeader) {
+  elfHeader.e_ident(llvm::ELF::EI_VERSION, 1);
+  elfHeader.e_ident(llvm::ELF::EI_OSABI, 0);
+  elfHeader.e_version(1);
+  elfHeader.e_flags(0x3);
+}
+
 } // elf
 } // lld
 
 #endif // LLD_READER_WRITER_ELF_HEXAGON_HEXAGON_LINKING_CONTEXT_H

lib/ReaderWriter/ELF/Hexagon/HexagonTargetHandler.h

 private:
   llvm::BumpPtrAllocator _alloc;
   static const Registry::KindStrings kindStrings[];
   HexagonLinkingContext &_ctx;
   std::unique_ptr<HexagonRuntimeFile<HexagonELFType> > _hexagonRuntimeFile;
   std::unique_ptr<HexagonTargetLayout<HexagonELFType>> _hexagonTargetLayout;
   std::unique_ptr<HexagonTargetRelocationHandler> _hexagonRelocationHandler;
 };
+
+template <class ELFT>
+void finalizeHexagonRuntimeAtomValues(HexagonTargetLayout<ELFT> &layout) {
+  auto gotAtomIter = layout.findAbsoluteAtom("_GLOBAL_OFFSET_TABLE_");
+  auto gotpltSection = layout.findOutputSection(".got.plt");
+  if (gotpltSection)
+    (*gotAtomIter)->_virtualAddr = gotpltSection->virtualAddr();
+  else
+    (*gotAtomIter)->_virtualAddr = 0;
+  auto dynamicAtomIter = layout.findAbsoluteAtom("_DYNAMIC");
+  auto dynamicSection = layout.findOutputSection(".dynamic");
+  if (dynamicSection)
+    (*dynamicAtomIter)->_virtualAddr = dynamicSection->virtualAddr();
+  else
+    (*dynamicAtomIter)->_virtualAddr = 0;
+}
+
 } // end namespace elf
 } // end namespace lld
 
 #endif