Convert other drivers to use WrapperNode.

[ruiu]

Summary

Convert other drivers to use WrapperNode. I think this is the last
complex patch in the series of refactoring patches, all the following
ones are in my opinion straightforward. You can see the final form
of the code at https://github.com/rui314/lld/commits/parse

[Bigcheese]

The gnuld parts look good to me.

[kledzik]

This seems to have lost the parallel reading/parsing of input files. It looks like parseFile() called by the driver is triggering the actual parsing and parse() called by the Driver in parallel just returns the error code from the parse.

[shankarke]

include/lld/ReaderWriter/ELFLinkingContext.h

293–313

How is the attribute accessed from the file ? I didnt see a accessor function, am I missing some detail ?

lib/Driver/GnuLdDriver.cpp

261–282

how is attributes going to be passed ?

[ruiu]

• Do not trigger actual file parsing when parseFile is called

include/lld/ReaderWriter/ELFLinkingContext.h

293–313

Well, that would be a question for you. :) The code was incomplete. I moved this piece of code from other file to this file. It's not new. Apparently we need more code to support these attributes but that's out of scope of this patch.

lib/Driver/GnuLdDriver.cpp

261–282

Attributes are not passed at this moment at least, and that's not actually a new behavior. ELFFileNode didn't use that attribute (other than printing a debug message). Maybe we should remove that. I'd think that doesn't have to be done in this patch.

[ruiu]

Ping.

[kledzik]

It still looks like mach-o files are parsed immediately (not in parallel). If that is intentional, because reworking the mach-o logic is complicated, then leave a FIXME comment there.

It would be helpful to rename parseFile() if its goal is no longer to parse files. I seems like its goal is to load the file into memory, and later parse()/doParse() are supposed to do the actual parsing.

[ruiu]

It's not intentional and I believe it's not actually parsed immediately.
Can you elaborate a bit why you think files would be parsed not in parallel?

As to the name, I totally agree with that. parseFile is no longer a good
name for that function. I'll rename loadFile (or readFile, but read could
imply that we are going to parse it as part of reading, so I'm inclined to
"load").

[kledzik]

I see. Given my comment in the previous patch about parallelism, I was expecting to see a change in the latest patch about when parsing happens. But you changed mach-o parseFile() a while ago to instantiate a File object, but not parse it until doParse() was invoked. So all is good. Just the parseFile() name confusing me.

[ruiu]

Thanks. I renamed loadFile and submitted as r225764.

include/lld/Core/ArchiveLibraryFile.h

static inline 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 const File *find(StringRef name, bool dataSymbolOnly) const = 0;
 
   virtual std::error_code
-  parseAllMembers(std::vector<std::unique_ptr<File>> &result) const = 0;
+  parseAllMembers(std::vector<std::unique_ptr<File>> &result) = 0;
 
   /// Returns a set of all defined symbols in the archive, i.e. all
   /// resolvable symbol using this file.
   virtual std::set<StringRef> getDefinedSymbols() const {
     return std::set<StringRef>();
   }
 
 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/File.h

 
 /// An ErrorFile represents a file that doesn't exist.
 /// If you try to parse a file which doesn't exist, an instance of this
 /// class will be returned. That's parse method always returns an error.
 /// This is useful to delay erroring on non-existent files, so that we
 /// can do unit testing a driver using non-existing file paths.
 class ErrorFile : public File {
 public:
-  ErrorFile(StringRef p, std::error_code ec) : File(p, kindObject), _ec(ec) {}
+  ErrorFile(StringRef path, std::error_code ec)
+      : File(path, kindObject), _ec(ec) {}
 
   std::error_code doParse() override { return _ec; }
 
   const atom_collection<DefinedAtom> &defined() const override {
     llvm_unreachable("internal error");
   }
   const atom_collection<UndefinedAtom> &undefined() const override {
     llvm_unreachable("internal error");

include/lld/Driver/DarwinInputGraph.h

-//===- lld/Driver/DarwinInputGraph.h - Input Graph Node for Mach-O linker -===//
-//
-//                             The LLVM Linker
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-///
-/// \file
-///
-/// Handles Options for MachO linking and provides InputElements
-/// for MachO linker
-///
-//===----------------------------------------------------------------------===//
-
-#ifndef LLD_DRIVER_DARWIN_INPUT_GRAPH_H
-#define LLD_DRIVER_DARWIN_INPUT_GRAPH_H
-
-#include "lld/Core/ArchiveLibraryFile.h"
-#include "lld/Core/InputGraph.h"
-#include "lld/ReaderWriter/MachOLinkingContext.h"
-
-namespace lld {
-
-/// \brief Represents a MachO File
-class MachOFileNode : public FileNode {
-public:
-  MachOFileNode(StringRef path, MachOLinkingContext &ctx)
-      : FileNode(path), _context(ctx), _isWholeArchive(false),
-        _upwardDylib(false) {}
-
-  /// \brief Parse the input file to lld::File.
-  std::error_code parse(const LinkingContext &ctx,
-                        raw_ostream &diagnostics) override;
-
-  void setLoadWholeArchive(bool value=true) {
-    _isWholeArchive = value;
-  }
-
-  void setUpwardDylib(bool value=true) {
-    _upwardDylib = value;
-  }
-
-private:
-  void narrowFatBuffer(std::unique_ptr<MemoryBuffer> &mb, StringRef filePath);
-
-  MachOLinkingContext &_context;
-  std::unique_ptr<const ArchiveLibraryFile> _archiveFile;
-  bool _isWholeArchive;
-  bool _upwardDylib;
-};
-
-} // namespace lld
-
-#endif

include/lld/Driver/GnuLdInputGraph.h

-//===- lld/Driver/GnuLdInputGraph.h - Input Graph Node for ELF linker------===//
-//
-//                             The LLVM Linker
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-///
-/// \file
-///
-/// Handles Options for the GNU style linker for ELF and provides InputElements
-/// for the GNU style linker for ELF
-///
-//===----------------------------------------------------------------------===//
-
-#ifndef LLD_DRIVER_GNU_LD_INPUT_GRAPH_H
-#define LLD_DRIVER_GNU_LD_INPUT_GRAPH_H
-
-#include "lld/Core/ArchiveLibraryFile.h"
-#include "lld/Core/InputGraph.h"
-#include "lld/Core/Resolver.h"
-#include "lld/ReaderWriter/ELFLinkingContext.h"
-
-namespace lld {
-
-/// \brief Represents a ELF File
-class ELFFileNode : public FileNode {
-public:
-  /// \brief The attributes class provides a way for a input file to look into
-  /// all the positional attributes that were specified in the command line.
-  /// There are few positional operators and the number of arguments to the
-  /// ELFFileNode class keeps growing. This achieves code to be clean as well.
-  class Attributes {
-  public:
-    Attributes()
-        : _isWholeArchive(false), _asNeeded(false), _isDashlPrefix(false),
-          _isSysRooted(false) {}
-    void setWholeArchive(bool isWholeArchive) {
-      _isWholeArchive = isWholeArchive;
-    }
-    void setAsNeeded(bool asNeeded) { _asNeeded = asNeeded; }
-    void setDashlPrefix(bool isDashlPrefix) { _isDashlPrefix = isDashlPrefix; }
-    void setSysRooted(bool isSysRooted) { _isSysRooted = isSysRooted; }
-
-  public:
-    bool _isWholeArchive;
-    bool _asNeeded;
-    bool _isDashlPrefix;
-    bool _isSysRooted;
-  };
-
-  ELFFileNode(ELFLinkingContext &ctx, StringRef path, Attributes &attributes)
-      : FileNode(path), _elfLinkingContext(ctx), _attributes(attributes) {}
-
-  ErrorOr<StringRef> getPath(const LinkingContext &ctx) const override;
-
-  /// \brief create an error string for printing purposes
-  std::string errStr(std::error_code) override;
-
-  /// \brief Dump the Input Element
-  bool dump(raw_ostream &diagnostics) override {
-    diagnostics << "Name    : " << *getPath(_elfLinkingContext) << "\n"
-                << "Type    : ELF File\n"
-                << "Attributes :\n"
-                << "  - wholeArchive : "
-                << ((_attributes._isWholeArchive) ? "true" : "false") << "\n"
-                << "  - asNeeded : "
-                << ((_attributes._asNeeded) ? "true" : "false") << "\n";
-    return true;
-  }
-
-  /// \brief Parse the input file to lld::File.
-  std::error_code parse(const LinkingContext &, raw_ostream &) override;
-
-private:
-  llvm::BumpPtrAllocator _alloc;
-  const ELFLinkingContext &_elfLinkingContext;
-  std::unique_ptr<const ArchiveLibraryFile> _archiveFile;
-  const Attributes _attributes;
-};
-
-} // namespace lld
-
-#endif

include/lld/Driver/WinLinkInputGraph.h

-//===- lld/Driver/WinLinkInputGraph.h - Input Graph Node for COFF linker --===//
-//
-//                             The LLVM Linker
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-///
-/// \file
-///
-/// Handles Options for PECOFF linking and provides InputElements
-/// for PECOFF linker
-///
-//===----------------------------------------------------------------------===//
-
-#ifndef LLD_DRIVER_WIN_LINK_INPUT_GRAPH_H
-#define LLD_DRIVER_WIN_LINK_INPUT_GRAPH_H
-
-#include "lld/Core/InputGraph.h"
-#include "lld/ReaderWriter/PECOFFLinkingContext.h"
-#include <map>
-
-namespace lld {
-
-/// \brief Represents a PECOFF File
-class PECOFFFileNode : public FileNode {
-public:
-  PECOFFFileNode(PECOFFLinkingContext &ctx, StringRef path)
-      : FileNode(path), _ctx(ctx), _parsed(false) {}
-
-  /// \brief Parse the input file to lld::File.
-  std::error_code parse(const LinkingContext &ctx,
-                        raw_ostream &diagnostics) override;
-
-protected:
-  const PECOFFLinkingContext &_ctx;
-
-private:
-  bool _parsed;
-};
-
-} // namespace lld
-
-#endif

include/lld/ReaderWriter/ELFLinkingContext.h

public:
   std::string demangle(StringRef symbolName) const override;
   bool demangleSymbols() const { return _demangle; }
   void setDemangleSymbols(bool d) { _demangle = d; }
 
   /// \brief Align segments.
   bool alignSegments() const { return _alignSegments; }
   void setAlignSegments(bool align) { _alignSegments = align; }
 
+  /// \brief The attributes class provides a way for a input file to look into
+  /// all the positional attributes that were specified in the command line.
+  /// There are few positional operators and the number of arguments to the
+  /// ELFFileNode class keeps growing. This achieves code to be clean as well.
+  class Attributes {
+  public:
+    Attributes()
+        : _isWholeArchive(false), _asNeeded(false), _isDashlPrefix(false),
+          _isSysRooted(false) {}
+    void setWholeArchive(bool isWholeArchive) {
+      _isWholeArchive = isWholeArchive;
+    }
+    void setAsNeeded(bool asNeeded) { _asNeeded = asNeeded; }
+    void setDashlPrefix(bool isDashlPrefix) { _isDashlPrefix = isDashlPrefix; }
+    void setSysRooted(bool isSysRooted) { _isSysRooted = isSysRooted; }
+
+    bool _isWholeArchive;
+    bool _asNeeded;
+    bool _isDashlPrefix;
+    bool _isSysRooted;
+  };
+
 private:
   ELFLinkingContext() LLVM_DELETED_FUNCTION;
 
 protected:
   ELFLinkingContext(llvm::Triple, std::unique_ptr<TargetHandlerBase>);
 
   Writer &writer() const override;
 

include/lld/ReaderWriter/MachOLinkingContext.h

private:
   bool _demangle;
   StringRef _bundleLoader;
   mutable std::unique_ptr<mach_o::ArchHandler> _archHandler;
   mutable std::unique_ptr<Writer> _writer;
   std::vector<SectionAlign> _sectAligns;
   mutable llvm::StringMap<mach_o::MachODylibFile*> _pathToDylibMap;
   mutable std::set<mach_o::MachODylibFile*> _allDylibs;
   mutable std::set<mach_o::MachODylibFile*> _upwardDylibs;
-  mutable std::vector<std::unique_ptr<class MachOFileNode>> _indirectDylibs;
+  mutable std::vector<std::unique_ptr<File>> _indirectDylibs;
   ExportMode _exportMode;
   llvm::StringSet<> _exportedSymbols;
   DebugInfoMode _debugInfoMode;
   std::unique_ptr<llvm::raw_fd_ostream> _dependencyInfo;
   llvm::StringMap<std::vector<OrderFileNode>> _orderFiles;
   unsigned _orderFileEntries;
 };
 
 } // end namespace lld
 
 #endif

lib/Driver/CMakeLists.txt

 set(LLVM_TARGET_DEFINITIONS UniversalDriverOptions.td)
 tablegen(LLVM UniversalDriverOptions.inc -gen-opt-parser-defs)
 set(LLVM_TARGET_DEFINITIONS GnuLdOptions.td)
 tablegen(LLVM GnuLdOptions.inc -gen-opt-parser-defs)
 set(LLVM_TARGET_DEFINITIONS CoreOptions.td)
 tablegen(LLVM CoreOptions.inc -gen-opt-parser-defs)
 set(LLVM_TARGET_DEFINITIONS DarwinLdOptions.td)
 tablegen(LLVM DarwinLdOptions.inc -gen-opt-parser-defs)
 set(LLVM_TARGET_DEFINITIONS WinLinkOptions.td)
 tablegen(LLVM WinLinkOptions.inc -gen-opt-parser-defs)
 add_public_tablegen_target(DriverOptionsTableGen)
 
 add_lld_library(lldDriver
   CoreDriver.cpp
-  DarwinInputGraph.cpp
   DarwinLdDriver.cpp
   Driver.cpp
   GnuLdDriver.cpp
-  GnuLdInputGraph.cpp
   UniversalDriver.cpp
   WinLinkDriver.cpp
-  WinLinkInputGraph.cpp
   WinLinkModuleDef.cpp
   )
 
 add_dependencies(lldDriver DriverOptionsTableGen)
 
 target_link_libraries(lldDriver ${cmake_2_8_12_INTERFACE}
   lldConfig
   lldPasses

lib/Driver/DarwinInputGraph.cpp

-//===- lib/ReaderWriter/MachO/DarwinInputGraph.cpp ------------------------===//
-//
-//                             The LLVM Linker
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include "lld/Driver/DarwinInputGraph.h"
-#include "lld/Core/ArchiveLibraryFile.h"
-#include "lld/Core/DefinedAtom.h"
-#include "lld/Core/File.h"
-#include "lld/Core/LLVM.h"
-#include "lld/Core/Reference.h"
-#include "lld/Core/SharedLibraryFile.h"
-
-namespace lld {
-
-
-/// \brief Parse the input file to lld::File.
-std::error_code MachOFileNode::parse(const LinkingContext &ctx,
-                                     raw_ostream &diagnostics)  {
-  ErrorOr<StringRef> filePath = getPath(ctx);
-  if (std::error_code ec = filePath.getError())
-    return ec;
-  ErrorOr<std::unique_ptr<MemoryBuffer>> mbOrErr =
-      MemoryBuffer::getFileOrSTDIN(*filePath);
-  if (std::error_code ec = mbOrErr.getError())
-    return ec;
-  std::unique_ptr<MemoryBuffer> mb = std::move(mbOrErr.get());
-
-  _context.addInputFileDependency(*filePath);
-  if (ctx.logInputFiles())
-    diagnostics << *filePath << "\n";
-
-  narrowFatBuffer(mb, *filePath);
-
-  std::vector<std::unique_ptr<File>> parsedFiles;
-  if (std::error_code ec = ctx.registry().parseFile(std::move(mb), parsedFiles))
-    return ec;
-  for (std::unique_ptr<File> &pf : parsedFiles) {
-    // If file is a dylib, inform LinkingContext about it.
-    if (SharedLibraryFile *shl = dyn_cast<SharedLibraryFile>(pf.get())) {
-      _context.registerDylib(reinterpret_cast<mach_o::MachODylibFile*>(shl),
-                             _upwardDylib);
-    }
-    // If file is an archive and -all_load, then add all members.
-    if (ArchiveLibraryFile *archive = dyn_cast<ArchiveLibraryFile>(pf.get())) {
-      if (_isWholeArchive) {
-        // Have this node own the FileArchive object.
-        _archiveFile.reset(archive);
-        pf.release();
-        // Add all members to _files vector
-        return archive->parseAllMembers(_files);
-      }
-    }
-    _files.push_back(std::move(pf));
-  }
-  return std::error_code();
-}
-
-
-/// If buffer contains a fat file, find required arch in fat buffer and
-/// switch buffer to point to just that required slice.
-void MachOFileNode::narrowFatBuffer(std::unique_ptr<MemoryBuffer> &mb,
-                                    StringRef filePath) {
-  // Check if buffer is a "fat" file that contains needed arch.
-  uint32_t offset;
-  uint32_t size;
-  if (!_context.sliceFromFatFile(*mb, offset, size)) {
-    return;
-  }
-  // Create new buffer containing just the needed slice.
-  auto subuf = MemoryBuffer::getFileSlice(filePath, size, offset);
-  if (subuf.getError())
-    return;
-  // The assignment to mb will release previous buffer.
-  mb = std::move(subuf.get());
-}
-
-
-} // end namesapce lld

lib/Driver/DarwinLdDriver.cpp

 //===- lib/Driver/DarwinLdDriver.cpp --------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 ///
 /// Concrete instance of the Driver for darwin's ld.
 ///
 //===----------------------------------------------------------------------===//
 
+#include "lld/Core/File.h"
+#include "lld/Core/ArchiveLibraryFile.h"
+#include "lld/Core/SharedLibraryFile.h"
 #include "lld/Driver/Driver.h"
-#include "lld/Driver/DarwinInputGraph.h"
+#include "lld/Driver/WrapperInputGraph.h"
 #include "lld/ReaderWriter/MachOLinkingContext.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/Option/Arg.h"
 #include "llvm/Option/Option.h"
 #include "llvm/Support/CommandLine.h"
+#include "llvm/Support/Debug.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/Host.h"
 #include "llvm/Support/MachO.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/PrettyStackTrace.h"
 #include "llvm/Support/Signals.h"

 };
 
 // Create OptTable class for parsing actual command line arguments
 class DarwinLdOptTable : public llvm::opt::OptTable {
 public:
   DarwinLdOptTable() : OptTable(infoTable, llvm::array_lengthof(infoTable)){}
 };
 
+std::vector<std::unique_ptr<File>>
+parseFiles(MachOLinkingContext &ctx, StringRef path,
+           raw_ostream &diag, bool wholeArchive, bool upwardDylib) {
+  ErrorOr<std::unique_ptr<MemoryBuffer>> mbOrErr =
+    MemoryBuffer::getFileOrSTDIN(path);
+  if (std::error_code ec = mbOrErr.getError())
+    return makeErrorFile(path, ec);
+  std::unique_ptr<MemoryBuffer> mb = std::move(mbOrErr.get());
+
+  ctx.addInputFileDependency(path);
+  if (ctx.logInputFiles())
+    diag << path << "\n";
+
+  // If buffer contains a fat file, find required arch in fat buffer
+  // and switch buffer to point to just that required slice.
+  // Check if buffer is a "fat" file that contains needed arch.
+  uint32_t offset;
+  uint32_t size;
+  if (ctx.sliceFromFatFile(*mb, offset, size)) {
+    // Create new buffer containing just the needed slice.
+    auto subuf = MemoryBuffer::getFileSlice(path, size, offset);
+    if (std::error_code ec = subuf.getError())
+      return makeErrorFile(path, ec);
+    // The assignment to mb will release previous buffer.
+    mb = std::move(subuf.get());
+  }
+
+  std::vector<std::unique_ptr<File>> files;
+  if (std::error_code ec = ctx.registry().parseFile(std::move(mb), files))
+    return makeErrorFile(path, ec);
+  for (std::unique_ptr<File> &pf : files) {
+    // If file is a dylib, inform LinkingContext about it.
+    if (SharedLibraryFile *shl = dyn_cast<SharedLibraryFile>(pf.get())) {
+      if (std::error_code ec = shl->parse())
+        return makeErrorFile(path, ec);
+      ctx.registerDylib(reinterpret_cast<mach_o::MachODylibFile*>(shl),
+                        upwardDylib);
+    }
+  }
+  if (wholeArchive)
+    return parseMemberFiles(files);
+  return files;
+}
+
 } // anonymous namespace
 
 // Test may be running on Windows. Canonicalize the path
 // separator to '/' to get consistent outputs for tests.
 static std::string canonicalizePath(StringRef path) {
   char sep = llvm::sys::path::get_separator().front();
   if (sep != '/') {
     std::string fixedPath = path;
     std::replace(fixedPath.begin(), fixedPath.end(), sep, '/');
     return fixedPath;
   } else {
     return path;
   }
 }
 
 static void addFile(StringRef path, std::unique_ptr<InputGraph> &inputGraph,
                     MachOLinkingContext &ctx, bool loadWholeArchive,
-                    bool upwardDylib) {
-  auto node = llvm::make_unique<MachOFileNode>(path, ctx);
-  if (loadWholeArchive)
-    node->setLoadWholeArchive();
-  if (upwardDylib)
-    node->setUpwardDylib();
-  inputGraph->addInputElement(std::move(node));
+                    bool upwardDylib, raw_ostream &diag) {
+  std::vector<std::unique_ptr<File>> files =
+      parseFiles(ctx, path, diag, loadWholeArchive, upwardDylib);
+  for (std::unique_ptr<File> &file : files)
+    inputGraph->addInputElement(
+        llvm::make_unique<WrapperNode>(std::move(file)));
 }
 
 // Export lists are one symbol per line.  Blank lines are ignored.
 // Trailing comments start with #.
 static std::error_code parseExportsList(StringRef exportFilePath,
                                         MachOLinkingContext &ctx,
                                         raw_ostream &diagnostics) {
   // Map in export list file.
while (!buffer.empty()) {
     if (!ctx.pathExists(path)) {
       return make_dynamic_error_code(Twine("File not found '")
                                      + path
                                      + "'");
     }
     if (ctx.testingFileUsage()) {
       diagnostics << "Found filelist entry " << canonicalizePath(path) << '\n';
     }
-    addFile(path, inputGraph, ctx, forceLoad, false);
+    addFile(path, inputGraph, ctx, forceLoad, false, diagnostics);
     buffer = lineAndRest.second;
   }
   return std::error_code();
 }
 
 /// Parse number assuming it is base 16, but allow 0x prefix.
 static bool parseNumberBase16(StringRef numStr, uint64_t &baseAddress) {
   if (numStr.startswith_lower("0x"))
     numStr = numStr.drop_front(2);
   return numStr.getAsInteger(16, baseAddress);
 }
 
 namespace lld {
 
 bool DarwinLdDriver::linkMachO(int argc, const char *argv[],
                                raw_ostream &diagnostics) {
   MachOLinkingContext ctx;
   if (!parse(argc, argv, ctx, diagnostics))
     return false;
   if (ctx.doNothing())
     return true;
-
-  // Register possible input file parsers.
-  ctx.registry().addSupportMachOObjects(ctx);
-  ctx.registry().addSupportArchives(ctx.logInputFiles());
-  ctx.registry().addSupportNativeObjects();
-  ctx.registry().addSupportYamlFiles();
-
   return link(ctx, diagnostics);
 }
 
 bool DarwinLdDriver::parse(int argc, const char *argv[],
                            MachOLinkingContext &ctx, raw_ostream &diagnostics) {
   // Parse command line options using DarwinLdOptions.td
   std::unique_ptr<llvm::opt::InputArgList> parsedArgs;
   DarwinLdOptTable table;
if (llvm::opt::Arg *archStr = parsedArgs->getLastArg(OPT_arch)) {
     arch = MachOLinkingContext::archFromName(archStr->getValue());
     if (arch == MachOLinkingContext::arch_unknown) {
       diagnostics << "error: unknown arch named '" << archStr->getValue()
                   << "'\n";
       return false;
     }
   }
   // If no -arch specified, scan input files to find first non-fat .o file.
-  if ((arch == MachOLinkingContext::arch_unknown)
-      && !parsedArgs->getLastArg(OPT_test_file_usage)) {
+  if (arch == MachOLinkingContext::arch_unknown) {
     for (auto &inFile: parsedArgs->filtered(OPT_INPUT)) {
       // This is expensive because it opens and maps the file.  But that is
       // ok because no -arch is rare.
       if (MachOLinkingContext::isThinObjectFile(inFile->getValue(), arch))
         break;
     }
-    if (arch == MachOLinkingContext::arch_unknown) {
+    if (arch == MachOLinkingContext::arch_unknown
+        && !parsedArgs->getLastArg(OPT_test_file_usage)) {
       // If no -arch and no options at all, print usage message.
       if (parsedArgs->size() == 0)
         table.PrintHelp(llvm::outs(), argv[0], "LLVM Linker", false);
       else
         diagnostics << "error: -arch not specified and could not be inferred\n";
       return false;
     }
   }
if (parsedArgs->getLastArg(OPT_test_file_usage)) {
     ctx.setDoNothing(true);
 
     // Only bother looking for an existence override if we're going to use it.
     for (auto existingPath : parsedArgs->filtered(OPT_path_exists)) {
       ctx.addExistingPathForDebug(existingPath->getValue());
     }
   }
 
+  // Register possible input file parsers.
+  if (!ctx.doNothing()) {
+    ctx.registry().addSupportMachOObjects(ctx);
+    ctx.registry().addSupportArchives(ctx.logInputFiles());
+    ctx.registry().addSupportNativeObjects();
+    ctx.registry().addSupportYamlFiles();
+  }
   std::unique_ptr<InputGraph> inputGraph(new InputGraph());
 
   // Now construct the set of library search directories, following ld64's
   // baroque set of accumulated hacks. Mostly, the algorithm constructs
   //     { syslibroots } x { libpaths }
   //
   // Unfortunately, there are numerous exceptions:
   //   1. Only absolute paths get modified by syslibroot options.
bool DarwinLdDriver::parse(int argc, const char *argv[],
   // Handle input files
   for (auto &arg : *parsedArgs) {
     bool upward;
     ErrorOr<StringRef> resolvedPath = StringRef();
     switch (arg->getOption().getID()) {
     default:
       continue;
     case OPT_INPUT:
-      addFile(arg->getValue(), inputGraph, ctx, globalWholeArchive, false);
+      addFile(arg->getValue(), inputGraph, ctx, globalWholeArchive, false, diagnostics);
       break;
     case OPT_upward_library:
-      addFile(arg->getValue(), inputGraph, ctx, false, true);
+      addFile(arg->getValue(), inputGraph, ctx, false, true, diagnostics);
       break;
     case OPT_force_load:
-      addFile(arg->getValue(), inputGraph, ctx, true, false);
+      addFile(arg->getValue(), inputGraph, ctx, true, false, diagnostics);
       break;
     case OPT_l:
     case OPT_upward_l:
       upward = (arg->getOption().getID() == OPT_upward_l);
       resolvedPath = ctx.searchLibrary(arg->getValue());
       if (!resolvedPath) {
         diagnostics << "Unable to find library for " << arg->getSpelling()
                     << arg->getValue() << "\n";
         return false;
       } else if (ctx.testingFileUsage()) {
         diagnostics << "Found " << (upward ? "upward " : " ") << "library "
                    << canonicalizePath(resolvedPath.get()) << '\n';
       }
-      addFile(resolvedPath.get(), inputGraph, ctx, globalWholeArchive, upward);
+      addFile(resolvedPath.get(), inputGraph, ctx, globalWholeArchive, upward, diagnostics);
       break;
     case OPT_framework:
     case OPT_upward_framework:
       upward = (arg->getOption().getID() == OPT_upward_framework);
       resolvedPath = ctx.findPathForFramework(arg->getValue());
       if (!resolvedPath) {
         diagnostics << "Unable to find framework for "
                     << arg->getSpelling() << " " << arg->getValue() << "\n";
         return false;
       } else if (ctx.testingFileUsage()) {
         diagnostics << "Found " << (upward ? "upward " : " ") << "framework "
                     << canonicalizePath(resolvedPath.get()) << '\n';
       }
-      addFile(resolvedPath.get(), inputGraph, ctx, globalWholeArchive, upward);
+      addFile(resolvedPath.get(), inputGraph, ctx, globalWholeArchive, upward, diagnostics);
       break;
     case OPT_filelist:
       if (std::error_code ec = parseFileList(arg->getValue(), inputGraph,
                                              ctx, globalWholeArchive,
                                              diagnostics)) {
         diagnostics << "error: " << ec.message()
                     << ", processing '-filelist " << arg->getValue()
                     << "'\n";

lib/Driver/GnuLdDriver.cpp

 //===- lib/Driver/GnuLdDriver.cpp -----------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 ///
 /// Concrete instance of the Driver for GNU's ld.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "lld/Driver/Driver.h"
-#include "lld/Driver/GnuLdInputGraph.h"
+#include "lld/Driver/WrapperInputGraph.h"
+#include "lld/ReaderWriter/ELFLinkingContext.h"
 #include "lld/ReaderWriter/LinkerScript.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/Option/Arg.h"
 #include "llvm/Option/Option.h"
bool GnuLdDriver::linkELF(int argc, const char *argv[],
                           raw_ostream &diagnostics) {
   BumpPtrAllocator alloc;
   std::tie(argc, argv) = maybeExpandResponseFiles(argc, argv, alloc);
   std::unique_ptr<ELFLinkingContext> options;
   if (!parse(argc, argv, options, diagnostics))
     return false;
   if (!options)
     return true;
-
-  // Register possible input file parsers.
-  options->registry().addSupportELFObjects(options->mergeCommonStrings(),
-                                           options->targetHandler());
-  options->registry().addSupportArchives(options->logInputFiles());
-  options->registry().addSupportYamlFiles();
-  options->registry().addSupportNativeObjects();
-  if (options->allowLinkWithDynamicLibraries())
-    options->registry().addSupportELFDynamicSharedObjects(
-        options->useShlibUndefines(), options->targetHandler());
   return link(*options, diagnostics);
 }
 
 static llvm::Optional<llvm::Triple::ArchType>
 getArchType(const llvm::Triple &triple, StringRef value) {
   switch (triple.getArch()) {
   case llvm::Triple::x86:
   case llvm::Triple::x86_64:
static bool isLinkerScript(StringRef path, raw_ostream &diag) {
   std::error_code ec = getFileMagic(path, magic);
   if (ec) {
     diag << "unknown input file format for file " << path << "\n";
     return false;
   }
   return magic == llvm::sys::fs::file_magic::unknown;
 }
 
+static ErrorOr<StringRef>
+findFile(ELFLinkingContext &ctx, StringRef path, bool dashL) {
+  // If the path was referred to by using a -l argument, let's search
+  // for the file in the search path.
+  if (dashL) {
+    ErrorOr<StringRef> pathOrErr = ctx.searchLibrary(path);
+    if (std::error_code ec = pathOrErr.getError())
+      return make_dynamic_error_code(
+          Twine("Unable to find library -l") + path + ": " + ec.message());
+    path = pathOrErr->str();
+  }
+  if (!llvm::sys::fs::exists(path))
+    return make_dynamic_error_code(
+        Twine("lld: cannot find file ") + path);
+  return path;
+}
+
 static bool isPathUnderSysroot(StringRef sysroot, StringRef path) {
   if (sysroot.empty())
     return false;
   while (!path.empty() && !llvm::sys::fs::equivalent(sysroot, path))
     path = llvm::sys::path::parent_path(path);
   return !path.empty();
 }
 
 static std::error_code
 evaluateLinkerScript(ELFLinkingContext &ctx, InputGraph *inputGraph,
                      StringRef path, raw_ostream &diag) {
   // Read the script file from disk and parse.
   ErrorOr<std::unique_ptr<MemoryBuffer>> mb =
       MemoryBuffer::getFileOrSTDIN(path);
   if (std::error_code ec = mb.getError())
     return ec;
-  if (ctx.logInputFiles())
-    diag << path << "\n";
   auto lexer = llvm::make_unique<script::Lexer>(std::move(mb.get()));
   auto parser = llvm::make_unique<script::Parser>(*lexer);
   script::LinkerScript *script = parser->parse();
   if (!script)
     return LinkerScriptReaderError::parse_error;
 
   // Evaluate script commands.
   // Currently we only recognize GROUP() command.
   bool sysroot = (!ctx.getSysroot().empty()
                   && isPathUnderSysroot(ctx.getSysroot(), path));
   for (const script::Command *c : script->_commands) {
     auto *group = dyn_cast<script::Group>(c);
     if (!group)
       continue;
     int numfiles = 0;
     for (const script::Path &path : group->getPaths()) {
       // TODO : Propagate Set WholeArchive/dashlPrefix
-      ELFFileNode::Attributes attr;
+      ELFLinkingContext::Attributes attr;
       attr.setSysRooted(sysroot);
       attr.setAsNeeded(path._asNeeded);
       attr.setDashlPrefix(path._isDashlPrefix);
+
+      ErrorOr<StringRef> pathOrErr = path._isDashlPrefix
+          ? ctx.searchLibrary(path._path) : ctx.searchFile(path._path, sysroot);
+      if (std::error_code ec = pathOrErr.getError())
+        return make_dynamic_error_code(
+            Twine("Unable to find file ") + path._path + ": " + ec.message());
+
+      std::vector<std::unique_ptr<File>> files
+          = parseFile(ctx, pathOrErr.get(), false);
+      for (std::unique_ptr<File> &file : files) {
+        if (ctx.logInputFiles())
+          diag << file->path() << "\n";
+        inputGraph->addInputElement(
+            std::unique_ptr<InputElement>(new WrapperNode(std::move(file))));
         ++numfiles;
-      inputGraph->addInputElement(llvm::make_unique<ELFFileNode>(
-                                      ctx, ctx.allocateString(path._path), attr));
+      }
     }
     inputGraph->addInputElement(llvm::make_unique<GroupEnd>(numfiles));
   }
   return std::error_code();
 }
 
 bool GnuLdDriver::applyEmulation(llvm::Triple &triple,
                                  llvm::opt::InputArgList &args,
                                  raw_ostream &diagnostics) {
if (!ctx) {
     diagnostics << "unknown target triple\n";
     return false;
   }
 
   std::unique_ptr<InputGraph> inputGraph(new InputGraph());
   std::stack<int> groupStack;
   int numfiles = 0;
 
-  ELFFileNode::Attributes attributes;
+  ELFLinkingContext::Attributes attributes;
 
   bool _outputOptionSet = false;
 
   // Ignore unknown arguments.
   for (auto unknownArg : parsedArgs->filtered(OPT_UNKNOWN))
     diagnostics << "warning: ignoring unknown argument: "
                 << unknownArg->getValue() << "\n";
 
if (llvm::opt::Arg *kind =
           parsedArgs->getLastArg(OPT_relocatable, OPT_static, OPT_shared,
                                  OPT_nmagic, OPT_omagic, OPT_no_omagic)) {
     switch (kind->getOption().getID()) {
     case OPT_relocatable:
       ctx->setOutputELFType(llvm::ELF::ET_REL);
       ctx->setPrintRemainingUndefines(false);
       ctx->setAllowRemainingUndefines(true);
       break;
-
     case OPT_static:
       ctx->setOutputELFType(llvm::ELF::ET_EXEC);
       ctx->setIsStaticExecutable(true);
       break;
     case OPT_shared:
       ctx->setOutputELFType(llvm::ELF::ET_DYN);
       ctx->setAllowShlibUndefines(true);
       ctx->setUseShlibUndefines(false);
if (llvm::opt::Arg *kind =
 
     case OPT_no_omagic:
       ctx->setOutputMagic(ELFLinkingContext::OutputMagic::DEFAULT);
       ctx->setNoAllowDynamicLibraries();
       break;
     }
   }
 
+  for (auto inputArg : *parsedArgs) {
+    switch (inputArg->getOption().getID()) {
+    case OPT_merge_strings:
+      ctx->setMergeCommonStrings(true);
+      break;
+    case OPT_t:
+      ctx->setLogInputFiles(true);
+      break;
+    case OPT_use_shlib_undefs:
+      ctx->setUseShlibUndefines(true);
+      break;
+    case OPT_no_allow_shlib_undefs:
+      ctx->setAllowShlibUndefines(false);
+      break;
+    case OPT_allow_shlib_undefs:
+      ctx->setAllowShlibUndefines(true);
+      break;
+    }
+  }
+
+  // Register possible input file parsers.
+  ctx->registry().addSupportELFObjects(
+      ctx->mergeCommonStrings(),
+      ctx->targetHandler());
+  ctx->registry().addSupportArchives(ctx->logInputFiles());
+  ctx->registry().addSupportYamlFiles();
+  ctx->registry().addSupportNativeObjects();
+  if (ctx->allowLinkWithDynamicLibraries())
+    ctx->registry().addSupportELFDynamicSharedObjects(
+        ctx->useShlibUndefines(), ctx->targetHandler());
+
   // Process all the arguments and create Input Elements
   for (auto inputArg : *parsedArgs) {
     switch (inputArg->getOption().getID()) {
     case OPT_mllvm:
       ctx->appendLLVMOption(inputArg->getValue());
       break;
     case OPT_e:
       ctx->setEntrySymbolName(inputArg->getValue());
       break;
 
     case OPT_output:
       _outputOptionSet = true;
       ctx->setOutputPath(inputArg->getValue());
       break;
 
     case OPT_noinhibit_exec:
       ctx->setAllowRemainingUndefines(true);
       break;
 
     case OPT_export_dynamic:
       ctx->setExportDynamic(true);
       break;
 
-    case OPT_merge_strings:
-      ctx->setMergeCommonStrings(true);
-      break;
-
-    case OPT_t:
-      ctx->setLogInputFiles(true);
-      break;
-
-    case OPT_no_allow_shlib_undefs:
-      ctx->setAllowShlibUndefines(false);
-      break;
-
-    case OPT_allow_shlib_undefs:
-      ctx->setAllowShlibUndefines(true);
-      break;
-
-    case OPT_use_shlib_undefs:
-      ctx->setUseShlibUndefines(true);
-      break;
-
     case OPT_allow_multiple_definition:
       ctx->setAllowDuplicates(true);
       break;
 
     case OPT_dynamic_linker:
       ctx->setInterpreter(inputArg->getValue());
       break;
 
case OPT_z: {
       break;
     }
 
     case OPT_INPUT:
     case OPT_l: {
       bool dashL = (inputArg->getOption().getID() == OPT_l);
       attributes.setDashlPrefix(dashL);
       StringRef path = inputArg->getValue();
-      std::string realpath = path;
 
-      // If the path was referred to by using a -l argument, let's search
-      // for the file in the search path.
-      if (dashL) {
-        ErrorOr<StringRef> pathOrErr = ctx->searchLibrary(path);
-        if (!pathOrErr) {
-          diagnostics << " Unable to find library -l" << path << "\n";
-          return false;
-        }
-        realpath = pathOrErr->str();
-      }
-      if (!llvm::sys::fs::exists(realpath)) {
-        diagnostics << "lld: cannot find file " << path << "\n";
+      ErrorOr<StringRef> pathOrErr = findFile(*ctx, path, dashL);
+      if (std::error_code ec = pathOrErr.getError()) {
+        diagnostics << ec.message() << "\n";
         return false;
       }
+      std::string realpath = pathOrErr.get();
+
       bool isScript =
           (!path.endswith(".objtxt") && isLinkerScript(realpath, diagnostics));
       if (isScript) {
+        if (ctx->logInputFiles())
+          diagnostics << path << "\n";
         std::error_code ec = evaluateLinkerScript(
             *ctx, inputGraph.get(), realpath, diagnostics);
         if (ec) {
           diagnostics << path << ": Error parsing linker script: "
                       << ec.message() << "\n";
           return false;
         }
         break;
       }
-      ++numfiles;
+      std::vector<std::unique_ptr<File>> files
+          = parseFile(*ctx, realpath, attributes._isWholeArchive);
+      for (std::unique_ptr<File> &file : files) {
+        if (ctx->logInputFiles())
+          diagnostics << file->path() << "\n";
         inputGraph->addInputElement(
-          llvm::make_unique<ELFFileNode>(*ctx, path, attributes));
+            std::unique_ptr<InputElement>(new WrapperNode(std::move(file))));
+      }
+      numfiles += files.size();
       break;
     }
 
     case OPT_rpath: {
       SmallVector<StringRef, 2> rpaths;
       StringRef(inputArg->getValue()).split(rpaths, ":");
       for (auto path : rpaths)
         ctx->addRpath(path);

lib/Driver/GnuLdInputGraph.cpp

-//===- lib/Driver/GnuLdInputGraph.cpp -------------------------------------===//
-//
-//                             The LLVM Linker
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include "lld/Driver/GnuLdInputGraph.h"
-#include "lld/ReaderWriter/LinkerScript.h"
-#include "llvm/Support/Errc.h"
-#include "llvm/Support/FileSystem.h"
-#include "llvm/Support/Path.h"
-
-using namespace lld;
-
-llvm::ErrorOr<StringRef> ELFFileNode::getPath(const LinkingContext &) const {
-  if (_attributes._isDashlPrefix)
-    return _elfLinkingContext.searchLibrary(_path);
-  return _elfLinkingContext.searchFile(_path, _attributes._isSysRooted);
-}
-
-std::string ELFFileNode::errStr(std::error_code errc) {
-  if (errc == llvm::errc::no_such_file_or_directory) {
-    if (_attributes._isDashlPrefix)
-      return (Twine("Unable to find library -l") + _path).str();
-    return (Twine("Unable to find file ") + _path).str();
-  }
-  return FileNode::errStr(errc);
-}
-
-/// \brief Parse the input file to lld::File.
-std::error_code ELFFileNode::parse(const LinkingContext &ctx,
-                                   raw_ostream &diagnostics) {
-  ErrorOr<StringRef> filePath = getPath(ctx);
-  if (std::error_code ec = filePath.getError())
-    return ec;
-  ErrorOr<std::unique_ptr<MemoryBuffer>> mb =
-      MemoryBuffer::getFileOrSTDIN(*filePath);
-  if (std::error_code ec = mb.getError())
-    return ec;
-  if (ctx.logInputFiles())
-    diagnostics << *filePath << "\n";
-
-  if (_attributes._isWholeArchive) {
-    std::vector<std::unique_ptr<File>> parsedFiles;
-    if (std::error_code ec = ctx.registry().parseFile(
-            std::move(mb.get()), parsedFiles))
-      return ec;
-    assert(parsedFiles.size() == 1);
-    std::unique_ptr<File> f(parsedFiles[0].release());
-    if (const auto *archive = dyn_cast<ArchiveLibraryFile>(f.get())) {
-      // Have this node own the FileArchive object.
-      _archiveFile.reset(archive);
-      f.release();
-      // Add all members to _files vector
-      return archive->parseAllMembers(_files);
-    }
-    // if --whole-archive is around non-archive, just use it as normal.
-    _files.push_back(std::move(f));
-    return std::error_code();
-  }
-  return ctx.registry().parseFile(std::move(mb.get()), _files);
-}

lib/Driver/WinLinkDriver.cpp

 //===- lib/Driver/WinLinkDriver.cpp ---------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 ///
 /// Concrete instance of the Driver for Windows link.exe.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "lld/Driver/Driver.h"
-#include "lld/Driver/WinLinkInputGraph.h"
 #include "lld/Driver/WinLinkModuleDef.h"
+#include "lld/Driver/WrapperInputGraph.h"
 #include "lld/ReaderWriter/PECOFFLinkingContext.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Object/COFF.h"
 #include "llvm/Option/Arg.h"
if (!isReadingDirectiveSection && expanded &&
     diag << "\n\n";
   }
 
   return parsedArgs;
 }
 
 // Returns true if the given file node has already been added to the input
 // graph.
-static bool hasLibrary(const PECOFFLinkingContext &ctx, FileNode *fileNode) {
-  ErrorOr<StringRef> path = fileNode->getPath(ctx);
-  if (!path)
-    return false;
+static bool hasLibrary(const PECOFFLinkingContext &ctx, File *file) {
+  StringRef path = file->path();
   for (std::unique_ptr<InputElement> &p : ctx.getInputGraph().inputElements())
     if (auto *f = dyn_cast<FileNode>(p.get()))
-      if (*path == *f->getPath(ctx))
+      if (*f->getPath(ctx) == path)
         return true;
   return false;
 }
 
 // If the first command line argument is "/lib", link.exe acts as if it's
 // "lib.exe" command. This feature is not documented and looks weird, or at
 // least seems redundant, but is needed for MSVC compatibility.
 static bool maybeRunLibCommand(int argc, const char **argv, raw_ostream &diag) {
for (int i = 2; i < argc; ++i)
     vec.push_back(argv[i]);
   vec.push_back(nullptr);
 
   if (llvm::sys::ExecuteAndWait(path.c_str(), &vec[0]) != 0)
     diag << "lib.exe failed\n";
   return true;
 }
 
+/// \brief Parse the input file to lld::File.
+void addFiles(PECOFFLinkingContext &ctx, StringRef path, raw_ostream &diag,
+        std::vector<std::unique_ptr<File>> &files) {
+  for (std::unique_ptr<File> &file : parseFile(ctx, path, false)) {
+    if (ctx.logInputFiles())
+      diag << file->path() << "\n";
+    files.push_back(std::move(file));
+  }
+}
+
 //
 // Main driver
 //
 
 bool WinLinkDriver::linkPECOFF(int argc, const char **argv, raw_ostream &diag) {
   if (maybeRunLibCommand(argc, argv, diag))
     return true;
 
   PECOFFLinkingContext ctx;
+  ctx.registry().addSupportCOFFObjects(ctx);
+  ctx.registry().addSupportCOFFImportLibraries(ctx);
+  ctx.registry().addSupportArchives(ctx.logInputFiles());
+  ctx.registry().addSupportNativeObjects();
+  ctx.registry().addSupportYamlFiles();
+
   std::vector<const char *> newargv = processLinkEnv(ctx, argc, argv);
   processLibEnv(ctx);
   if (!parse(newargv.size() - 1, &newargv[0], ctx, diag))
     return false;
 
   // Create the file if needed.
   if (ctx.getCreateManifest() && !ctx.getEmbedManifest())
     if (!createSideBySideManifestFile(ctx, diag))
       return false;
 
-  // Register possible input file parsers.
-  ctx.registry().addSupportCOFFObjects(ctx);
-  ctx.registry().addSupportCOFFImportLibraries(ctx);
-  ctx.registry().addSupportArchives(ctx.logInputFiles());
-  ctx.registry().addSupportNativeObjects();
-  ctx.registry().addSupportYamlFiles();
-
   return link(ctx, diag);
 }
 
 bool WinLinkDriver::parse(int argc, const char *argv[],
                           PECOFFLinkingContext &ctx, raw_ostream &diag,
                           bool isReadingDirectiveSection,
                           std::set<StringRef> *undefinedSymbols) {
   // Parse may be called from multiple threads simultaneously to parse .drectve
   // sections. This function is not thread-safe because it mutates the context
   // object. So acquire the lock.
   std::lock_guard<std::recursive_mutex> lock(ctx.getMutex());
 
   std::map<StringRef, StringRef> failIfMismatchMap;
   // Parse the options.
   std::unique_ptr<llvm::opt::InputArgList> parsedArgs =
       parseArgs(argc, argv, ctx, diag, isReadingDirectiveSection);
   if (!parsedArgs)
     return false;
 
   // The list of input files.
-  std::vector<std::unique_ptr<FileNode> > files;
-  std::vector<std::unique_ptr<FileNode> > libraries;
+  std::vector<std::unique_ptr<File>> files;
+  std::vector<std::unique_ptr<File>> libraries;
 
   // Handle /help
   if (parsedArgs->getLastArg(OPT_help)) {
     WinLinkOptTable table;
     table.PrintHelp(llvm::outs(), argv[0], "LLVM Linker", false);
     return false;
   }
 
if (it != inputFiles.begin()) {
       ctx.registerTemporaryFile(resObj);
     }
   }
 
   // Prepare objects to add them to input graph.
   for (StringRef path : inputFiles) {
     path = ctx.allocate(path);
     if (isLibraryFile(path)) {
-      libraries.push_back(std::unique_ptr<FileNode>(
-          new PECOFFFileNode(ctx, getLibraryPath(ctx, path))));
+      addFiles(ctx, getLibraryPath(ctx, path), diag, libraries);
     } else {
-      files.push_back(std::unique_ptr<FileNode>(
-          new PECOFFFileNode(ctx, getObjectPath(ctx, path))));
+      addFiles(ctx, getObjectPath(ctx, path), diag, files);
     }
   }
 
   // Specify /noentry without /dll is an error.
   if (!ctx.hasEntry() && !parsedArgs->getLastArg(OPT_dll)) {
     diag << "/noentry must be specified with /dll\n";
     return false;
   }
 
   // If dead-stripping is enabled, we need to add the entry symbol and
   // symbols given by /include to the dead strip root set, so that it
   // won't be removed from the output.
   if (ctx.deadStrip())
     for (const StringRef symbolName : ctx.initialUndefinedSymbols())
       ctx.addDeadStripRoot(symbolName);
 
   // Add the libraries specified by /defaultlib unless they are already added
   // nor blacklisted by /nodefaultlib.
   if (!ctx.getNoDefaultLibAll())
     for (const StringRef path : defaultLibs)
       if (!ctx.hasNoDefaultLib(path))
-        libraries.push_back(std::unique_ptr<FileNode>(
-            new PECOFFFileNode(ctx, getLibraryPath(ctx, path.lower()))));
+  addFiles(ctx, getLibraryPath(ctx, path.lower()), diag, libraries);
 
   if (files.empty() && !isReadingDirectiveSection) {
     diag << "No input files\n";
     return false;
   }
 
   // If /out option was not specified, the default output file name is
   // constructed by replacing an extension of the first input file
   // with ".exe".
   if (ctx.outputPath().empty()) {
-    StringRef path = *cast<FileNode>(&*files[0])->getPath(ctx);
+    StringRef path = files[0]->path();
     ctx.setOutputPath(replaceExtension(ctx, path, ".exe"));
   }
 
   // Add the input files to the input graph.
   if (!ctx.hasInputGraph())
     ctx.setInputGraph(std::unique_ptr<InputGraph>(new InputGraph()));
-  for (std::unique_ptr<FileNode> &file : files) {
+  for (std::unique_ptr<File> &file : files) {
     if (isReadingDirectiveSection)
-      if (file->parse(ctx, diag))
+      if (file->parse())
         return false;
-    ctx.getInputGraph().addInputElement(std::move(file));
+    ctx.getInputGraph().addInputElement(
+  std::unique_ptr<InputElement>(new WrapperNode(std::move(file))));
   }
 
   // Add the library group to the input graph.
   if (!isReadingDirectiveSection) {
     // The container for the entry point file.
     std::unique_ptr<SimpleFileNode> entry(new SimpleFileNode("<entry>"));
     ctx.setEntryNode(entry.get());
     ctx.getInputGraph().addInputElement(std::move(entry));
 
     // Add a group-end marker.
     ctx.getInputGraph().addInputElement(llvm::make_unique<GroupEnd>(0));
   }
 
   // Add the library files to the library group.
-  for (std::unique_ptr<FileNode> &lib : libraries) {
-    if (!hasLibrary(ctx, lib.get())) {
+  for (std::unique_ptr<File> &file : libraries) {
+    if (!hasLibrary(ctx, file.get())) {
       if (isReadingDirectiveSection)
-        if (lib->parse(ctx, diag))
+        if (file->parse())
           return false;
-      ctx.addLibraryFile(std::move(lib));
+      ctx.addLibraryFile(
+  std::unique_ptr<FileNode>(new WrapperNode(std::move(file))));
     }
   }
 
   // Validate the combination of options used.
   return ctx.validate(diag);
 }
 
 } // namespace lld

lib/Driver/WinLinkInputGraph.cpp

-//===- lib/Driver/WinLinkInputGraph.cpp -----------------------------------===//
-//
-//                             The LLVM Linker
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include "lld/Driver/WinLinkInputGraph.h"
-
-namespace lld {
-
-/// \brief Parse the input file to lld::File.
-std::error_code PECOFFFileNode::parse(const LinkingContext &ctx,
-                                      raw_ostream &diagnostics) {
-  if (_parsed)
-    return std::error_code();
-  _parsed = true;
-  ErrorOr<StringRef> filePath = getPath(ctx);
-  if (std::error_code ec = filePath.getError()) {
-    diagnostics << "File not found: " << _path << "\n";
-    return ec;
-  }
-
-  ErrorOr<std::unique_ptr<MemoryBuffer>> mb =
-      MemoryBuffer::getFileOrSTDIN(*filePath);
-  if (std::error_code ec = mb.getError()) {
-    diagnostics << "Cannot open file: " << *filePath << "\n";
-    return ec;
-  }
-
-  if (ctx.logInputFiles())
-    diagnostics << *filePath << "\n";
-
-  return ctx.registry().parseFile(std::move(mb.get()), _files);
-}
-
-} // end anonymous namespace

lib/Passes/RoundTripNativePass.cpp

void RoundTripNativePass::perform(std::unique_ptr<MutableFile> &mergedFile) {
 
   std::error_code ec = _context.registry().parseFile(
       std::move(mb.get()), _nativeFile);
   if (ec) {
     // Note: we need a way for Passes to report errors.
     llvm_unreachable("native reader not registered or read error");
   }
   File *objFile = _nativeFile[0].get();
+  if (objFile->parse())
+    llvm_unreachable("native reader parse error");
   mergedFile.reset(new SimpleFileWrapper(_context, *objFile));
 
   llvm::sys::fs::remove(tmpNativeFile.str());
 }

lib/Passes/RoundTripYAMLPass.cpp

void RoundTripYAMLPass::perform(std::unique_ptr<MutableFile> &mergedFile) {
 
   std::error_code ec = _context.registry().parseFile(
       std::move(mb.get()), _yamlFile);
   if (ec) {
     // Note: we need a way for Passes to report errors.
     llvm_unreachable("yaml reader not registered or read error");
   }
   File *objFile = _yamlFile[0].get();
+  if (objFile->parse())
+    llvm_unreachable("native reader parse error");
   mergedFile.reset(new SimpleFileWrapper(_context, *objFile));
   llvm::sys::fs::remove(tmpYAMLFile.str());
 }

lib/ReaderWriter/FileArchive.cpp

if (instantiateMember(ci, result))
       return nullptr;
 
     // give up the pointer so that this object no longer manages it
     return result.release();
   }
 
   /// \brief parse each member
   std::error_code
-  parseAllMembers(std::vector<std::unique_ptr<File>> &result) const override {
+  parseAllMembers(std::vector<std::unique_ptr<File>> &result) override {
+    if (std::error_code ec = parse())
+      return ec;
     for (auto mf = _archive->child_begin(), me = _archive->child_end();
          mf != me; ++mf) {
       std::unique_ptr<File> file;
       if (std::error_code ec = instantiateMember(mf, file))
         return ec;
       result.push_back(std::move(file));
     }
     return std::error_code();
instantiateMember(Archive::child_iterator member,
 
     if (_logLoading)
       llvm::errs() << memberPath << "\n";
 
     std::unique_ptr<MemoryBuffer> memberMB(MemoryBuffer::getMemBuffer(
         mb.getBuffer(), memberPath, false));
 
     std::vector<std::unique_ptr<File>> files;
-    _registry.parseFile(std::move(memberMB), files);
+    if (std::error_code ec = _registry.parseFile(std::move(memberMB), files))
+      return ec;
     assert(files.size() == 1);
     result = std::move(files[0]);
+    if (std::error_code ec = result->parse())
+      return ec;
 
     // 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

lib/ReaderWriter/MachO/ExecutableAtoms.hpp

MachHeaderAliasFile(const MachOLinkingContext &context)
         _machHeaderSymbolName = "__mh_preload_header";
         break;
       default:
         llvm_unreachable("no mach_header symbol for file type");
       }
   }
 
   std::error_code
-  parseAllMembers(std::vector<std::unique_ptr<File>> &result) const override {
+  parseAllMembers(std::vector<std::unique_ptr<File>> &result) override {
     return std::error_code();
   }
 
   const File *find(StringRef sym, bool dataSymbolOnly) const override {
     if (sym.equals("___dso_handle") || sym.equals(_machHeaderSymbolName)) {
       _definedAtoms._atoms.push_back(new (_alloc) MachODefinedAtom(
           *this, sym, DefinedAtom::scopeLinkageUnit,
           DefinedAtom::typeMachHeader, DefinedAtom::mergeNo, false, false,

lib/ReaderWriter/MachO/MachOLinkingContext.cpp

 //===- lib/ReaderWriter/MachO/MachOLinkingContext.cpp ---------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lld/ReaderWriter/MachOLinkingContext.h"
 #include "ArchHandler.h"
 #include "File.h"
 #include "MachONormalizedFile.h"
 #include "MachOPasses.h"
+#include "lld/Core/ArchiveLibraryFile.h"
 #include "lld/Core/PassManager.h"
-#include "lld/Driver/DarwinInputGraph.h"
 #include "lld/Passes/LayoutPass.h"
 #include "lld/Passes/RoundTripYAMLPass.h"
 #include "lld/ReaderWriter/Reader.h"
 #include "lld/ReaderWriter/Writer.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/Config/config.h"
 #include "llvm/Support/Errc.h"

 
 Writer &MachOLinkingContext::writer() const {
   if (!_writer)
     _writer = createWriterMachO(*this);
   return *_writer;
 }
 
 MachODylibFile* MachOLinkingContext::loadIndirectDylib(StringRef path) {
-  std::unique_ptr<MachOFileNode> node(new MachOFileNode(path, *this));
-  std::error_code ec = node->parse(*this, llvm::errs());
-  if (ec)
+  ErrorOr<std::unique_ptr<MemoryBuffer>> mbOrErr
+      = MemoryBuffer::getFileOrSTDIN(path);
+  if (mbOrErr.getError())
     return nullptr;
 
-  assert(node->files().size() == 1 && "expected one file in dylib");
-  // lld::File object is owned by MachOFileNode object. This method returns
-  // an unowned pointer to the lld::File object.
-  MachODylibFile* result = reinterpret_cast<MachODylibFile*>(
-                                                   node->files().front().get());
-
+  std::vector<std::unique_ptr<File>> files;
+  if (registry().parseFile(std::move(mbOrErr.get()), files))
+    return nullptr;
+  assert(files.size() == 1 && "expected one file in dylib");
+  MachODylibFile* result = reinterpret_cast<MachODylibFile*>(files[0].get());
   // Node object now owned by _indirectDylibs vector.
-  _indirectDylibs.push_back(std::move(node));
-
+  _indirectDylibs.push_back(std::move(files[0]));
   return result;
 }
 
 
 MachODylibFile* MachOLinkingContext::findIndirectDylib(StringRef path) {
   // See if already loaded.
   auto pos = _pathToDylibMap.find(path);
   if (pos != _pathToDylibMap.end())

lib/ReaderWriter/PECOFF/LinkerGeneratedSymbolFile.h

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) const override {
+  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;

lib/ReaderWriter/Reader.cpp

Registry::parseFile(std::unique_ptr<MemoryBuffer> mb,
   StringRef extension = llvm::sys::path::extension(mb->getBufferIdentifier());
 
   // Ask each registered reader if it can handle this file type or extension.
   for (const std::unique_ptr<Reader> &reader : _readers) {
     if (!reader->canParse(fileType, extension, *mb))
       continue;
     if (std::error_code ec = reader->parseFile(std::move(mb), *this, result))
       return ec;
-    for (std::unique_ptr<File> &file : result)
-      if (std::error_code ec = file->parse())
-        return ec;
     return std::error_code();
   }
 
   // No Reader could parse this file.
   return make_error_code(llvm::errc::executable_format_error);
 }
 
 static const Registry::KindStrings kindStrings[] = {

lib/ReaderWriter/YAML/ReaderWriterYAML.cpp

const File *find(StringRef name, bool dataSymbolOnly) const override {
             }
           }
         }
       }
       return nullptr;
     }
 
     virtual std::error_code
-    parseAllMembers(std::vector<std::unique_ptr<File>> &result) const override {
+    parseAllMembers(std::vector<std::unique_ptr<File>> &result) override {
       return std::error_code();
     }
 
     StringRef               _path;
     std::vector<ArchMember> _members;
   };
 
   class NormalizedFile : public lld::File {

test/Driver/libsearch-inputGraph.test

-RUN: lld -flavor gnu -target x86_64-linux -L%p/../elf/Inputs -lfnarchive \
-RUN:   --output-filetype=yaml --noinhibit-exec 2> %t.err
-RUN: FileCheck %s < %t.err
-
-RUN: lld -flavor gnu -target x86_64-linux  -L%p/../elf/Inputs --whole-archive \
-RUN:   -lfnarchive --output-filetype=yaml --noinhibit-exec 2> %t1.err
-RUN: FileCheck %s -check-prefix="WHOLEARCHIVE" < %t1.err
-
-RUN: lld -flavor gnu -target x86_64-linux  -L%p/../elf/Inputs --whole-archive \
-RUN:   --as-needed -lfnarchive --output-filetype=yaml --noinhibit-exec 2> %t2.err
-RUN: FileCheck %s -check-prefix="ASNEEDED" < %t2.err
-
-RUN: lld -flavor gnu -target x86_64-linux  --sysroot=%p/../elf -L=/Inputs \
-RUN:   -lfnarchive --output-filetype=yaml --noinhibit-exec 2> %t3.err
-RUN: FileCheck -check-prefix="SYSROOT" %s < %t3.err
-
-CHECK: Name    : {{[^ ]+}}elf/Inputs{{[\\/]}}libfnarchive.a
-CHECK: Type    : ELF File
-CHECK: Attributes :
-CHECK:   - wholeArchive : false
-CHECK:   - asNeeded : false
-
-WHOLEARCHIVE: Name    : {{[^ ]+}}elf/Inputs{{[\\/]}}libfnarchive.a
-WHOLEARCHIVE: Type    : ELF File
-WHOLEARCHIVE: Attributes :
-WHOLEARCHIVE:   - wholeArchive : true
-WHOLEARCHIVE:   - asNeeded : false
-
-ASNEEDED: Name    : {{[^ ]+}}elf/Inputs{{[\\/]}}libfnarchive.a
-ASNEEDED: Type    : ELF File
-ASNEEDED: Attributes :
-ASNEEDED:   - wholeArchive : true
-ASNEEDED:   - asNeeded : true
-
-SYSROOT: Name    : {{[^ ]+}}elf/Inputs{{[\\/]}}libfnarchive.a
-SYSROOT: Type    : ELF File
-SYSROOT: Attributes :
-SYSROOT:   - wholeArchive : false
-SYSROOT:   - asNeeded : false

test/pecoff/hello64.test

 # RUN: yaml2obj %p/Inputs/hello64.obj.yaml > %t.obj
 
 # RUN: lld -flavor link /out:%t.exe /subsystem:windows /machine:x64 \
 # RUN:   /entry:main -- %t.obj %p/Inputs/hello64lib.lib
 # RUN: llvm-objdump -disassemble %t.exe | FileCheck %s
 
 CHECK: 6000: 48 83 ec 28             subq    $40, %rsp
 CHECK: 6004: 48 c7 c1 00 00 00 00    movq    $0, %rcx
 CHECK: 600b: 48 8d 15 f4 af ff ff    leaq    -20492(%rip), %rdx
 CHECK: 6012: 4c 8d 05 e7 af ff ff    leaq    -20505(%rip), %r8
 CHECK: 6019: 41 b9 00 00 00 00       movl    $0, %r9d
 CHECK: 601f: e8 0a 00 00 00          callq   10
 CHECK: 6024: b9 00 00 00 00          movl    $0, %ecx
 CHECK: 6029: e8 08 00 00 00          callq   8
-CHECK: 602e: ff 25 d4 cf ff ff       jmpq    *-12332(%rip)
+CHECK: 602e: ff 25 d2 cf ff ff       jmpq    *-12334(%rip)
 CHECK: 6034: cc                      int3
 CHECK: 6035: cc                      int3
-CHECK: 6036: ff 25 c4 cf ff ff       jmpq    *-12348(%rip)
+CHECK: 6036: ff 25 c2 cf ff ff       jmpq    *-12350(%rip)
 CHECK: 603c: cc                      int3
 CHECK: 603d: cc                      int3

unittests/DriverTests/WinLinkDriverTest.cpp

 // Test for command line flags that are ignored.
 //
 
 TEST_F(WinLinkParserTest, Ignore) {
   // There are some no-op command line options that are recognized for
   // compatibility with link.exe.
   EXPECT_TRUE(parse("link.exe", "/nologo", "/errorreport:prompt",
                     "/incremental", "/incremental:no", "/delay:unload",
-                    "/disallowlib:foo", "/pdbaltpath:bar", "/verbose",
-                    "/verbose:icf", "/wx", "/wx:no", "/tlbid:1",
-                    "/tlbout:foo", "/idlout:foo", "/ignore:4000",
-                    "/ignoreidl", "/implib:foo", "/safeseh",
+                    "/disallowlib:foo", "/pdbaltpath:bar",
+                    "/wx", "/wx:no", "/tlbid:1", "/tlbout:foo", "/idlout:foo",
+                    "/ignore:4000", "/ignoreidl", "/implib:foo", "/safeseh",
                     "/safeseh:no", "/functionpadmin", "/maxilksize:1024",
                     "a.obj", nullptr));
   EXPECT_EQ("", errorMessage());
   EXPECT_EQ(3, inputFileCount());
   EXPECT_EQ("a.obj", inputFile(0));
 }
 
 //