[lld-link] implement -start-lib and -end-lib

[inglorion]

Summary

This implements -start-lib and -end-lib flags for lld-link, analogous
to the similarly named options in ld.lld. Object files after
-start-lib are included in the link only when needed to resolve
undefined symbols. The -end-lib flag goes back to the normal behavior
of always including object files in the link. This mimics the
semantics of static libraries, but without needing to actually create
the archive file.

[inglorion]

Seeing the code here, I see I still need to handle LazyObject in symbol resolution.

[inglorion]

fix places where I needed to add handling of LazyObject symbols

[inglorion]

Primarily, this change adds a LazyObject Symbol kind, and a LazyObjFile InputFile kind. A LazyObject represents a symbol defined in a LazyObjFile, and a LazyObjFile is either a native object file or a bitcode file that we know of, but have not yet decided to link in. As with the LazyArchive symbols we already had, when we encounter both a lazy symbol and an Undefined symbol, we resolve this by linking in the file that defines the symbol, so the result is a Defined symbol.

The change also modifies the way we track wholearchive. This was previously passed as a boolean. Because it doesn't make sense to have both wholearchive (which says to link in all objects in an archive regardless of whether their symbols are referenced) and -start-lib (which says to only link in objects only when their symbols are referenced), this change replaces this with a mode enum which can be wholearchive, lazy, or neither.

Finally, -start-lib and -end-lib are added to the options the linker accepts, and we perform some sanity checks (no -end-lib without -start-lib, for example).

[ruiu]

lld/COFF/DebugTypes.cpp

234

AddMode is not an enum class, so it is in the namespace of LinkerDriver, so it can just be LinkerDriver::NORMAL

lld/COFF/Driver.cpp

1578–1581

Too much nesting I guess? I'd write this way

if (InLib)
  enqueuePath(*path, LAZY);
else if (isWholeArchive(*Path))
  enqueuePath(*path, WHOLE_ARCHIVE);
else
  enqueuePath(*path, NORMAL);

1594

I think you can omit AddMode::.

[MaskRay]

lld/COFF/InputFiles.cpp

831

symbols(std::move(symbols)) to avoid a copy.

lld/COFF/SymbolTable.cpp

608

auto * can be used here because the type is obvious from the right hand side. (in lld's code base this idiom is used a lot)

[MaskRay]

lld/COFF/InputFiles.h

133

symbols(std::move(symbols))

[inglorion]

comments by @ruiu and @MaskRay (thanks!)

• made AddMode an enum class
• simplified AddMode computation in OPT_INPUT case
• added missing std::moves
• use auto instead of explicitly naming LazyArchive

[inglorion]

lld/COFF/DebugTypes.cpp

234

I had actually meant for this to be an enum class. Added the missing "class". Thanks!

lld/COFF/Driver.cpp

1578–1581

Thanks! That is much clearer.

lld/COFF/InputFiles.h

133

Thanks!

[MaskRay]

lld/test/COFF/start-lib-cmd-diagnostics.ll

15

What made you decide -start-lib and -wholearchive: cannot be used together?

I noticed that -wholearchive: can apply on both archives and regular object files. However, there is no test before this patch that test -wholearchive: can apply on object files.

In ELF, the -wholearchive: counterpart is a pair of --whole-archive and --no-whole-archive. --start-lib is allowed to be used together because

• --start-lib applies on object files
• --whole-archive applies on archives

Their use cases don't overlap so their combination is not rejected.

[ruiu]

lld/test/COFF/start-lib-cmd-diagnostics.ll

15

I agree with MaskRay. Giving static libraries object file semantics and object files library file semantics at the same time seems odd but they don't technically conflict. I can't think of a sane use case of the combination of the features, but I don't think we should ban the combination.

[inglorion]

• allow mixing -start-lib and -wholearchive:

[ruiu]

LGTM

lld/COFF/InputFiles.cpp

142

nit: if you flip the condition you can write this way:

for (const lto::InputFile::Symbol &sym : obj->symbols()) {
  if (!sym.isUndefined())
    symtab->addLazyObject(this, sym.getName());

lld/COFF/Options.td

180

Can you add the same help message as the ELF linker?

[MaskRay]

--start-lib semantics look very similar to ELF now :)

[inglorion]

Implemented ruiu's requests before committing. Thanks for reviewing!

[mstorsjo]

This caused failures in a sanitizer buildbot: http://lab.llvm.org:8011/builders/sanitizer-x86_64-linux-bootstrap-msan/builds/14443/steps/check-lld%20msan/logs/stdio

lld/COFF/DebugTypes.cpp

void TypeServerSource::enqueue(const ObjFile *dependentFile,
   Optional<std::string> p = findPdbPath(ts.Name, dependentFile);
   if (!p)
     return;
   auto it = TypeServerSource::instances.emplace(
       *p, std::pair<std::string, TypeServerSource *>{});
   if (!it.second)
     return; // another OBJ already scheduled this PDB for load
 
-  driver->enqueuePath(*p, false);
+  driver->enqueuePath(*p, LinkerDriver::AddMode::NORMAL);
 }
 
 // Create an instance of TypeServerSource or an error string if the PDB couldn't
 // be loaded. The error message will be displayed later, when the referring OBJ
 // will be merged in. NOTE - a PDB load failure is not a link error: some
 // debug info will simply be missing from the final PDB - that is the default
 // accepted behavior.
 void lld::coff::loadTypeServerSource(llvm::MemoryBufferRef m) {

lld/COFF/Driver.h

private:
 
   std::vector<const char *> tokenize(StringRef s);
 
   COFFOptTable table;
 };
 
 class LinkerDriver {
 public:
+  enum AddMode {
+    NORMAL,
+    WHOLE_ARCHIVE,
+    LAZY,
+  };
   void link(llvm::ArrayRef<const char *> args);
 
   // Used by the resolver to parse .drectve section contents.
   void parseDirectives(InputFile *file);
 
   // Used by ArchiveFile to enqueue members.
   void enqueueArchiveMember(const Archive::Child &c, const Archive::Symbol &sym,
                             StringRef parentName);
 
   MemoryBufferRef takeBuffer(std::unique_ptr<MemoryBuffer> mb);
 
-  void enqueuePath(StringRef path, bool wholeArchive);
+  void enqueuePath(StringRef path, AddMode mode);
 
 private:
   std::unique_ptr<llvm::TarWriter> tar; // for /linkrepro
 
   // Opens a file. Path has to be resolved already.
   MemoryBufferRef openFile(StringRef path);
 
   // Searches a file from search paths.
private:
   // There are four different entry point functions for them,
   // {w,}{WinMain,main}CRTStartup, respectively. The linker needs to
   // choose the right one depending on which "main" function is defined.
   // This function looks up the symbol table and resolve corresponding
   // entry point name.
   StringRef findDefaultEntry();
   WindowsSubsystem inferSubsystem();
 
-  void addBuffer(std::unique_ptr<MemoryBuffer> mb, bool wholeArchive);
+  void addBuffer(std::unique_ptr<MemoryBuffer> mb, AddMode mode);
   void addArchiveBuffer(MemoryBufferRef mbref, StringRef symName,
                         StringRef parentName, uint64_t offsetInArchive);
 
   void enqueueTask(std::function<void()> task);
   bool run();
 
   std::list<std::function<void()>> taskQueue;
   std::vector<StringRef> filePaths;

lld/COFF/Driver.cpp

MemoryBufferRef LinkerDriver::takeBuffer(std::unique_ptr<MemoryBuffer> mb) {
   make<std::unique_ptr<MemoryBuffer>>(std::move(mb)); // take ownership
 
   if (driver->tar)
     driver->tar->append(relativeToRoot(mbref.getBufferIdentifier()),
                         mbref.getBuffer());
   return mbref;
 }
 
-void LinkerDriver::addBuffer(std::unique_ptr<MemoryBuffer> mb,
-                             bool wholeArchive) {
+void LinkerDriver::addBuffer(std::unique_ptr<MemoryBuffer> mb, AddMode mode) {
   StringRef filename = mb->getBufferIdentifier();
 
   MemoryBufferRef mbref = takeBuffer(std::move(mb));
   filePaths.push_back(filename);
 
   // File type is detected by contents, not by file extension.
   switch (identify_magic(mbref.getBuffer())) {
   case file_magic::windows_resource:
     resources.push_back(mbref);
     break;
   case file_magic::archive:
-    if (wholeArchive) {
+    if (mode == AddMode::WHOLE_ARCHIVE) {
       std::unique_ptr<Archive> file =
           CHECK(Archive::create(mbref), filename + ": failed to parse archive");
       Archive *archive = file.get();
       make<std::unique_ptr<Archive>>(std::move(file)); // take ownership
 
       for (MemoryBufferRef m : getArchiveMembers(archive))
         addArchiveBuffer(m, "<whole-archive>", filename, 0);
       return;
     }
     symtab->addFile(make<ArchiveFile>(mbref));
     break;
   case file_magic::bitcode:
+    if (mode == AddMode::LAZY)
+      symtab->addFile(make<LazyObjFile>(mbref));
+    else
       symtab->addFile(make<BitcodeFile>(mbref, "", 0));
     break;
   case file_magic::coff_object:
   case file_magic::coff_import_library:
+    if (mode == AddMode::LAZY)
+      symtab->addFile(make<LazyObjFile>(mbref));
+    else
       symtab->addFile(make<ObjFile>(mbref));
     break;
   case file_magic::pdb:
     loadTypeServerSource(mbref);
     break;
   case file_magic::coff_cl_gl_object:
     error(filename + ": is not a native COFF file. Recompile without /GL");
     break;
   case file_magic::pecoff_executable:
     if (filename.endswith_lower(".dll")) {
       error(filename + ": bad file type. Did you specify a DLL instead of an "
                        "import library?");
       break;
     }
     LLVM_FALLTHROUGH;
   default:
     error(mbref.getBufferIdentifier() + ": unknown file type");
     break;
   }
 }
 
-void LinkerDriver::enqueuePath(StringRef path, bool wholeArchive) {
+void LinkerDriver::enqueuePath(StringRef path, AddMode mode) {
   auto future =
       std::make_shared<std::future<MBErrPair>>(createFutureForFile(path));
   std::string pathStr = path;
   enqueueTask([=]() {
     auto mbOrErr = future->get();
     if (mbOrErr.second) {
       std::string msg =
           "could not open '" + pathStr + "': " + mbOrErr.second.message();
       // Check if the filename is a typo for an option flag. OptTable thinks
       // that all args that are not known options and that start with / are
       // filenames, but e.g. `/nodefaultlibs` is more likely a typo for
       // the option `/nodefaultlib` than a reference to a file in the root
       // directory.
       std::string nearest;
       if (COFFOptTable().findNearest(pathStr, nearest) > 1)
         error(msg);
       else
         error(msg + "; did you mean '" + nearest + "'");
     } else
-      driver->addBuffer(std::move(mbOrErr.first), wholeArchive);
+      driver->addBuffer(std::move(mbOrErr.first), mode);
   });
 }
 
 void LinkerDriver::addArchiveBuffer(MemoryBufferRef mb, StringRef symName,
                                     StringRef parentName,
                                     uint64_t offsetInArchive) {
   file_magic magic = identify_magic(mb.getBuffer());
   if (magic == file_magic::coff_import_library) {
for (auto *arg : args) {
     case OPT_aligncomm:
       parseAligncomm(arg->getValue());
       break;
     case OPT_alternatename:
       parseAlternateName(arg->getValue());
       break;
     case OPT_defaultlib:
       if (Optional<StringRef> path = findLib(arg->getValue()))
-        enqueuePath(*path, false);
+        enqueuePath(*path, AddMode::NORMAL);
       break;
     case OPT_entry:
       config->entry = addUndefined(mangle(arg->getValue()));
       break;
     case OPT_failifmismatch:
       checkFailIfMismatch(arg->getValue(), file);
       break;
     case OPT_incl:
void LinkerDriver::link(ArrayRef<const char *> argsArr) {
   auto isWholeArchive = [&](StringRef path) -> bool {
     if (args.hasArg(OPT_wholearchive_flag))
       return true;
     if (Optional<sys::fs::UniqueID> id = getUniqueID(path))
       return wholeArchives.count(*id);
     return false;
   };
 
-  // Create a list of input files. Files can be given as arguments
-  // for /defaultlib option.
-  for (auto *arg : args.filtered(OPT_INPUT, OPT_wholearchive_file))
+  // Create a list of input files. These can be given as OPT_INPUT options
+  // and OPT_wholearchive_file options, and we also need to track OPT_start_lib
+  // and OPT_end_lib.
+  bool inLib = false;
+  for (auto *arg : args) {
+    switch (arg->getOption().getID()) {
+    case OPT_end_lib:
+      if (!inLib)
+        error("stray " + arg->getSpelling());
+      inLib = false;
+      break;
+    case OPT_start_lib:
+      if (inLib)
+        error("nested " + arg->getSpelling());
+      inLib = true;
+      break;
+    case OPT_wholearchive_file:
+      if (inLib)
+        error("may not nest " + arg->getSpelling() + " in -start-lib");
       if (Optional<StringRef> path = findFile(arg->getValue()))
-      enqueuePath(*path, isWholeArchive(*path));
+        enqueuePath(*path, AddMode::WHOLE_ARCHIVE);
+      break;
+    case OPT_INPUT:
+      if (Optional<StringRef> path = findFile(arg->getValue())) {
+        enqueuePath(*path, inLib
+                               ? AddMode::LAZY
+                               : (isWholeArchive(*path) ? AddMode::WHOLE_ARCHIVE
+                                                        : AddMode::NORMAL));
+      }
+      break;
+    default:
+      // Ignore other options.
+      break;
+    }
+  }
 
+  // Process files specified as /defaultlib. These should be enequeued after
+  // other files, which is why they are in a separate loop.
   for (auto *arg : args.filtered(OPT_defaultlib))
     if (Optional<StringRef> path = findLib(arg->getValue()))
-      enqueuePath(*path, false);
+      enqueuePath(*path, AddMode::NORMAL);
 
   // Windows specific -- Create a resource file containing a manifest file.
   if (config->manifest == Configuration::Embed)
-    addBuffer(createManifestRes(), false);
+    addBuffer(createManifestRes(), AddMode::NORMAL);
 
   // Read all input files given via the command line.
   run();
 
   if (errorCount())
     return;
 
   // We should have inferred a machine type by now from the input files, but if
do {
     // Windows specific -- if __load_config_used can be resolved, resolve it.
     if (symtab->findUnderscore("_load_config_used"))
       addUndefined(mangle("_load_config_used"));
   } while (run());
 
   if (args.hasArg(OPT_include_optional)) {
     // Handle /includeoptional
     for (auto *arg : args.filtered(OPT_include_optional))
-      if (dyn_cast_or_null<Lazy>(symtab->find(arg->getValue())))
+      if (dyn_cast_or_null<LazyArchive>(symtab->find(arg->getValue())))
         addUndefined(arg->getValue());
     while (run());
   }
 
   if (config->mingw) {
     // Load any further object files that might be needed for doing automatic
     // imports.
     //

lld/COFF/InputFiles.h

 //===- InputFiles.h ---------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_COFF_INPUT_FILES_H
 #define LLD_COFF_INPUT_FILES_H
 
 #include "Config.h"
 #include "lld/Common/LLVM.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DenseSet.h"
+#include "llvm/BinaryFormat/Magic.h"
 #include "llvm/DebugInfo/CodeView/TypeRecord.h"
 #include "llvm/LTO/LTO.h"
 #include "llvm/Object/Archive.h"
 #include "llvm/Object/COFF.h"
 #include "llvm/Support/StringSaver.h"
 #include <memory>
 #include <set>
 #include <vector>

 class SectionChunk;
 class Symbol;
 class Undefined;
 class TpiSource;
 
 // The root class of input files.
 class InputFile {
 public:
-  enum Kind { ArchiveKind, ObjectKind, ImportKind, BitcodeKind };
+  enum Kind {
+    ArchiveKind,
+    ObjectKind,
+    LazyObjectKind,
+    ImportKind,
+    BitcodeKind
+  };
   Kind kind() const { return fileKind; }
   virtual ~InputFile() {}
 
   // Returns the filename.
   StringRef getName() const { return mb.getBufferIdentifier(); }
 
   // Reads a file (the constructor doesn't do that).
   virtual void parse() = 0;
public:
   // which ensures that we don't load the same member more than once.
   void addMember(const Archive::Symbol &sym);
 
 private:
   std::unique_ptr<Archive> file;
   llvm::DenseSet<uint64_t> seen;
 };
 
+// .obj or .o file between -start-lib and -end-lib.
+class LazyObjFile : public InputFile {
+public:
+  explicit LazyObjFile(MemoryBufferRef m) : InputFile(LazyObjectKind, m) {}
+  static bool classof(const InputFile *f) {
+    return f->kind() == LazyObjectKind;
+  }
+  // Makes this object file part of the link.
+  void fetch();
+  // Adds the symbols in this file to the symbol table as LazyObject symbols.
+  void parse() override;
+
+private:
+  std::vector<Symbol *> symbols;
+};
+
 // .obj or .o file. This may be a member of an archive file.
 class ObjFile : public InputFile {
 public:
   explicit ObjFile(MemoryBufferRef m) : InputFile(ObjectKind, m) {}
+  explicit ObjFile(MemoryBufferRef m, std::vector<Symbol *> &&symbols)
+      : InputFile(ObjectKind, m), symbols(symbols) {}
   static bool classof(const InputFile *f) { return f->kind() == ObjectKind; }
   void parse() override;
   MachineTypes getMachineType() override;
   ArrayRef<Chunk *> getChunks() { return chunks; }
   ArrayRef<SectionChunk *> getDebugChunks() { return debugChunks; }
   ArrayRef<SectionChunk *> getSXDataChunks() { return sXDataChunks; }
   ArrayRef<SectionChunk *> getGuardFidChunks() { return guardFidChunks; }
   ArrayRef<SectionChunk *> getGuardLJmpChunks() { return guardLJmpChunks; }
public:
   bool live = !config->doGC;
   bool thunkLive = !config->doGC;
 };
 
 // Used for LTO.
 class BitcodeFile : public InputFile {
 public:
   BitcodeFile(MemoryBufferRef mb, StringRef archiveName,
-              uint64_t offsetInArchive);
+              uint64_t offsetInArchive)
+      : BitcodeFile(mb, archiveName, offsetInArchive, {}) {}
+  explicit BitcodeFile(MemoryBufferRef m, StringRef archiveName,
+                       uint64_t offsetInArchive,
+                       std::vector<Symbol *> &&symbols);
   static bool classof(const InputFile *f) { return f->kind() == BitcodeKind; }
   ArrayRef<Symbol *> getSymbols() { return symbols; }
   MachineTypes getMachineType() override;
   static std::vector<BitcodeFile *> instances;
   std::unique_ptr<llvm::lto::InputFile> obj;
 
 private:
   void parse() override;
 
   std::vector<Symbol *> symbols;
 };
 
+inline bool isBitcode(MemoryBufferRef mb) {
+  return identify_magic(mb.getBuffer()) == llvm::file_magic::bitcode;
+}
+
 std::string replaceThinLTOSuffix(StringRef path);
 } // namespace coff
 
 std::string toString(const coff::InputFile *file);
 } // namespace lld
 
 #endif

lld/COFF/InputFiles.cpp

if (u->weakAlias && u->weakAlias != target) {
       if (config->mingw)
         return;
       symtab->reportDuplicate(source, f);
     }
     u->weakAlias = target;
   }
 }
 
+static bool ignoredSymbolName(StringRef name) {
+  return name == "@feat.00" || name == "@comp.id";
+}
+
 ArchiveFile::ArchiveFile(MemoryBufferRef m) : InputFile(ArchiveKind, m) {}
 
 void ArchiveFile::parse() {
   // Parse a MemoryBufferRef as an archive file.
   file = CHECK(Archive::create(mb), this);
 
   // Read the symbol table to construct Lazy objects.
   for (const Archive::Symbol &sym : file->symbols())
-    symtab->addLazy(this, sym);
+    symtab->addLazyArchive(this, sym);
 }
 
 // Returns a buffer pointing to a member file containing a given symbol.
 void ArchiveFile::addMember(const Archive::Symbol &sym) {
   const Archive::Child &c =
       CHECK(sym.getMember(),
             "could not get the member for symbol " + toCOFFString(sym));
 
for (const ErrorOr<Archive::Child> &cOrErr : file->children(err)) {
     v.push_back(mbref);
   }
   if (err)
     fatal(file->getFileName() +
           ": Archive::children failed: " + toString(std::move(err)));
   return v;
 }
 
+void LazyObjFile::fetch() {
+  if (mb.getBuffer().empty())
+    return;
+
+  InputFile *file;
+  if (isBitcode(mb))
+    file = make<BitcodeFile>(mb, "", 0, std::move(symbols));
+  else
+    file = make<ObjFile>(mb, std::move(symbols));
+  mb = {};
+  symtab->addFile(file);
+}
+
+void LazyObjFile::parse() {
+  if (isBitcode(this->mb)) {
+    // Bitcode file.
+    std::unique_ptr<lto::InputFile> obj =
+        CHECK(lto::InputFile::create(this->mb), this);
+    for (const lto::InputFile::Symbol &sym : obj->symbols()) {
+      if (sym.isUndefined())
+        continue;
+      symtab->addLazyObject(this, sym.getName());
+    }
+    return;
+  }
+
+  // Native object file.
+  COFFObjectFile *coffObj =
+      dyn_cast<COFFObjectFile>(CHECK(createBinary(mb), this).get());
+  uint32_t numSymbols = coffObj->getNumberOfSymbols();
+  for (uint32_t i = 0; i < numSymbols; ++i) {
+    COFFSymbolRef coffSym = check(coffObj->getSymbol(i));
+    if (coffSym.isUndefined() || !coffSym.isExternal() ||
+        coffSym.isWeakExternal())
+      continue;
+    StringRef name;
+    coffObj->getSymbolName(coffSym, name);
+    if (coffSym.isAbsolute() && ignoredSymbolName(name))
+      continue;
+    symtab->addLazyObject(this, name);
+    i += coffSym.getNumberOfAuxSymbols();
+  }
+}
+
 void ObjFile::parse() {
   // Parse a memory buffer as a COFF file.
   std::unique_ptr<Binary> bin = CHECK(createBinary(mb), this);
 
   if (auto *obj = dyn_cast<COFFObjectFile>(bin.get())) {
     bin.release();
     coffObj.reset(obj);
   } else {
if (sym.isCommon()) {
     chunks.push_back(c);
     return symtab->addCommon(this, getName(), sym.getValue(), sym.getGeneric(),
                              c);
   }
 
   if (sym.isAbsolute()) {
     StringRef name = getName();
 
-    // Skip special symbols.
-    if (name == "@comp.id")
-      return nullptr;
-    if (name == "@feat.00") {
+    if (name == "@feat.00")
       feat00Flags = sym.getValue();
+    // Skip special symbols.
+    if (ignoredSymbolName(name))
       return nullptr;
-    }
 
     if (sym.isExternal())
       return symtab->addAbsolute(name, sym);
     return make<DefinedAbsolute>(name, sym);
   }
 
   int32_t sectionNumber = sym.getSectionNumber();
   if (sectionNumber == llvm::COFF::IMAGE_SYM_DEBUG)
void ImportFile::parse() {
   // address pointed by the __imp_ symbol. (This allows you to call
   // DLL functions just like regular non-DLL functions.)
   if (hdr->getType() == llvm::COFF::IMPORT_CODE)
     thunkSym = symtab->addImportThunk(
         name, cast_or_null<DefinedImportData>(impSym), hdr->Machine);
 }
 
 BitcodeFile::BitcodeFile(MemoryBufferRef mb, StringRef archiveName,
-                         uint64_t offsetInArchive)
-    : InputFile(BitcodeKind, mb) {
+                         uint64_t offsetInArchive,
+                         std::vector<Symbol *> &&symbols)
+    : InputFile(BitcodeKind, mb), symbols(symbols) {
   std::string path = mb.getBufferIdentifier().str();
   if (config->thinLTOIndexOnly)
     path = replaceThinLTOSuffix(mb.getBufferIdentifier());
 
   // ThinLTO assumes that all MemoryBufferRefs given to it have a unique
   // name. If two archives define two members with the same name, this
   // causes a collision which result in only one of the objects being taken
   // into consideration at LTO time (which very likely causes undefined

lld/COFF/Options.td

defm tsaware  : B<"tsaware",
                   "Create non-Terminal Server aware executable">;
 
 def help : F<"help">;
 
 // /?? and -?? must be before /? and -? to not confuse lib/Options.
 def help_q : Flag<["/??", "-??", "/?", "-?"], "">, Alias<help>;
 
 // LLD extensions
+def end_lib : F<"end-lib">;
 def exclude_all_symbols : F<"exclude-all-symbols">;
 def export_all_symbols : F<"export-all-symbols">;
 defm demangle : B<"demangle",
     "Demangle symbols in output (default)",
     "Do not demangle symbols in output">;
 def include_optional : Joined<["/", "-", "/?", "-?"], "includeoptional:">,
     HelpText<"Add symbol as undefined, but allow it to remain undefined">;
 def kill_at : F<"kill-at">;
 def lldmingw : F<"lldmingw">;
 def output_def : Joined<["/", "-", "/?", "-?"], "output-def:">;
 def pdb_source_path : P<"pdbsourcepath",
                         "Base path used to make relative source file path absolute in PDB">;
 def rsp_quoting : Joined<["--"], "rsp-quoting=">,
   HelpText<"Quoting style for response files, 'windows' (default) or 'posix'">;
+def start_lib : F<"start-lib">;
 def thinlto_emit_imports_files :
     F<"thinlto-emit-imports-files">,
     HelpText<"Emit .imports files with -thinlto-index-only">;
 def thinlto_index_only :
     F<"thinlto-index-only">,
     HelpText<"Instead of linking, emit ThinLTO index files">;
 def thinlto_index_only_arg : P<
     "thinlto-index-only",

lld/COFF/SymbolTable.h

 namespace coff {
 
 class Chunk;
 class CommonChunk;
 class Defined;
 class DefinedAbsolute;
 class DefinedRegular;
 class DefinedRelative;
-class Lazy;
+class LazyArchive;
 class SectionChunk;
 class Symbol;
 
 // SymbolTable is a bucket of all known symbols, including defined,
 // undefined, or lazy symbols (the last one is symbols in archive
 // files whose archive members are not yet loaded).
 //
 // We put all symbols of all files to a SymbolTable, and the
public:
 
   // Creates an Undefined symbol for a given name.
   Symbol *addUndefined(StringRef name);
 
   Symbol *addSynthetic(StringRef n, Chunk *c);
   Symbol *addAbsolute(StringRef n, uint64_t va);
 
   Symbol *addUndefined(StringRef name, InputFile *f, bool isWeakAlias);
-  void addLazy(ArchiveFile *f, const Archive::Symbol &sym);
+  void addLazyArchive(ArchiveFile *f, const Archive::Symbol &sym);
+  void addLazyObject(LazyObjFile *f, StringRef n);
   Symbol *addAbsolute(StringRef n, COFFSymbolRef s);
   Symbol *addRegular(InputFile *f, StringRef n,
                      const llvm::object::coff_symbol_generic *s = nullptr,
                      SectionChunk *c = nullptr);
   std::pair<DefinedRegular *, bool>
   addComdat(InputFile *f, StringRef n,
             const llvm::object::coff_symbol_generic *s = nullptr);
   Symbol *addCommon(InputFile *f, StringRef n, uint64_t size,

lld/COFF/SymbolTable.cpp

if (!sym->isUsedInRegularObj)
       continue;
     if (undef->getWeakAlias())
       continue;
 
     StringRef name = undef->getName();
 
     if (name.startswith("__imp_"))
       continue;
-    // If we have an undefined symbol, but we have a Lazy representing a
+    // If we have an undefined symbol, but we have a LazyArchive representing a
     // symbol we could load from file, make sure to load that.
-    Lazy *l = dyn_cast_or_null<Lazy>(find(("__imp_" + name).str()));
+    LazyArchive *l =
+        dyn_cast_or_null<LazyArchive>(find(("__imp_" + name).str()));
     if (!l || l->pendingArchiveLoad)
       continue;
 
     log("Loading lazy " + l->getName() + " from " + l->file->getName() +
         " for automatic import");
     l->pendingArchiveLoad = true;
     l->file->addMember(l->sym);
   }
std::pair<Symbol *, bool> SymbolTable::insert(StringRef name, InputFile *file) {
   return result;
 }
 
 Symbol *SymbolTable::addUndefined(StringRef name, InputFile *f,
                                   bool isWeakAlias) {
   Symbol *s;
   bool wasInserted;
   std::tie(s, wasInserted) = insert(name, f);
-  if (wasInserted || (isa<Lazy>(s) && isWeakAlias)) {
+  if (wasInserted || (isa<LazyArchive>(s) && isWeakAlias)) {
     replaceSymbol<Undefined>(s, name);
     return s;
   }
-  if (auto *l = dyn_cast<Lazy>(s)) {
+  if (auto *l = dyn_cast<LazyArchive>(s)) {
     if (!s->pendingArchiveLoad) {
       s->pendingArchiveLoad = true;
       l->file->addMember(l->sym);
     }
   }
   return s;
 }
 
-void SymbolTable::addLazy(ArchiveFile *f, const Archive::Symbol &sym) {
+void SymbolTable::addLazyArchive(ArchiveFile *f, const Archive::Symbol &sym) {
   StringRef name = sym.getName();
   Symbol *s;
   bool wasInserted;
   std::tie(s, wasInserted) = insert(name);
   if (wasInserted) {
-    replaceSymbol<Lazy>(s, f, sym);
+    replaceSymbol<LazyArchive>(s, f, sym);
     return;
   }
   auto *u = dyn_cast<Undefined>(s);
   if (!u || u->weakAlias || s->pendingArchiveLoad)
     return;
   s->pendingArchiveLoad = true;
   f->addMember(sym);
 }
 
+void SymbolTable::addLazyObject(LazyObjFile *f, StringRef n) {
+  Symbol *s;
+  bool wasInserted;
+  std::tie(s, wasInserted) = insert(n, f);
+  if (wasInserted) {
+    replaceSymbol<LazyObject>(s, f, n);
+    return;
+  }
+  auto *u = dyn_cast<Undefined>(s);
+  if (!u || u->weakAlias || s->pendingArchiveLoad)
+    return;
+  s->pendingArchiveLoad = true;
+  f->fetch();
+}
+
 void SymbolTable::reportDuplicate(Symbol *existing, InputFile *newFile) {
   std::string msg = "duplicate symbol: " + toString(*existing) + " in " +
                     toString(existing->getFile()) + " and in " +
                     toString(newFile);
 
   if (config->forceMultiple)
     warn(msg);
   else
     error(msg);
 }
 
 Symbol *SymbolTable::addAbsolute(StringRef n, COFFSymbolRef sym) {
   Symbol *s;
   bool wasInserted;
   std::tie(s, wasInserted) = insert(n, nullptr);
   s->isUsedInRegularObj = true;
-  if (wasInserted || isa<Undefined>(s) || isa<Lazy>(s))
+  if (wasInserted || isa<Undefined>(s) || isa<LazyArchive>(s))
     replaceSymbol<DefinedAbsolute>(s, n, sym);
   else if (!isa<DefinedCOFF>(s))
     reportDuplicate(s, nullptr);
   return s;
 }
 
 Symbol *SymbolTable::addAbsolute(StringRef n, uint64_t va) {
   Symbol *s;
   bool wasInserted;
   std::tie(s, wasInserted) = insert(n, nullptr);
   s->isUsedInRegularObj = true;
-  if (wasInserted || isa<Undefined>(s) || isa<Lazy>(s))
+  if (wasInserted || isa<Undefined>(s) || isa<LazyArchive>(s))
     replaceSymbol<DefinedAbsolute>(s, n, va);
   else if (!isa<DefinedCOFF>(s))
     reportDuplicate(s, nullptr);
   return s;
 }
 
 Symbol *SymbolTable::addSynthetic(StringRef n, Chunk *c) {
   Symbol *s;
   bool wasInserted;
   std::tie(s, wasInserted) = insert(n, nullptr);
   s->isUsedInRegularObj = true;
-  if (wasInserted || isa<Undefined>(s) || isa<Lazy>(s))
+  if (wasInserted || isa<Undefined>(s) || isa<LazyArchive>(s))
     replaceSymbol<DefinedSynthetic>(s, n, c);
   else if (!isa<DefinedCOFF>(s))
     reportDuplicate(s, nullptr);
   return s;
 }
 
 Symbol *SymbolTable::addRegular(InputFile *f, StringRef n,
                                 const coff_symbol_generic *sym,
Symbol *SymbolTable::addCommon(InputFile *f, StringRef n, uint64_t size,
   return s;
 }
 
 Symbol *SymbolTable::addImportData(StringRef n, ImportFile *f) {
   Symbol *s;
   bool wasInserted;
   std::tie(s, wasInserted) = insert(n, nullptr);
   s->isUsedInRegularObj = true;
-  if (wasInserted || isa<Undefined>(s) || isa<Lazy>(s)) {
+  if (wasInserted || isa<Undefined>(s) || isa<LazyArchive>(s)) {
     replaceSymbol<DefinedImportData>(s, n, f);
     return s;
   }
 
   reportDuplicate(s, f);
   return nullptr;
 }
 
 Symbol *SymbolTable::addImportThunk(StringRef name, DefinedImportData *id,
                                     uint16_t machine) {
   Symbol *s;
   bool wasInserted;
   std::tie(s, wasInserted) = insert(name, nullptr);
   s->isUsedInRegularObj = true;
-  if (wasInserted || isa<Undefined>(s) || isa<Lazy>(s)) {
+  if (wasInserted || isa<Undefined>(s) || isa<LazyArchive>(s)) {
     replaceSymbol<DefinedImportThunk>(s, name, id, machine);
     return s;
   }
 
   reportDuplicate(s, id->file);
   return nullptr;
 }
 
 void SymbolTable::addLibcall(StringRef name) {
   Symbol *sym = findUnderscore(name);
   if (!sym)
     return;
 
-  if (Lazy *l = dyn_cast<Lazy>(sym)) {
+  if (LazyArchive *l = dyn_cast<LazyArchive>(sym)) {
     MemoryBufferRef mb = l->getMemberBuffer();
     if (identify_magic(mb.getBuffer()) == llvm::file_magic::bitcode)
       addUndefined(sym->getName());
   }
 }
 
 std::vector<Chunk *> SymbolTable::getChunks() {
   std::vector<Chunk *> res;

lld/COFF/Symbols.h

enum Kind {
     DefinedCommonKind,
     DefinedLocalImportKind,
     DefinedImportThunkKind,
     DefinedImportDataKind,
     DefinedAbsoluteKind,
     DefinedSyntheticKind,
 
     UndefinedKind,
-    LazyKind,
+    LazyArchiveKind,
+    LazyObjectKind,
 
     LastDefinedCOFFKind = DefinedCommonKind,
     LastDefinedKind = DefinedSyntheticKind,
   };
 
   Kind kind() const { return static_cast<Kind>(symbolKind); }
 
   // Returns the symbol name.

 
 private:
   Chunk *c;
 };
 
 // This class represents a symbol defined in an archive file. It is
 // created from an archive file header, and it knows how to load an
 // object file from an archive to replace itself with a defined
-// symbol. If the resolver finds both Undefined and Lazy for
-// the same name, it will ask the Lazy to load a file.
-class Lazy : public Symbol {
+// symbol. If the resolver finds both Undefined and LazyArchive for
+// the same name, it will ask the LazyArchive to load a file.
+class LazyArchive : public Symbol {
 public:
-  Lazy(ArchiveFile *f, const Archive::Symbol s)
-      : Symbol(LazyKind, s.getName()), file(f), sym(s) {}
+  LazyArchive(ArchiveFile *f, const Archive::Symbol s)
+      : Symbol(LazyArchiveKind, s.getName()), file(f), sym(s) {}
 
-  static bool classof(const Symbol *s) { return s->kind() == LazyKind; }
+  static bool classof(const Symbol *s) { return s->kind() == LazyArchiveKind; }
 
   MemoryBufferRef getMemberBuffer();
 
   ArchiveFile *file;
 
 private:
   friend SymbolTable;
 
 private:
   const Archive::Symbol sym;
 };
 
+class LazyObject : public Symbol {
+public:
+  LazyObject(LazyObjFile *f, StringRef n)
+      : Symbol(LazyObjectKind, n), file(f) {}
+  static bool classof(const Symbol *s) { return s->kind() == LazyObjectKind; }
+  LazyObjFile *file;
+};
+
 // Undefined symbols.
 class Undefined : public Symbol {
 public:
   explicit Undefined(StringRef n) : Symbol(UndefinedKind, n) {}
 
   static bool classof(const Symbol *s) { return s->kind() == UndefinedKind; }
 
   // An undefined symbol can have a fallback symbol which gives an
inline uint64_t Defined::getRVA() {
   case DefinedImportThunkKind:
     return cast<DefinedImportThunk>(this)->getRVA();
   case DefinedLocalImportKind:
     return cast<DefinedLocalImport>(this)->getRVA();
   case DefinedCommonKind:
     return cast<DefinedCommon>(this)->getRVA();
   case DefinedRegularKind:
     return cast<DefinedRegular>(this)->getRVA();
-  case LazyKind:
+  case LazyArchiveKind:
+  case LazyObjectKind:
   case UndefinedKind:
     llvm_unreachable("Cannot get the address for an undefined symbol.");
   }
   llvm_unreachable("unknown symbol kind");
 }
 
 inline Chunk *Defined::getChunk() {
   switch (kind()) {
   case DefinedRegularKind:
     return cast<DefinedRegular>(this)->getChunk();
   case DefinedAbsoluteKind:
     return nullptr;
   case DefinedSyntheticKind:
     return cast<DefinedSynthetic>(this)->getChunk();
   case DefinedImportDataKind:
     return cast<DefinedImportData>(this)->getChunk();
   case DefinedImportThunkKind:
     return cast<DefinedImportThunk>(this)->getChunk();
   case DefinedLocalImportKind:
     return cast<DefinedLocalImport>(this)->getChunk();
   case DefinedCommonKind:
     return cast<DefinedCommon>(this)->getChunk();
-  case LazyKind:
+  case LazyArchiveKind:
+  case LazyObjectKind:
   case UndefinedKind:
     llvm_unreachable("Cannot get the chunk of an undefined symbol.");
   }
   llvm_unreachable("unknown symbol kind");
 }
 
 // A buffer class that is large enough to hold any Symbol-derived
 // object. We allocate memory using this class and instantiate a symbol
 // using the placement new.
 union SymbolUnion {
   alignas(DefinedRegular) char a[sizeof(DefinedRegular)];
   alignas(DefinedCommon) char b[sizeof(DefinedCommon)];
   alignas(DefinedAbsolute) char c[sizeof(DefinedAbsolute)];
   alignas(DefinedSynthetic) char d[sizeof(DefinedSynthetic)];
-  alignas(Lazy) char e[sizeof(Lazy)];
+  alignas(LazyArchive) char e[sizeof(LazyArchive)];
   alignas(Undefined) char f[sizeof(Undefined)];
   alignas(DefinedImportData) char g[sizeof(DefinedImportData)];
   alignas(DefinedImportThunk) char h[sizeof(DefinedImportThunk)];
   alignas(DefinedLocalImport) char i[sizeof(DefinedLocalImport)];
 };
 
 template <typename T, typename... ArgT>
 void replaceSymbol(Symbol *s, ArgT &&... arg) {

lld/COFF/Symbols.cpp

if (nameData == nullptr) {
     assert(nameSize == nameStr.size() && "name length truncated");
   }
   return StringRef(nameData, nameSize);
 }
 
 InputFile *Symbol::getFile() {
   if (auto *sym = dyn_cast<DefinedCOFF>(this))
     return sym->file;
-  if (auto *sym = dyn_cast<Lazy>(this))
+  if (auto *sym = dyn_cast<LazyArchive>(this))
     return sym->file;
   return nullptr;
 }
 
 bool Symbol::isLive() const {
   if (auto *r = dyn_cast<DefinedRegular>(this))
     return r->getChunk()->live;
   if (auto *imp = dyn_cast<DefinedImportData>(this))

 Defined *Undefined::getWeakAlias() {
   // A weak alias may be a weak alias to another symbol, so check recursively.
   for (Symbol *a = weakAlias; a; a = cast<Undefined>(a)->weakAlias)
     if (auto *d = dyn_cast<Defined>(a))
       return d;
   return nullptr;
 }
 
-MemoryBufferRef Lazy::getMemberBuffer() {
+MemoryBufferRef LazyArchive::getMemberBuffer() {
   Archive::Child c =
     CHECK(sym.getMember(),
           "could not get the member for symbol " + toCOFFString(sym));
   return CHECK(c.getMemoryBufferRef(),
       "could not get the buffer for the member defining symbol " +
       toCOFFString(sym));
 }
 } // namespace coff
 } // namespace lld

lld/COFF/Writer.cpp

static void maybeAddAddressTakenFunction(SymbolRVASet &addressTakenSyms,
   case Symbol::DefinedCommonKind:
     // Common is always data, so it is ignored.
     break;
   case Symbol::DefinedAbsoluteKind:
   case Symbol::DefinedSyntheticKind:
     // Absolute is never code, synthetic generally isn't and usually isn't
     // determinable.
     break;
-  case Symbol::LazyKind:
+  case Symbol::LazyArchiveKind:
+  case Symbol::LazyObjectKind:
   case Symbol::UndefinedKind:
     // Undefined symbols resolve to zero, so they don't have an RVA. Lazy
     // symbols shouldn't have relocations.
     break;
 
   case Symbol::DefinedImportThunkKind:
     // Thunks are always code, include them.
     addSymbolToRVASet(addressTakenSyms, cast<Defined>(s));

lld/test/COFF/Inputs/start-lib1.ll

+target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-pc-windows-msvc"
+
+declare i32 @bar()
+
+define i32 @foo() {
+  %1 = call i32 () @bar()
+  %2 = add i32 %1, 1
+  ret i32 %2
+}
+
+!llvm.linker.options = !{!0}
+!0 = !{!"/INCLUDE:foo"}

lld/test/COFF/Inputs/start-lib2.ll

+target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-pc-windows-msvc"
+
+define i32 @bar() {
+  ret i32 1
+}
+
+!llvm.linker.options = !{!0}
+!0 = !{!"/INCLUDE:bar"}

lld/test/COFF/start-lib-cmd-diagnostics.ll

+; REQUIRES: x86
+;
+; We need an input file to lld, so create one.
+; RUN: llc -filetype=obj %s -o %t.obj
+
+; RUN: not lld-link %t.obj -end-lib 2>&1 \
+; RUN:     | FileCheck --check-prefix=STRAY_END %s
+; STRAY_END: stray -end-lib
+
+; RUN: not lld-link -start-lib -start-lib %t.obj 2>&1 \
+; RUN:     | FileCheck --check-prefix=NESTED_START %s
+; NESTED_START: nested -start-lib
+
+; RUN: not lld-link -start-lib %t.obj -wholearchive:%t.obj 2>&1 \
+; RUN:     | FileCheck --check-prefix=WHOLEARCHIVE %s
+; WHOLEARCHIVE: may not nest -wholearchive: in -start-lib
+
+target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-pc-windows-msvc"
+
+define void @main() {
+  ret void
+}

lld/test/COFF/start-lib.ll

+; REQUIRES: x86
+;
+; RUN: llc -filetype=obj %s -o %t.obj
+; RUN: llc -filetype=obj %p/Inputs/start-lib1.ll -o %t1.obj
+; RUN: llc -filetype=obj %p/Inputs/start-lib2.ll -o %t2.obj
+; RUN: opt -thinlto-bc %s -o %t.bc
+; RUN: opt -thinlto-bc %p/Inputs/start-lib1.ll -o %t1.bc
+; RUN: opt -thinlto-bc %p/Inputs/start-lib2.ll -o %t2.bc
+;
+; RUN: lld-link -out:%t1.exe -entry:main -opt:noref -lldmap:%t1.map \
+; RUN:     %t.obj %t1.obj %t2.obj
+; RUN: FileCheck --check-prefix=TEST1 %s < %t1.map
+; RUN: lld-link -out:%t1.exe -entry:main -opt:noref -lldmap:%t1.thinlto.map \
+; RUN:     %t.bc %t1.bc %t2.bc
+; RUN: FileCheck --check-prefix=TEST1 %s < %t1.thinlto.map
+; TEST1: foo
+; TEST1: bar
+;
+; RUN: lld-link -out:%t2.exe -entry:main -opt:noref -lldmap:%t2.map \
+; RUN:     %t.obj -start-lib %t1.obj -end-lib %t2.obj
+; RUN: FileCheck --check-prefix=TEST2 %s < %t2.map
+; RUN: lld-link -out:%t2.exe -entry:main -opt:noref -lldmap:%t2.thinlto.map \
+; RUN:     %t.bc -start-lib %t1.bc -end-lib %t2.bc
+; RUN: FileCheck --check-prefix=TEST2 %s < %t2.thinlto.map
+; TEST2-NOT: Name: foo
+; TEST2: bar
+; TEST2-NOT: Name: foo
+;
+; RUN: lld-link -out:%t3.exe -entry:main -opt:noref -lldmap:%t3.map \
+; RUN:     %t.obj -start-lib %t1.obj %t2.obj
+; RUN: FileCheck --check-prefix=TEST3 %s < %t3.map
+; RUN: lld-link -out:%t3.exe -entry:main -opt:noref -lldmap:%t3.thinlto.map \
+; RUN:     %t.bc -start-lib %t1.bc %t2.bc
+; RUN: FileCheck --check-prefix=TEST3 %s < %t3.thinlto.map
+; TEST3-NOT: foo
+; TEST3-NOT: bar
+
+target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-pc-windows-msvc"
+
+define void @main() {
+  ret void
+}