[lld] Introduce registry and Reference kind tuple

The main changes are in:
  include/lld/Core/Reference.h
  include/lld/ReaderWriter/Reader.h
Everything else is details to support the main change.

1) Registration based Readers
Previously, lld had a tangled interdependency with all the Readers.  It would
have been impossible to make a streamlined linker (say for a JIT) which
just supported one file format and one architecture (no yaml, no archives, etc).
The old model also required a LinkingContext to read an object file, which
would have made .o inspection tools awkward.

The new model is that there is a global Registry object. You programmatically 
register the Readers you want with the registry object. Whenever you need to 
read/parse a file, you ask the registry to do it, and the registry tries each 
registered reader.

For ease of use with the existing lld code base, there is one Registry
object inside the LinkingContext object. 


2) Changing kind value to be a tuple
Beside Readers, the registry also keeps track of the mapping for Reference
Kind values to and from strings.  Along with that, this patch also fixes
an ambiguity with the previous Reference::Kind values.  The problem was that
we wanted to reuse existing relocation type values as Reference::Kind values.
But then how can the YAML write know how to convert a value to a string? The
fix is to change the 32-bit Reference::Kind into a tuple with an 8-bit namespace
(e.g. ELF, COFFF, etc), an 8-bit architecture (e.g. x86_64, PowerPC, etc), and
a 16-bit value.  This tuple system allows conversion to and from strings with 
no ambiguities.

llvm-svn: 197727

1 files changed, 201 insertions, 107 deletions

diff --git a/lld/lib/ReaderWriter/FileArchive.cpp b/lld/lib/ReaderWriter/FileArchive.cpp
index 26c70dba9a9..471916d0ff8 100644
--- a/lld/lib/ReaderWriter/FileArchive.cpp
+++ b/lld/lib/ReaderWriter/FileArchive.cpp
@@ -1,155 +1,249 @@
-//===- lld/ReaderWriter/FileArchive.cpp - Archive Library File -----------===//
+//===- lib/ReaderWriter/FileArchive.cpp -----------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
-//===---------------------------------------------------------------------===//
+//===----------------------------------------------------------------------===//
 
-#include "lld/ReaderWriter/FileArchive.h"
+#include "lld/Core/ArchiveLibraryFile.h"
+#include "lld/Core/LLVM.h"
 
 #include "llvm/ADT/Hashing.h"
-#include "llvm/Object/ObjectFile.h"
+#include "llvm/ADT/StringRef.h"
 #include "llvm/Object/Archive.h"
+#include "llvm/Object/ObjectFile.h"
+#include "llvm/Support/Debug.h"
+#include "llvm/Support/Format.h"
 #include "llvm/Support/MemoryBuffer.h"
 
 #include <unordered_map>
+#include <set>
+
+using llvm::object::Archive;
+using llvm::object::ObjectFile;
+using llvm::object::SymbolRef;
+using llvm::object::symbol_iterator;
+using llvm::object::object_error;
 
 namespace lld {
 
-/// \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.
-const File *FileArchive::find(StringRef name, bool dataSymbolOnly) const {
-  auto member = _symbolMemberMap.find(name);
-  if (member == _symbolMemberMap.end())
-    return nullptr;
+namespace {
 
-  llvm::object::Archive::child_iterator ci = member->second;
+/// \brief The FileArchive class represents an Archive Library file
+class FileArchive : public lld::ArchiveLibraryFile {
+public:
 
-  if (dataSymbolOnly) {
-    OwningPtr<MemoryBuffer> buff;
-    if (ci->getMemoryBuffer(buff, true))
+  virtual ~FileArchive() { }
+
+  /// \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.
+  virtual const File *find(StringRef name, bool dataSymbolOnly) const {
+    auto member = _symbolMemberMap.find(name);
+    if (member == _symbolMemberMap.end()) 
       return nullptr;
-    if (isDataSymbol(buff.take(), name))
+    Archive::child_iterator ci = member->second;
+
+   // Don't return a member already returned
+    const char *memberStart = ci->getBuffer().data();
+    if (_membersInstantiated.count(memberStart)) 
       return nullptr;
+
+    if (dataSymbolOnly) {
+      OwningPtr<MemoryBuffer> buff;
+      if (ci->getMemoryBuffer(buff, true))
+        return nullptr;
+      if (isDataSymbol(buff.take(), name))
+        return nullptr;
+    }
+
+    std::vector<std::unique_ptr<File>> result;
+    if (instantiateMember(ci, result))
+      return nullptr;
+    assert(result.size() == 1);
+
+    // give up the pointer so that this object no longer manages it
+    return result[0].release();
   }
 
-  std::vector<std::unique_ptr<File> > result;
+  /// \brief Load all members of the archive ?
+  virtual bool isWholeArchive() const { return _isWholeArchive; }
 
-  OwningPtr<MemoryBuffer> buff;
-  if (ci->getMemoryBuffer(buff, true))
-    return nullptr;
-  if (_context.logInputFiles())
-    llvm::outs() << buff->getBufferIdentifier() << "\n";
-  std::unique_ptr<MemoryBuffer> mb(buff.take());
-  if (_context.getDefaultReader().parseFile(mb, result))
-    return nullptr;
+  /// \brief parse each member
+  virtual error_code
+    parseAllMembers(std::vector<std::unique_ptr<File>> &result) const {
+    for (auto mf = _archive->begin_children(),
+              me = _archive->end_children(); mf != me; ++mf) {
+      if (error_code ec=instantiateMember(mf, result))
+        return ec;
+    }
+    return error_code::success();
+  }
 
-  assert(result.size() == 1);
+  virtual const atom_collection<DefinedAtom> &defined() const {
+    return _definedAtoms;
+  }
 
-  // give up the pointer so that this object no longer manages it
-  return result[0].release();
-}
+  virtual const atom_collection<UndefinedAtom> &undefined() const {
+    return _undefinedAtoms;
+  }
+
+  virtual const atom_collection<SharedLibraryAtom> &sharedLibrary() const {
+    return _sharedLibraryAtoms;
+  }
+
+  virtual const atom_collection<AbsoluteAtom> &absolute() const {
+    return _absoluteAtoms;
+  }
 
-/// \brief parse each member
-error_code FileArchive::parseAllMembers(
-    std::vector<std::unique_ptr<File> > &result) const {
-  for (auto mf = _archive->begin_children(), me = _archive->end_children();
-       mf != me; ++mf) {
+protected:
+  error_code instantiateMember(Archive::child_iterator member,
+                             std::vector<std::unique_ptr<File>> &result) const {
     OwningPtr<MemoryBuffer> buff;
-    if (error_code ec = mf->getMemoryBuffer(buff, true))
+    if (error_code ec=member->getMemoryBuffer(buff, true))
       return ec;
-    if (_context.logInputFiles())
+    if (_logLoading)
       llvm::outs() << buff->getBufferIdentifier() << "\n";
-    std::unique_ptr<MemoryBuffer> mbc(buff.take());
-    if (error_code ec = _context.getDefaultReader().parseFile(mbc, result))
-      return ec;
+    std::unique_ptr<MemoryBuffer> mb(buff.take());
+    _registry.parseFile(mb, result);
+    const char *memberStart = member->getBuffer().data();
+    _membersInstantiated.insert(memberStart);
+    return error_code::success();
   }
-  return error_code::success();
-}
 
-const ArchiveLibraryFile::atom_collection<DefinedAtom> &
-FileArchive::defined() const {
-  return _definedAtoms;
-}
 
-const ArchiveLibraryFile::atom_collection<UndefinedAtom> &
-FileArchive::undefined() const {
-  return _undefinedAtoms;
-}
+  error_code isDataSymbol(MemoryBuffer *mb, StringRef symbol) const {
+    std::unique_ptr<ObjectFile>
+                    obj(ObjectFile::createObjectFile(mb));
+    error_code ec;
+    SymbolRef::Type symtype;
+    uint32_t symflags;
+    symbol_iterator ibegin = obj->begin_symbols();
+    symbol_iterator iend = obj->end_symbols();
+    StringRef symbolname;
 
-const ArchiveLibraryFile::atom_collection<SharedLibraryAtom> &
-FileArchive::sharedLibrary() const {
-  return _sharedLibraryAtoms;
-}
+    for (symbol_iterator i = ibegin; i != iend; i.increment(ec)) {
+      if (ec) return ec;
 
-const ArchiveLibraryFile::atom_collection<AbsoluteAtom> &
-FileArchive::absolute() const {
-  return _absoluteAtoms;
-}
+      // Get symbol name
+      if ((ec = (i->getName(symbolname)))) return ec;
 
-error_code FileArchive::isDataSymbol(MemoryBuffer *mb, StringRef symbol) const {
-  std::unique_ptr<llvm::object::ObjectFile> obj(
-      llvm::object::ObjectFile::createObjectFile(mb));
-  error_code ec;
-  llvm::object::SymbolRef::Type symtype;
-  uint32_t symflags;
-  llvm::object::symbol_iterator ibegin = obj->begin_symbols();
-  llvm::object::symbol_iterator iend = obj->end_symbols();
-  StringRef symbolname;
-
-  for (llvm::object::symbol_iterator i = ibegin; i != iend; i.increment(ec)) {
-    if (ec)
-      return ec;
+      if (symbolname != symbol)
+          continue;
 
-    // Get symbol name
-    if (error_code ec = i->getName(symbolname))
-      return ec;
+      // Get symbol flags
+      if ((ec = (i->getFlags(symflags)))) return ec;
 
-    if (symbolname != symbol)
-      continue;
+      if (symflags <= SymbolRef::SF_Undefined)
+          continue;
 
-    // Get symbol flags
-    if (error_code ec = i->getFlags(symflags))
-      return ec;
+      // Get Symbol Type
+      if ((ec = (i->getType(symtype)))) return ec;
 
-    if (symflags <= llvm::object::SymbolRef::SF_Undefined)
-      continue;
+      if (symtype == SymbolRef::ST_Data) {
+        return error_code::success();
+      }
+    }
+    return object_error::parse_failed;
+  }
 
-    // Get Symbol Type
-    if (error_code ec = i->getType(symtype))
-      return ec;
+private:
+  typedef std::unordered_map<StringRef,Archive::child_iterator> MemberMap;
+  typedef std::set<const char*> InstantiatedSet;
+
+  const Registry                           &_registry;
+  std::unique_ptr<Archive>                  _archive;
+  mutable MemberMap                         _symbolMemberMap;
+  mutable InstantiatedSet                   _membersInstantiated;
+  atom_collection_vector<DefinedAtom>       _definedAtoms;
+  atom_collection_vector<UndefinedAtom>     _undefinedAtoms;
+  atom_collection_vector<SharedLibraryAtom> _sharedLibraryAtoms;
+  atom_collection_vector<AbsoluteAtom>      _absoluteAtoms;
+  bool                                      _isWholeArchive;
+  bool                                      _logLoading;
+
+public:
+  /// only subclasses of ArchiveLibraryFile can be instantiated
+  FileArchive(const Registry &registry,
+              Archive* archive,
+              StringRef path,
+              bool isWholeArchive,
+              bool logLoading)
+      : ArchiveLibraryFile(path),
+        _registry(registry),
+        _archive(std::move(archive)),
+        _isWholeArchive(isWholeArchive),
+        _logLoading(logLoading) {
+  }
 
-    if (symtype == llvm::object::SymbolRef::ST_Data) {
-      return error_code::success();
+  error_code buildTableOfContents() {
+    DEBUG_WITH_TYPE("FileArchive",
+                    llvm::dbgs() << "Table of contents for archive '"
+                                 << _archive->getFileName() << "':\n");
+    for (auto i = _archive->begin_symbols(), e = _archive->end_symbols();
+              i != e; ++i) {
+      StringRef name;
+      error_code ec;
+      Archive::child_iterator member;
+      if ((ec = i->getName(name)))
+        return ec;
+      if ((ec = i->getMember(member)))
+        return ec;
+      DEBUG_WITH_TYPE("FileArchive",
+           llvm::dbgs() << llvm::format("0x%08llX ", member->getBuffer().data())
+                        << "'" << name << "'\n");
+      _symbolMemberMap[name] = member;
     }
+    return error_code::success();  
   }
-  return llvm::object::object_error::parse_failed;
-}
 
-FileArchive::FileArchive(const LinkingContext &context,
-                         std::unique_ptr<MemoryBuffer> mb, error_code &ec,
-                         bool isWholeArchive)
-    : ArchiveLibraryFile(context, mb->getBufferIdentifier()),
-      _isWholeArchive(isWholeArchive) {
-  std::unique_ptr<llvm::object::Archive> archive_obj(
-      new llvm::object::Archive(mb.release(), ec));
-  if (ec)
-    return;
-  _archive.swap(archive_obj);
-
-  // Cache symbols.
-  for (auto i = _archive->begin_symbols(), e = _archive->end_symbols(); i != e;
-       ++i) {
-    StringRef name;
-    llvm::object::Archive::child_iterator member;
-    if ((ec = i->getName(name)))
-      return;
-    if ((ec = i->getMember(member)))
-      return;
-    _symbolMemberMap[name] = member;
+}; // class FileArchive
+
+
+
+class ArchiveReader : public Reader {
+public:
+  ArchiveReader(bool logLoading) : _logLoading(logLoading) { }
+  
+  virtual bool canParse(file_magic magic, StringRef, const MemoryBuffer&) const{
+    return (magic == llvm::sys::fs::file_magic::archive);
+  }
+  
+  virtual error_code
+  parseFile(std::unique_ptr<MemoryBuffer> &mb, const Registry &reg,
+            std::vector<std::unique_ptr<File>> &result) const {
+    // Make Archive object which will be owned by FileArchive object.
+    error_code ec;
+    Archive* archive = new Archive(mb.get(), ec);
+    if (ec)
+      return ec;
+    StringRef path = mb->getBufferIdentifier();
+    // Construct FileArchive object.
+    std::unique_ptr<FileArchive> file(new FileArchive(reg, archive, 
+                                                     path, false, _logLoading));
+    ec = file->buildTableOfContents();
+    if (ec)
+      return ec;
+      
+    // Transfer ownership of memory buffer to Archive object.
+    mb.release();
+    
+    result.push_back(std::move(file));
+    return error_code::success();     
   }
+private:
+  bool  _logLoading;
+};
+
+
+} // anonymous namespace
+
+
+void Registry::addSupportArchives(bool logLoading) {
+  add(std::unique_ptr<Reader>(new ArchiveReader(logLoading)));
 }
 
 } // end namespace lld
+
+