Update ThinLTO Indexing logic

[rdhindsa]

Summary

1. Instead of writing empty index for file, this patch tracks the state of files in ObjectToIndexFileState. If the files are not indexed , only then we emit the empty files.
2. For ThinLTO Index only, skip cache pruning and iterating over tasks, since there is at most one output object file

[tejohnson]

lld/ELF/LTO.cpp

300 ↗

(On Diff #145312)

There won't always be a regular LTO file created via splitting for ThinLTO builds, so Buff[0] should be empty some of the time. Do you have a test for this case?

The other thing being done by the loop below is a call to createObjectFile, does that need to be done for Buff[0] if non-empty too?

[pcc]

This seems fine for now, but instead of copying this behaviour into LLD, it really ought to be a feature of the LTO implementation.

lld/ELF/LTO.cpp

262–269 ↗

(On Diff #145312)

I think this needs to be moved after the call to LTO::run.

300 ↗

(On Diff #145312)

Buff[0] should always be non-empty, see D41267.

[rdhindsa]

lld/ELF/LTO.cpp

300 ↗

(On Diff #145312)

I have added the test as well to ensure that one file is generated in this case. We just need to save this file and, we don't need to call createObjectFile, since we exit from LLD just after this step.

[tejohnson]

This LGTM, but wait until pcc or ruiu accept it.

[pcc]

I think this will need a rebase.

[rdhindsa]

Rebased diff.

[pcc]

LGTM

lld/trunk/ELF/LTO.h

public:
   std::vector<InputFile *> compile();
 
 private:
   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;
+  llvm::StringMap<bool> ObjectToIndexFileState;
 };
 } // namespace elf
 } // namespace lld
 
 #endif

lld/trunk/ELF/LTO.cpp

BitcodeCompiler::BitcodeCompiler() {
   // Initialize LTOObj.
   lto::ThinBackend Backend;
 
   if (Config->ThinLTOIndexOnly) {
     StringRef Path = Config->ThinLTOIndexOnlyArg;
     if (!Path.empty())
       IndexFile = openFile(Path);
 
+    auto OnIndexWrite = [&](const std::string &Identifier) {
+      ObjectToIndexFileState[Identifier] = true;
+    };
+
     Backend = lto::createWriteIndexesThinBackend(
         Config->ThinLTOPrefixReplace.first, Config->ThinLTOPrefixReplace.second,
-        Config->ThinLTOEmitImportsFiles, IndexFile.get(), nullptr);
+        Config->ThinLTOEmitImportsFiles, IndexFile.get(), OnIndexWrite);
   } else if (Config->ThinLTOJobs != -1U) {
     Backend = lto::createInProcessThinBackend(Config->ThinLTOJobs);
   }
 
   LTOObj = llvm::make_unique<lto::LTO>(createConfig(), Backend,
                                        Config->LTOPartitions);
 
   // Initialize UsedStartStop.
static void undefine(Symbol *S) {
   replaceSymbol<Undefined>(S, nullptr, S->getName(), STB_GLOBAL, STV_DEFAULT,
                            S->Type);
 }
 
 void BitcodeCompiler::add(BitcodeFile &F) {
   lto::InputFile &Obj = *F.Obj;
   bool IsExec = !Config->Shared && !Config->Relocatable;
 
-  // Create the empty files which, if indexed, will be overwritten later.
-  if (Config->ThinLTOIndexOnly) {
-    std::string Path = getThinLTOOutputFile(Obj.getName());
-    openFile(Path + ".thinlto.bc");
-
-    if (Config->ThinLTOEmitImportsFiles)
-      openFile(Path + ".imports");
-  }
+  if (Config->ThinLTOIndexOnly)
+    ObjectToIndexFileState.insert({Obj.getName(), false});
 
   ArrayRef<Symbol *> Syms = F.getSymbols();
   ArrayRef<lto::InputFile::Symbol> ObjSyms = Obj.symbols();
   std::vector<lto::SymbolResolution> Resols(Syms.size());
 
   // Provide a resolution to the LTO API for each symbol.
   for (size_t I = 0, E = Syms.size(); I != E; ++I) {
     Symbol *Sym = Syms[I];
for (size_t I = 0, E = Syms.size(); I != E; ++I) {
     R.LinkerRedefined = !Sym->CanInline;
   }
   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;
   unsigned MaxTasks = LTOObj->getMaxTasks();
   Buff.resize(MaxTasks);
   Files.resize(MaxTasks);
 
   // 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) {
                           Files[Task] = std::move(MB);
                         }));
 
   checkError(LTOObj->run(
       [&](size_t Task) {
         return llvm::make_unique<lto::NativeObjectStream>(
             llvm::make_unique<raw_svector_ostream>(Buff[Task]));
       },
       Cache));
 
-  if (!Config->ThinLTOCacheDir.empty())
-    pruneCache(Config->ThinLTOCacheDir, Config->ThinLTOCachePolicy);
+  // Emit empty index files for non-indexed files
+  if (Config->ThinLTOIndexOnly) {
+    for (auto &Identifier : ObjectToIndexFileState)
+      if (!Identifier.getValue()) {
+        std::string Path = getThinLTOOutputFile(Identifier.getKey());
+        openFile(Path + ".thinlto.bc");
 
-  for (unsigned I = 0; I != MaxTasks; ++I) {
-    if (Buff[I].empty())
-      continue;
-    if (Config->SaveTemps) {
-      if (I == 0)
-        saveBuffer(Buff[I], Config->OutputFile + ".lto.o");
-      else
-        saveBuffer(Buff[I], Config->OutputFile + Twine(I) + ".lto.o");
+        if (Config->ThinLTOEmitImportsFiles)
+          openFile(Path + ".imports");
       }
-    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::string Path = getThinLTOOutputFile(F->getName());
       std::unique_ptr<raw_fd_ostream> OS = openFile(Path + ".thinlto.bc");
       if (!OS)
         continue;
 
       ModuleSummaryIndex M(false);
       M.setSkipModuleByDistributedBackend();
       WriteIndexToFile(M, *OS);
 
       if (Config->ThinLTOEmitImportsFiles)
         openFile(Path + ".imports");
     }
 
+    if (Config->SaveTemps)
+      saveBuffer(Buff[0], Config->OutputFile + ".lto.o");
+
     // 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 (IndexFile)
       IndexFile->close();
     return {};
   }
+  if (!Config->ThinLTOCacheDir.empty())
+    pruneCache(Config->ThinLTOCacheDir, Config->ThinLTOCachePolicy);
+
+  std::vector<InputFile *> Ret;
+  for (unsigned I = 0; I != MaxTasks; ++I) {
+    if (Buff[I].empty())
+      continue;
+    if (Config->SaveTemps) {
+      if (I == 0)
+        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);
+  }
 
   for (std::unique_ptr<MemoryBuffer> &File : Files)
     if (File)
       Ret.push_back(createObjectFile(*File));
   return Ret;
 }

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

 ; 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
 ; RUN: not ls %t4.o.thinlto.bc
 
+; Ensure lld generates one regular LTO file via splitting for ThinLTO builds
+; RUN: rm -f %t.lto.o
+; RUN: ld.lld -save-temps --plugin-opt=thinlto-index-only -shared %t.o %t2.o -o %t
+; RUN: llvm-readobj -h %t.lto.o | FileCheck %s --check-prefix=FORMAT
+
 ; First force single-threaded mode
 ; RUN: rm -f %t.lto.o %t1.lto.o
 ; RUN: ld.lld -save-temps --thinlto-jobs=1 -shared %t.o %t2.o -o %t
 ; RUN: llvm-nm %t1.lto.o | FileCheck %s --check-prefix=NM1
 ; RUN: llvm-nm %t2.lto.o | FileCheck %s --check-prefix=NM2
 
 ; Next force multi-threaded mode
 ; RUN: rm -f %t2.lto.o %t21.lto.o
 ; RUN: ld.lld -save-temps --thinlto-jobs=2 -shared %t.o %t2.o -o %t2
 ; RUN: llvm-nm %t21.lto.o | FileCheck %s --check-prefix=NM1
 ; RUN: llvm-nm %t22.lto.o | FileCheck %s --check-prefix=NM2
 
 ; Then check without --thinlto-jobs (which currently default to hardware_concurrency)
 ; We just check that we don't crash or fail (as it's not sure which tests are
 ; stable on the final output file itself.
 ; RUN: ld.lld -shared %t.o %t2.o -o %t2
 
 ; NM: T f
 ; NM1: T f
 ; NM1-NOT: U g
 ; NM2: T g
+; FORMAT: Format: ELF64-x86-64
 
 ; The backend index for this module contains summaries from itself and
 ; Inputs/thinlto.ll, as it imports from the latter.
 ; BACKEND1: <MODULE_STRTAB_BLOCK
 ; BACKEND1-NEXT: <ENTRY {{.*}} record string = '{{.*}}thinlto.ll.tmp{{.*}}.o'
 ; BACKEND1-NEXT: <ENTRY {{.*}} record string = '{{.*}}thinlto.ll.tmp{{.*}}.o'
 ; BACKEND1-NEXT: </MODULE_STRTAB_BLOCK
 ; BACKEND1: <GLOBALVAL_SUMMARY_BLOCK