Add an option to use the MSVC linker to link LTO-generated object files.

[ruiu]

Summary

This patch defines a new command line option, /MSVCLTO, to LLD.
If that option is given, LLD invokes link.exe to link LTO-generated
object files. This is hacky but useful because link.exe can create
PDB files.

[pcc]

lld/COFF/DriverUtils.cpp

647

Should this create a response file instead of passing the arguments directly?

652

Should this strip all inputs or just bitcode files?

658

What about /opt:lld*?

lld/COFF/SymbolTable.cpp

354

Maybe call this something like compileBitcodeFiles?

[ruiu]

• Updated as per pcc's review comments.

lld/COFF/DriverUtils.cpp

647

Done.

652

Strip only bitcode files.

658

lldmap and lldmap_file are only options that start with lld in COFF.

lld/COFF/SymbolTable.cpp

354

Done.

[pcc]

lld/COFF/DriverUtils.cpp

658

I was referring to /opt:lldlto=N, /opt:lldltojobs=N and /opt:lldltopartitions=N.

lld/test/COFF/msvclto.ll

3

Why do you have "not" here? I'd expect this to succeed on Windows.

[ruiu]

• Updated as per review comments.

[ruiu]

lld/COFF/DriverUtils.cpp

658

Ah. We should skip these options too. Done.

lld/test/COFF/msvclto.ll

3

We only need to verify the command line arguments passed to MSVC, so I added || true to make this line always succeed.

[pcc]

LGTM

lld/COFF/DriverUtils.cpp

659

I guess defaultlib flags will always refer to archive files, so you probably don't want to strip them.

lld/COFF/Driver.h

 // incompatible objects.
 void checkFailIfMismatch(StringRef Arg);
 
 // Convert Windows resource files (.res files) to a .obj file
 // using cvtres.exe.
 std::unique_ptr<MemoryBuffer>
 convertResToCOFF(const std::vector<MemoryBufferRef> &MBs);
 
+void runMSVCLinker(llvm::opt::InputArgList &Args, ArrayRef<StringRef> Objects);
+
 // Create enum with OPT_xxx values for each option in Options.td
 enum {
   OPT_INVALID = 0,
 #define OPTION(_1, _2, ID, _4, _5, _6, _7, _8, _9, _10, _11) OPT_##ID,
 #include "Options.inc"
 #undef OPTION
 };
 
 } // namespace coff
 } // namespace lld
 
 #endif

lld/COFF/Driver.cpp

for (auto Pair : Config->AlternateNames) {
           U->WeakAlias = Symtab.addUndefined(To);
     }
 
     // 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 /msvclto is given, we use the MSVC linker to link LTO output files.
+  // This is useful because MSVC link.exe can generate complete PDBs.
+  if (Args.hasArg(OPT_msvclto)) {
+    std::vector<StringRef> ObjectFiles = Symtab.compileBitcodeFiles();
+    runMSVCLinker(Args, ObjectFiles);
+    exit(0);
+  }
+
   // Do LTO by compiling bitcode input files to a set of native COFF files then
   // link those files.
   Symtab.addCombinedLTOObjects();
   run();
 
   // Make sure we have resolved all symbols.
   Symtab.reportRemainingUndefines();
 

lld/COFF/DriverUtils.cpp

 public:
   explicit Executor(StringRef S) : Saver(Alloc), Prog(Saver.save(S)) {}
   void add(StringRef S) { Args.push_back(Saver.save(S).data()); }
   void add(std::string &S) { Args.push_back(Saver.save(S).data()); }
   void add(Twine S) { Args.push_back(Saver.save(S).data()); }
   void add(const char *S) { Args.push_back(Saver.save(S).data()); }
 
   void run() {
+    if (Config->Verbose) {
+      outs() << Prog;
+      for (const char *Arg : Args)
+        outs() << " " << Arg;
+      outs() << '\n';
+    }
+
     ErrorOr<std::string> ExeOrErr = sys::findProgramByName(Prog);
     if (auto EC = ExeOrErr.getError())
       fatal(EC, "unable to find " + Prog + " in PATH: ");
     const char *Exe = Saver.save(*ExeOrErr).data();
+
     Args.insert(Args.begin(), Exe);
     Args.push_back(nullptr);
     if (sys::ExecuteAndWait(Args[0], Args.data()) != 0) {
       for (const char *S : Args)
         if (S)
           errs() << S << " ";
       fatal("ExecuteAndWait failed");
     }
while (!S.empty()) {
     Out << "\"\n";
   }
 }
 
 // An RAII temporary file class that automatically removes a temporary file.
 namespace {
 class TemporaryFile {
 public:
-  TemporaryFile(StringRef Prefix, StringRef Extn) {
+  TemporaryFile(StringRef Prefix, StringRef Extn, StringRef Contents = "") {
     SmallString<128> S;
     if (auto EC = sys::fs::createTemporaryFile("lld-" + Prefix, Extn, S))
       fatal(EC, "cannot create a temporary file");
     Path = S.str();
+
+    if (!Contents.empty()) {
+      std::error_code EC;
+      raw_fd_ostream OS(Path, EC, sys::fs::F_None);
+      if (EC)
+        fatal(EC, "failed to open " + Path);
+      OS << Contents;
+    }
   }
 
   TemporaryFile(TemporaryFile &&Obj) {
     std::swap(Path, Obj.Path);
   }
 
   ~TemporaryFile() {
     if (Path.empty())
for (MemoryBufferRef MB : MBs) {
 
     E.add(ResFile.Path);
   }
 
   E.run();
   return File.getMemoryBuffer();
 }
 
+static bool isBitcodeFile(StringRef Path) {
+  std::unique_ptr<MemoryBuffer> MB = check(
+      MemoryBuffer::getFile(Path, -1, false, true), "could not open " + Path);
+  StringRef Buf = MB->getBuffer();
+  return sys::fs::identify_magic(Buf) == sys::fs::file_magic::bitcode;
+}
+
+// Run MSVC link.exe for given in-memory object files.
+// Command line options are copied from those given to LLD.
+// This is for the /msvclto option.
+void runMSVCLinker(opt::InputArgList &Args, ArrayRef<StringRef> Objects) {
+  // Write the in-memory object files to disk.
+  std::vector<TemporaryFile> Temps;
+  for (StringRef S : Objects)
+    Temps.emplace_back("lto", "obj", S);
+
+  // Create a response file.
+  std::string Rsp = "/nologo ";
+  for (TemporaryFile &T : Temps)
+    Rsp += quote(T.Path) + " ";
+
+  for (auto *Arg : Args) {
+    switch (Arg->getOption().getID()) {
+    case OPT_defaultlib:
+    case OPT_linkrepro:
+    case OPT_lldmap:
+    case OPT_lldmap_file:
+    case OPT_msvclto:
+      // LLD-specific options are stripped.
+      break;
+    case OPT_INPUT:
+      // Bitcode files are stripped as they've been compiled to
+      // native object files.
+      if (!isBitcodeFile(Arg->getValue()))
+        Rsp += quote(Arg->getValue()) + " ";
+      break;
+    default:
+      Rsp += toString(Arg) + " ";
+    }
+  }
+
+  if (Config->Verbose)
+    outs() << "link.exe " << Rsp << "\n";
+
+  // Run MSVC link.exe.
+  Temps.emplace_back("lto", "rsp", Rsp);
+  Executor E("link.exe");
+  E.add(Twine("@" + Temps.back().Path));
+  E.run();
+}
+
 // Create OptTable
 
 // Create prefix string literals used in Options.td
 #define PREFIX(NAME, VALUE) const char *const NAME[] = VALUE;
 #include "Options.inc"
 #undef PREFIX
 
 // Create table mapping all options defined in Options.td

lld/COFF/LTO.h

 class InputFile;
 
 class BitcodeCompiler {
 public:
   BitcodeCompiler();
   ~BitcodeCompiler();
 
   void add(BitcodeFile &F);
-  std::vector<InputFile *> compile();
+  std::vector<StringRef> compile();
 
 private:
   std::unique_ptr<llvm::lto::LTO> LTOObj;
   std::vector<SmallString<0>> Buff;
 };
 }
 }
 
 #endif

lld/COFF/LTO.cpp

for (const lto::InputFile::Symbol &ObjSym : Obj.symbols()) {
     R.VisibleToRegularObj = Sym->IsUsedInRegularObj;
     if (R.Prevailing)
       undefine(Sym);
   }
   checkError(LTOObj->add(std::move(F.Obj), Resols));
 }
 
 // Merge all the bitcode files we have seen, codegen the result
-// and return the resulting ObjectFile(s).
-std::vector<InputFile *> BitcodeCompiler::compile() {
-  std::vector<InputFile *> Ret;
+// and return the resulting objects.
+std::vector<StringRef> BitcodeCompiler::compile() {
   unsigned MaxTasks = LTOObj->getMaxTasks();
   Buff.resize(MaxTasks);
 
   checkError(LTOObj->run([&](size_t Task) {
     return llvm::make_unique<lto::NativeObjectStream>(
         llvm::make_unique<raw_svector_ostream>(Buff[Task]));
   }));
 
-  for (unsigned I = 0; I != MaxTasks; ++I) {
-    if (Buff[I].empty())
-      continue;
-    Ret.push_back(make<ObjectFile>(MemoryBufferRef(Buff[I], "lto.tmp")));
-  }
+  std::vector<StringRef> Ret;
+  for (unsigned I = 0; I != MaxTasks; ++I)
+    if (!Buff[I].empty())
+      Ret.emplace_back(Buff[I].data(), Buff[I].size());
   return Ret;
 }

lld/COFF/Options.td

 defm safeseh : B<"safeseh", "Produce an image with Safe Exception Handler">;
 defm tsaware  : B<"tsaware", "Create non-Terminal Server aware executable">;
 
 def help : F<"help">;
 def help_q : Flag<["/?", "-?"], "">, Alias<help>;
 
 // LLD extensions
 def nosymtab : F<"nosymtab">;
+def msvclto : F<"msvclto">;
 
 // Flags for debugging
 def debugpdb : F<"debugpdb">;
 def dumppdb : Joined<["/", "-"], "dumppdb">;
 def lldmap : F<"lldmap">;
 def lldmap_file : Joined<["/", "-"], "lldmap:">;
 
 //==============================================================================

lld/COFF/SymbolTable.h

public:
   // a weak alias for U.
   void mangleMaybe(SymbolBody *B);
   StringRef findMangle(StringRef Name);
 
   // Build a set of COFF objects representing the combined contents of
   // BitcodeFiles and add them to the symbol table. Called after all files are
   // added and before the writer writes results to a file.
   void addCombinedLTOObjects();
+  std::vector<StringRef> compileBitcodeFiles();
 
   // The writer needs to handle DLL import libraries specially in
   // order to create the import descriptor table.
   std::vector<ImportFile *> ImportFiles;
 
   // The writer needs to infer the machine type from the object files.
   std::vector<ObjectFile *> ObjectFiles;
 

lld/COFF/SymbolTable.cpp

void SymbolTable::mangleMaybe(SymbolBody *B) {
   if (!Alias.empty())
     U->WeakAlias = addUndefined(Alias);
 }
 
 SymbolBody *SymbolTable::addUndefined(StringRef Name) {
   return addUndefined(Name, nullptr, false)->body();
 }
 
-void SymbolTable::addCombinedLTOObjects() {
-  if (BitcodeFiles.empty())
-    return;
-
+std::vector<StringRef> SymbolTable::compileBitcodeFiles() {
   LTO.reset(new BitcodeCompiler);
   for (BitcodeFile *F : BitcodeFiles)
     LTO->add(*F);
+  return LTO->compile();
+}
 
-  for (auto *File : LTO->compile()) {
-    auto *Obj = cast<ObjectFile>(File);
-    ObjectFiles.push_back(Obj);
+void SymbolTable::addCombinedLTOObjects() {
+  if (BitcodeFiles.empty())
+    return;
+  for (StringRef Object : compileBitcodeFiles()) {
+    auto *Obj = make<ObjectFile>(MemoryBufferRef(Object, "lto.tmp"));
     Obj->parse();
+    ObjectFiles.push_back(Obj);
   }
 }
+
 } // namespace coff
 } // namespace lld

lld/test/COFF/Inputs/msvclto.s

+.globl foo
+foo:
+ret

lld/test/COFF/msvclto.ll

+; RUN: llvm-as -o %t1.obj %s
+; RUN: llvm-mc -triple=x86_64-pc-windows-msvc -filetype=obj -o %t2.obj %p/Inputs/msvclto.s
+; RUN: not lld-link %t1.obj %t2.obj /msvclto /out:%t.exe /entry:main /verbose \
+; RUN:   /subsystem:console > %t.log 2>&1
+; RUN: FileCheck %s < %t.log
+
+; CHECK: link.exe /nologo {{.*}} {{.*}}2.obj /out:{{.*}}.exe /entry:main /verbose /subsystem:console
+
+target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-pc-windows-msvc"
+
+declare void @foo()
+
+define i32 @main() {
+  call void @foo()
+  ret i32 0
+}