Remove dead flags.

[ruiu]

Summary

searchArchivesToOverrideTentativeDefinitions and
searchSharedLibrariesToOverrideTentativeDefinitions are always false.
For the dead flags, we have a fairly large amount of code which is
never be executed.

[• rafael]

Gosh, looks like this is dead since it was added in r173117 :-(

+1 for deleting it, but Lang get the final say in this code.

Cheers,
Rafael

[• rafael]

Sorry, my mistake. It is dead ever since r146844, the very first commit :-(

Cheers,
Rafael

[• rafael]

ping.

Lang, is this OK?

Cheers,
Rafael

[lhames]

Thanks for the ping, and sorry for the delayed review Rui. This looks good to me.

[ruiu]

Submitted as r264653.

[Eugene.Zelenko]

Committed in r264653.

include/lld/Core/ArchiveLibraryFile.h

 class ArchiveLibraryFile : public File {
 public:
   static bool classof(const File *f) {
     return f->kind() == kindArchiveLibrary;
   }
 
   /// Check if any member of the archive contains an Atom with the
   /// specified name and return the File object for that member, or nullptr.
-  virtual File *find(StringRef name, bool dataSymbolOnly) = 0;
+  virtual File *find(StringRef name) = 0;
 
   virtual std::error_code
   parseAllMembers(std::vector<std::unique_ptr<File>> &result) = 0;
 
 protected:
   /// only subclasses of ArchiveLibraryFile can be instantiated
   ArchiveLibraryFile(StringRef path) : File(path, kindArchiveLibrary) {}
 };
 
 } // namespace lld
 
 #endif // LLD_CORE_ARCHIVE_LIBRARY_FILE_H

include/lld/Core/LinkingContext.h

public:
 
   /// Add the given symbol name to the dead strip root set. Only used if
   /// deadStrip() returns true.
   void addDeadStripRoot(StringRef symbolName) {
     assert(!symbolName.empty() && "Empty symbol cannot be a dead strip root");
     _deadStripRoots.push_back(symbolName);
   }
 
-  /// Archive files (aka static libraries) are normally lazily loaded.  That is,
-  /// object files within an archive are only loaded and linked in, if the
-  /// object file contains a DefinedAtom which will replace an existing
-  /// UndefinedAtom.  If this method returns true, core linking will also look
-  /// for archive members to replace existing tentative definitions in addition
-  /// to replacing undefines. Note: a "tentative definition" (also called a
-  /// "common" symbols) is a C (but not C++) concept. They are modeled in lld
-  /// as a DefinedAtom with merge() of mergeAsTentative.
-  bool searchArchivesToOverrideTentativeDefinitions() const {
-    return _searchArchivesToOverrideTentativeDefinitions;
-  }
-
-  /// Normally core linking will turn a tentative definition into a real
-  /// definition if not replaced by a real DefinedAtom from some object file.
-  /// If this method returns true, core linking will search all supplied
-  /// dynamic shared libraries for symbol names that match remaining tentative
-  /// definitions.  If any are found, the corresponding tentative definition
-  /// atom is replaced with SharedLibraryAtom.
-  bool searchSharedLibrariesToOverrideTentativeDefinitions() const {
-    return _searchSharedLibrariesToOverrideTentativeDefinitions;
-  }
-
   /// Normally, every UndefinedAtom must be replaced by a DefinedAtom or a
   /// SharedLibraryAtom for the link to be successful.  This method controls
   /// whether core linking prints out a list of remaining UndefinedAtoms.
   ///
   /// \todo This should be a method core linking calls with a list of the
   /// UndefinedAtoms so that different drivers can format the error message
   /// as needed.
   bool printRemainingUndefines() const { return _printRemainingUndefines; }
public:
   // the symbol if your platform supports dead-stripping, so that the symbol
   // will not be removed from the output.
   void setEntrySymbolName(StringRef name) {
     _entrySymbolName = name;
   }
 
   void setDeadStripping(bool enable) { _deadStrip = enable; }
   void setGlobalsAreDeadStripRoots(bool v) { _globalsAreDeadStripRoots = v; }
-  void setSearchArchivesToOverrideTentativeDefinitions(bool search) {
-    _searchArchivesToOverrideTentativeDefinitions = search;
-  }
-  void setSearchSharedLibrariesToOverrideTentativeDefinitions(bool search) {
-    _searchSharedLibrariesToOverrideTentativeDefinitions = search;
-  }
   void setPrintRemainingUndefines(bool print) {
     _printRemainingUndefines = print;
   }
   void setAllowRemainingUndefines(bool allow) {
     _allowRemainingUndefines = allow;
   }
   void setAllowShlibUndefines(bool allow) { _allowShlibUndefines = allow; }
   void setLogInputFiles(bool log) { _logInputFiles = log; }
protected:
   /// Method to create an internal file for an undefined symbol
   virtual std::unique_ptr<File> createUndefinedSymbolFile() const;
   std::unique_ptr<File> createUndefinedSymbolFile(StringRef filename) const;
 
   StringRef _outputPath;
   StringRef _entrySymbolName;
   bool _deadStrip;
   bool _globalsAreDeadStripRoots;
-  bool _searchArchivesToOverrideTentativeDefinitions;
-  bool _searchSharedLibrariesToOverrideTentativeDefinitions;
   bool _printRemainingUndefines;
   bool _allowRemainingUndefines;
   bool _logInputFiles;
   bool _allowShlibUndefines;
   OutputFileType _outputFileType;
   std::vector<StringRef> _deadStripRoots;
   std::vector<const char *> _llvmOptions;
   StringRefVector _initialUndefinedSymbols;

include/lld/Core/Resolver.h

public:
   std::error_code handleSharedLibrary(File &);
 
   /// @brief do work of merging and resolving and return list
   bool resolve();
 
   std::unique_ptr<SimpleFile> resultFile() { return std::move(_result); }
 
 private:
-  typedef std::function<ErrorOr<bool>(StringRef, bool)> UndefCallback;
+  typedef std::function<ErrorOr<bool>(StringRef)> UndefCallback;
 
   bool undefinesAdded(int begin, int end);
   File *getFile(int &index);
 
   /// \brief The main function that iterates over the files to resolve
   bool resolveUndefines();
   void updateReferences();
   void deadStripOptimize();
   bool checkUndefines();
   void removeCoalescedAwayAtoms();
   void checkDylibSymbolCollisions();
-  ErrorOr<bool> forEachUndefines(File &file, bool searchForOverrides,
-                                 UndefCallback callback);
+  ErrorOr<bool> forEachUndefines(File &file, UndefCallback callback);
 
   void markLive(const Atom *atom);
   void addAtoms(const std::vector<const DefinedAtom *>&);
 
   class MergedFile : public SimpleFile {
   public:
     MergedFile() : SimpleFile("<linker-internal>", kindResolverMergedObject) {}
     void addAtoms(std::vector<const Atom*>& atoms);

include/lld/Core/SharedLibraryFile.h

 public:
   static bool classof(const File *f) {
     return f->kind() == kindSharedLibrary;
   }
 
   /// Check if the shared library exports a symbol with the specified name.
   /// If so, return a SharedLibraryAtom which represents that exported
   /// symbol.  Otherwise return nullptr.
-  virtual const SharedLibraryAtom *exports(StringRef name,
-                                           bool dataSymbolOnly) const = 0;
+  virtual const SharedLibraryAtom *exports(StringRef name) const = 0;
 
   // Returns the install name.
   virtual StringRef getDSOName() const = 0;
 
   const AtomVector<DefinedAtom> &defined() const override {
     return _definedAtoms;
   }
 

include/lld/Core/Simple.h

public:
   const AtomVector<SharedLibraryAtom> &sharedLibrary() const override {
     return _sharedLibraryAtoms;
   }
 
   const AtomVector<AbsoluteAtom> &absolute() const override {
     return _absoluteAtoms;
   }
 
-  File *find(StringRef sym, bool dataSymbolOnly) override {
+  File *find(StringRef sym) override {
     // For descendants:
     // do some checks here and return dynamically generated files with atoms.
     return nullptr;
   }
 
   std::error_code
   parseAllMembers(std::vector<std::unique_ptr<File>> &result) override {
     return std::error_code();

lib/Core/LinkingContext.cpp

 #include "lld/Core/Simple.h"
 #include "lld/Core/Writer.h"
 #include "llvm/ADT/Triple.h"
 
 namespace lld {
 
 LinkingContext::LinkingContext()
     : _deadStrip(false), _globalsAreDeadStripRoots(false),
-      _searchArchivesToOverrideTentativeDefinitions(false),
-      _searchSharedLibrariesToOverrideTentativeDefinitions(false),
       _printRemainingUndefines(true), _allowRemainingUndefines(false),
       _logInputFiles(false), _allowShlibUndefines(true),
       _outputFileType(OutputFileType::Default), _nextOrdinal(0) {}
 
 LinkingContext::~LinkingContext() {}
 
 bool LinkingContext::validate(raw_ostream &diagnostics) {
   return validateImpl(diagnostics);

lib/Core/Resolver.cpp

ErrorOr<bool> Resolver::handleFile(File &file) {
   }
   for (const SharedLibraryAtom *atom : file.sharedLibrary())
     doSharedLibraryAtom(*atom);
   for (const AbsoluteAtom *atom : file.absolute())
     doAbsoluteAtom(*atom);
   return undefAdded;
 }
 
-ErrorOr<bool> Resolver::forEachUndefines(File &file, bool searchForOverrides,
-                                         UndefCallback callback) {
+ErrorOr<bool> Resolver::forEachUndefines(File &file, UndefCallback callback) {
   size_t i = _undefineIndex[&file];
   bool undefAdded = false;
   do {
     for (; i < _undefines.size(); ++i) {
       StringRef undefName = _undefines[i];
       if (undefName.empty())
         continue;
       const Atom *atom = _symbolTable.findByName(undefName);
       if (!isa<UndefinedAtom>(atom) || _symbolTable.isCoalescedAway(atom)) {
         // The symbol was resolved by some other file. Cache the result.
         _undefines[i] = "";
         continue;
       }
-      auto undefAddedOrError = callback(undefName, false);
+      auto undefAddedOrError = callback(undefName);
       if (undefAddedOrError.getError())
         return undefAddedOrError;
       undefAdded |= undefAddedOrError.get();
     }
-    if (!searchForOverrides)
-      continue;
-    for (StringRef tentDefName : _symbolTable.tentativeDefinitions()) {
-      // Load for previous tentative may also have loaded
-      // something that overrode this tentative, so always check.
-      const Atom *curAtom = _symbolTable.findByName(tentDefName);
-      assert(curAtom != nullptr);
-      if (const DefinedAtom *curDefAtom = dyn_cast<DefinedAtom>(curAtom)) {
-        if (curDefAtom->merge() == DefinedAtom::mergeAsTentative) {
-          auto undefAddedOrError = callback(tentDefName, true);
-          if (undefAddedOrError.getError())
-            return undefAddedOrError;
-          undefAdded |= undefAddedOrError.get();
-        }
-      }
-    }
   } while (i < _undefines.size());
   _undefineIndex[&file] = i;
   return undefAdded;
 }
 
 ErrorOr<bool> Resolver::handleArchiveFile(File &file) {
   ArchiveLibraryFile *archiveFile = cast<ArchiveLibraryFile>(&file);
-  bool searchForOverrides =
-      _ctx.searchArchivesToOverrideTentativeDefinitions();
-  return forEachUndefines(file, searchForOverrides,
-                          [&](StringRef undefName,
-                              bool dataSymbolOnly)->ErrorOr<bool> {
-    if (File *member = archiveFile->find(undefName, dataSymbolOnly)) {
+  return forEachUndefines(file, [&](StringRef undefName) -> ErrorOr<bool> {
+    if (File *member = archiveFile->find(undefName)) {
       member->setOrdinal(_ctx.getNextOrdinalAndIncrement());
       return handleFile(*member);
     }
     return false;
   });
 }
 
 std::error_code Resolver::handleSharedLibrary(File &file) {
   // Add all the atoms from the shared library
   SharedLibraryFile *sharedLibrary = cast<SharedLibraryFile>(&file);
   auto undefAddedOrError = handleFile(*sharedLibrary);
   if (undefAddedOrError.getError())
     return undefAddedOrError.getError();
-  bool searchForOverrides =
-      _ctx.searchSharedLibrariesToOverrideTentativeDefinitions();
-  undefAddedOrError = forEachUndefines(file, searchForOverrides,
-                                       [&](StringRef undefName,
-                                           bool dataSymbolOnly)->ErrorOr<bool> {
-    if (const SharedLibraryAtom *atom =
-            sharedLibrary->exports(undefName, dataSymbolOnly))
+  undefAddedOrError =
+      forEachUndefines(file, [&](StringRef undefName) -> ErrorOr<bool> {
+        if (const SharedLibraryAtom *atom = sharedLibrary->exports(undefName))
           doSharedLibraryAtom(*atom);
         return false;
       });
 
   if (undefAddedOrError.getError())
     return undefAddedOrError.getError();
   return std::error_code();
 }
 
 bool Resolver::doUndefinedAtom(const UndefinedAtom &atom) {
   DEBUG_WITH_TYPE("resolver", llvm::dbgs()

lib/ReaderWriter/FileArchive.cpp

 public:
   FileArchive(std::unique_ptr<MemoryBuffer> mb, const Registry &reg,
               StringRef path, bool logLoading)
       : ArchiveLibraryFile(path), _mb(std::shared_ptr<MemoryBuffer>(mb.release())),
         _registry(reg), _logLoading(logLoading) {}
 
   /// \brief Check if any member of the archive contains an Atom with the
   /// specified name and return the File object for that member, or nullptr.
-  File *find(StringRef name, bool dataSymbolOnly) override {
+  File *find(StringRef name) override {
     auto member = _symbolMemberMap.find(name);
     if (member == _symbolMemberMap.end())
       return nullptr;
     Archive::child_iterator ci = member->second;
     if (ci->getError())
       return nullptr;
 
     // Don't return a member already returned
     ErrorOr<StringRef> buf = (*ci)->getBuffer();
     if (!buf)
       return nullptr;
     const char *memberStart = buf->data();
     if (_membersInstantiated.count(memberStart))
       return nullptr;
-    if (dataSymbolOnly && !isDataSymbol(ci, name))
-      return nullptr;
-
     _membersInstantiated.insert(memberStart);
 
     std::unique_ptr<File> result;
     if (instantiateMember(ci, result))
       return nullptr;
 
     File *file = result.get();
     _filesReturned.push_back(std::move(result));
std::error_code instantiateMember(Archive::child_iterator cOrErr,
     result->setArchivePath(_archive->getFileName());
 
     // The memory buffer is co-owned by the archive file and the children,
     // so that the bufffer is deallocated when all the members are destructed.
     result->setSharedMemoryBuffer(_mb);
     return std::error_code();
   }
 
-  // Parses the given memory buffer as an object file, and returns true
-  // code if the given symbol is a data symbol. If the symbol is not a data
-  // symbol or does not exist, returns false.
-  bool isDataSymbol(Archive::child_iterator cOrErr, StringRef symbol) const {
-    if (cOrErr->getError())
-      return false;
-    Archive::child_iterator member = cOrErr->get();
-    ErrorOr<llvm::MemoryBufferRef> buf = (*member)->getMemoryBufferRef();
-    if (buf.getError())
-      return false;
-    std::unique_ptr<MemoryBuffer> mb(MemoryBuffer::getMemBuffer(
-        buf.get().getBuffer(), buf.get().getBufferIdentifier(), false));
-
-    auto objOrErr(ObjectFile::createObjectFile(mb->getMemBufferRef()));
-    if (objOrErr.getError())
-      return false;
-    std::unique_ptr<ObjectFile> obj = std::move(objOrErr.get());
-
-    for (SymbolRef sym : obj->symbols()) {
-      // Skip until we find the symbol.
-      ErrorOr<StringRef> name = sym.getName();
-      if (!name)
-        return false;
-      if (*name != symbol)
-        continue;
-      uint32_t flags = sym.getFlags();
-      if (flags <= SymbolRef::SF_Undefined)
-        continue;
-
-      // Returns true if it's a data symbol.
-      SymbolRef::Type type = sym.getType();
-      if (type == SymbolRef::ST_Data)
-        return true;
-    }
-    return false;
-  }
-
   std::error_code buildTableOfContents() {
     DEBUG_WITH_TYPE("FileArchive", llvm::dbgs()
                                        << "Table of contents for archive '"
                                        << _archive->getFileName() << "':\n");
     for (const Archive::Symbol &sym : _archive->symbols()) {
       StringRef name = sym.getName();
       ErrorOr<Archive::child_iterator> memberOrErr = sym.getMember();
       if (std::error_code ec = memberOrErr.getError())

lib/ReaderWriter/MachO/File.h

 class MachODylibFile : public SharedLibraryFile {
 public:
   MachODylibFile(std::unique_ptr<MemoryBuffer> mb, MachOLinkingContext *ctx)
       : SharedLibraryFile(mb->getBufferIdentifier()),
         _mb(std::move(mb)), _ctx(ctx) {}
 
   MachODylibFile(StringRef path) : SharedLibraryFile(path) {}
 
-  const SharedLibraryAtom *exports(StringRef name, bool isData) const override {
+  const SharedLibraryAtom *exports(StringRef name) const override {
     // Pass down _installName so that if this requested symbol
     // is re-exported through this dylib, the SharedLibraryAtom's loadName()
     // is this dylib installName and not the implementation dylib's.
     // NOTE: isData is not needed for dylibs (it matters for static libs).
     return exports(name, _installName);
   }
 
   /// Adds symbol name that this dylib exports. The corresponding

lib/ReaderWriter/MachO/FlatNamespaceFile.h

 // A FlateNamespaceFile instance may be added as a resolution source of last
 // resort, depending on how -flat_namespace and -undefined are set.
 //
 class FlatNamespaceFile : public SharedLibraryFile {
 public:
   FlatNamespaceFile(const MachOLinkingContext &context)
     : SharedLibraryFile("flat namespace") { }
 
-  const SharedLibraryAtom *exports(StringRef name,
-                                   bool dataSymbolOnly) const override {
+  const SharedLibraryAtom *exports(StringRef name) const override {
     _sharedLibraryAtoms.push_back(
       new (allocator()) MachOSharedLibraryAtom(*this, name, getDSOName(),
                                                false));
 
     return _sharedLibraryAtoms.back();
   }
 
   StringRef getDSOName() const override { return "flat-namespace"; }

lib/ReaderWriter/YAML/ReaderWriterYAML.cpp

public:
     sharedLibrary() const override {
       return _noSharedLibraryAtoms;
     }
 
     const AtomVector<lld::AbsoluteAtom> &absolute() const override {
       return _noAbsoluteAtoms;
     }
 
-    File *find(StringRef name, bool dataSymbolOnly) override {
-      for (const ArchMember &member : _members) {
-        for (const lld::DefinedAtom *atom : member._content->defined()) {
-          if (name == atom->name()) {
-            if (!dataSymbolOnly)
-              return const_cast<File *>(member._content);
-            switch (atom->contentType()) {
-            case lld::DefinedAtom::typeData:
-            case lld::DefinedAtom::typeZeroFill:
-              return const_cast<File *>(member._content);
-            default:
-              break;
-            }
-          }
-        }
-      }
+    File *find(StringRef name) override {
+      for (const ArchMember &member : _members)
+        for (const lld::DefinedAtom *atom : member._content->defined())
+          if (name == atom->name())
       return nullptr;
     }
 
     std::error_code
     parseAllMembers(std::vector<std::unique_ptr<File>> &result) override {
       return std::error_code();
     }