This is my Driver refactoring patch.

The major changes are:
1) LinkerOptions has been merged into TargetInfo
2) LinkerInvocation has been merged into Driver
3) Drivers no longer convert arguments into an intermediate (core) argument 
   list, but instead create a TargetInfo object and call setter methods on 
   it. This is only how in-process linking would work. That is, you can 
   programmatically set up a TargetInfo object which controls the linking.
4) Lots of tweaks to test suite to work with driver changes
5) Add the DarwinDriver
6) I heavily doxygen commented TargetInfo.h

Things to do after this patch is committed:
a) Consider renaming TargetInfo, given its new roll. 
b) Consider pulling the list of input files out of TargetInfo. This will 
   enable in-process clients to create one TargetInfo the re-use it with 
   different input file lists.
c) Work out a way for Drivers to format the warnings and error done in 
   core linking.

llvm-svn: 178776

1 files changed, 16 insertions, 15 deletions

diff --git a/lld/lib/ReaderWriter/ReaderArchive.cpp b/lld/lib/ReaderWriter/ReaderArchive.cpp
index 370348b8990..d3287dd429d 100644
--- a/lld/lib/ReaderWriter/ReaderArchive.cpp
+++ b/lld/lib/ReaderWriter/ReaderArchive.cpp
@@ -10,7 +10,6 @@
 #include "lld/ReaderWriter/ReaderArchive.h"
 
 #include "lld/Core/ArchiveLibraryFile.h"
-#include "lld/Core/LinkerOptions.h"
 
 #include "llvm/ADT/Hashing.h"
 #include "llvm/Object/ObjectFile.h"
@@ -46,8 +45,10 @@ public:
     OwningPtr<MemoryBuffer> buff;
     if (ci->getMemoryBuffer(buff, true))
       return nullptr;
-    LinkerInput li(std::unique_ptr<MemoryBuffer>(buff.take()));
-    if (_getReader(li)->parseFile(li.takeBuffer(), result))
+    std::unique_ptr<MemoryBuffer> mb(buff.take());
+    if (_targetInfo.logInputFiles())
+      llvm::outs() << buff->getBufferIdentifier() << "\n";
+    if (_targetInfo.parseFile(mb, result))
       return nullptr;
 
     assert(result.size() == 1);
@@ -121,8 +122,7 @@ protected:
   }
 
 private:
-  std::function<ErrorOr<Reader&> (const LinkerInput &)> _getReader;
-  std::unique_ptr<llvm::object::Archive> _archive;
+  std::unique_ptr<llvm::object::Archive>    _archive;
   atom_collection_vector<DefinedAtom>       _definedAtoms;
   atom_collection_vector<UndefinedAtom>     _undefinedAtoms;
   atom_collection_vector<SharedLibraryAtom> _sharedLibraryAtoms;
@@ -132,10 +132,8 @@ private:
 public:
   /// only subclasses of ArchiveLibraryFile can be instantiated
   FileArchive(const TargetInfo &ti,
-              std::function<ErrorOr<Reader &>(const LinkerInput &)> getReader,
               std::unique_ptr<llvm::MemoryBuffer> mb, error_code &ec)
-      : ArchiveLibraryFile(ti, mb->getBufferIdentifier()),
-        _getReader(getReader) {
+      : ArchiveLibraryFile(ti, mb->getBufferIdentifier()) {
     std::unique_ptr<llvm::object::Archive> archive_obj(
         new llvm::object::Archive(mb.release(), ec));
     if (ec)
@@ -155,16 +153,17 @@ public:
     }
   }
 
-  std::unordered_map<StringRef, llvm::object::Archive::child_iterator> _symbolMemberMap;
+  std::unordered_map<StringRef, 
+                     llvm::object::Archive::child_iterator> _symbolMemberMap;
 }; // class FileArchive
 
 // Returns a vector of Files that are contained in the archive file
 // pointed to by the MemoryBuffer
-error_code ReaderArchive::parseFile(std::unique_ptr<llvm::MemoryBuffer> mb,
-                                    std::vector<std::unique_ptr<File>> &result){
+error_code ReaderArchive::parseFile(std::unique_ptr<llvm::MemoryBuffer> &mb,
+                            std::vector<std::unique_ptr<File>> &result) const {
   error_code ec;
 
-  if (_options._forceLoadArchives) {
+  if (_targetInfo.forceLoadAllArchives()) {
     _archive.reset(new llvm::object::Archive(mb.release(), ec));
     if (ec)
       return ec;
@@ -174,13 +173,15 @@ error_code ReaderArchive::parseFile(std::unique_ptr<llvm::MemoryBuffer> mb,
       OwningPtr<MemoryBuffer> buff;
       if ((ec = mf->getMemoryBuffer(buff, true)))
         return ec;
-      LinkerInput li(std::unique_ptr<MemoryBuffer>(buff.take()));
-      if ((ec = _getReader(li)->parseFile(li.takeBuffer(), result)))
+      std::unique_ptr<MemoryBuffer> mbc(buff.take());
+      if (_targetInfo.logInputFiles())
+        llvm::outs() << buff->getBufferIdentifier() << "\n";
+      if ((ec = _targetInfo.parseFile(mbc, result)))
         return ec;
     }
   } else {
     std::unique_ptr<File> f;
-    f.reset(new FileArchive(_targetInfo, _getReader, std::move(mb), ec));
+    f.reset(new FileArchive(_targetInfo, std::move(mb), ec));
     if (ec)
       return ec;