Initial implementation of link-time optimization for the new COFF linker.

[pcc]

Summary

This implementation is known to work in very simple cases (see new test case).

[ruiu]

This is very small amount code, and all the things seem to fit naturally to the existing things. Very nice.

COFF/InputFiles.cpp

251

Use parentheses for ifs having elses for consistency.

261

Ditto

COFF/InputFiles.h

162

Can you add a brief comment for this class saying that this is for LTO, just like I did for other classes?

168

Use override instead of virtual.

171

Add using llvm::LTOModule at beginning of this file.

176

Name -> Filename.

COFF/SymbolTable.cpp

63

Move this piece of code after addArchive(ArchiveFile *) for consistent order.

235

Remove this blank line.

239

Use real type instead of auto.

252

You want to cache size() -- for (unsigned I = 1, E = BitcodeFiles.size(), I != E ...)

260–278

What does this code do? Why do we need to insert new Undefined symbols at this point?

Ah, I think I understand what you are doing. LTO object file is added after all files are resolved, and at this moment we are about to add "duplicate" symbols, correct?

Maybe a better approach is to tweak Defined::compare so that any symbol whose type is of DefinedBitcode always "win" over any other symbols.

280

You want to return addFile's return value.

COFF/SymbolTable.h

62

Also mention that that this function is called after all files are added and before writer writes results to a file.

COFF/Symbols.cpp

85

Use new instead of make_unique with consistency with other lines in this function.

[ruiu]

COFF/SymbolTable.cpp

278

On second thought, I'm now thinking that replacing DefinedBitcode symbols with regular defined symbols can be done without going through addFile. We have a list of symbols which need to be replaced, and we also have symbols in this file that should replace them. So we can just do that by overriding Symbol's Body pointers.

Not sure which is better, so it's just an idea.

[pcc]

COFF/SymbolTable.cpp

278

Ah, I think I understand what you are doing. LTO object file is added after all files are resolved, and at this moment we are about to add "duplicate" symbols, correct?

Correct.

Maybe a better approach is to tweak Defined::compare so that any symbol whose type is of DefinedBitcode always "win" over any other symbols.

Do you mean that non-DefinedBitcode symbols should win over DefinedBitcode symbols? I did consider that approach to start with, but the problem with that approach is that it would prevent us from diagnosing multiply defined symbols correctly. Consider the case where a.o (bitcode) and b.o (COFF) both define a strong symbol 'foo'. When linking a.o with b.o, when we add b.o we will need to diagnose a conflict between a DefinedBitcode and a DefinedRegular. When linking a.o on its own, we have exactly the same situation when we add the LTO object, but we shouldn't diagnose.

On second thought, I'm now thinking that replacing DefinedBitcode symbols with regular defined symbols can be done without going through addFile. We have a list of symbols which need to be replaced, and we also have symbols in this file that should replace them. So we can just do that by overriding Symbol's Body pointers.

I prefer this approach. I'm a little concerned about duplication of logic between here and SymbolTable::resolve (especially once we add more COFF features), but maybe that should be dealt with later if it becomes a problem.

[pcc]

• Address most review comments
• Use custom symbol resolution during LTO

COFF/InputFiles.cpp

251

Done

261

Done

COFF/InputFiles.h

162

Done

168

Done

171

Done

176

Done

COFF/SymbolTable.cpp

63

Done

235

Done

239

Done

252

Done

278

Done

280

This code is now gone.

COFF/SymbolTable.h

62

Done

COFF/Symbols.cpp

85

Done

[ruiu]

LGTM

COFF/Driver.cpp

126

Add a comment saying that initialize for LTO.

COFF/SymbolTable.cpp

263

Looks like Obj leaks here.

271

This can be Symbol * instead of Symbol *&.

274

Can't this fit in 80 columns? (If not, never mind).

[pcc]

• Address review comments

[pcc]

(waiting for D10114)

COFF/Driver.cpp

126

Done

COFF/SymbolTable.cpp

263

Fixed.

271

Done

[pcc]

Rebase

COFF/CMakeLists.txt

 set(LLVM_TARGET_DEFINITIONS Options.td)
 tablegen(LLVM Options.inc -gen-opt-parser-defs)
 add_public_tablegen_target(COFFOptionsTableGen)
 
 add_llvm_library(lldCOFF
   Chunks.cpp
   Driver.cpp
   DriverUtils.cpp
   InputFiles.cpp
   SymbolTable.cpp
   Symbols.cpp
   Writer.cpp
+
+  LINK_COMPONENTS
+  ${LLVM_TARGETS_TO_BUILD}
+  Core
+  LTO
+  MC
+  MCDisassembler
+  Support
   )
 
 add_dependencies(lldCOFF COFFOptionsTableGen)

COFF/Driver.cpp

 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Option/Arg.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Option/Option.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Process.h"
+#include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/raw_ostream.h"
 #include <memory>
 
 using namespace llvm;
 using llvm::COFF::IMAGE_SUBSYSTEM_UNKNOWN;
 using llvm::COFF::IMAGE_SUBSYSTEM_WINDOWS_CUI;
 using llvm::COFF::IMAGE_SUBSYSTEM_WINDOWS_GUI;
 using llvm::sys::Process;
ErrorOr<std::unique_ptr<InputFile>> LinkerDriver::openFile(StringRef Path) {
   std::unique_ptr<MemoryBuffer> MB = std::move(MBOrErr.get());
   MemoryBufferRef MBRef = MB->getMemBufferRef();
   OwningMBs.push_back(std::move(MB)); // take ownership
 
   // File type is detected by contents, not by file extension.
   file_magic Magic = identify_magic(MBRef.getBuffer());
   if (Magic == file_magic::archive)
     return std::unique_ptr<InputFile>(new ArchiveFile(MBRef));
+  if (Magic == file_magic::bitcode)
+    return std::unique_ptr<InputFile>(new BitcodeFile(Path));
   return std::unique_ptr<InputFile>(new ObjectFile(MBRef));
 }
 
 namespace {
 class BumpPtrStringSaver : public llvm::cl::StringSaver {
 public:
   BumpPtrStringSaver(lld::coff::StringAllocator *A) : Alloc(A) {}
   const char *SaveString(const char *S) override {
if (Optional<StringRef> Path = findLib(Arg->getValue())) {
       std::unique_ptr<InputFile> File = std::move(FileOrErr.get());
       Res->push_back(std::move(File));
     }
   }
   return std::error_code();
 }
 
 // Find file from search paths. You can omit ".obj", this function takes
 // care of that. Note that the returned path is not guaranteed to exist.
 StringRef LinkerDriver::doFindFile(StringRef Filename) {
   bool hasPathSep = (Filename.find_first_of("/\\") != StringRef::npos);
   if (hasPathSep)
     return Filename;
   bool hasExt = (Filename.find('.') != StringRef::npos);
   for (StringRef Dir : SearchPaths) {
     SmallString<128> Path = Dir;
     llvm::sys::path::append(Path, Filename);
while (!Env.empty()) {
     StringRef Path;
     std::tie(Path, Env) = Env.split(';');
     Ret.push_back(Path);
   }
   return Ret;
 }
 
 bool LinkerDriver::link(int Argc, const char *Argv[]) {
+  // Needed for LTO.
+  llvm::InitializeAllTargetInfos();
+  llvm::InitializeAllTargets();
+  llvm::InitializeAllTargetMCs();
+  llvm::InitializeAllAsmParsers();
+  llvm::InitializeAllAsmPrinters();
+  llvm::InitializeAllDisassemblers();
+
   // Parse command line options.
   auto ArgsOrErr = parseArgs(Argc, Argv);
   if (auto EC = ArgsOrErr.getError()) {
     llvm::errs() << EC.message() << "\n";
     return false;
   }
   std::unique_ptr<llvm::opt::InputArgList> Args = std::move(ArgsOrErr.get());
 
if (Config->EntryName.empty()) {
     }
     Config->EntryName = EntryOrErr.get();
   }
 
   // Make sure we have resolved all symbols.
   if (Symtab.reportRemainingUndefines())
     return false;
 
+  if (auto EC = Symtab.addCombinedLTOObject()) {
+    llvm::errs() << EC.message() << "\n";
+    return false;
+  }
+
   // /include option takes precedence over garbage collection.
   for (auto *Arg : Args->filtered(OPT_incl))
     Symtab.find(Arg->getValue())->markLive();
 
   // Windows specific -- if no /subsystem is given, we need to infer
   // that from entry point name.
   if (Config->Subsystem == IMAGE_SUBSYSTEM_UNKNOWN) {
     Config->Subsystem =

COFF/InputFiles.h

 #ifndef LLD_COFF_INPUT_FILES_H
 #define LLD_COFF_INPUT_FILES_H
 
 #include "Chunks.h"
 #include "Memory.h"
 #include "Symbols.h"
 #include "lld/Core/LLVM.h"
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/LTO/LTOModule.h"
 #include "llvm/Object/Archive.h"
 #include "llvm/Object/COFF.h"
 #include <memory>
 #include <set>
 #include <vector>
 
 namespace lld {
 namespace coff {
 
+using llvm::LTOModule;
 using llvm::object::Archive;
 using llvm::object::COFFObjectFile;
 
 // The root class of input files.
 class InputFile {
 public:
-  enum Kind { ArchiveKind, ObjectKind, ImportKind };
+  enum Kind { ArchiveKind, ObjectKind, ImportKind, BitcodeKind };
   Kind kind() const { return FileKind; }
   virtual ~InputFile() {}
 
   // Returns the filename.
   virtual StringRef getName() = 0;
 
   // Returns symbols defined by this file.
   virtual std::vector<SymbolBody *> &getSymbols() = 0;
private:
   std::error_code parse() override;
 
   MemoryBufferRef MB;
   std::vector<SymbolBody *> SymbolBodies;
   llvm::BumpPtrAllocator Alloc;
   StringAllocator StringAlloc;
 };
 
+// Used for LTO.
+class BitcodeFile : public InputFile {
+public:
+  explicit BitcodeFile(StringRef S) : InputFile(BitcodeKind), Filename(S) {}
+  explicit BitcodeFile(MemoryBufferRef M) : InputFile(BitcodeKind), MBRef(M) {}
+  static bool classof(const InputFile *F) { return F->kind() == BitcodeKind; }
+  StringRef getName() override { return Filename; }
+  std::vector<SymbolBody *> &getSymbols() override { return SymbolBodies; }
+
+  LTOModule *getModule() const { return M.get(); }
+  LTOModule *releaseModule() { return M.release(); }
+
+private:
+  std::error_code parse() override;
+
+  std::string Filename;
+  MemoryBufferRef MBRef;
+  std::vector<SymbolBody *> SymbolBodies;
+  llvm::BumpPtrAllocator Alloc;
+  std::unique_ptr<LTOModule> M;
+};
+
 } // namespace coff
 } // namespace lld
 
 #endif

COFF/InputFiles.cpp

 //===- InputFiles.cpp -----------------------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Chunks.h"
 #include "Error.h"
 #include "InputFiles.h"
 #include "Writer.h"
 #include "llvm/ADT/STLExtras.h"
+#include "llvm/LTO/LTOModule.h"
 #include "llvm/Object/COFF.h"
 #include "llvm/Support/COFF.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm::object;
 using namespace llvm::support::endian;
std::error_code ImportFile::parse() {
   // If type is function, we need to create a thunk which jump to an
   // 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)
     SymbolBodies.push_back(new (Alloc) DefinedImportThunk(Name, ImpSym));
   return std::error_code();
 }
 
+std::error_code BitcodeFile::parse() {
+  std::string Err;
+  if (!Filename.empty()) {
+    M.reset(LTOModule::createFromFile(Filename.c_str(), llvm::TargetOptions(),
+                                      Err));
+  } else {
+    M.reset(LTOModule::createFromBuffer(MBRef.getBufferStart(),
+                                        MBRef.getBufferSize(),
+                                        llvm::TargetOptions(), Err));
+  }
+  if (!Err.empty()) {
+    llvm::errs() << Err << '\n';
+    return make_error_code(LLDError::BrokenFile);
+  }
+
+  for (unsigned I = 0, E = M->getSymbolCount(); I != E; ++I) {
+    StringRef SymName = M->getSymbolName(I);
+    if ((M->getSymbolAttributes(I) & LTO_SYMBOL_DEFINITION_MASK) ==
+        LTO_SYMBOL_DEFINITION_UNDEFINED) {
+      SymbolBodies.push_back(new (Alloc) Undefined(SymName));
+    } else {
+      SymbolBodies.push_back(new (Alloc) DefinedBitcode(SymName));
+    }
+  }
+
+  return std::error_code();
+}
 } // namespace coff
 } // namespace lld

COFF/SymbolTable.h

public:
   // choose the right one depending on which `main` function is defined.
   // This function looks up the symbol table and resolve corresponding
   // entry point name.
   ErrorOr<StringRef> findDefaultEntry();
 
   // Dump contents of the symbol table to stderr.
   void dump();
 
+  // Build a COFF object representing the combined contents of BitcodeFiles
+  // and add it to the symbol table. Called after all files are added and
+  // before the writer writes results to a file.
+  std::error_code addCombinedLTOObject();
+
   // The writer needs to handle DLL import libraries specially in
   // order to create the import descriptor table.
   std::vector<std::unique_ptr<ImportFile>> ImportFiles;
 
   // The writer needs to infer the machine type from the object files.
   std::vector<std::unique_ptr<ObjectFile>> ObjectFiles;
 
   // Creates an Undefined symbol for a given name.
   std::error_code addUndefined(StringRef Name);
 
   // Rename From -> To in the symbol table.
   std::error_code rename(StringRef From, StringRef To);
 
 private:
   std::error_code addObject(ObjectFile *File);
   std::error_code addArchive(ArchiveFile *File);
   std::error_code addImport(ImportFile *File);
+  std::error_code addBitcode(BitcodeFile *File);
 
   std::error_code resolve(SymbolBody *Body);
   std::error_code addMemberFile(Lazy *Body);
   std::error_code addSymbol(SymbolBody *Body);
 
   std::unordered_map<StringRef, Symbol *> Symtab;
   std::vector<std::unique_ptr<ArchiveFile>> ArchiveFiles;
+  std::vector<std::unique_ptr<BitcodeFile>> BitcodeFiles;
   std::vector<std::unique_ptr<SymbolBody>> OwningSymbols;
+  std::unique_ptr<MemoryBuffer> LTOObjectFile;
   llvm::BumpPtrAllocator Alloc;
 };
 
 } // namespace pecoff
 } // namespace lld
 
 #endif

COFF/SymbolTable.cpp

 //===- SymbolTable.cpp ----------------------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Config.h"
 #include "Driver.h"
 #include "Error.h"
 #include "SymbolTable.h"
 #include "llvm/ADT/STLExtras.h"
+#include "llvm/LTO/LTOCodeGenerator.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
 
 namespace lld {
 namespace coff {
 
 SymbolTable::SymbolTable() {
   addSymbol(new DefinedAbsolute("__ImageBase", Config->ImageBase));
   if (!Config->EntryName.empty())
     addUndefined(Config->EntryName);
 }
 
 std::error_code SymbolTable::addFile(std::unique_ptr<InputFile> File) {
   if (auto EC = File->parse())
     return EC;
   InputFile *FileP = File.release();
   if (auto *P = dyn_cast<ObjectFile>(FileP))
     return addObject(P);
   if (auto *P = dyn_cast<ArchiveFile>(FileP))
     return addArchive(P);
+  if (auto *P = dyn_cast<BitcodeFile>(FileP))
+    return addBitcode(P);
   return addImport(cast<ImportFile>(FileP));
 }
 
 std::error_code SymbolTable::addObject(ObjectFile *File) {
   ObjectFiles.emplace_back(File);
   for (SymbolBody *Body : File->getSymbols())
     if (Body->isExternal())
       if (auto EC = resolve(Body))
         return EC;
 
   // If an object file contains .drectve section, read it and add
   // files listed in the section.
   StringRef Dir = File->getDirectives();
   if (!Dir.empty()) {
     std::vector<std::unique_ptr<InputFile>> Libs;
     if (auto EC = Driver->parseDirectives(Dir, &Libs))
       return EC;
     for (std::unique_ptr<InputFile> &Lib : Libs)
       addFile(std::move(Lib));
   }
   return std::error_code();
 }
 
 std::error_code SymbolTable::addArchive(ArchiveFile *File) {
   ArchiveFiles.emplace_back(File);
   for (SymbolBody *Body : File->getSymbols())
     if (auto EC = resolve(Body))
       return EC;
   return std::error_code();
 }
 
+std::error_code SymbolTable::addBitcode(BitcodeFile *File) {
+  BitcodeFiles.emplace_back(File);
+  for (SymbolBody *Body : File->getSymbols())
+    if (Body->isExternal())
+      if (auto EC = resolve(Body))
+        return EC;
+
+  // TODO: Handle linker directives.
+  return std::error_code();
+}
+
 std::error_code SymbolTable::addImport(ImportFile *File) {
   ImportFiles.emplace_back(File);
   for (SymbolBody *Body : File->getSymbols())
     if (auto EC = resolve(Body))
       return EC;
   return std::error_code();
 }
 
void SymbolTable::dump() {
   for (auto &P : Symtab) {
     Symbol *Ref = P.second;
     if (auto *Body = dyn_cast<Defined>(Ref->Body))
       llvm::dbgs() << Twine::utohexstr(Config->ImageBase + Body->getRVA())
                    << " " << Body->getName() << "\n";
   }
 }
 
+std::error_code SymbolTable::addCombinedLTOObject() {
+  if (BitcodeFiles.empty())
+    return std::error_code();
+
+  llvm::LTOCodeGenerator CG;
+  std::set<DefinedBitcode *> PreservedBitcodeSymbols;
+
+  // All symbols referenced by non-bitcode objects must be preserved.
+  for (std::unique_ptr<ObjectFile> &File : ObjectFiles)
+    for (SymbolBody *Body : File->getSymbols())
+      if (auto *S = dyn_cast<DefinedBitcode>(Body->getReplacement()))
+        PreservedBitcodeSymbols.insert(S);
+
+  // Likewise for the linker-generated reference to the entry point.
+  if (auto *S = dyn_cast<DefinedBitcode>(Symtab[Config->EntryName]->Body))
+    PreservedBitcodeSymbols.insert(S);
+
+  for (DefinedBitcode *S : PreservedBitcodeSymbols)
+    CG.addMustPreserveSymbol(S->getName());
+
+  CG.setModule(BitcodeFiles[0]->releaseModule());
+  for (unsigned I = 1, E = BitcodeFiles.size(); I != E; ++I)
+    CG.addModule(BitcodeFiles[I]->getModule());
+
+  std::string ErrMsg;
+  LTOObjectFile = CG.compile(false, false, false, ErrMsg);
+  if (!LTOObjectFile) {
+    llvm::errs() << ErrMsg << '\n';
+    return make_error_code(LLDError::BrokenFile);
+  }
+
+  // Create an object file and add it to the symbol table by replacing any
+  // DefinedBitcode symbols with the definitions in the object file.
+  auto Obj = new ObjectFile(LTOObjectFile->getMemBufferRef());
+  ObjectFiles.emplace_back(Obj);
+  if (auto EC = Obj->parse())
+    return EC;
+  for (SymbolBody *Body : Obj->getSymbols()) {
+    if (!Body->isExternal())
+      continue;
+
+    // Find an existing Symbol. We should not see any new symbols at this point.
+    StringRef Name = Body->getName();
+    Symbol *Sym = Symtab[Name];
+    if (!Sym) {
+      llvm::errs() << "LTO: unexpected new symbol: " << Name << '\n';
+      return make_error_code(LLDError::BrokenFile);
+    }
+    Body->setBackref(Sym);
+
+    if (isa<DefinedBitcode>(Sym->Body)) {
+      // The symbol should now be defined.
+      if (!isa<Defined>(Body)) {
+        llvm::errs() << "LTO: undefined symbol: " << Name << '\n';
+        return make_error_code(LLDError::BrokenFile);
+      }
+      Sym->Body = Body;
+    }
+  }
+
+  return std::error_code();
+}
+
 } // namespace coff
 } // namespace lld

COFF/Symbols.h

 class SymbolBody {
 public:
   enum Kind {
     DefinedFirst,
     DefinedRegularKind,
     DefinedAbsoluteKind,
     DefinedImportDataKind,
     DefinedImportThunkKind,
+    DefinedBitcodeKind,
     DefinedLast,
     UndefinedKind,
     LazyKind,
   };
 
   Kind kind() const { return SymbolKind; }
   virtual ~SymbolBody() {}
 
public:
   uint64_t getRVA() override { return Data.getRVA(); }
   uint64_t getFileOff() override { return Data.getFileOff(); }
   Chunk *getChunk() { return &Data; }
 
 private:
   ImportThunkChunk Data;
 };
 
+class DefinedBitcode : public Defined {
+public:
+  DefinedBitcode(StringRef Name) : Defined(DefinedBitcodeKind, Name) {}
+
+  static bool classof(const SymbolBody *S) {
+    return S->kind() == DefinedBitcodeKind;
+  }
+
+  uint64_t getRVA() override { llvm_unreachable("bitcode reached writer"); }
+  uint64_t getFileOff() override { llvm_unreachable("bitcode reached writer"); }
+};
+
 } // namespace coff
 } // namespace lld
 
 #endif

COFF/Symbols.cpp

ErrorOr<std::unique_ptr<InputFile>> Lazy::getMember() {
   MemoryBufferRef MBRef = MBRefOrErr.get();
 
   // getMember returns an empty buffer if the member was already
   // read from the library.
   if (MBRef.getBuffer().empty())
     return std::unique_ptr<InputFile>(nullptr);
 
   file_magic Magic = identify_magic(MBRef.getBuffer());
+  if (Magic == file_magic::bitcode)
+    return std::unique_ptr<InputFile>(new BitcodeFile(MBRef));
   if (Magic == file_magic::coff_import_library)
     return std::unique_ptr<InputFile>(new ImportFile(MBRef));
 
   if (Magic != file_magic::coff_object) {
     llvm::errs() << File->getName() << ": unknown file type\n";
     return make_error_code(LLDError::InvalidFile);
   }
 
   std::unique_ptr<InputFile> Obj(new ObjectFile(MBRef));
   Obj->setParentName(File->getName());
   return std::move(Obj);
 }
 
 } // namespace coff
 } // namespace lld

test/CMakeLists.txt

configure_lit_site_cfg(
   ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.in
   ${CMAKE_CURRENT_BINARY_DIR}/lit.site.cfg)
 configure_lit_site_cfg(
   ${CMAKE_CURRENT_SOURCE_DIR}/Unit/lit.site.cfg.in
   ${CMAKE_CURRENT_BINARY_DIR}/Unit/lit.site.cfg
   )
 
 set(LLD_TEST_DEPS
-  FileCheck not llvm-ar llvm-nm
+  FileCheck not llvm-ar llvm-as llvm-nm llc
   lld llvm-config llvm-objdump llvm-readobj yaml2obj obj2yaml
   linker-script-test macho-dump llvm-mc llvm-nm
   )
 if (LLVM_INCLUDE_TESTS)
   set(LLD_TEST_DEPS ${LLD_TEST_DEPS} LLDUnitTests)
 endif()
 
 set(LLD_TEST_PARAMS

test/COFF/Inputs/lto-dep.ll

+target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-pc-windows-msvc"
+
+define void @foo() {
+  ret void
+}

test/COFF/lto.ll

+; RUN: llvm-as -o %T/main.lto.obj %s
+; RUN: llvm-as -o %T/foo.lto.obj %S/Inputs/lto-dep.ll
+; RUN: rm -f %T/foo.lto.lib
+; RUN: llvm-ar cru %T/foo.lto.lib %T/foo.lto.obj
+
+; RUN: llc -filetype=obj -o %T/main.obj %s
+; RUN: llc -filetype=obj -o %T/foo.obj %S/Inputs/lto-dep.ll
+; RUN: rm -f %T/foo.lib
+; RUN: llvm-ar cru %T/foo.lib %T/foo.obj
+
+; RUN: lld -flavor link2 /out:%T/main.exe /entry:main /subsystem:console %T/main.lto.obj %T/foo.lto.obj
+; RUN: llvm-readobj -file-headers %T/main.exe | FileCheck -check-prefix=HEADERS-11 %s
+; RUN: llvm-objdump -d %T/main.exe | FileCheck -check-prefix=TEXT-11 %s
+; RUN: lld -flavor link2 /out:%T/main.exe /entry:main /subsystem:console %T/main.lto.obj %T/foo.lto.lib
+; RUN: llvm-readobj -file-headers %T/main.exe | FileCheck -check-prefix=HEADERS-11 %s
+; RUN: llvm-objdump -d %T/main.exe | FileCheck -check-prefix=TEXT-11 %s
+
+; RUN: lld -flavor link2 /out:%T/main.exe /entry:main /subsystem:console %T/main.obj %T/foo.lto.obj
+; RUN: llvm-readobj -file-headers %T/main.exe | FileCheck -check-prefix=HEADERS-01 %s
+; RUN: llvm-objdump -d %T/main.exe | FileCheck -check-prefix=TEXT-01 %s
+; RUN: lld -flavor link2 /out:%T/main.exe /entry:main /subsystem:console %T/main.obj %T/foo.lto.lib
+; RUN: llvm-readobj -file-headers %T/main.exe | FileCheck -check-prefix=HEADERS-01 %s
+; RUN: llvm-objdump -d %T/main.exe | FileCheck -check-prefix=TEXT-01 %s
+
+; RUN: lld -flavor link2 /out:%T/main.exe /entry:main /subsystem:console %T/main.lto.obj %T/foo.obj
+; RUN: llvm-readobj -file-headers %T/main.exe | FileCheck -check-prefix=HEADERS-10 %s
+; RUN: llvm-objdump -d %T/main.exe | FileCheck -check-prefix=TEXT-10 %s
+; RUN: lld -flavor link2 /out:%T/main.exe /entry:main /subsystem:console %T/main.lto.obj %T/foo.lib
+; RUN: llvm-readobj -file-headers %T/main.exe | FileCheck -check-prefix=HEADERS-10 %s
+; RUN: llvm-objdump -d %T/main.exe | FileCheck -check-prefix=TEXT-10 %s
+
+; HEADERS-11: AddressOfEntryPoint: 0x1000
+; TEXT-11: Disassembly of section .text:
+; TEXT-11-NEXT: .text:
+; TEXT-11-NEXT: xorl  %eax, %eax
+; TEXT-11-NEXT: retq
+
+; HEADERS-01: AddressOfEntryPoint: 0x1000
+; TEXT-01: Disassembly of section .text:
+; TEXT-01-NEXT: .text:
+; TEXT-01-NEXT: subq  $40, %rsp
+; TEXT-01-NEXT: callq 7
+; TEXT-01-NEXT: xorl  %eax, %eax
+; TEXT-01-NEXT: addq  $40, %rsp
+; TEXT-01-NEXT: retq
+; TEXT-01-NEXT: retq
+
+; HEADERS-10: AddressOfEntryPoint: 0x1010
+; TEXT-10: Disassembly of section .text:
+; TEXT-10-NEXT: .text:
+; TEXT-10-NEXT: retq
+; TEXT-10-NEXT: int3
+; TEXT-10-NEXT: int3
+; TEXT-10-NEXT: int3
+; TEXT-10-NEXT: int3
+; TEXT-10-NEXT: int3
+; TEXT-10-NEXT: int3
+; TEXT-10-NEXT: int3
+; TEXT-10-NEXT: int3
+; TEXT-10-NEXT: int3
+; TEXT-10-NEXT: int3
+; TEXT-10-NEXT: int3
+; TEXT-10-NEXT: int3
+; TEXT-10-NEXT: int3
+; TEXT-10-NEXT: int3
+; TEXT-10-NEXT: int3
+; TEXT-10-NEXT: subq  $40, %rsp
+; TEXT-10-NEXT: callq -25
+; TEXT-10-NEXT: xorl  %eax, %eax
+; TEXT-10-NEXT: addq  $40, %rsp
+; TEXT-10-NEXT: retq
+
+target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-pc-windows-msvc"
+
+define i32 @main() {
+  call void @foo()
+  ret i32 0
+}
+
+declare void @foo()

test/lit.cfg

 
 # testFormat: The test format to use to interpret tests.
 #
 # For now we require '&&' between commands, until they get globally killed and
 # the test runner updated.
 config.test_format = lit.formats.ShTest(execute_external)
 
 # suffixes: A list of file extensions to treat as test files.
-config.suffixes = ['.objtxt', '.test']
+config.suffixes = ['.ll', '.objtxt', '.test']
 
 # excludes: A list of directories to exclude from the testsuite. The 'Inputs'
 # subdirectories contain auxiliary inputs for various tests in their parent
 # directories.
 config.excludes = ['Inputs']
 
 # test_source_root: The root path where tests are located.
 config.test_source_root = os.path.dirname(__file__)