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

255

Use parentheses for ifs having elses for consistency.

265

Ditto

COFF/InputFiles.h

167

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

173

Use override instead of virtual.

176

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

181

Name -> Filename.

COFF/SymbolTable.cpp

65

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

193

Remove this blank line.

197

Use real type instead of auto.

210

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

218–236

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.

238

You want to return addFile's return value.

COFF/SymbolTable.h

53

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

236

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

236

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

255

Done

265

Done

COFF/InputFiles.h

167

Done

173

Done

176

Done

181

Done

COFF/SymbolTable.cpp

65

Done

193

Done

197

Done

210

Done

236

Done

238

This code is now gone.

COFF/SymbolTable.h

53

Done

COFF/Symbols.cpp

85

Done

[ruiu]

LGTM

COFF/Driver.cpp

101

Add a comment saying that initialize for LTO.

COFF/SymbolTable.cpp

232

Looks like Obj leaks here.

240

This can be Symbol * instead of Symbol *&.

243

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

[pcc]

• Address review comments

[pcc]

(waiting for D10114)

COFF/Driver.cpp

101

Done

COFF/SymbolTable.cpp

232

Fixed.

240

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/Optional.h"
 #include "llvm/ADT/STLExtras.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;
 
 namespace lld {
 namespace coff {
 
 Configuration *Config;
 
 static std::string getOutputPath(llvm::opt::InputArgList *Args) {
   if (auto *Arg = Args->getLastArg(OPT_out))
     return Arg->getValue();
   for (auto *Arg : Args->filtered(OPT_INPUT)) {
     if (!StringRef(Arg->getValue()).endswith_lower(".obj"))
       continue;
     SmallString<128> Val = StringRef(Arg->getValue());
     llvm::sys::path::replace_extension(Val, ".exe");
     return Val.str();
   }
   llvm_unreachable("internal error");
 }
 
-std::unique_ptr<InputFile> createFile(StringRef Path) {
+ErrorOr<std::unique_ptr<InputFile>> createFile(StringRef Path) {
   if (StringRef(Path).endswith_lower(".lib"))
-    return llvm::make_unique<ArchiveFile>(Path);
-  return llvm::make_unique<ObjectFile>(Path);
+    return std::unique_ptr<InputFile>(llvm::make_unique<ArchiveFile>(Path));
+
+  llvm::sys::fs::file_magic Magic;
+  if (auto EC = llvm::sys::fs::identify_magic(Path, Magic))
+    return EC;
+  if (Magic == llvm::sys::fs::file_magic::bitcode)
+    return std::unique_ptr<InputFile>(llvm::make_unique<BitcodeFile>(Path));
+  return std::unique_ptr<InputFile>(llvm::make_unique<ObjectFile>(Path));
 }
 
 namespace {
 class BumpPtrStringSaver : public llvm::cl::StringSaver {
 public:
   BumpPtrStringSaver(lld::coff::StringAllocator *A) : Alloc(A) {}
   const char *SaveString(const char *S) override {
     return Alloc->save(S).data();
for (auto *Arg : Args->filtered(OPT_defaultlib)) {
     if (!Config->insertFile(Path))
       continue;
     Res->push_back(llvm::make_unique<ArchiveFile>(Path));
   }
   return std::error_code();
 }
 
 bool link(int Argc, const char *Argv[]) {
+  llvm::InitializeAllTargetInfos();
+  llvm::InitializeAllTargets();
+  llvm::InitializeAllTargetMCs();
+  llvm::InitializeAllAsmParsers();
+  llvm::InitializeAllAsmPrinters();
+  llvm::InitializeAllDisassemblers();
+
   // Parse command line options.
   Config = new Configuration();
   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());
bool link(int Argc, const char *Argv[]) {
 
   // Parse all input files and put all symbols to the symbol table.
   // The symbol table will take care of name resolution.
   SymbolTable Symtab;
   for (auto *Arg : Args->filtered(OPT_INPUT)) {
     std::string Path = findFile(Arg->getValue());
     if (!Config->insertFile(Path))
       continue;
-    if (auto EC = Symtab.addFile(createFile(Path))) {
+    auto FileOrErr = createFile(Path);
+    if (auto EC = FileOrErr.getError()) {
+      llvm::errs() << Path << ": " << EC.message() << "\n";
+      return false;
+    }
+    if (auto EC = Symtab.addFile(std::move(FileOrErr.get()))) {
       llvm::errs() << Path << ": " << EC.message() << "\n";
       return false;
     }
   }
   if (Symtab.reportRemainingUndefines())
     return false;
 
+  if (auto EC = Symtab.addCombinedLTOObject()) {
+    llvm::errs() << EC.message() << "\n";
+    return false;
+  }
+
   // Write the result.
   Writer Out(&Symtab);
   if (auto EC = Out.write(getOutputPath(Args.get()))) {
     llvm::errs() << EC.message() << "\n";
     return false;
   }
   return true;
 }
 
 } // namespace coff
 } // namespace lld

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 MBRef;
   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 "InputFiles.h"
 #include "Writer.h"
 #include "lld/Core/Error.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())
+    return make_dynamic_error_code(StringRef(Err));
+
+  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:
   // mechanisms to allow aliases, a name can be resolved to a
   // different symbol). Returns a nullptr if not found.
   SymbolBody *find(StringRef Name);
 
   // Dump contents of the symbol table to stderr.
   void dump();
 
   // Try to infer the machine type from the object files known to the symbol
   // table.
   llvm::COFF::MachineTypes getInferredMachineType();
 
+  // 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;
 
 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);
   void addInitialSymbol(SymbolBody *Body);
 
   std::unordered_map<StringRef, Symbol *> Symtab;
   std::vector<std::unique_ptr<ObjectFile>> ObjectFiles;
   std::vector<std::unique_ptr<ArchiveFile>> ArchiveFiles;
+  std::vector<std::unique_ptr<BitcodeFile>> BitcodeFiles;
   std::vector<std::unique_ptr<SymbolBody>> OwnedSymbols;
+  std::unique_ptr<MemoryBuffer> LTOObjectFile;
   llvm::BumpPtrAllocator Alloc;
   StringAllocator StringAlloc;
 };
 
 } // 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 "SymbolTable.h"
 #include "lld/Core/Error.h"
 #include "llvm/ADT/STLExtras.h"
+#include "llvm/LTO/LTOCodeGenerator.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace lld {
 namespace coff {
 
 SymbolTable::SymbolTable() {
   addInitialSymbol(new DefinedAbsolute("__ImageBase", Config->ImageBase));
   addInitialSymbol(new Undefined(Config->EntryName));
 }
 
 void SymbolTable::addInitialSymbol(SymbolBody *Body) {
   OwnedSymbols.push_back(std::unique_ptr<SymbolBody>(Body));
   Symtab[Body->getName()] = new (Alloc) Symbol(Body);
 }
 
 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 = parseDirectives(Dir, &Libs, &StringAlloc))
       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() {
   }
 }
 
 llvm::COFF::MachineTypes SymbolTable::getInferredMachineType() {
   for (std::unique_ptr<ObjectFile> &File : ObjectFiles) {
     // Try to infer machine type from the magic byte of the object file.
     auto MT =
         static_cast<llvm::COFF::MachineTypes>(File->getCOFFObj()->getMachine());
     if (MT != llvm::COFF::IMAGE_FILE_MACHINE_UNKNOWN)
       return MT;
   }
   return llvm::COFF::IMAGE_FILE_MACHINE_UNKNOWN;
 }
 
+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)
+    return make_dynamic_error_code(StringRef(ErrMsg));
+
+  // 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("<LTO object>", LTOObjectFile->getMemBufferRef());
+  if (auto EC = Obj->parse())
+    return EC;
+  ObjectFiles.emplace_back(Obj);
+  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)
+      return make_dynamic_error_code(Twine("LTO: unexpected new symbol: ") +
+                                     Name);
+    Body->setBackref(Sym);
+
+    if (isa<DefinedBitcode>(Sym->Body)) {
+      // The symbol should now be defined.
+      if (!isa<Defined>(Body))
+        return make_dynamic_error_code(Twine("LTO: undefined symbol: ") + Name);
+      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)
     return make_dynamic_error_code("unknown file type");
 
   std::unique_ptr<InputFile> Obj(new ObjectFile(MBRef.getBufferIdentifier(), 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 %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 %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 %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 %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 %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 %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__)