LLD: ELF: Define mergeHeaderFlags to ELFLinkingContext.

[ruiu]

Summary

Only MIPS defined the member function, but this feature is not actually
MIPS-specific. Also, the dependency to the MIPS-only member function
prevented us from merging <Arch>ELF{Object,DSO}Reader.

This patch moves the feature from MipsLinkingContext to LinkingContext.

[atanasyan]

LGTM. Good solution.

include/lld/ReaderWriter/ELFLinkingContext.h

public:
 
   script::Sema &linkerScriptSema() { return _linkerScriptSema; }
   const script::Sema &linkerScriptSema() const { return _linkerScriptSema; }
 
   // Set R_ARM_TARGET1 relocation behaviour
   bool armTarget1Rel() const { return _armTarget1Rel; }
   void setArmTarget1Rel(bool value) { _armTarget1Rel = value; }
 
+  /// Each time a reader reads a new file, this member function is called
+  /// with the file's ELF magics. This is supposed to "merge" all attributes
+  /// to generate output ELF file magic. This can also reject input files
+  /// if they conflict with previous input files.
+  virtual std::error_code mergeHeaderFlags(uint8_t fileClass, uint64_t flags) {
+    return std::error_code();
+  }
+
 protected:
   ELFLinkingContext(llvm::Triple triple, std::unique_ptr<TargetHandler> handler)
       : _triple(triple), _targetHandler(std::move(handler)) {}
 
   Writer &writer() const override;
 
   /// Method to create a internal file for an undefined symbol
   std::unique_ptr<File> createUndefinedSymbolFile() const override;

lib/ReaderWriter/ELF/ELFReader.h

public:
   bool canParse(file_magic magic, StringRef,
                 const MemoryBuffer &buf) const override {
     return magic == FileMagic && elfHeader(buf)->e_machine == ContextT::machine;
   }
 
   std::error_code
   loadFile(std::unique_ptr<MemoryBuffer> mb, const class Registry &,
            std::vector<std::unique_ptr<File>> &result) const override {
+    auto &hdr = *this->elfHeader(*mb);
+    if (auto ec = _ctx.mergeHeaderFlags(hdr.getFileClass(), hdr.e_flags))
+      return ec;
+
     std::size_t maxAlignment =
         1ULL << llvm::countTrailingZeros(uintptr_t(mb->getBufferStart()));
     auto f = createELF<FileT>(llvm::object::getElfArchType(mb->getBuffer()),
                               maxAlignment, std::move(mb), _ctx);
     if (std::error_code ec = f.getError())
       return ec;
     result.push_back(std::move(*f));
     return std::error_code();

lib/ReaderWriter/ELF/Mips/MipsELFReader.h

-//===- lib/ReaderWriter/ELF/MipsELFReader.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_MIPS_MIPS_ELF_READER_H
-#define LLD_READER_WRITER_ELF_MIPS_MIPS_ELF_READER_H
-
-#include "ELFReader.h"
-#include "MipsELFFile.h"
-#include "MipsELFFlagsMerger.h"
-#include "MipsLinkingContext.h"
-
-namespace lld {
-namespace elf {
-
-template <class ELFT>
-class MipsELFObjectReader
-    : public ELFObjectReader<ELFT, MipsLinkingContext, lld::elf::MipsELFFile> {
-  typedef ELFObjectReader<ELFT, MipsLinkingContext, lld::elf::MipsELFFile>
-      BaseReaderType;
-
-public:
-  MipsELFObjectReader(MipsLinkingContext &ctx)
-      : BaseReaderType(ctx), _flagMerger(ctx.getELFFlagsMerger()) {}
-
-  std::error_code
-  loadFile(std::unique_ptr<MemoryBuffer> mb, const Registry &registry,
-           std::vector<std::unique_ptr<File>> &result) const override {
-    auto &hdr = *this->elfHeader(*mb);
-    if (auto ec = _flagMerger.mergeHeaderFlags(hdr.getFileClass(), hdr.e_flags))
-      return ec;
-    return BaseReaderType::loadFile(std::move(mb), registry, result);
-  }
-
-private:
-  MipsELFFlagsMerger &_flagMerger;
-};
-
-template <class ELFT>
-class MipsELFDSOReader : public ELFDSOReader<ELFT, MipsLinkingContext> {
-  typedef ELFDSOReader<ELFT, MipsLinkingContext> BaseReaderType;
-
-public:
-  MipsELFDSOReader(MipsLinkingContext &ctx)
-      : BaseReaderType(ctx), _flagMerger(ctx.getELFFlagsMerger()) {}
-
-  std::error_code
-  loadFile(std::unique_ptr<MemoryBuffer> mb, const Registry &registry,
-           std::vector<std::unique_ptr<File>> &result) const override {
-    auto &hdr = *this->elfHeader(*mb);
-    if (auto ec = _flagMerger.mergeHeaderFlags(hdr.getFileClass(), hdr.e_flags))
-      return ec;
-    return BaseReaderType::loadFile(std::move(mb), registry, result);
-  }
-
-private:
-  MipsELFFlagsMerger &_flagMerger;
-};
-
-} // namespace elf
-} // namespace lld
-
-#endif

lib/ReaderWriter/ELF/Mips/MipsLinkingContext.h

 typedef llvm::object::ELFType<llvm::support::big, 2, true> Mips64BEType;
 
 class MipsLinkingContext final : public ELFLinkingContext {
 public:
   static std::unique_ptr<ELFLinkingContext> create(llvm::Triple);
   static const int machine = llvm::ELF::EM_MIPS;
   MipsLinkingContext(llvm::Triple triple);
 
+  std::error_code mergeHeaderFlags(uint8_t fileClass, uint64_t flags) override;
   uint32_t getMergedELFFlags() const;
-  MipsELFFlagsMerger &getELFFlagsMerger();
   void registerRelocationNames(Registry &r) override;
 
   // ELFLinkingContext
   uint64_t getBaseAddress() const override;
   StringRef entrySymbolName() const override;
   StringRef getDefaultInterpreter() const override;
   void addPasses(PassManager &pm) override;
   bool isRelaOutputFormat() const override { return false; }

lib/ReaderWriter/ELF/Mips/MipsLinkingContext.cpp

default:
     llvm_unreachable("Unhandled arch");
   }
 }
 
 MipsLinkingContext::MipsLinkingContext(llvm::Triple triple)
     : ELFLinkingContext(triple, createTarget(triple, *this)),
       _flagsMerger(triple.isArch64Bit()) {}
 
-uint32_t MipsLinkingContext::getMergedELFFlags() const {
-  return _flagsMerger.getMergedELFFlags();
+std::error_code MipsLinkingContext::mergeHeaderFlags(uint8_t fileClass,
+                                                     uint64_t flags) {
+  return _flagsMerger.mergeHeaderFlags(fileClass, flags);
 }
 
-MipsELFFlagsMerger &MipsLinkingContext::getELFFlagsMerger() {
-  return _flagsMerger;
+uint32_t MipsLinkingContext::getMergedELFFlags() const {
+  return _flagsMerger.getMergedELFFlags();
 }
 
 uint64_t MipsLinkingContext::getBaseAddress() const {
   if (_baseAddress == 0 && getOutputELFType() == llvm::ELF::ET_EXEC)
     return getTriple().isArch64Bit() ? 0x120000000 : 0x400000;
   return _baseAddress;
 }
 

lib/ReaderWriter/ELF/Mips/MipsTargetHandler.h

 //===- lib/ReaderWriter/ELF/Mips/MipsTargetHandler.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_MIPS_MIPS_TARGET_HANDLER_H
 #define LLD_READER_WRITER_ELF_MIPS_MIPS_TARGET_HANDLER_H
 
+#include "ELFReader.h"
 #include "MipsDynamicLibraryWriter.h"
-#include "MipsELFReader.h"
+#include "MipsELFFile.h"
 #include "MipsExecutableWriter.h"
 #include "MipsLinkingContext.h"
 #include "MipsRelocationHandler.h"
 #include "MipsSectionChunks.h"
 #include "TargetLayout.h"
 #include "llvm/ADT/DenseSet.h"
 
 namespace lld {
private:
   MipsGOTSection<ELFT> *_gotSection;
   MipsPLTSection<ELFT> *_pltSection;
   llvm::Optional<AtomLayout *> _gpAtom;
   llvm::Optional<AtomLayout *> _gpDispAtom;
 };
 
 /// \brief TargetHandler for Mips
 template <class ELFT> class MipsTargetHandler final : public TargetHandler {
+  typedef ELFObjectReader<ELFT, MipsLinkingContext, lld::elf::MipsELFFile> ObjReader;
+  typedef ELFDSOReader<ELFT, MipsLinkingContext> DSOReader;
+
 public:
   MipsTargetHandler(MipsLinkingContext &ctx)
       : _ctx(ctx), _targetLayout(new MipsTargetLayout<ELFT>(ctx)),
         _relocationHandler(
             createMipsRelocationHandler<ELFT>(ctx, *_targetLayout)) {}
 
   std::unique_ptr<Reader> getObjReader() override {
-    return llvm::make_unique<MipsELFObjectReader<ELFT>>(_ctx);
+    return llvm::make_unique<ObjReader>(_ctx);
   }
 
   std::unique_ptr<Reader> getDSOReader() override {
-    return llvm::make_unique<MipsELFDSOReader<ELFT>>(_ctx);
+    return llvm::make_unique<DSOReader>(_ctx);
   }
 
   const TargetRelocationHandler &getRelocationHandler() const override {
     return *_relocationHandler;
   }
 
   std::unique_ptr<Writer> getWriter() override {
     switch (_ctx.getOutputELFType()) {