Refactor ThinLTO-related code in BitcodeCompiler.cpp. NFC.

[ruiu]

Summary

Refactor ThinLTO-related code in BitcodeCompiler.cpp. NFC.

[rdhindsa]

LGTM

lld/trunk/ELF/LTO.h

 
 class BitcodeCompiler {
 public:
   BitcodeCompiler();
   ~BitcodeCompiler();
 
   void add(BitcodeFile &F);
   std::vector<InputFile *> compile();
-  void addLazyObjFile(LazyObjFile *File);
 
 private:
   void init();
 
   std::unique_ptr<llvm::lto::LTO> LTOObj;
   std::vector<SmallString<0>> Buff;
   std::vector<std::unique_ptr<MemoryBuffer>> Files;
   llvm::DenseSet<StringRef> UsedStartStop;
   std::unique_ptr<llvm::raw_fd_ostream> IndexFile;
 };
 } // namespace elf
 } // namespace lld
 
 #endif

lld/trunk/ELF/LTO.cpp

static void diagnosticHandler(const DiagnosticInfo &DI) {
   warn(ErrStorage);
 }
 
 static void checkError(Error E) {
   handleAllErrors(std::move(E),
                   [&](ErrorInfoBase &EIB) { error(EIB.message()); });
 }
 
-// With the ThinLTOIndexOnly option, only the thin link is performed, and will
-// generate index files for the ThinLTO backends in a distributed build system.
-// The distributed build system may expect that index files are created for all
-// input bitcode objects provided to the linker for the thin link. However,
-// index files will not normally be created for input bitcode objects that
-// either aren't selected by the linker (i.e. in a static library and not
-// needed), or because they don't have a summary. Therefore we need to create
-// empty dummy index file outputs in those cases.
-// If SkipModule is true then .thinlto.bc should contain just
-// SkipModuleByDistributedBackend flag which requests distributed backend
-// to skip the compilation of the corresponding module and produce an empty
-// object file.
-static void writeEmptyDistributedBuildOutputs(StringRef ModulePath,
-                                              bool SkipModule) {
-  std::string NewModulePath =
-      lto::getThinLTOOutputFile(ModulePath, Config->ThinLTOPrefixReplace.first,
-                                Config->ThinLTOPrefixReplace.second);
-
-  std::error_code EC;
-  raw_fd_ostream OS(NewModulePath + ".thinlto.bc", EC,
-                    sys::fs::OpenFlags::F_None);
-  if (EC)
-    error("failed to write " + NewModulePath + ".thinlto.bc" + ": " +
-          EC.message());
-
-  if (SkipModule) {
-    ModuleSummaryIndex Index(false);
-    Index.setSkipModuleByDistributedBackend();
-    WriteIndexToFile(Index, OS);
-  }
-}
-
 // Creates an empty file to store a list of object files for final
 // linking of distributed ThinLTO.
 static std::unique_ptr<raw_fd_ostream> openFile(StringRef File) {
   if (File.empty())
     return nullptr;
 
   std::error_code EC;
   auto Ret =
       llvm::make_unique<raw_fd_ostream>(File, EC, sys::fs::OpenFlags::F_None);
-  if (EC)
-    error("cannot create " + File + ": " + EC.message());
+  if (EC) {
+    error("cannot open " + File + ": " + EC.message());
+    return nullptr;
+  }
   return Ret;
 }
 
+static std::string getThinLTOOutputFile(StringRef ModulePath) {
+  return lto::getThinLTOOutputFile(ModulePath,
+                                   Config->ThinLTOPrefixReplace.first,
+                                   Config->ThinLTOPrefixReplace.second) +
+         ".thinlto.bc";
+}
+
 // Initializes IndexFile, Backend and LTOObj members.
 void BitcodeCompiler::init() {
   lto::Config Conf;
 
   // LLD supports the new relocations.
   Conf.Options = InitTargetOptionsFromCodeGenFlags();
   Conf.Options.RelaxELFRelocations = true;
 
replaceSymbol<Undefined>(S, nullptr, S->getName(), STB_GLOBAL, STV_DEFAULT,
                            S->Type);
 }
 
 void BitcodeCompiler::add(BitcodeFile &F) {
   lto::InputFile &Obj = *F.Obj;
 
   // Create the empty files which, if indexed, will be overwritten later.
   if (Config->ThinLTOIndexOnly)
-    writeEmptyDistributedBuildOutputs(Obj.getName(), false);
+    openFile(getThinLTOOutputFile(Obj.getName()));
 
   unsigned SymNum = 0;
   std::vector<Symbol *> Syms = F.getSymbols();
   std::vector<lto::SymbolResolution> Resols(Syms.size());
 
   bool IsExecutable = !Config->Shared && !Config->Relocatable;
 
   // Provide a resolution to the LTO API for each symbol.

 // 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;
   unsigned MaxTasks = LTOObj->getMaxTasks();
   Buff.resize(MaxTasks);
   Files.resize(MaxTasks);
 
-  // If LazyObjFile has not been added to link, emit empty index files
-  if (Config->ThinLTOIndexOnly)
-    for (LazyObjFile *F : LazyObjFiles)
-      if (!F->AddedToLink && isBitcode(F->MB))
-        addLazyObjFile(F);
-
   // The --thinlto-cache-dir option specifies the path to a directory in which
   // to cache native object files for ThinLTO incremental builds. If a path was
   // specified, configure LTO to use it as the cache directory.
   lto::NativeObjectCache Cache;
   if (!Config->ThinLTOCacheDir.empty())
     Cache = check(
         lto::localCache(Config->ThinLTOCacheDir,
                         [&](size_t Task, std::unique_ptr<MemoryBuffer> MB) {
if (Config->SaveTemps) {
         saveBuffer(Buff[I], Config->OutputFile + ".lto.o");
       else
         saveBuffer(Buff[I], Config->OutputFile + Twine(I) + ".lto.o");
     }
     InputFile *Obj = createObjectFile(MemoryBufferRef(Buff[I], "lto.tmp"));
     Ret.push_back(Obj);
   }
 
+  // If LazyObjFile has not been added to link, emit empty index files.
+  // This is needed because this is what GNU gold plugin does and we have a
+  // distributed build system that depends on that behavior.
+  if (Config->ThinLTOIndexOnly) {
+    for (LazyObjFile *F : LazyObjFiles) {
+      if (F->AddedToLink || !isBitcode(F->MB))
+        continue;
+
+      std::unique_ptr<raw_fd_ostream> OS =
+          openFile(getThinLTOOutputFile(F->getName()));
+      if (!OS)
+        continue;
+
+      ModuleSummaryIndex M(false);
+      M.setSkipModuleByDistributedBackend();
+      WriteIndexToFile(M, *OS);
+    }
+
     // ThinLTO with index only option is required to generate only the index
     // files. After that, we exit from linker and ThinLTO backend runs in a
     // distributed environment.
-  if (Config->ThinLTOIndexOnly)
     exit(0);
+  }
 
   for (std::unique_ptr<MemoryBuffer> &File : Files)
     if (File)
       Ret.push_back(createObjectFile(*File));
-
   return Ret;
 }
-
-// For lazy object files not added to link, adds empty index files
-void BitcodeCompiler::addLazyObjFile(LazyObjFile *File) {
-  writeEmptyDistributedBuildOutputs(File->getBuffer().getBufferIdentifier(),
-                                    /*SkipModule=*/true);
-}

lld/trunk/test/ELF/lto/thinlto.ll

 ; IN1-NEXT: {{.*}}thinlto.ll.tmp2.o
 ; IN1-NEXT: {{.*}}thinlto.ll.tmp4.o
 
 ; Ensure lld generates error if unable to write to index file
 ; RUN: rm -f %t4.o.thinlto.bc
 ; RUN: touch %t4.o.thinlto.bc
 ; RUN: chmod 400 %t4.o.thinlto.bc
 ; RUN: ld.lld -m elf_x86_64 --plugin-opt=thinlto-index-only -shared %t.o %t4.o -o %t5 2>&1 | FileCheck %s --check-prefix=ERR
-; ERR: failed to write {{.*}}4.o.thinlto.bc: {{P|p}}ermission denied
+; ERR: cannot open {{.*}}4.o.thinlto.bc: {{P|p}}ermission denied
 
 ; Ensure lld doesn't generates index files when thinlto-index-only is not enabled
 ; RUN: rm -f %t.o.thinlto.bc
 ; RUN: rm -f %t2.o.thinlto.bc
 ; RUN: rm -f %t4.o.thinlto.bc
 ; RUN: ld.lld -m elf_x86_64 -shared %t.o %t2.o %t4.o -o %t5
 ; RUN: not ls %t.o.thinlto.bc
 ; RUN: not ls %t2.o.thinlto.bc