[lld][ELF] Ability to resolve undefined symbols lazily

[denis-protivensky]

Summary

Some symbols like _GLOBAL_OFFSET_TABLE_ may occur in linked object files when not usually expected (for example, glibc uses them for STT_GNU_IFUNC optimization). The patch lets writers override specific method and handle such kind of lazy resolution if needed.
Added implementation of handling _GLOBAL_OFFSET_TABLE_ symbol for ARM platform.

[shankarke]

include/lld/Core/LinkingContext.h

310 ↗

(On Diff #21470)

Can you change the comment to specify the new functionality ?

lib/ReaderWriter/ELF/ARM/ARMExecutableWriter.h

45 ↗

(On Diff #21470)

why static const ? StringRef is already a const. Strange way of initializing.

49 ↗

(On Diff #21470)

remove const from StringRef.

lib/ReaderWriter/ELF/OutputELFWriter.h

70–78 ↗

(On Diff #21470)

Can you add a test where you have multiple absolute symbols being added, I dont see how this works. This is error prone and could we create a new runtime file for every symbol, like a archive library.

[ruiu]

This is not a specific comment to this patch, but this patch is too complicated than it can be. It's not your fault, though.

What you are trying to do with this patch is "try to resolve _GLOBAL_OFFSET_TABLE_ as an absolute symbol to .got.plt if there is any reference to the symbol. If .got.plt doesn't exist, use 0 as its address". That's simple. But this patch involves notions of virtual archive file, virtual file, finalizeInputFiles hook and so on and so on. Something is wrong. Maybe the very notion of "virtual archive file generating atoms on demand" is not a good way to do this kind of things, contrary to our expectations. I don't have any specific plan, but I see rooms to simplify this part of the linker. We need to revisit this.

include/lld/Core/Simple.h

105 ↗

(On Diff #21470)

I expect all subclasses need to implement this function, so it's better to not define this here, so that the compiler raises an error if definition is missing.

lib/ReaderWriter/ELF/ARM/ARMExecutableWriter.h

87 ↗

(On Diff #21470)

Remove this line

lib/ReaderWriter/PECOFF/LinkerGeneratedSymbolFile.h

100 ↗

(On Diff #21470)

Thank you for doing this!

[denis-protivensky]

Okay, since we drop this patch - I won't make any additional changes to it.

include/lld/Core/Simple.h

105 ↗

(On Diff #21470)

I deliberately added it while copying your implementation of virtual archive just because my understanding of Simple group of classes is that they are defaults that can be picked up and used as-is. In general, I agree that this method is excessive for the class. I'd rather say it shouldn't be in the Simple group, but I didn't find better place for it.

lib/ReaderWriter/ELF/OutputELFWriter.h

70–78 ↗

(On Diff #21470)

As an alternative, think of such method prototype for derived classes:
File* processUndefinedSymbol(StringRef symName);

It forces the implementor to write spaghetti code that is more error prone than this (I thought about it during the implementation). I prefer to move the complexity to the base class and free the descendants from potential errors.

[ruiu]

I didn't request a change to this patch -- I pointed out that the way we usually uses needs to be improved some way. This patch is LGTM. Please submit after addressing other comments.

include/lld/Core/Simple.h

105 ↗

(On Diff #21470)

Understood.

[denis-protivensky]

Updated:

• removed const of StringRef
• added more symbols (__exidx_start/_end) with tests to show how it all works
• reworked the point of concern in DynamicSymbolFile::find() so it now uses unique_bump_ptr instead of llvm::Optional and the code is a bit cleaner
• fixed usage of findAbsoluteAtom iterators
• updated comments for LinkingContext::finalizeInputFiles

[ruiu]

LGTM

lib/ReaderWriter/ELF/ARM/ARMExecutableWriter.h

73 ↗

(On Diff #21691)

else if? The next line would override a result of one line above.

[shankarke]

LGTM.

lib/ReaderWriter/ELF/OutputELFWriter.h

63 ↗

(On Diff #21691)

dynamic symbols for executable only ? I think this is applicable for shared libraries as well right ?

[denis-protivensky]

lib/ReaderWriter/ELF/ARM/ARMExecutableWriter.h

73 ↗

(On Diff #21691)

Ah, thanks, good catch!

lib/ReaderWriter/ELF/OutputELFWriter.h

63 ↗

(On Diff #21691)

Right, will update it during commit.

lld/trunk/include/lld/Core/LinkingContext.h

public:
   ///
   /// \param linkedFile This is the merged/linked graph of all input file Atoms.
   virtual std::error_code writeFile(const File &linkedFile) const;
 
   /// Return the next ordinal and Increment it.
   virtual uint64_t getNextOrdinalAndIncrement() const { return _nextOrdinal++; }
 
   // This function is called just before the Resolver kicks in.
-  // Derived classes may use that chance to rearrange the input files.
-  virtual void maybeSortInputFiles() {}
+  // Derived classes may use it to change the list of input files.
+  virtual void finalizeInputFiles() {}
 
   TaskGroup &getTaskGroup() { return _taskGroup; }
 
   /// @}
 protected:
   LinkingContext(); // Must be subclassed
 
   /// Abstract method to lazily instantiate the Writer.

lld/trunk/include/lld/Core/Simple.h

 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_CORE_SIMPLE_H
 #define LLD_CORE_SIMPLE_H
 
 #include "lld/Core/DefinedAtom.h"
 #include "lld/Core/File.h"
+#include "lld/Core/ArchiveLibraryFile.h"
 #include "lld/Core/LinkingContext.h"
 #include "lld/Core/Reference.h"
 #include "lld/Core/UndefinedAtom.h"
 #include "llvm/ADT/ilist.h"
 #include "llvm/ADT/ilist_node.h"
 
 namespace lld {
 

 
 private:
   atom_collection_vector<DefinedAtom>        _definedAtoms;
   atom_collection_vector<UndefinedAtom>      _undefinedAtoms;
   atom_collection_vector<SharedLibraryAtom>  _sharedLibraryAtoms;
   atom_collection_vector<AbsoluteAtom>       _absoluteAtoms;
 };
 
+/// \brief Archive library file that may be used as a virtual container
+/// for symbols that should be added dynamically in response to
+/// call to find() method.
+class SimpleArchiveLibraryFile : public ArchiveLibraryFile {
+public:
+  SimpleArchiveLibraryFile(StringRef filename)
+      : ArchiveLibraryFile(filename) {}
+
+  const atom_collection<DefinedAtom> &defined() const override {
+    return _definedAtoms;
+  }
+
+  const atom_collection<UndefinedAtom> &undefined() const override {
+    return _undefinedAtoms;
+  }
+
+  const atom_collection<SharedLibraryAtom> &sharedLibrary() const override {
+    return _sharedLibraryAtoms;
+  }
+
+  const atom_collection<AbsoluteAtom> &absolute() const override {
+    return _absoluteAtoms;
+  }
+
+  File *find(StringRef sym, bool dataSymbolOnly) 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();
+  }
+
+private:
+  atom_collection_vector<DefinedAtom> _definedAtoms;
+  atom_collection_vector<UndefinedAtom> _undefinedAtoms;
+  atom_collection_vector<SharedLibraryAtom> _sharedLibraryAtoms;
+  atom_collection_vector<AbsoluteAtom> _absoluteAtoms;
+};
+
 class SimpleReference : public Reference {
 public:
   SimpleReference(Reference::KindNamespace ns, Reference::KindArch arch,
                   Reference::KindValue value, uint64_t off, const Atom *t,
                   Reference::Addend a)
       : Reference(ns, arch, value), _target(t), _offsetInAtom(off), _addend(a),
         _next(nullptr), _prev(nullptr) {
   }

lld/trunk/include/lld/ReaderWriter/ELFLinkingContext.h

 #include "llvm/Support/ELF.h"
 #include <map>
 #include <memory>
 #include <set>
 
 namespace lld {
 class DefinedAtom;
 class Reference;
+class File;
 
 namespace elf {
 template <typename ELFT> class TargetHandler;
 }
 
 class TargetHandlerBase {
 public:
   virtual ~TargetHandlerBase() {}
public:
   void setMergeCommonStrings(bool v) { _mergeCommonStrings = v; }
   void setUseShlibUndefines(bool use) { _useShlibUndefines = use; }
   void setOutputELFType(uint32_t type) { _outputELFType = type; }
 
   bool shouldExportDynamic() const { return _exportDynamic; }
 
   void createInternalFiles(std::vector<std::unique_ptr<File>> &) const override;
 
+  void finalizeInputFiles() override;
+
   /// \brief Set the dynamic linker path
   void setInterpreter(StringRef dynamicLinker) {
     _dynamicLinkerArg = true;
     _dynamicLinkerPath = dynamicLinker;
   }
 
   /// \brief Set NMAGIC output kind when the linker specifies --nmagic
   /// or -n in the command line
const std::vector<std::unique_ptr<script::Parser>> &scripts() const {
     return _scripts;
   }
 
   // --wrap option.
   void addWrapForSymbol(StringRef sym) { _wrapCalls.insert(sym); }
 
   const llvm::StringSet<> &wrapCalls() const { return _wrapCalls; }
 
+  void setUndefinesResolver(std::unique_ptr<File> resolver);
+
 private:
   ELFLinkingContext() = delete;
 
 protected:
   ELFLinkingContext(llvm::Triple, std::unique_ptr<TargetHandlerBase>);
 
   Writer &writer() const override;
 
protected:
   StringRef _sysrootPath;
   StringRef _soname;
   StringRefVector _rpathList;
   StringRefVector _rpathLinkList;
   llvm::StringSet<> _wrapCalls;
   std::map<std::string, uint64_t> _absoluteSymbols;
   llvm::StringSet<> _dynamicallyExportedSymbols;
   std::vector<std::unique_ptr<script::Parser>> _scripts;
+  std::unique_ptr<File> _resolver;
 };
 } // end namespace lld
 
 #endif

lld/trunk/include/lld/ReaderWriter/MachOLinkingContext.h

public:
   static bool is64Bit(Arch arch);
   static bool isHostEndian(Arch arch);
   static bool isBigEndian(Arch arch);
 
   /// Construct 32-bit value from string "X.Y.Z" where
   /// bits are xxxx.yy.zz.  Largest number is 65535.255.255
   static bool parsePackedVersion(StringRef str, uint32_t &result);
 
-  void maybeSortInputFiles() override;
+  void finalizeInputFiles() override;
 
   bool customAtomOrderer(const DefinedAtom *left, const DefinedAtom *right,
                          bool &leftBeforeRight) const;
 
 private:
   Writer &writer() const override;
   mach_o::MachODylibFile* loadIndirectDylib(StringRef path);
   void checkExportWhiteList(const DefinedAtom *atom) const;

lld/trunk/lib/Driver/Driver.cpp

bool Driver::link(LinkingContext &context, raw_ostream &diagnostics) {
   // Give target a chance to add files.
   std::vector<std::unique_ptr<File>> implicitFiles;
   context.createImplicitFiles(implicitFiles);
   for (auto i = implicitFiles.rbegin(), e = implicitFiles.rend(); i != e; ++i) {
     auto &members = context.getNodes();
     members.insert(members.begin(), llvm::make_unique<FileNode>(std::move(*i)));
   }
 
-  // Give target a chance to sort the input files.
+  // Give target a chance to postprocess input files.
   // Mach-O uses this chance to move all object files before library files.
-  context.maybeSortInputFiles();
+  // ELF adds specific undefined symbols resolver.
+  context.finalizeInputFiles();
 
   // Do core linking.
   ScopedTask resolveTask(getDefaultDomain(), "Resolve");
   Resolver resolver(context);
   if (!resolver.resolve())
     return false;
   std::unique_ptr<MutableFile> merged = resolver.resultFile();
   resolveTask.end();

lld/trunk/lib/ReaderWriter/ELF/ARM/ARMExecutableWriter.h

 public:
   ARMExecutableWriter(ARMLinkingContext &context,
                       ARMTargetLayout<ELFT> &layout);
 
 protected:
   // Add any runtime files and their atoms to the output
   bool createImplicitFiles(std::vector<std::unique_ptr<File>> &) override;
 
-  void finalizeDefaultAtomValues() override {
-    // Finalize the atom values that are part of the parent.
-    ExecutableWriter<ELFT>::finalizeDefaultAtomValues();
-  }
+  void finalizeDefaultAtomValues() override;
 
   void addDefaultAtoms() override {
     ExecutableWriter<ELFT>::addDefaultAtoms();
   }
 
   /// \brief Create symbol table.
   unique_bump_ptr<SymbolTable<ELFT>> createSymbolTable() override;
 
+  void processUndefinedSymbol(StringRef symName,
+                              CRuntimeFile<ELFT> &file) const override;
 private:
   ARMLinkingContext &_context;
   ARMTargetLayout<ELFT> &_armLayout;
+
+  static StringRef gotSymbol;
 };
 
 template <class ELFT>
+StringRef ARMExecutableWriter<ELFT>::gotSymbol = "_GLOBAL_OFFSET_TABLE_";
+
+template <class ELFT>
 ARMExecutableWriter<ELFT>::ARMExecutableWriter(ARMLinkingContext &context,
                                                ARMTargetLayout<ELFT> &layout)
     : ExecutableWriter<ELFT>(context, layout), _context(context),
       _armLayout(layout) {}
 
 template <class ELFT>
 bool ARMExecutableWriter<ELFT>::createImplicitFiles(
     std::vector<std::unique_ptr<File>> &result) {
   ExecutableWriter<ELFT>::createImplicitFiles(result);
   return true;
 }
 
 template <class ELFT>
+void ARMExecutableWriter<ELFT>::finalizeDefaultAtomValues() {
+  // Finalize the atom values that are part of the parent.
+  ExecutableWriter<ELFT>::finalizeDefaultAtomValues();
+  auto gotAtomIter = _armLayout.findAbsoluteAtom(gotSymbol);
+  if (gotAtomIter != _armLayout.absoluteAtoms().end()) {
+    auto *gotAtom = *gotAtomIter;
+    if (auto gotpltSection = _armLayout.findOutputSection(".got.plt"))
+      gotAtom->_virtualAddr = gotpltSection->virtualAddr();
+    else if (auto gotSection = _armLayout.findOutputSection(".got"))
+      gotAtom->_virtualAddr = gotSection->virtualAddr();
+    else
+      gotAtom->_virtualAddr = 0;
+  }
+  // TODO: resolve addresses of __exidx_start/_end atoms
+}
+
+template <class ELFT>
 unique_bump_ptr<SymbolTable<ELFT>>
     ARMExecutableWriter<ELFT>::createSymbolTable() {
   return unique_bump_ptr<SymbolTable<ELFT>>(
       new (this->_alloc) ARMSymbolTable<ELFT>(this->_context));
 }
 
+template <class ELFT>
+void ARMExecutableWriter<ELFT>::processUndefinedSymbol(
+    StringRef symName, CRuntimeFile<ELFT> &file) const {
+  if (symName == gotSymbol) {
+    file.addAbsoluteAtom(gotSymbol);
+  } else if (symName.startswith("__exidx")) {
+    file.addAbsoluteAtom("__exidx_start");
+    file.addAbsoluteAtom("__exidx_end");
+  }
+}
+
 } // namespace elf
 } // namespace lld
 
 #endif // LLD_READER_WRITER_ELF_ARM_ARM_EXECUTABLE_WRITER_H

lld/trunk/lib/ReaderWriter/ELF/ELFLinkingContext.cpp

for (auto &i : getAbsoluteSymbols()) {
     uint64_t val = i.second;
     file->addAtom(*(new (_allocator) SimpleAbsoluteAtom(
         *file, sym, Atom::scopeGlobal, val)));
   }
   files.push_back(std::move(file));
   LinkingContext::createInternalFiles(files);
 }
 
+void ELFLinkingContext::finalizeInputFiles() {
+  // Add virtual archive that resolves undefined symbols.
+  if (_resolver)
+    getNodes().push_back(llvm::make_unique<FileNode>(std::move(_resolver)));
+}
+
 std::unique_ptr<File> ELFLinkingContext::createUndefinedSymbolFile() const {
   if (_initialUndefinedSymbols.empty())
     return nullptr;
   std::unique_ptr<SimpleFile> undefinedSymFile(
       new SimpleFile("command line option -u"));
   for (auto undefSymStr : _initialUndefinedSymbols)
     undefinedSymFile->addAtom(*(new (_allocator) CommandLineUndefinedAtom(
         *undefinedSymFile, undefSymStr)));
if (demangled != NULL) {
     free(demangled);
     return result;
   }
 #endif
 
   return symbolName;
 }
 
+void ELFLinkingContext::setUndefinesResolver(std::unique_ptr<File> resolver) {
+  assert(isa<ArchiveLibraryFile>(resolver.get()) && "Wrong resolver type");
+  _resolver = std::move(resolver);
+}
+
 } // end namespace lld

lld/trunk/lib/ReaderWriter/ELF/OutputELFWriter.h

 
 #include "DefaultLayout.h"
 #include "ELFFile.h"
 #include "TargetLayout.h"
 #include "lld/Core/Instrumentation.h"
 #include "lld/Core/Parallel.h"
 #include "lld/Core/SharedLibraryFile.h"
 #include "lld/ReaderWriter/ELFLinkingContext.h"
+#include "lld/Core/Simple.h"
 #include "lld/Core/Writer.h"
+#include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/Support/Path.h"
 
 namespace lld {
 namespace elf {
 using namespace llvm;
 using namespace llvm::object;
 
 template <class ELFT> class OutputELFWriter;
 template <class ELFT> class TargetLayout;
 
+namespace {
+
+template<class ELFT>
+class SymbolFile : public CRuntimeFile<ELFT> {
+public:
+  SymbolFile(ELFLinkingContext &context)
+      : CRuntimeFile<ELFT>(context, "Dynamic absolute symbols"),
+        _atomsAdded(false) {}
+
+  Atom *addAbsoluteAtom(StringRef symbolName) override {
+    auto *a = CRuntimeFile<ELFT>::addAbsoluteAtom(symbolName);
+    if (a) _atomsAdded = true;
+    return a;
+  }
+
+  Atom *addUndefinedAtom(StringRef) override {
+    llvm_unreachable("Cannot add undefined atoms to resolve undefined symbols");
+  }
+
+  bool hasAtoms() const { return _atomsAdded; }
+
+private:
+  bool _atomsAdded;
+};
+
+template<class ELFT>
+class DynamicSymbolFile : public SimpleArchiveLibraryFile {
+  typedef std::function<void(StringRef, CRuntimeFile<ELFT> &)> Resolver;
+public:
+  DynamicSymbolFile(ELFLinkingContext &context, Resolver resolver)
+      : SimpleArchiveLibraryFile("Dynamically added runtime symbols"),
+        _context(context), _resolver(resolver) {}
+
+  File *find(StringRef sym, bool dataSymbolOnly) override {
+    if (!_file)
+      _file.reset(new (_alloc) SymbolFile<ELFT>(_context));
+
+    assert(!_file->hasAtoms() && "The file shouldn't have atoms yet");
+    _resolver(sym, *_file);
+    // If atoms were added - release the file to the caller.
+    return _file->hasAtoms() ? _file.release() : nullptr;
+  }
+
+private:
+  ELFLinkingContext &_context;
+  Resolver _resolver;
+
+  // The allocator should go before bump pointers because of
+  // reversed destruction order.
+  llvm::BumpPtrAllocator _alloc;
+  unique_bump_ptr<SymbolFile<ELFT>> _file;
+};
+
+} // end anon namespace
+
 //===----------------------------------------------------------------------===//
 //  OutputELFWriter Class
 //===----------------------------------------------------------------------===//
 /// \brief This acts as the base class for all the ELF writers that are output
 /// for emitting an ELF output file. This class also acts as a common class for
 /// creating static and dynamic executables. All the function in this class
 /// can be overridden and an appropriate writer be created
 template<class ELFT>
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 false;
   }
 
+  /// \brief Process undefined symbols that left after resolution step.
+  virtual void processUndefinedSymbol(StringRef symName,
+                                      CRuntimeFile<ELFT> &file) const {}
+
   llvm::BumpPtrAllocator _alloc;
 
   const ELFLinkingContext &_context;
   TargetHandler<ELFT> &_targetHandler;
 
   typedef llvm::DenseMap<const Atom *, uint64_t> AtomToAddress;
   AtomToAddress _atomToAddressMap;
   TargetLayout<ELFT> &_layout;
for (auto sec : _layout.sections())
     if (auto section = dyn_cast<Section<ELFT>>(sec))
       if (!_layout.hasOutputSegment(section))
         _shdrtab->updateSection(section);
 }
 
 template <class ELFT>
 bool OutputELFWriter<ELFT>::createImplicitFiles(
     std::vector<std::unique_ptr<File>> &) {
+  // Add the virtual archive to resolve undefined symbols.
+  // The file will be added later in the linking context.
+  auto callback = [this](StringRef sym, CRuntimeFile<ELFT> &file) {
+    processUndefinedSymbol(sym, file);
+  };
+  auto &ctx = const_cast<ELFLinkingContext &>(_context);
+  ctx.setUndefinesResolver(
+      llvm::make_unique<DynamicSymbolFile<ELFT>>(ctx, std::move(callback)));
   return true;
 }
 
 template <class ELFT> void OutputELFWriter<ELFT>::createDefaultSections() {
   _elfHeader.reset(new (_alloc) ELFHeader<ELFT>(_context));
   _programHeader.reset(new (_alloc) ProgramHeader<ELFT>(_context));
   _layout.setHeader(_elfHeader.get());
   _layout.setProgramHeader(_programHeader.get());

lld/trunk/lib/ReaderWriter/MachO/MachOLinkingContext.cpp

 
 // The darwin linker processes input files in two phases.  The first phase
 // links in all object (.o) files in command line order. The second phase
 // links in libraries in command line order.
 // In this function we reorder the input files so that all the object files
 // comes before any library file. We also make a group for the library files
 // so that the Resolver will reiterate over the libraries as long as we find
 // new undefines from libraries.
-void MachOLinkingContext::maybeSortInputFiles() {
+void MachOLinkingContext::finalizeInputFiles() {
   std::vector<std::unique_ptr<Node>> &elements = getNodes();
   std::stable_sort(elements.begin(), elements.end(),
                    [](const std::unique_ptr<Node> &a,
                       const std::unique_ptr<Node> &b) {
                      return !isLibrary(a) && isLibrary(b);
                    });
   size_t numLibs = std::count_if(elements.begin(), elements.end(), isLibrary);
   elements.push_back(llvm::make_unique<GroupEnd>(numLibs));
 }
 
 } // end namespace lld

lld/trunk/lib/ReaderWriter/PECOFF/LinkerGeneratedSymbolFile.h

 //===- lib/ReaderWriter/PECOFF/LinkerGeneratedSymbolFile.h ----------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Atoms.h"
-#include "lld/Core/ArchiveLibraryFile.h"
 #include "lld/Core/Simple.h"
 #include "lld/ReaderWriter/PECOFFLinkingContext.h"
 #include "llvm/Support/Allocator.h"
 #include <algorithm>
 #include <mutex>
 
 using llvm::COFF::WindowsSubsystem;
 
ImpSymbolFile(StringRef defsym, StringRef undefsym, uint64_t ordinal,
     addAtom(_undefined);
   };
 
 private:
   SimpleUndefinedAtom _undefined;
   ImpPointerAtom _defined;
 };
 
-class VirtualArchiveLibraryFile : public ArchiveLibraryFile {
-public:
-  VirtualArchiveLibraryFile(StringRef filename)
-      : ArchiveLibraryFile(filename) {}
-
-  const atom_collection<DefinedAtom> &defined() const override {
-    return _definedAtoms;
-  }
-
-  const atom_collection<UndefinedAtom> &undefined() const override {
-    return _undefinedAtoms;
-  }
-
-  const atom_collection<SharedLibraryAtom> &sharedLibrary() const override {
-    return _sharedLibraryAtoms;
-  }
-
-  const atom_collection<AbsoluteAtom> &absolute() const override {
-    return _absoluteAtoms;
-  }
-
-  std::error_code
-  parseAllMembers(std::vector<std::unique_ptr<File>> &result) override {
-    return std::error_code();
-  }
-
-private:
-  atom_collection_vector<DefinedAtom> _definedAtoms;
-  atom_collection_vector<UndefinedAtom> _undefinedAtoms;
-  atom_collection_vector<SharedLibraryAtom> _sharedLibraryAtoms;
-  atom_collection_vector<AbsoluteAtom> _absoluteAtoms;
-};
-
 // A file to make Resolver to resolve a symbol TO instead of a symbol FROM,
 // using fallback mechanism for an undefined symbol. One can virtually rename an
 // undefined symbol using this file.
 class SymbolRenameFile : public SimpleFile {
 public:
   SymbolRenameFile(StringRef from, StringRef to)
       : SimpleFile("<symbol-rename>"), _fromSym(from), _toSym(to),
         _from(*this, _fromSym, &_to), _to(*this, _toSym) {

 //   void hello() { printf("Hello\n"); }
 //   extern void (*_imp__hello)();
 //   int main() {
 //      _imp__hello();
 //      return 0;
 //   }
 //
 // This odd feature is for the compatibility with MSVC link.exe.
-class LocallyImportedSymbolFile : public impl::VirtualArchiveLibraryFile {
+class LocallyImportedSymbolFile : public SimpleArchiveLibraryFile {
 public:
   LocallyImportedSymbolFile(const PECOFFLinkingContext &ctx)
-      : VirtualArchiveLibraryFile("__imp_"), _is64(ctx.is64Bit()),
+      : SimpleArchiveLibraryFile("__imp_"), _is64(ctx.is64Bit()),
         _ordinal(0) {}
 
   File *find(StringRef sym, bool dataSymbolOnly) override {
     std::string prefix = "__imp_";
     if (!sym.startswith(prefix))
       return nullptr;
     StringRef undef = sym.substr(prefix.size());
     return new (_alloc) impl::ImpSymbolFile(sym, undef, _ordinal++, _is64);
   }
 
 private:
   bool _is64;
-  mutable uint64_t _ordinal;
-  mutable llvm::BumpPtrAllocator _alloc;
+  uint64_t _ordinal;
+  llvm::BumpPtrAllocator _alloc;
 };
 
 // A ExportedSymbolRenameFile is a virtual archive file for dllexported symbols.
 //
 // One usually has to specify the exact symbol name to resolve it. That's true
 // in most cases for PE/COFF, except the one described below.
 //
 // DLLExported symbols can be specified using a module definition file. In a

 // are already parsed and read and (2) all the defined symbols in archive files
 // that are not yet be parsed.
 //
 // If Resolver asks this file to return an atom for a dllexported symbol, find()
 // looks up the set, doing ambiguous matching. If there's a symbol with @
 // prefix, it returns an atom to rename the dllexported symbol, hoping that
 // Resolver will find the new symbol with atsign from an archive file at the
 // next visit.
-class ExportedSymbolRenameFile : public impl::VirtualArchiveLibraryFile {
+class ExportedSymbolRenameFile : public SimpleArchiveLibraryFile {
 public:
   ExportedSymbolRenameFile(const PECOFFLinkingContext &ctx)
-      : VirtualArchiveLibraryFile("<export>"),
+      : SimpleArchiveLibraryFile("<export>"),
         _ctx(const_cast<PECOFFLinkingContext *>(&ctx)) {
     for (PECOFFLinkingContext::ExportDesc &desc : _ctx->getDllExports())
       _exportedSyms.insert(desc.name);
   }
 
   File *find(StringRef sym, bool dataSymbolOnly) override {
     typedef PECOFFLinkingContext::ExportDesc ExportDesc;
     if (_exportedSyms.count(sym) == 0)
       return nullptr;
     std::string replace;
     if (!findDecoratedSymbol(_ctx, sym.str(), replace))
       return nullptr;
 
     for (ExportDesc &exp : _ctx->getDllExports())
       if (exp.name == sym)
         exp.mangledName = replace;
     if (_ctx->deadStrip())
       _ctx->addDeadStripRoot(_ctx->allocate(replace));
     return new (_alloc) impl::SymbolRenameFile(sym, replace);
   }
 
 private:
   std::set<std::string> _exportedSyms;
-  mutable llvm::BumpPtrAllocator _alloc;
-  mutable PECOFFLinkingContext *_ctx;
+  llvm::BumpPtrAllocator _alloc;
+  PECOFFLinkingContext *_ctx;
 };
 
 // Windows has not only one but many entry point functions. The
 // appropriate one is automatically selected based on the subsystem
 // setting and the user-supplied entry point function.
 //
 // http://msdn.microsoft.com/en-us/library/f9t8842e.aspx
 class EntryPointFile : public SimpleFile {

lld/trunk/test/elf/ARM/missing-symbol.test

+# Check that _MISSING_SYMBOL_ symbol is not resolved
+
+# RUN: yaml2obj -format=elf %s > %t-o.o
+# RUN: lld -flavor gnu -target arm -m armelf_linux_eabi -Bstatic \
+# RUN: --noinhibit-exec %t-o.o -o %t 2>&1 | FileCheck %s
+
+# CHECK: Undefined symbol: {{.*}}: _MISSING_SYMBOL_
+
+---
+FileHeader:
+  Class:           ELFCLASS32
+  Data:            ELFDATA2LSB
+  Type:            ET_REL
+  Machine:         EM_ARM
+  Flags:           [ EF_ARM_EABI_VER5 ]
+Sections:
+  - Name:            .text
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
+    AddressAlign:    0x0000000000000004
+    Content:         80B483B000AF40F20003C0F200037B60002318460C37BD465DF8047B704700BF
+  - Name:            .data
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_WRITE, SHF_ALLOC ]
+    AddressAlign:    0x0000000000000001
+    Content:         ''
+  - Name:            .bss
+    Type:            SHT_NOBITS
+    Flags:           [ SHF_WRITE, SHF_ALLOC ]
+    AddressAlign:    0x0000000000000001
+    Content:         ''
+Symbols:
+  Global:
+    - Name:            main
+      Type:            STT_FUNC
+      Section:         .text
+      Value:           0x0000000000000001
+    - Name:            _MISSING_SYMBOL_
+...

lld/trunk/test/elf/ARM/undef-lazy-symbol.test

+# Check that _GLOBAL_OFFSET_TABLE_ symbol is resolved
+
+# RUN: yaml2obj -format=elf -docnum 1 %s > %t-got.o
+# RUN: lld -flavor gnu -target arm -m armelf_linux_eabi -Bstatic \
+# RUN: --noinhibit-exec %t-got.o -o %t
+# RUN: llvm-readobj -symbols %t | FileCheck -check-prefix=GOT %s
+
+# GOT:   Name: _GLOBAL_OFFSET_TABLE_ (185)
+# GOT-NEXT:   Value: {{[0-9]+}}
+# GOT-NEXT:   Size: 0
+# GOT-NEXT:   Binding: Global (0x1)
+# GOT-NEXT:   Type: Object (0x1)
+# GOT-NEXT:   Other: 0
+# GOT-NEXT:   Section: Absolute (0xFFF1)
+
+# Check that __exidx_start/_end symbols are resolved
+
+# RUN: yaml2obj -format=elf -docnum 2 %s > %t-exidx.o
+# RUN: lld -flavor gnu -target arm -m armelf_linux_eabi -Bstatic \
+# RUN: --defsym=main=fn --noinhibit-exec %t-exidx.o -o %t
+# RUN: llvm-readobj -symbols %t | FileCheck -check-prefix=EXIDX %s
+
+# EXIDX:   Name: __exidx_start (188)
+# EXIDX-NEXT:   Value: {{[0-9]+}}
+# EXIDX-NEXT:   Size: 0
+# EXIDX-NEXT:   Binding: Global (0x1)
+# EXIDX-NEXT:   Type: Object (0x1)
+# EXIDX-NEXT:   Other: 0
+# EXIDX-NEXT:   Section: Absolute (0xFFF1)
+#
+# EXIDX:   Name: __exidx_end (202)
+# EXIDX-NEXT:   Value: {{[0-9]+}}
+# EXIDX-NEXT:   Size: 0
+# EXIDX-NEXT:   Binding: Global (0x1)
+# EXIDX-NEXT:   Type: Object (0x1)
+# EXIDX-NEXT:   Other: 0
+# EXIDX-NEXT:   Section: Absolute (0xFFF1)
+
+# Check that all symbols are resolved
+
+# RUN: yaml2obj -format=elf -docnum 1 %s > %t-got.o
+# RUN: yaml2obj -format=elf -docnum 2 %s > %t-exidx.o
+# RUN: lld -flavor gnu -target arm -m armelf_linux_eabi -Bstatic \
+# RUN: --noinhibit-exec %t-got.o %t-exidx.o -o %t
+# RUN: llvm-readobj -symbols %t | FileCheck -check-prefix=SYMS %s
+
+# SYMS:   Name: _GLOBAL_OFFSET_TABLE_ (188)
+# SYMS-NEXT:   Value: {{[0-9]+}}
+# SYMS-NEXT:   Size: 0
+# SYMS-NEXT:   Binding: Global (0x1)
+# SYMS-NEXT:   Type: Object (0x1)
+# SYMS-NEXT:   Other: 0
+# SYMS-NEXT:   Section: Absolute (0xFFF1)
+#
+# SYMS:   Name: __exidx_start (210)
+# SYMS-NEXT:   Value: {{[0-9]+}}
+# SYMS-NEXT:   Size: 0
+# SYMS-NEXT:   Binding: Global (0x1)
+# SYMS-NEXT:   Type: Object (0x1)
+# SYMS-NEXT:   Other: 0
+# SYMS-NEXT:   Section: Absolute (0xFFF1)
+#
+# SYMS:   Name: __exidx_end (224)
+# SYMS-NEXT:   Value: {{[0-9]+}}
+# SYMS-NEXT:   Size: 0
+# SYMS-NEXT:   Binding: Global (0x1)
+# SYMS-NEXT:   Type: Object (0x1)
+# SYMS-NEXT:   Other: 0
+# SYMS-NEXT:   Section: Absolute (0xFFF1)
+
+# got.o
+---
+FileHeader:
+  Class:           ELFCLASS32
+  Data:            ELFDATA2LSB
+  Type:            ET_REL
+  Machine:         EM_ARM
+  Flags:           [ EF_ARM_EABI_VER5 ]
+Sections:
+  - Name:            .text
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
+    AddressAlign:    0x0000000000000004
+    Content:         80B483B000AF40F20003C0F200037B60002318460C37BD465DF8047B704700BF
+  - Name:            .data
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_WRITE, SHF_ALLOC ]
+    AddressAlign:    0x0000000000000001
+    Content:         ''
+  - Name:            .bss
+    Type:            SHT_NOBITS
+    Flags:           [ SHF_WRITE, SHF_ALLOC ]
+    AddressAlign:    0x0000000000000001
+    Content:         ''
+Symbols:
+  Global:
+    - Name:            main
+      Type:            STT_FUNC
+      Section:         .text
+      Value:           0x0000000000000001
+    - Name:            _GLOBAL_OFFSET_TABLE_
+
+# exidx.o
+---
+FileHeader:
+  Class:           ELFCLASS32
+  Data:            ELFDATA2LSB
+  Type:            ET_REL
+  Machine:         EM_ARM
+  Flags:           [ EF_ARM_EABI_VER5 ]
+Sections:
+  - Name:            .text
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
+    AddressAlign:    0x0000000000000004
+    Content:         80B483B000AF40F20003C0F200037B60002318460C37BD465DF8047B704700BF
+  - Name:            .data
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_WRITE, SHF_ALLOC ]
+    AddressAlign:    0x0000000000000001
+    Content:         ''
+  - Name:            .bss
+    Type:            SHT_NOBITS
+    Flags:           [ SHF_WRITE, SHF_ALLOC ]
+    AddressAlign:    0x0000000000000001
+    Content:         ''
+Symbols:
+  Global:
+    - Name:            fn
+      Type:            STT_FUNC
+      Section:         .text
+      Value:           0x0000000000000001
+    - Name:            __exidx_start
+    - Name:            __exidx_end
+...