[lld] Reapply "[ELF] Only mark as DT_NEEDED libs that are strictly necessary"

[rafaelauler]

Summary

When committed in r219353, this patch originally caused problems because I have had only tested it using an optimized build. However, in debug builds, LLD (in Driver.cpp) adds two additional passes that serializes all atoms via YAML and reads it back. Since I have changed ObjectAtom to hold a new reference, the serialization was removing the extra data.

I decided to implement this in another way, similar to the original MIPS way, by using a StringSet that holds the names of all copied atoms instead of directly holding a reference to the copied atom. In this way, I simplify this patch and eliminate the necessity of changing the DefinedAtom hierarchy to hold a new data.

[rafaelauler]

Thanks Shankar. Committed r219449.

include/lld/ReaderWriter/ELFLinkingContext.h

public:
   /// This table is evaluated at loadtime by the dynamic loader and is
   /// referenced by the DT_RELA{,ENT,SZ} entries in the dynamic table.
   /// Relocations that return true will be added to the dynamic relocation
   /// table.
   virtual bool isDynamicRelocation(const DefinedAtom &,
                                    const Reference &) const {
     return false;
   }
+
+  /// \brief Is this a copy relocation?
+  ///
+  /// If this is a copy relocation, its target must be an ObjectAtom. We must
+  /// include in DT_NEEDED the name of the library where this object came from.
+  virtual bool isCopyRelocation(const Reference &) const {
+    return false;
+  }
+
   bool validateImpl(raw_ostream &diagnostics) override;
 
   /// \brief Does the linker allow dynamic libraries to be linked with?
   /// This is true when the output mode of the executable is set to be
   /// having NMAGIC/OMAGIC
   virtual bool allowLinkWithDynamicLibraries() const {
     if (_outputMagic == OutputMagic::NMAGIC ||
         _outputMagic == OutputMagic::OMAGIC || _noAllowDynamicLibraries)

lib/ReaderWriter/ELF/AArch64/AArch64LinkingContext.h

bool isDynamicRelocation(const DefinedAtom &,
     case llvm::ELF::R_AARCH64_TLSDESC:
     case llvm::ELF::R_AARCH64_IRELATIVE:
       return true;
     default:
       return false;
     }
   }
 
+  bool isCopyRelocation(const Reference &r) const override {
+    if (r.kindNamespace() != Reference::KindNamespace::ELF)
+      return false;
+    assert(r.kindArch() == Reference::KindArch::AArch64);
+    if (r.kindValue() == llvm::ELF::R_AARCH64_COPY)
+      return true;
+    return false;
+  }
+
   bool isPLTRelocation(const DefinedAtom &,
                                const Reference &r) const override {
     if (r.kindNamespace() != Reference::KindNamespace::ELF)
       return false;
     assert(r.kindArch() == Reference::KindArch::AArch64);
     switch (r.kindValue()) {
     case llvm::ELF::R_AARCH64_JUMP_SLOT:
     case llvm::ELF::R_AARCH64_IRELATIVE:

lib/ReaderWriter/ELF/DefaultLayout.h

 //===- lib/ReaderWriter/ELF/DefaultLayout.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_DEFAULT_LAYOUT_H
 #define LLD_READER_WRITER_ELF_DEFAULT_LAYOUT_H
 
+#include "Atoms.h"
 #include "Chunk.h"
 #include "HeaderChunks.h"
 #include "Layout.h"
 #include "SectionChunks.h"
 #include "SegmentChunks.h"
 
 #include "lld/Core/Instrumentation.h"
 #include "lld/Core/STDExtras.h"
for (const auto &phdr : *_programHeader)
         return phdr->p_memsz;
     return 0;
   }
 
   bool isReferencedByDefinedAtom(const Atom *a) const {
     return _referencedDynAtoms.count(a);
   }
 
+  bool isCopied(const SharedLibraryAtom *sla) const {
+    return _copiedDynSymNames.count(sla->name());
+  }
+
 protected:
   /// \brief Allocate a new section.
   virtual AtomSection<ELFT> *createSection(
       StringRef name, int32_t contentType,
       DefinedAtom::ContentPermissions contentPermissions,
       SectionOrder sectionOrder);
 
 protected:
   llvm::BumpPtrAllocator _allocator;
   SectionMapT _sectionMap;
   MergedSectionMapT _mergedSectionMap;
   AdditionalSegmentMapT _additionalSegmentMap;
   SegmentMapT _segmentMap;
   std::vector<Chunk<ELFT> *> _sections;
   std::vector<Segment<ELFT> *> _segments;
   std::vector<MergedSections<ELFT> *> _mergedSections;
   ELFHeader<ELFT> *_elfHeader;
   ProgramHeader<ELFT> *_programHeader;
   LLD_UNIQUE_BUMP_PTR(RelocationTable<ELFT>) _dynamicRelocationTable;
   LLD_UNIQUE_BUMP_PTR(RelocationTable<ELFT>) _pltRelocationTable;
   std::vector<lld::AtomLayout *> _absoluteAtoms;
   AtomSetT _referencedDynAtoms;
+  llvm::StringSet<> _copiedDynSymNames;
   const ELFLinkingContext &_context;
 };
 
 /// \brief Handle linker scripts. TargetLayouts would derive
 /// from this class to override some of the functionalities.
 template<class ELFT>
 class ScriptLayout: public DefaultLayout<ELFT> {
 public:
for (const auto &reloc : *definedAtom) {
 
       if (!reloc->target())
         continue;
 
       //Ignore undefined atoms that are not target of dynamic relocations
       if (isa<UndefinedAtom>(reloc->target()) && isLocalReloc)
         continue;
 
+      if (_context.isCopyRelocation(*reloc)) {
+        _copiedDynSymNames.insert(definedAtom->name());
+        continue;
+      }
+
       _referencedDynAtoms.insert(reloc->target());
     }
 
     return section->appendAtom(atom);
   } else if (const AbsoluteAtom *absoluteAtom = dyn_cast<AbsoluteAtom>(atom)) {
     // Absolute atoms are not part of any section, they are global for the whole
     // link
     _absoluteAtoms.push_back(new (_allocator)

lib/ReaderWriter/ELF/ExecutableWriter.h

ExecutableWriter(const ELFLinkingContext &context, TargetLayout<ELFT> &layout)
         _runtimeFile(new CRuntimeFile<ELFT>(context)) {}
 
 protected:
   virtual void buildDynamicSymbolTable(const File &file);
   virtual void addDefaultAtoms();
   virtual bool createImplicitFiles(std::vector<std::unique_ptr<File> > &);
   virtual void finalizeDefaultAtomValues();
   virtual void createDefaultSections();
+
+  virtual bool isNeededTagRequired(const SharedLibraryAtom *sla) const {
+    return this->_layout.isCopied(sla);
+  }
+
   LLD_UNIQUE_BUMP_PTR(InterpSection<ELFT>) _interpSection;
   std::unique_ptr<CRuntimeFile<ELFT> > _runtimeFile;
 };
 
 //===----------------------------------------------------------------------===//
 //  ExecutableWriter
 //===----------------------------------------------------------------------===//
 template<class ELFT>

lib/ReaderWriter/ELF/Mips/MipsDynamicLibraryWriter.h

protected:
   void finalizeDefaultAtomValues() override;
 
   std::error_code setELFHeader() override {
     DynamicLibraryWriter<ELFT>::setELFHeader();
     _writeHelper.setELFHeader(*this->_elfHeader);
     return std::error_code();
   }
 
-  bool isNeededTagRequired(const SharedLibraryAtom *sla) const override {
-    return _writeHelper.isNeededTagRequired(sla);
-  }
-
   LLD_UNIQUE_BUMP_PTR(DynamicTable<ELFT>) createDynamicTable();
 
   LLD_UNIQUE_BUMP_PTR(DynamicSymbolTable<ELFT>) createDynamicSymbolTable();
 
 private:
   MipsELFWriter<ELFT> _writeHelper;
   MipsLinkingContext &_mipsContext;
   MipsTargetLayout<Mips32ElELFType> &_mipsTargetLayout;

lib/ReaderWriter/ELF/Mips/MipsELFWriters.h

if (_ctx.isDynamic()) {
       file->addAbsoluteAtom("_GLOBAL_OFFSET_TABLE_");
       file->addAbsoluteAtom("_gp");
       file->addAbsoluteAtom("_gp_disp");
       file->addAbsoluteAtom("__gnu_local_gp");
     }
     return file;
   }
 
-  bool isNeededTagRequired(const SharedLibraryAtom *sla) const {
-    return _targetLayout.isReferencedByDefinedAtom(sla) ||
-           _targetLayout.isCopied(sla);
-  }
-
 private:
   MipsLinkingContext &_ctx;
   MipsTargetLayout<ELFT> &_targetLayout;
 
   void setAtomValue(StringRef name, uint64_t value) {
     auto atom = _targetLayout.findAbsoluteAtom(name);
     assert(atom != _targetLayout.absoluteAtoms().end());
     (*atom)->_virtualAddr = value;
   }
 };
 
 } // elf
 } // lld
 
 #endif

lib/ReaderWriter/ELF/Mips/MipsExecutableWriter.h

protected:
   void finalizeDefaultAtomValues() override;
 
   std::error_code setELFHeader() override {
     ExecutableWriter<ELFT>::setELFHeader();
     _writeHelper.setELFHeader(*this->_elfHeader);
     return std::error_code();
   }
 
-  bool isNeededTagRequired(const SharedLibraryAtom *sla) const override {
-    return _writeHelper.isNeededTagRequired(sla);
-  }
-
   LLD_UNIQUE_BUMP_PTR(DynamicTable<ELFT>) createDynamicTable();
 
   LLD_UNIQUE_BUMP_PTR(DynamicSymbolTable<ELFT>) createDynamicSymbolTable();
 
 private:
   MipsELFWriter<ELFT> _writeHelper;
   MipsLinkingContext &_mipsContext;
   MipsTargetLayout<Mips32ElELFType> &_mipsTargetLayout;

lib/ReaderWriter/ELF/Mips/MipsLinkingContext.h

public:
   bool isLittleEndian() const override;
   uint64_t getBaseAddress() const override;
   StringRef entrySymbolName() const override;
   StringRef getDefaultInterpreter() const override;
   void addPasses(PassManager &pm) override;
   bool isRelaOutputFormat() const override { return false; }
   bool isDynamicRelocation(const DefinedAtom &,
                            const Reference &r) const override;
+  bool isCopyRelocation(const Reference &r) const override;
   bool isPLTRelocation(const DefinedAtom &, const Reference &r) const override;
 };
 
 } // elf
 } // lld
 
 #endif

lib/ReaderWriter/ELF/Mips/MipsLinkingContext.cpp

bool MipsLinkingContext::isDynamicRelocation(const DefinedAtom &,
   case llvm::ELF::R_MIPS_TLS_DTPREL32:
   case llvm::ELF::R_MIPS_TLS_TPREL32:
     return true;
   default:
     return false;
   }
 }
 
+bool MipsLinkingContext::isCopyRelocation(const Reference &r) const {
+  if (r.kindNamespace() != Reference::KindNamespace::ELF)
+    return false;
+  assert(r.kindArch() == Reference::KindArch::Mips);
+  if (r.kindValue() == llvm::ELF::R_MIPS_COPY)
+    return true;
+  return false;
+}
+
 bool MipsLinkingContext::isPLTRelocation(const DefinedAtom &,
                                          const Reference &r) const {
   if (r.kindNamespace() != Reference::KindNamespace::ELF)
     return false;
   assert(r.kindArch() == Reference::KindArch::Mips);
   switch (r.kindValue()) {
   case llvm::ELF::R_MIPS_JUMP_SLOT:
     return true;
   default:
     return false;
   }
 }

lib/ReaderWriter/ELF/Mips/MipsTargetHandler.h

Layout::SegmentType getSegmentType(Section<ELFType> *section) const override {
     case DefaultLayout<ELFType>::ORDER_CTORS:
     case DefaultLayout<ELFType>::ORDER_DTORS:
       return llvm::ELF::PT_LOAD;
     default:
       return TargetLayout<ELFType>::getSegmentType(section);
     }
   }
 
-  ErrorOr<const lld::AtomLayout &> addAtom(const Atom *atom) override {
-    // Maintain:
-    // 1. Set of shared library atoms referenced by regular defined atoms.
-    // 2. Set of shared library atoms have corresponding R_MIPS_COPY copies.
-    if (const auto *da = dyn_cast<DefinedAtom>(atom))
-      for (const Reference *ref : *da) {
-        if (ref->kindNamespace() == lld::Reference::KindNamespace::ELF) {
-          assert(ref->kindArch() == Reference::KindArch::Mips);
-          if (ref->kindValue() == llvm::ELF::R_MIPS_COPY)
-            _copiedDynSymNames.insert(atom->name());
-        }
-      }
-
-    return TargetLayout<ELFType>::addAtom(atom);
-  }
-
-  bool isCopied(const SharedLibraryAtom *sla) const {
-    return _copiedDynSymNames.count(sla->name());
-  }
-
   /// \brief GP offset relative to .got section.
   uint64_t getGPOffset() const { return 0x7FF0; }
 
   /// \brief Get '_gp' symbol atom layout.
   AtomLayout *getGP() {
     if (!_gpAtom.hasValue()) {
       auto atom = this->findAbsoluteAtom("_gp");
       _gpAtom = atom != this->absoluteAtoms().end() ? *atom : nullptr;
public:
   }
 
 private:
   llvm::BumpPtrAllocator _alloc;
   MipsGOTSection<ELFType> *_gotSection;
   MipsPLTSection<ELFType> *_pltSection;
   llvm::Optional<AtomLayout *> _gpAtom;
   llvm::Optional<AtomLayout *> _gpDispAtom;
-  llvm::StringSet<> _copiedDynSymNames;
 };
 
 /// \brief Mips Runtime file.
 template <class ELFType>
 class MipsRuntimeFile final : public CRuntimeFile<ELFType> {
 public:
   MipsRuntimeFile(const MipsLinkingContext &ctx)
       : CRuntimeFile<ELFType>(ctx, "Mips runtime file") {}

lib/ReaderWriter/ELF/OutputELFWriter.h

protected:
 
   /// \brief Create entry in the dynamic symbols table for this atom.
   virtual bool isDynSymEntryRequired(const SharedLibraryAtom *sla) const {
     return _layout.isReferencedByDefinedAtom(sla);
   }
 
   /// \brief Create DT_NEEDED dynamic tage for the shared library.
   virtual bool isNeededTagRequired(const SharedLibraryAtom *sla) const {
-    return true;
+    return false;
   }
 
   llvm::BumpPtrAllocator _alloc;
 
   const ELFLinkingContext &_context;
   TargetHandler<ELFT> &_targetHandler;
 
   typedef llvm::DenseMap<const Atom *, uint64_t> AtomToAddress;
void OutputELFWriter<ELFT>::buildStaticSymbolTable(const File &file) {
   for (const UndefinedAtom *a : file.undefined())
     _symtab->addSymbol(a, ELF::SHN_UNDEF);
 }
 
 template <class ELFT>
 void OutputELFWriter<ELFT>::buildDynamicSymbolTable(const File &file) {
   ScopedTask task(getDefaultDomain(), "buildDynamicSymbolTable");
   for (const auto &sla : file.sharedLibrary()) {
-    if (isDynSymEntryRequired(sla))
+    if (isDynSymEntryRequired(sla)) {
       _dynamicSymbolTable->addSymbol(sla, ELF::SHN_UNDEF);
+      _soNeeded.insert(sla->loadName());
+      continue;
+    }
     if (isNeededTagRequired(sla))
       _soNeeded.insert(sla->loadName());
   }
   // Never mark the dynamic linker as DT_NEEDED
   _soNeeded.erase(sys::path::filename(_context.getInterpreter()));
   for (const auto &loadName : _soNeeded) {
     Elf_Dyn dyn;
     dyn.d_tag = DT_NEEDED;

lib/ReaderWriter/ELF/X86_64/X86_64LinkingContext.h

bool isDynamicRelocation(const DefinedAtom &,
     case llvm::ELF::R_X86_64_DTPMOD64:
     case llvm::ELF::R_X86_64_DTPOFF64:
       return true;
     default:
       return false;
     }
   }
 
+  bool isCopyRelocation(const Reference &r) const override {
+    if (r.kindNamespace() != Reference::KindNamespace::ELF)
+      return false;
+    assert(r.kindArch() == Reference::KindArch::x86_64);
+    if (r.kindValue() == llvm::ELF::R_X86_64_COPY)
+      return true;
+    return false;
+  }
+
   virtual bool isPLTRelocation(const DefinedAtom &,
                                const Reference &r) const override {
     if (r.kindNamespace() != Reference::KindNamespace::ELF)
       return false;
     assert(r.kindArch() == Reference::KindArch::x86_64);
     switch (r.kindValue()) {
     case llvm::ELF::R_X86_64_JUMP_SLOT:
     case llvm::ELF::R_X86_64_IRELATIVE: