[ThinLTO] upgrade IR symtab in parallel ahead of time

[ychen]

Summary

Before parsing file, collect all bitcode files that need upgrade, and perform the actual upgrade in parallel, assuming the time taken to upgrade the symtab is proportion to the file size. Probably some of the upgrade is not necessary if the bitcode file is archive member and no symbol is defined there. After some experiments, it seems that the cost would be low because of parallelization.

Add an lld option(--cache-ir-symtab) to enable this behavior (default off). In the long run, I think it is beneficial to turn it on by default.

For symtab upgrade path, this reduces clang binary linking (all file hit lto cache) to ~5.5 (8 core, 16 threads) seconds from ~13s. Non-upgrade path takes about 3.8s.

[steven_wu]

This sounds like a good idea. Have you thought about just write out upgraded bitcode file on disk (since you named it a "SymTabCache"), maybe into thinLTO cache? This will speed up the incremental build as well. I think most of the upgrade path are coming from linking a bitcode static library, which is probably not changing during incremental build so we just need to upgrade once.

[ychen]

In D71261#1786331, @steven_wu wrote:

This sounds like a good idea. Have you thought about just write out upgraded bitcode file on disk (since you named it a "SymTabCache"), maybe into thinLTO cache? This will speed up the incremental build as well. I think most of the upgrade path are coming from linking a bitcode static library, which is probably not changing during incremental build so we just need to upgrade once.

Thanks for the feedback, @steven_wu. I think there would be more improvement by caching the upgraded IR symbol table (the IR module self is in memory but not parsed). I would do some experiments to get rough numbers. I think it will be a separate patch for the caching because it helps with or without this patch.

[steven_wu]

LLVM LTO part LGTM. I will get another pair of eyes on lld changes.

[ychen]

• rebase

[ychen]

gentle ping. Could reviewers help take a look at the linker part?

[tejohnson]

@MaskRay and @ruiu are the best reviewers for the LLD changes.

One high level question and one request:

Does this affect the laziness of Lazy object/archive files? It looked to me as if those perhaps were going to be upgraded non-lazily after this change.

It would be good to add equivalent support to gold-plugin.cpp as well so that those remain in sync on functionality.

[MaskRay]

For symtab upgrade path, this reduces clang binary linking (all file hit lto cache) to ~5.5 (8 core, 16 threads) seconds from ~13s. Non-upgrade path takes about 3.8s.

This looks promising and I want to try out this patch for our internal targets. The patch does not apply at HEAD. Do you mind rebasing it?

lld/ELF/Driver.cpp

72–75

Apologies that I just touched namespace lld { lines which might require you to rebase.

lld/ELF/Options.td

106

Use the same name as the option name.

Use BB for strict two dashes. GNU ld's loose option parsing cause some parsing ambiguity. We want to avoid one-dash long options for newer options.

llvm/lib/Object/IRSymtab.cpp

312–315

Do we have a better testing this other than using an environment variable?

[ychen]

• rebase

[ychen]

In D71261#2038881, @tejohnson wrote:

@MaskRay and @ruiu are the best reviewers for the LLD changes.

One high level question and one request:

Does this affect the laziness of Lazy object/archive files? It looked to me as if those perhaps were going to be upgraded non-lazily after this change.

Yes, it indeed pre-upgrades the IR symbol table of Lazy object/archive files. It is a little bit wasteful potentially. Good thing is that parallelization makes the cost trivial.

It would be good to add equivalent support to gold-plugin.cpp as well so that those remain in sync on functionality.

Understood. I will look into that.

[ychen]

• Address comments

[ychen]

llvm/lib/Object/IRSymtab.cpp

312–315

Not that I'm aware of. @tejohnson any suggestions?

[MaskRay]

Just to confirm. @ychen Do you have lots of bitcode files with different versions which require upgrade in LTO?

I tested with an internal program and there seems to be 1% improvement on time, minor cost on memory usage. I need to collect a bit more applications for benchmark.
Loading LazyObjFile and ArchiveFile eagerly may potentially accelerate "Parse input files". (Our Bazel builds use very file archives (we don't use --nostart_end_lib))
There is a proposal in 2019-04 http://lists.llvm.org/pipermail/llvm-dev/2019-April/131902.html making the scheme more generic.

@ruiu Is this proposal unfinished yet? I think we can at least add an option to opt in that mode (parsing LazyObjFile (and probably ArchiveFile) eagerly). This bitcode parsing may need a dependency on that mode.

lld/ELF/InputFiles.cpp

510

Why is the change?

1527

This logic requires a test.

[ychen]

In D71261#2040732, @MaskRay wrote:

Just to confirm. @ychen Do you have lots of bitcode files with different versions which require upgrade in LTO?

Yes. The number I collected was for cases for all files are bitcode and need upgrade.

I tested with an internal program and there seems to be 1% improvement on time, minor cost on memory usage. I need to collect a bit more applications for benchmark.
Loading LazyObjFile and ArchiveFile eagerly may potentially accelerate "Parse input files". (Our Bazel builds use very file archives (we don't use --nostart_end_lib))
There is a proposal in 2019-04 http://lists.llvm.org/pipermail/llvm-dev/2019-April/131902.html making the scheme more generic.

@ruiu Is this proposal unfinished yet? I think we can at least add an option to opt in that mode (parsing LazyObjFile (and probably ArchiveFile) eagerly). This bitcode parsing may need a dependency on that mode.

[ychen]

In D71261#2038881, @tejohnson wrote:

It would be good to add equivalent support to gold-plugin.cpp as well so that those remain in sync on functionality.

It seems that the gold plugin API does not work well with the pre-upgrade this patch is proposing. Without pre-upgrade, the upgrade happens during InputFile::create in claim_file_hook. Pre-upgrade needs to happen before claim_file_hook where something like vector<Input_path> is available. The plugin API does not seem to have this hook. Not quite sure how to proceed with this restriction.

[ychen]

• Add linker test for the option and dependent libraries

[ychen]

• reupload

[ychen]

lld/ELF/InputFiles.cpp

510

To factor out the common code getPath to be used later.

1527

I added a test case to the deplib test file. It should cover this if statement.

[MaskRay]

Add an lld option(--cache-ir-symtab) to enable this behavior (default off). In the long run, I think it is beneficial to turn it on by default.

I tested this patch internally. There is some minor performance loss turning on --cache-ir-symtab. That may be because we don't have mismatching versions of bitcode files.
I guess many users do the same (same version of bitcode files), so I am unsure this should be on by default.

lld/ELF/Driver.cpp

546

Drop AheadOfTime. It is not part of the option name.

If this is an LTO specific option, --lto-* may be more suitable.

[MaskRay]

Also, I still want to check whether doing further work on http://lists.llvm.org/pipermail/llvm-dev/2019-April/131902.html can avoid the LTO specific option.

Request for changes (just in case). Sorry..

[ychen]

• replace cacheIRSymTabAheadOfTime with cacheIRSymTab

[ychen]

In D71261#2045732, @MaskRay wrote:

Also, I still want to check whether doing further work on http://lists.llvm.org/pipermail/llvm-dev/2019-April/131902.html can avoid the LTO specific option.

Request for changes (just in case). Sorry..

Not a problem. I'm curious to know too :-)

[tejohnson]

In D71261#2043242, @ychen wrote:

In D71261#2038881, @tejohnson wrote:

It would be good to add equivalent support to gold-plugin.cpp as well so that those remain in sync on functionality.

It seems that the gold plugin API does not work well with the pre-upgrade this patch is proposing. Without pre-upgrade, the upgrade happens during InputFile::create in claim_file_hook. Pre-upgrade needs to happen before claim_file_hook where something like vector<Input_path> is available. The plugin API does not seem to have this hook. Not quite sure how to proceed with this restriction.

That's true the claim_file_hook is called on files one by one from gold. But there is a second call to InputFile::create for each claimed module, done from addModule, which I assume will upgrade them a second time. In that case the caller has the whole list of input files that were claimed, so something similar could presumably be done there.

[ychen]

In D71261#2045724, @MaskRay wrote:

Add an lld option(--cache-ir-symtab) to enable this behavior (default off). In the long run, I think it is beneficial to turn it on by default.

I tested this patch internally. There is some minor performance loss turning on --cache-ir-symtab. That may be because we don't have mismatching versions of bitcode files.
I guess many users do the same (same version of bitcode files), so I am unsure this should be on by default.

This mostly benefits ThinLTO incremental build. When there are a lot of bitcode files need to be upgraded, the performance increase is obvious; if not, I expected the performance loss is very minor. There are some heuristics could help performance loss. For example, skip pre-upgrade when the number of candidate files is smaller than some threshold. Anyhow, I think it is reasonable to make it opt-in to begin with.

[ychen]

In D71261#2045798, @tejohnson wrote:

In D71261#2043242, @ychen wrote:

In D71261#2038881, @tejohnson wrote:

It would be good to add equivalent support to gold-plugin.cpp as well so that those remain in sync on functionality.

It seems that the gold plugin API does not work well with the pre-upgrade this patch is proposing. Without pre-upgrade, the upgrade happens during InputFile::create in claim_file_hook. Pre-upgrade needs to happen before claim_file_hook where something like vector<Input_path> is available. The plugin API does not seem to have this hook. Not quite sure how to proceed with this restriction.

That's true the claim_file_hook is called on files one by one from gold. But there is a second call to InputFile::create for each claimed module, done from addModule, which I assume will upgrade them a second time. In that case the caller has the whole list of input files that were claimed, so something similar could presumably be done there.

Thanks for the pointer! I will look into that.

[ychen]

• Add gold plugin support
• Use inheritance to increase code reuse.

[ychen]

In D71261#2045732, @MaskRay wrote:

Also, I still want to check whether doing further work on http://lists.llvm.org/pipermail/llvm-dev/2019-April/131902.html can avoid the LTO specific option.

Request for changes (just in case). Sorry..

Any updates?

[ychen]

Make unit test more robust:¬

• add more unique characters for input filenames
• use absolute path for test input files

[ychen]

• clang-format/lint

[ychen]

• format

lld/ELF/Config.h

struct Configuration {
   bool allowShlibUndefined;
   bool androidPackDynRelocs;
   bool armHasBlx = false;
   bool armHasMovtMovw = false;
   bool armJ1J2BranchEncoding = false;
   bool asNeeded = false;
   bool bsymbolic;
   bool bsymbolicFunctions;
+  bool cacheIRSymTab;
   bool callGraphProfileSort;
   bool checkSections;
   bool compressDebugSections;
   bool cref;
   bool defineCommon;
   bool demangle = true;
   bool dependentLibraries;
   bool disableVerify;

lld/ELF/Driver.h

 //===- Driver.h -------------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_ELF_DRIVER_H
 #define LLD_ELF_DRIVER_H
 
 #include "LTO.h"
 #include "SymbolTable.h"
 #include "lld/Common/LLVM.h"
 #include "lld/Common/Reproduce.h"
 #include "llvm/ADT/Optional.h"
+#include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSet.h"
+#include "llvm/LTO/LTO.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace lld {
+
+class IRSymtabFileCacheLLD : public llvm::lto::IRSymtabFileCache {
+  llvm::StringMap<llvm::MemoryBufferRef> loadedFiles;
+
+public:
+  void upgrade(const std::vector<std::string> &files);
+  llvm::Optional<llvm::MemoryBufferRef> getMemBuffer(StringRef path) const;
+};
+
+extern IRSymtabFileCacheLLD *irSymTabCache;
+
 namespace elf {
 
 extern class LinkerDriver *driver;
 
 class LinkerDriver {
 public:
   void main(ArrayRef<const char *> args);
   void addFile(StringRef path, bool withLOption);

lld/ELF/Driver.cpp

 #include "lld/Common/Filesystem.h"
 #include "lld/Common/Memory.h"
 #include "lld/Common/Strings.h"
 #include "lld/Common/TargetOptionsCommandFlags.h"
 #include "lld/Common/Version.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringSwitch.h"
+#include "llvm/Bitcode/BitcodeReader.h"
 #include "llvm/LTO/LTO.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Compression.h"
 #include "llvm/Support/GlobPattern.h"
 #include "llvm/Support/LEB128.h"
 #include "llvm/Support/Parallel.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/TarWriter.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/TimeProfiler.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cstdlib>
 #include <utility>
 
 using namespace llvm;
 using namespace llvm::ELF;
 using namespace llvm::object;
 using namespace llvm::sys;
 using namespace llvm::support;
 using namespace lld;
 using namespace lld::elf;
 
+lld::IRSymtabFileCacheLLD *lld::irSymTabCache;
+
 Configuration *elf::config;
 LinkerDriver *elf::driver;
 
 static void setConfigs(opt::InputArgList &args);
 static void readConfigs(opt::InputArgList &args);
 
 bool elf::link(ArrayRef<const char *> args, bool canExitEarly,
                raw_ostream &stdoutOS, raw_ostream &stderrOS) {
   lld::stdoutOS = &stdoutOS;
std::vector<std::pair<MemoryBufferRef, uint64_t>> static getArchiveMembers(
 
   // Take ownership of memory buffers created for members of thin archives.
   for (std::unique_ptr<MemoryBuffer> &mb : file->takeThinBuffers())
     make<std::unique_ptr<MemoryBuffer>>(std::move(mb));
 
   return v;
 }
 
+void lld::IRSymtabFileCacheLLD::upgrade(const std::vector<std::string> &files) {
+  using namespace llvm::sys::fs;
+
+  std::vector<MemoryBufferRef> toCache;
+
+  for (auto &f : files) {
+    Optional<MemoryBufferRef> buffer = readFile(f);
+    if (!buffer.hasValue())
+      return;
+    MemoryBufferRef mbref = *buffer;
+    loadedFiles.try_emplace(f, mbref);
+
+    switch (identify_magic(mbref.getBuffer())) {
+    case file_magic::archive: {
+      for (const std::pair<MemoryBufferRef, uint64_t> &p :
+           getArchiveMembers(mbref))
+        if (identify_magic(p.first.getBuffer()) == file_magic::bitcode)
+          toCache.push_back(p.first);
+      break;
+    }
+
+    case file_magic::bitcode:
+      toCache.push_back(mbref);
+      break;
+    default:
+      break;
+    }
+  }
+
+  IRSymtabFileCache::upgrade(toCache);
+}
+
+Optional<MemoryBufferRef>
+lld::IRSymtabFileCacheLLD::getMemBuffer(StringRef path) const {
+  auto iter = loadedFiles.find(path);
+  if (iter != loadedFiles.end())
+    return iter->second;
+  return None;
+}
+
 // Opens a file and create a file object. Path has to be resolved already.
 void LinkerDriver::addFile(StringRef path, bool withLOption) {
   using namespace sys::fs;
 
-  Optional<MemoryBufferRef> buffer = readFile(path);
+  Optional<MemoryBufferRef> buffer;
+  if (irSymTabCache)
+    buffer = irSymTabCache->getMemBuffer(path);
+  if (!buffer.hasValue())
+    buffer = readFile(path);
   if (!buffer.hasValue())
     return;
+
   MemoryBufferRef mbref = *buffer;
 
   if (config->formatBinary) {
     files.push_back(make<BinaryFile>(mbref));
     return;
   }
 
   switch (identify_magic(mbref.getBuffer())) {
if (args.hasArg(OPT_v) && !args.hasArg(OPT_INPUT))
     return;
   if (args.hasArg(OPT_version))
     return;
 
   // Initialize time trace profiler.
   if (config->timeTraceEnabled)
     timeTraceProfilerInitialize(config->timeTraceGranularity, config->progName);
 
+  if (config->cacheIRSymTab)
+    irSymTabCache = new IRSymtabFileCacheLLD();
+
   {
     llvm::TimeTraceScope timeScope("ExecuteLinker");
 
     initLLVM();
     createFiles(args);
     if (errorCount())
       return;
 
static void readConfigs(opt::InputArgList &args) {
   config->disableVerify = args.hasArg(OPT_disable_verify);
   config->discard = getDiscard(args);
   config->dwoDir = args.getLastArgValue(OPT_plugin_opt_dwo_dir_eq);
   config->dynamicLinker = getDynamicLinker(args);
   config->ehFrameHdr =
       args.hasFlag(OPT_eh_frame_hdr, OPT_no_eh_frame_hdr, false);
   config->emitLLVM = args.hasArg(OPT_plugin_opt_emit_llvm, false);
   config->emitRelocs = args.hasArg(OPT_emit_relocs);
+  config->cacheIRSymTab =
+      args.hasFlag(OPT_cache_ir_symtab, OPT_no_cache_ir_symtab, false);
   config->callGraphProfileSort = args.hasFlag(
       OPT_call_graph_profile_sort, OPT_no_call_graph_profile_sort, true);
   config->enableNewDtags =
       args.hasFlag(OPT_enable_new_dtags, OPT_disable_new_dtags, true);
   config->entry = args.getLastArgValue(OPT_entry);
   config->executeOnly =
       args.hasFlag(OPT_execute_only, OPT_no_execute_only, false);
   config->exportDynamic =
error("unknown -format value: " + s +
         " (supported formats: elf, default, binary)");
   return false;
 }
 
 void LinkerDriver::createFiles(opt::InputArgList &args) {
   // For --{push,pop}-state.
   std::vector<std::tuple<bool, bool, bool>> stack;
 
+  if (irSymTabCache) {
+    std::vector<std::string> files;
+    for (auto *arg : args) {
+      switch (arg->getOption().getID()) {
+      case OPT_library:
+        if (Optional<std::string> path = searchLibrary(arg->getValue()))
+          files.push_back(*path);
+        break;
+      case OPT_INPUT:
+        files.push_back(arg->getValue());
+        break;
+      }
+    }
+    irSymTabCache->upgrade(files);
+  }
+
   // Iterate over argv to process input files and positional arguments.
   for (auto *arg : args) {
     switch (arg->getOption().getID()) {
     case OPT_library:
       addLibrary(arg->getValue());
       break;
     case OPT_INPUT:
       addFile(arg->getValue(), /*withLOption=*/false);
template <class ELFT> void LinkerDriver::link(opt::InputArgList &args) {
   // add files to the link, via autolinking, these files are always
   // appended to the Files vector.
   {
     llvm::TimeTraceScope timeScope("Parse input files");
     for (size_t i = 0; i < files.size(); ++i)
       parseFile(files[i]);
   }
 
+  if (irSymTabCache) {
+    delete irSymTabCache;
+    irSymTabCache = nullptr;
+  }
+
   // Now that we have every file, we can decide if we will need a
   // dynamic symbol table.
   // We need one if we were asked to export dynamic symbols or if we are
   // producing a shared library.
   // We also need one if any shared libraries are used and for pie executables
   // (probably because the dynamic linker needs it).
   config->hasDynSymTab =
       !sharedFiles.empty() || config->isPic || config->exportDynamic;

lld/ELF/InputFiles.cpp

 //
 // When the option is given, we link "just symbols". The section table is
 // initialized with null pointers.
 template <class ELFT> void ObjFile<ELFT>::initializeJustSymbols() {
   ArrayRef<Elf_Shdr> sections = CHECK(this->getObj().sections(), this);
   this->sections.resize(sections.size());
 }
 
+static Optional<std::pair<std::string, bool>> getPath(StringRef specifier) {
+  if (fs::exists(specifier))
+    return std::make_pair(specifier.str(), false);
+  else if (Optional<std::string> s = findFromSearchPaths(specifier))
+    return std::make_pair(*s, true);
+  else if (Optional<std::string> s = searchLibraryBaseName(specifier))
+    return std::make_pair(*s, true);
+  return None;
+}
+
 // An ELF object file may contain a `.deplibs` section. If it exists, the
 // section contains a list of library specifiers such as `m` for libm. This
 // function resolves a given name by finding the first matching library checking
 // the various ways that a library can be specified to LLD. This ELF extension
 // is a form of autolinking and is called `dependent libraries`. It is currently
 // unique to LLVM and lld.
 static void addDependentLibrary(StringRef specifier, const InputFile *f) {
   if (!config->dependentLibraries)
     return;
-  if (fs::exists(specifier))
-    driver->addFile(specifier, /*withLOption=*/false);
-  else if (Optional<std::string> s = findFromSearchPaths(specifier))
-    driver->addFile(*s, /*withLOption=*/true);
-  else if (Optional<std::string> s = searchLibraryBaseName(specifier))
-    driver->addFile(*s, /*withLOption=*/true);
+  if (Optional<std::pair<std::string, bool>> path = getPath(specifier))
+    driver->addFile(path->first, /*withLOption=*/path->second);
   else
     error(toString(f) +
           ": unable to find library from dependent library specifier: " +
           specifier);
 }
 
 // Record the membership of a section group so that in the garbage collection
 // pass, section group members are kept or discarded as a unit.
 template <class ELFT>
BitcodeFile::BitcodeFile(MemoryBufferRef mb, StringRef archiveName,
                          uint64_t offsetInArchive)
     : InputFile(BitcodeKind, mb) {
   this->archiveName = std::string(archiveName);
 
   std::string path = mb.getBufferIdentifier().str();
   if (config->thinLTOIndexOnly)
     path = replaceThinLTOSuffix(mb.getBufferIdentifier());
 
+  if (irSymTabCache)
+    obj = CHECK(lto::InputFile::create(mb, *irSymTabCache), this);
+  else
+    obj = CHECK(lto::InputFile::create(mb), this);
+
   // ThinLTO assumes that all MemoryBufferRefs given to it have a unique
   // name. If two archives define two members with the same name, this
   // causes a collision which result in only one of the objects being taken
   // into consideration at LTO time (which very likely causes undefined
   // symbols later in the link stage). So we append file offset to make
   // filename unique.
   StringRef name =
       archiveName.empty()
           ? saver.save(path)
           : saver.save(archiveName + "(" + path::filename(path) + " at " +
                        utostr(offsetInArchive) + ")");
-  MemoryBufferRef mbref(mb.getBuffer(), name);
-
-  obj = CHECK(lto::InputFile::create(mbref), this);
+  obj->setName(name);
 
   Triple t(obj->getTargetTriple());
   ekind = getBitcodeELFKind(t);
   emachine = getBitcodeMachineKind(mb.getBufferIdentifier(), t);
 }
 
 static uint8_t mapVisibility(GlobalValue::VisibilityTypes gvVisibility) {
   switch (gvVisibility) {
template <class ELFT> void BitcodeFile::parse() {
   std::vector<bool> keptComdats;
   for (StringRef s : obj->getComdatTable())
     keptComdats.push_back(
         symtab->comdatGroups.try_emplace(CachedHashStringRef(s), this).second);
 
   for (const lto::InputFile::Symbol &objSym : obj->symbols())
     symbols.push_back(createBitcodeSymbol<ELFT>(keptComdats, objSym, *this));
 
+  if (config->dependentLibraries && irSymTabCache) {
+    std::vector<std::string> filesToUpgrade;
+    for (auto l : obj->getDependentLibraries())
+      if (Optional<std::pair<std::string, bool>> path = getPath(l))
+        filesToUpgrade.push_back(path->first);
+    irSymTabCache->upgrade(filesToUpgrade);
+  }
+
   for (auto l : obj->getDependentLibraries())
     addDependentLibrary(l, this);
 }
 
 void BinaryFile::parse() {
   ArrayRef<uint8_t> data = arrayRefFromStringRef(mb.getBuffer());
   auto *section = make<InputSection>(this, SHF_ALLOC | SHF_WRITE, SHT_PROGBITS,
                                      8, data, ".data");

lld/ELF/Options.td

 defm dependent_libraries: BB<"dependent-libraries",
     "Process dependent library specifiers from input files (default)",
     "Ignore dependent library specifiers from input files">;
 
 defm as_needed: B<"as-needed",
     "Only set DT_NEEDED for shared libraries if used",
     "Always set DT_NEEDED for shared libraries (default)">;
 
+defm cache_ir_symtab: BB<"cache-ir-symtab",
+    "Cache IR symbol table before parsing input files",
+    "Do not cache IR symbol table before parsing input files (default)">;
+
 defm call_graph_ordering_file:
   Eq<"call-graph-ordering-file", "Layout sections to optimize the given callgraph">;
 
 defm call_graph_profile_sort: BB<"call-graph-profile-sort",
     "Reorder sections with call graph profile (default)",
     "Do not reorder sections with call graph profile">;
 
 // -chroot doesn't have a help text because it is an internal option.

lld/test/ELF/deplibs.s

 # RUN: mkdir -p %t.cwd
 # RUN: cd %t.cwd
 # RUN: llvm-ar rc %t.dir/foo.a %tfoo.o
 # RUN: touch %t.dir/libbar.so
 # RUN: cp %t.dir/foo.a %t.cwd/libcmdline.a
 # RUN: ld.lld %t.o libcmdline.a -o /dev/null -L %t.dir --trace 2>&1 | \
 # RUN:   FileCheck %s -DOBJ=%t.o -DSO=%t.dir --check-prefix CMDLINE \
 # RUN:                --implicit-check-not=foo.a --implicit-check-not=libbar.so
+# RUN: ld.lld %t.o libcmdline.a -o /dev/null -L %t.dir --trace --cache-ir-symtab 2>&1 | \
+# RUN:   FileCheck %s -DOBJ=%t.o -DSO=%t.dir --check-prefix CMDLINE \
+# RUN:                --implicit-check-not=foo.a --implicit-check-not=libbar.so
 # CMDLINE:      [[OBJ]]
 # CMDLINE-NEXT: {{^libcmdline\.a}}
 
 ## LLD tries to resolve dependent library specifiers in the following order:
 ##   1) The literal name in the current working directory.
 ##   2) The literal name in a library search path.
 ##   3) The name, prefixed with "lib" and suffixed with ".so" or ".a" in a
 ##      library search path. This means that a directive of "foo.a" could lead

llvm/include/llvm/Bitcode/BitcodeReader.h

typedef llvm::function_ref<Optional<std::string>(StringRef)>
   public:
     StringRef getBuffer() const {
       return StringRef((const char *)Buffer.begin(), Buffer.size());
     }
 
     StringRef getStrtab() const { return Strtab; }
 
     StringRef getModuleIdentifier() const { return ModuleIdentifier; }
+    void setModuleIdentifier(StringRef ModId) { ModuleIdentifier = ModId; }
 
     /// Read the bitcode module and prepare for lazy deserialization of function
     /// bodies. If ShouldLazyLoadMetadata is true, lazily load metadata as well.
     /// If IsImporting is true, this module is being parsed for ThinLTO
     /// importing into another module.
     Expected<std::unique_ptr<Module>> getLazyModule(LLVMContext &Context,
                                                     bool ShouldLazyLoadMetadata,
                                                     bool IsImporting);

llvm/include/llvm/LTO/LTO.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LTO_LTO_H
 #define LLVM_LTO_LTO_H
 
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/StringMap.h"
+#include "llvm/Bitcode/BitcodeReader.h"
 #include "llvm/IR/ModuleSummaryIndex.h"
 #include "llvm/LTO/Config.h"
+#include "llvm/Object/IRObjectFile.h"
 #include "llvm/Object/IRSymtab.h"
 #include "llvm/Support/Error.h"
+#include "llvm/Support/ThreadPool.h"
 #include "llvm/Support/thread.h"
 #include "llvm/Transforms/IPO/FunctionImport.h"
 
 namespace llvm {
 
 class BitcodeModule;
 class Error;
 class IRMover;

 /// Setups the output file for saving statistics.
 Expected<std::unique_ptr<ToolOutputFile>>
 setupStatsFile(StringRef StatsFilename);
 
 class LTO;
 struct SymbolResolution;
 class ThinBackendProc;
 
+// For parallelizing IR symtab upgrading.
+class IRSymtabFileCache {
+  ThreadPool BackendThreadPool;
+  using CacheType =
+      DenseMap<MemoryBufferRef, std::unique_ptr<object::IRSymtabFile>>;
+  CacheType Cache;
+
+public:
+  void upgrade(const std::vector<MemoryBufferRef> &);
+  object::IRSymtabFile *get(const MemoryBufferRef &) const;
+};
+
 /// An input file. This is a symbol table wrapper that only exposes the
 /// information that an LTO client should need in order to do symbol resolution.
 class InputFile {
 public:
   class Symbol;
 
 private:
   // FIXME: Remove LTO class friendship once we have bitcode symbol tables.
   friend LTO;
   InputFile() = default;
+  InputFile(object::IRSymtabFile &&SF);
 
   std::vector<BitcodeModule> Mods;
   SmallVector<char, 0> Strtab;
   std::vector<Symbol> Symbols;
 
   // [begin, end) for each module
   std::vector<std::pair<size_t, size_t>> ModuleSymIndices;
 
   StringRef TargetTriple, SourceFileName, COFFLinkerOpts;
   std::vector<StringRef> DependentLibraries;
   std::vector<StringRef> ComdatTable;
 
 public:
   ~InputFile();
 
   /// Create an InputFile.
   static Expected<std::unique_ptr<InputFile>> create(MemoryBufferRef Object);
+  static Expected<std::unique_ptr<InputFile>>
+  create(MemoryBufferRef Object, IRSymtabFileCache &IRSymTabCache);
 
   /// The purpose of this class is to only expose the symbol information that an
   /// LTO client should need in order to do symbol resolution.
   class Symbol : irsymtab::Symbol {
     friend LTO;
 
   public:
     Symbol(const irsymtab::Symbol &S) : irsymtab::Symbol(S) {}
public:
   StringRef getCOFFLinkerOpts() const { return COFFLinkerOpts; }
 
   /// Returns dependent library specifiers from the input file.
   ArrayRef<StringRef> getDependentLibraries() const { return DependentLibraries; }
 
   /// Returns the path to the InputFile.
   StringRef getName() const;
 
+  /// Set the path to the InputFile.
+  void setName(StringRef Name);
+
   /// Returns the input file's target triple.
   StringRef getTargetTriple() const { return TargetTriple; }
 
   /// Returns the source file path specified at compile time.
   StringRef getSourceFileName() const { return SourceFileName; }
 
   // Returns a table with all the comdats used by this file.
   ArrayRef<StringRef> getComdatTable() const { return ComdatTable; }

llvm/include/llvm/Object/IRObjectFile.h

 struct IRSymtabFile {
   std::vector<BitcodeModule> Mods;
   SmallVector<char, 0> Symtab, Strtab;
   irsymtab::Reader TheReader;
 };
 
 /// Reads a bitcode file, creating its irsymtab if necessary.
 Expected<IRSymtabFile> readIRSymtab(MemoryBufferRef MBRef);
-
+bool needToUpgradeIRSymtab(MemoryBufferRef MBRef);
 }
 
 }
 
 #endif

llvm/include/llvm/Object/IRSymtab.h

 /// irsymtab are owned by Symtab and Strtab.
 struct FileContents {
   SmallVector<char, 0> Symtab, Strtab;
   Reader TheReader;
 };
 
 /// Reads the contents of a bitcode file, creating its irsymtab if necessary.
 Expected<FileContents> readBitcode(const BitcodeFileContents &BFC);
+bool needUpgrade(const BitcodeFileContents &BFC);
 
 } // end namespace irsymtab
 } // end namespace llvm
 
 #endif // LLVM_OBJECT_IRSYMTAB_H

llvm/include/llvm/Support/MemoryBuffer.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_SUPPORT_MEMORYBUFFER_H
 #define LLVM_SUPPORT_MEMORYBUFFER_H
 
 #include "llvm-c/Types.h"
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Support/CBindingWrapping.h"
 #include "llvm/Support/ErrorOr.h"
 #include <cstddef>
 #include <cstdint>
 #include <memory>
 
public:
   const char *getBufferStart() const { return Buffer.begin(); }
   const char *getBufferEnd() const { return Buffer.end(); }
   size_t getBufferSize() const { return Buffer.size(); }
 };
 
 // Create wrappers for C Binding types (see CBindingWrapping.h).
 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(MemoryBuffer, LLVMMemoryBufferRef)
 
+// Support MemoryBufferRef as DenseMap keys.
+template <> struct DenseMapInfo<MemoryBufferRef> {
+  static inline MemoryBufferRef getEmptyKey() {
+    static MemoryBufferRef EmptyKey(DenseMapInfo<StringRef>::getEmptyKey(),
+                                    DenseMapInfo<StringRef>::getEmptyKey());
+    return EmptyKey;
+  }
+  static inline MemoryBufferRef getTombstoneKey() {
+    static MemoryBufferRef TombstoneKey(
+        DenseMapInfo<StringRef>::getTombstoneKey(),
+        DenseMapInfo<StringRef>::getTombstoneKey());
+    return TombstoneKey;
+  }
+  static unsigned getHashValue(const MemoryBufferRef &MBref) {
+    return hash_combine(MBref.getBuffer().data(), MBref.getBuffer().size());
+  }
+  static bool isEqual(const MemoryBufferRef &LHS, const MemoryBufferRef &RHS) {
+    return LHS.getBuffer().data() == RHS.getBuffer().data() &&
+           LHS.getBuffer().size() == RHS.getBuffer().size();
+  }
+};
+
 } // end namespace llvm
 
 #endif // LLVM_SUPPORT_MEMORYBUFFER_H

llvm/lib/LTO/LTO.cpp

 #include "llvm/IR/Mangler.h"
 #include "llvm/IR/Metadata.h"
 #include "llvm/LTO/LTOBackend.h"
 #include "llvm/LTO/SummaryBasedOptimizations.h"
 #include "llvm/Linker/IRMover.h"
 #include "llvm/Object/IRObjectFile.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Error.h"
+#include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/SHA1.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/TargetRegistry.h"
-#include "llvm/Support/ThreadPool.h"
 #include "llvm/Support/Threading.h"
 #include "llvm/Support/TimeProfiler.h"
 #include "llvm/Support/VCSRevision.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Target/TargetMachine.h"
 #include "llvm/Target/TargetOptions.h"
 #include "llvm/Transforms/IPO.h"
 #include "llvm/Transforms/IPO/PassManagerBuilder.h"
void llvm::thinLTOInternalizeAndPromoteInIndex(
   for (auto &I : Index)
     thinLTOInternalizeAndPromoteGUID(Index.getValueInfo(I), isExported,
                                      isPrevailing);
 }
 
 // Requires a destructor for std::vector<InputModule>.
 InputFile::~InputFile() = default;
 
-Expected<std::unique_ptr<InputFile>> InputFile::create(MemoryBufferRef Object) {
-  std::unique_ptr<InputFile> File(new InputFile);
-
-  Expected<IRSymtabFile> FOrErr = readIRSymtab(Object);
-  if (!FOrErr)
-    return FOrErr.takeError();
+InputFile::InputFile(IRSymtabFile &&SF) {
+  TargetTriple = SF.TheReader.getTargetTriple();
+  SourceFileName = SF.TheReader.getSourceFileName();
+  COFFLinkerOpts = SF.TheReader.getCOFFLinkerOpts();
+  DependentLibraries = SF.TheReader.getDependentLibraries();
+  ComdatTable = SF.TheReader.getComdatTable();
 
-  File->TargetTriple = FOrErr->TheReader.getTargetTriple();
-  File->SourceFileName = FOrErr->TheReader.getSourceFileName();
-  File->COFFLinkerOpts = FOrErr->TheReader.getCOFFLinkerOpts();
-  File->DependentLibraries = FOrErr->TheReader.getDependentLibraries();
-  File->ComdatTable = FOrErr->TheReader.getComdatTable();
-
-  for (unsigned I = 0; I != FOrErr->Mods.size(); ++I) {
-    size_t Begin = File->Symbols.size();
+  for (unsigned I = 0; I != SF.Mods.size(); ++I) {
+    size_t Begin = Symbols.size();
     for (const irsymtab::Reader::SymbolRef &Sym :
-         FOrErr->TheReader.module_symbols(I))
+         SF.TheReader.module_symbols(I))
       // Skip symbols that are irrelevant to LTO. Note that this condition needs
       // to match the one in Skip() in LTO::addRegularLTO().
       if (Sym.isGlobal() && !Sym.isFormatSpecific())
-        File->Symbols.push_back(Sym);
-    File->ModuleSymIndices.push_back({Begin, File->Symbols.size()});
+        Symbols.push_back(Sym);
+    ModuleSymIndices.push_back({Begin, Symbols.size()});
   }
 
-  File->Mods = FOrErr->Mods;
-  File->Strtab = std::move(FOrErr->Strtab);
-  return std::move(File);
+  Mods = SF.Mods;
+  Strtab = std::move(SF.Strtab);
+}
+
+Expected<std::unique_ptr<InputFile>> InputFile::create(MemoryBufferRef Object) {
+  Expected<IRSymtabFile> FOrErr = readIRSymtab(Object);
+  if (!FOrErr)
+    return FOrErr.takeError();
+  return std::unique_ptr<InputFile>(new InputFile(std::move(*FOrErr)));
+}
+
+Expected<std::unique_ptr<InputFile>>
+InputFile::create(MemoryBufferRef Object, IRSymtabFileCache &IRSymTabCache) {
+  if (IRSymtabFile *FOrErr = IRSymTabCache.get(Object))
+    return std::unique_ptr<InputFile>(new InputFile(std::move(*FOrErr)));
+  return InputFile::create(Object);
 }
 
 StringRef InputFile::getName() const {
   return Mods[0].getModuleIdentifier();
 }
 
+void InputFile::setName(StringRef Name) {
+  return Mods[0].setModuleIdentifier(Name);
+}
+
 BitcodeModule &InputFile::getSingleBitcodeModule() {
   assert(Mods.size() == 1 && "Expect only one bitcode module");
   return Mods[0];
 }
 
 LTO::RegularLTOState::RegularLTOState(unsigned ParallelCodeGenParallelismLevel,
                                       const Config &Conf)
     : ParallelCodeGenParallelismLevel(ParallelCodeGenParallelismLevel),
if (Error E = BackendProc->start(Task, Mod.second, ImportLists[Mod.first],
                                      ResolvedODR[Mod.first], ThinLTO.ModuleMap))
       return E;
     ++Task;
   }
 
   return BackendProc->wait();
 }
 
+void IRSymtabFileCache::upgrade(const std::vector<MemoryBufferRef> &MBrefs) {
+  // Cache IR SymTab only if it needs to be upgraded. Also try to balance the
+  // amount work each thread will do based on aggregate MemoryBufferRef size.
+  std::vector<MemoryBufferRef> ToCache;
+  unsigned TotalBufSize = 0;
+  for (auto &M : MBrefs)
+    if (Cache.count(M) == 0 && needToUpgradeIRSymtab(M)) {
+      ToCache.push_back(M);
+      TotalBufSize += M.getBufferSize();
+      Cache.try_emplace(M, nullptr);
+    }
+
+  if (ToCache.size() == 0)
+    return;
+
+  // If too few symtabs to cache, assign one to each thread.
+  const unsigned ThinLTOParallelismLevel = BackendThreadPool.getThreadCount();
+  const unsigned ThreadLocal = ToCache.size() >= ThinLTOParallelismLevel
+                                   ? TotalBufSize / ThinLTOParallelismLevel
+                                   : 0;
+
+  auto PreLoad = [&](std::vector<MemoryBufferRef>::iterator II,
+                     std::vector<MemoryBufferRef>::iterator IE) {
+    for (; II != IE; ++II) {
+      Expected<IRSymtabFile> FOrErr = readIRSymtab(*II);
+      if (FOrErr)
+        Cache.find(*II)->second.reset(new IRSymtabFile(std::move(*FOrErr)));
+      else
+        consumeError(FOrErr.takeError());
+    }
+  };
+
+  auto CI = ToCache.begin();
+  unsigned CurTotal = 0;
+  unsigned NumThread = 0;
+  for (auto I = ToCache.begin(), E = ToCache.end(); I != E; ++I) {
+    CurTotal += I->getBufferSize();
+    if (CurTotal < ThreadLocal)
+      continue;
+
+    CurTotal = 0;
+    BackendThreadPool.async(PreLoad, CI, I + 1);
+    CI = I + 1;
+    if (++NumThread == (ThinLTOParallelismLevel - 1)) {
+      BackendThreadPool.async(PreLoad, CI, E);
+      break;
+    }
+  }
+  BackendThreadPool.wait();
+}
+
+IRSymtabFile *IRSymtabFileCache::get(const MemoryBufferRef &M) const {
+  auto Iter = Cache.find(M);
+  if (Iter != Cache.end())
+    return Iter->second.get();
+  return nullptr;
+}
+
 Expected<std::unique_ptr<ToolOutputFile>> lto::setupLLVMOptimizationRemarks(
     LLVMContext &Context, StringRef RemarksFilename, StringRef RemarksPasses,
     StringRef RemarksFormat, bool RemarksWithHotness, int Count) {
   std::string Filename = std::string(RemarksFilename);
   // For ThinLTO, file.opt.<format> becomes
   // file.opt.<format>.thin.<num>.<format>.
   if (!Filename.empty() && Count != -1)
     Filename =

llvm/lib/Object/IRObjectFile.cpp

for (auto BM : *BMsOrErr) {
 
     Mods.push_back(std::move(*MOrErr));
   }
 
   return std::unique_ptr<IRObjectFile>(
       new IRObjectFile(*BCOrErr, std::move(Mods)));
 }
 
+bool object::needToUpgradeIRSymtab(MemoryBufferRef MBRef) {
+  Expected<MemoryBufferRef> BCOrErr =
+      IRObjectFile::findBitcodeInMemBuffer(MBRef);
+  if (!BCOrErr)
+    return false;
+
+  Expected<BitcodeFileContents> BFCOrErr = getBitcodeFileContents(*BCOrErr);
+  if (!BFCOrErr)
+    return false;
+  return irsymtab::needUpgrade(*BFCOrErr);
+}
+
 Expected<IRSymtabFile> object::readIRSymtab(MemoryBufferRef MBRef) {
   IRSymtabFile F;
   Expected<MemoryBufferRef> BCOrErr =
       IRObjectFile::findBitcodeInMemBuffer(MBRef);
   if (!BCOrErr)
     return BCOrErr.takeError();
 
   Expected<BitcodeFileContents> BFCOrErr = getBitcodeFileContents(*BCOrErr);

llvm/lib/Object/IRSymtab.cpp

Error Builder::addSymbol(const ModuleSymbolTable &Msymtab,
   return Error::success();
 }
 
 Error Builder::build(ArrayRef<Module *> IRMods) {
   storage::Header Hdr;
 
   assert(!IRMods.empty());
   Hdr.Version = storage::Header::kCurrentVersion;
+  if (getenv("LLVM_REEVAL_IR_SYMTAB_PRODUCER"))
+    setStr(Hdr.Producer, getExpectedProducerName());
+  else
     setStr(Hdr.Producer, kExpectedProducerName);
   setStr(Hdr.TargetTriple, IRMods[0]->getTargetTriple());
   setStr(Hdr.SourceFileName, IRMods[0]->getSourceFileName());
   TT = Triple(IRMods[0]->getTargetTriple());
 
   for (auto *M : IRMods)
     if (Error Err = addModule(M))
       return Err;
 
static Expected<FileContents> upgrade(ArrayRef<BitcodeModule> BMs) {
   FC.Strtab.resize(StrtabBuilder.getSize());
   StrtabBuilder.write((uint8_t *)FC.Strtab.data());
 
   FC.TheReader = {{FC.Symtab.data(), FC.Symtab.size()},
                   {FC.Strtab.data(), FC.Strtab.size()}};
   return std::move(FC);
 }
 
-Expected<FileContents> irsymtab::readBitcode(const BitcodeFileContents &BFC) {
+bool irsymtab::needUpgrade(const BitcodeFileContents &BFC) {
   if (BFC.Mods.empty())
-    return make_error<StringError>("Bitcode file does not contain any modules",
-                                   inconvertibleErrorCode());
+    return false;
 
   if (BFC.StrtabForSymtab.empty() ||
       BFC.Symtab.size() < sizeof(storage::Header))
-    return upgrade(BFC.Mods);
+    return true;
 
   // We cannot use the regular reader to read the version and producer, because
   // it will expect the header to be in the current format. The only thing we
   // can rely on is that the version and producer will be present as the first
   // struct elements.
   auto *Hdr = reinterpret_cast<const storage::Header *>(BFC.Symtab.data());
   unsigned Version = Hdr->Version;
   StringRef Producer = Hdr->Producer.get(BFC.StrtabForSymtab);
   if (Version != storage::Header::kCurrentVersion ||
       Producer != kExpectedProducerName)
-    return upgrade(BFC.Mods);
+    return true;
 
   FileContents FC;
   FC.TheReader = {{BFC.Symtab.data(), BFC.Symtab.size()},
                   {BFC.StrtabForSymtab.data(), BFC.StrtabForSymtab.size()}};
 
   // Finally, make sure that the number of modules in the symbol table matches
   // the number of modules in the bitcode file. If they differ, it may mean that
   // the bitcode file was created by binary concatenation, so we need to create
   // a new symbol table from scratch.
   if (FC.TheReader.getNumModules() != BFC.Mods.size())
-    return upgrade(std::move(BFC.Mods));
+    return true;
+
+  return false;
+}
+
+Expected<FileContents> irsymtab::readBitcode(const BitcodeFileContents &BFC) {
+  if (BFC.Mods.empty())
+    return make_error<StringError>("Bitcode file does not contain any modules",
+                                   inconvertibleErrorCode());
+  if (needUpgrade(BFC))
+    return upgrade(BFC.Mods);
 
+  FileContents FC;
+  FC.TheReader = {{BFC.Symtab.data(), BFC.Symtab.size()},
+                  {BFC.StrtabForSymtab.data(), BFC.StrtabForSymtab.size()}};
   return std::move(FC);
 }

llvm/tools/gold/gold-plugin.cpp

 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/Threading.h"
 #include "llvm/Support/raw_ostream.h"
 #include <list>
 #include <map>
 #include <plugin-api.h>
 #include <string>
 #include <system_error>
 #include <utility>
 #include <vector>
 
 // FIXME: remove this declaration when we stop maintaining Ubuntu Quantal and
 // Precise and Debian Wheezy (binutils 2.23 is required)
 #define LDPO_PIE 3
 
#endif
   static std::string RemarksPasses;
   static bool RemarksWithHotness = false;
   static std::string RemarksFormat;
 
   // Context sensitive PGO options.
   static std::string cs_profile_path;
   static bool cs_pgo_gen = false;
 
+  static bool cache_ir_symtab = false;
+
   static void process_plugin_option(const char *opt_)
   {
     if (opt_ == nullptr)
       return;
     llvm::StringRef opt = opt_;
 
     if (opt.consume_front("mcpu=")) {
       mcpu = std::string(opt);
static void process_plugin_option(const char *opt_)
     } else if (opt.consume_front("opt-remarks-passes=")) {
       RemarksPasses = std::string(opt);
     } else if (opt == "opt-remarks-with-hotness") {
       RemarksWithHotness = true;
     } else if (opt.consume_front("opt-remarks-format=")) {
       RemarksFormat = std::string(opt);
     } else if (opt.consume_front("stats-file=")) {
       stats_file = std::string(opt);
+    } else if (opt == "cache-ir-symtab") {
+      cache_ir_symtab = true;
     } else {
       // Save this option to pass to the code generator.
       // ParseCommandLineOptions() expects argv[0] to be program name. Lazily
       // add that.
       if (extra.empty())
         extra.push_back("LLVMgold");
 
       extra.push_back(opt_);

 
 static void check(Error E, std::string Msg = "LLVM gold plugin") {
   handleAllErrors(std::move(E), [&](ErrorInfoBase &EIB) -> Error {
     message(LDPL_FATAL, "%s: %s", Msg.c_str(), EIB.message().c_str());
     return Error::success();
   });
 }
 
-template <typename T> static T check(Expected<T> E) {
+template <typename T> static T check(Expected<T> E, std::string Msg = "") {
   if (E)
     return std::move(*E);
+  if (Msg.length())
+    check(E.takeError(), Msg);
+  else
     check(E.takeError());
   return T();
 }
 
 /// Called by gold to see whether this file is one that our plugin can handle.
 /// We'll try to open it and register all the symbols with add_symbol if
 /// possible.
 static ld_plugin_status claim_file_hook(const ld_plugin_input_file *file,
                                         int *claimed) {

 static void freeSymName(ld_plugin_symbol &Sym) {
   free(Sym.name);
   free(Sym.comdat_key);
   Sym.name = nullptr;
   Sym.comdat_key = nullptr;
 }
 
 /// Helper to get a file's symbols and a view into it via gold callbacks.
-static const void *getSymbolsAndView(claimed_file &F) {
+static Optional<MemoryBufferRef> getSymbolsAndMemoryBuf(claimed_file &F,
+                                                        StringRef Filename) {
   ld_plugin_status status = get_symbols(F.handle, F.syms.size(), F.syms.data());
   if (status == LDPS_NO_SYMS)
-    return nullptr;
+    return None;
 
   if (status != LDPS_OK)
     message(LDPL_FATAL, "Failed to get symbol information");
 
   const void *View;
   if (get_view(F.handle, &View) != LDPS_OK)
     message(LDPL_FATAL, "Failed to get a view of file");
 
-  return View;
+  return MemoryBufferRef{StringRef((const char *)View, F.filesize), Filename};
 }
 
 /// Parse the thinlto-object-suffix-replace option into the \p OldSuffix and
 /// \p NewSuffix strings, if it was specified.
 static void getThinLTOOldAndNewSuffix(std::string &OldSuffix,
                                       std::string &NewSuffix) {
   assert(options::thinlto_object_suffix_replace.empty() ||
          options::thinlto_object_suffix_replace.find(";") != StringRef::npos);
return !S.empty() && (isAlpha(S[0]) || S[0] == '_') &&
          std::all_of(S.begin() + 1, S.end(),
                      [](char C) { return C == '_' || isAlnum(C); });
 }
 
 static bool isUndefined(ld_plugin_symbol &Sym) {
   return Sym.def == LDPK_UNDEF || Sym.def == LDPK_WEAKUNDEF;
 }
 
-static void addModule(LTO &Lto, claimed_file &F, const void *View,
-                      StringRef Filename) {
-  MemoryBufferRef BufferRef(StringRef((const char *)View, F.filesize),
-                            Filename);
-  Expected<std::unique_ptr<InputFile>> ObjOrErr = InputFile::create(BufferRef);
-
-  if (!ObjOrErr)
-    message(LDPL_FATAL, "Could not read bitcode from file : %s",
-            toString(ObjOrErr.takeError()).c_str());
+static void addModule(LTO &Lto, claimed_file &F, MemoryBufferRef BufferRef,
+                      IRSymtabFileCache *IRSymTabCache) {
+  std::unique_ptr<InputFile> Input;
+  if (IRSymTabCache)
+    Input = check(InputFile::create(BufferRef, *IRSymTabCache),
+                  "Could not read bitcode from file");
+  else
+    Input = check(InputFile::create(BufferRef),
+                  "Could not read bitcode from file");
 
   unsigned SymNum = 0;
-  std::unique_ptr<InputFile> Input = std::move(ObjOrErr.get());
   auto InputFileSyms = Input->symbols();
   assert(InputFileSyms.size() == F.syms.size());
   std::vector<SymbolResolution> Resols(F.syms.size());
   for (ld_plugin_symbol &Sym : F.syms) {
     const InputFile::Symbol &InpSym = InputFileSyms[SymNum];
     SymbolResolution &R = Resols[SymNum++];
 
     ld_plugin_symbol_resolution Resolution =
static std::vector<std::pair<SmallString<128>, bool>> runLTO() {
 
   std::string OldPrefix, NewPrefix;
   if (options::thinlto_index_only)
     getThinLTOOldAndNewPrefix(OldPrefix, NewPrefix);
 
   std::string OldSuffix, NewSuffix;
   getThinLTOOldAndNewSuffix(OldSuffix, NewSuffix);
 
+  std::vector<std::pair<claimed_file &, MemoryBufferRef>> AddToLTO;
+
   for (claimed_file &F : Modules) {
     if (options::thinlto && !HandleToInputFile.count(F.leader_handle))
       HandleToInputFile.insert(std::make_pair(
           F.leader_handle, std::make_unique<PluginInputFile>(F.handle)));
     // In case we are thin linking with a minimized bitcode file, ensure
     // the module paths encoded in the index reflect where the backends
     // will locate the full bitcode files for compiling/importing.
     std::string Identifier =
         getThinLTOObjectFileName(F.name, OldSuffix, NewSuffix);
     auto ObjFilename = ObjectToIndexFileState.insert({Identifier, false});
     assert(ObjFilename.second);
-    if (const void *View = getSymbolsAndView(F))
-      addModule(*Lto, F, View, ObjFilename.first->first());
+    if (Optional<MemoryBufferRef> MBRefOrErr =
+            getSymbolsAndMemoryBuf(F, ObjFilename.first->first()))
+      AddToLTO.push_back({F, *MBRefOrErr});
     else if (options::thinlto_index_only) {
       ObjFilename.first->second = true;
       writeEmptyDistributedBuildOutputs(Identifier, OldPrefix, NewPrefix,
                                         /* SkipModule */ true);
     }
   }
 
+  IRSymtabFileCache *IRSymTabCache = nullptr;
+  if (options::cache_ir_symtab) {
+    IRSymTabCache = new IRSymtabFileCache();
+
+    std::vector<MemoryBufferRef> MBrefs;
+    for (auto &M : AddToLTO)
+      MBrefs.push_back(M.second);
+    IRSymTabCache->upgrade(MBrefs);
+  }
+
+  for (auto &M : AddToLTO)
+    addModule(*Lto, M.first, M.second, IRSymTabCache);
+
+  if (IRSymTabCache) {
+    delete IRSymTabCache;
+    IRSymTabCache = nullptr;
+  }
+
   SmallString<128> Filename;
   // Note that getOutputFileName will append a unique ID for each task
   if (!options::obj_path.empty())
     Filename = options::obj_path;
   else if (options::TheOutputType == options::OT_SAVE_TEMPS)
     Filename = output_name + ".o";
   else if (options::TheOutputType == options::OT_ASM_ONLY)
     Filename = output_name;

llvm/unittests/CMakeLists.txt

 add_subdirectory(Option)
 add_subdirectory(Remarks)
 add_subdirectory(Passes)
 add_subdirectory(ProfileData)
 add_subdirectory(Support)
 add_subdirectory(TableGen)
 add_subdirectory(Target)
 add_subdirectory(TextAPI)
+add_subdirectory(ThinLTO)
 add_subdirectory(Transforms)
 add_subdirectory(XRay)
 add_subdirectory(tools)

llvm/unittests/ThinLTO/CMakeLists.txt

+set(LLVM_LINK_COMPONENTS
+  AsmParser
+  BinaryFormat
+  Core
+  LTO
+  Support
+  )
+
+add_llvm_unittest(ThinLTOTests
+  PreUpgradeIRSymbolTable.cpp
+  )

llvm/unittests/ThinLTO/PreUpgradeIRSymbolTable.cpp

+//===- llvm/unittest/ThinLTO/PreUpgradeIRSymbolTable.cpp ------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/Analysis/ModuleSummaryAnalysis.h"
+#include "llvm/Analysis/ProfileSummaryInfo.h"
+#include "llvm/AsmParser/Parser.h"
+#include "llvm/BinaryFormat/Magic.h"
+#include "llvm/Bitcode/BitcodeWriter.h"
+#include "llvm/Config/config.h"
+#include "llvm/IR/Module.h"
+#include "llvm/LTO/LTO.h"
+#include "llvm/Support/FileSystem.h"
+#include "llvm/Support/SourceMgr.h"
+#include "llvm/Support/ToolOutputFile.h"
+#include "gtest/gtest.h"
+
+using namespace llvm;
+
+static ::testing::AssertionResult NoError(std::error_code EC) {
+  if (!EC)
+    return ::testing::AssertionSuccess();
+  return ::testing::AssertionFailure()
+         << "error " << EC.value() << ": " << EC.message();
+}
+
+std::vector<std::unique_ptr<MemoryBuffer>> AllBuffers;
+
+namespace {
+
+class IRSymtabFileCacheTest : public lto::IRSymtabFileCache {
+  StringMap<MemoryBufferRef> LoadedFiles;
+
+public:
+  void upgrade(const std::vector<std::string> &Files) {
+    std::vector<MemoryBufferRef> ToCache;
+    for (auto &F : Files) {
+      auto MBOrErr = MemoryBuffer::getFile(F, -1, false);
+      if (!MBOrErr)
+        return;
+      MemoryBufferRef MBref = MBOrErr.get()->getMemBufferRef();
+      AllBuffers.emplace_back(std::move(*MBOrErr));
+
+      LoadedFiles.try_emplace(F, MBref);
+      ToCache.push_back(MBref);
+    }
+
+    lto::IRSymtabFileCache::upgrade(ToCache);
+  }
+  Optional<MemoryBufferRef> getMemBuffer(const std::string &Path) const {
+    auto I = LoadedFiles.find(Path);
+    if (I != LoadedFiles.end())
+      return I->second;
+    return None;
+  }
+};
+
+#ifdef _MSC_VER
+#define setenv(name, var, ignore) _putenv_s(name, var)
+#endif
+
+#if HAVE_SETENV || _MSC_VER
+struct PreUpgradeIRSymbolTableTest : public ::testing::Test {
+  LLVMContext Context;
+  SMDiagnostic Err;
+  std::unique_ptr<Module> ValidModule;
+  std::unique_ptr<Module> InvalidModule;
+
+  PreUpgradeIRSymbolTableTest()
+      : ValidModule(parseAssemblyString(
+            "target datalayout = \"e-m:e-i64:64-f80:128-n8:16:32:64-S128\"\n"
+            "define void @f() {\n"
+            "  ret void\n"
+            "}\n",
+            Err, Context)),
+        InvalidModule(parseAssemblyString("define void @g() {\n"
+                                          "  ret void\n"
+                                          "}\n",
+                                          Err, Context)) {}
+
+  enum class InputKind {
+    ValidAndUpgradable,
+    ValidAndNonUpgradable,
+    Invalid,
+  };
+
+  void createInputFiles(std::vector<std::string> &InputFiles,
+                        const std::vector<InputKind> Inputs) {
+    for (auto Kind : Inputs) {
+      SmallString<64> TmpName;
+      sys::fs::createUniquePath("thinlto-preload-ir-symtab-%%%%%%%%.o", TmpName,
+                                /*MakeAbsolute=*/true);
+
+      std::error_code EC;
+      std::unique_ptr<llvm::ToolOutputFile> Out =
+          std::make_unique<llvm::ToolOutputFile>(TmpName, EC,
+                                                 llvm::sys::fs::OF_None);
+      ASSERT_TRUE(NoError(EC));
+      Module &M = Kind == InputKind::Invalid ? *InvalidModule : *ValidModule;
+      ProfileSummaryInfo PSI(M);
+      auto Index = buildModuleSummaryIndex(M, nullptr, &PSI);
+      if (Kind == InputKind::ValidAndUpgradable) {
+        setenv("LLVM_OVERRIDE_PRODUCER", "old-producer", 1);
+        setenv("LLVM_REEVAL_IR_SYMTAB_PRODUCER", "1", 1);
+      }
+      WriteBitcodeToFile(M, Out->os(), true, &Index);
+      if (Kind == InputKind::ValidAndUpgradable) {
+        unsetenv("LLVM_REEVAL_IR_SYMTAB_PRODUCER");
+        unsetenv("LLVM_OVERRIDE_PRODUCER");
+      }
+      Out->keep();
+      InputFiles.push_back(TmpName.c_str());
+    }
+  }
+
+  void testPreUpgradeForInputFiles(const std::vector<InputKind> Inputs) {
+    std::vector<std::string> InputFiles;
+    createInputFiles(InputFiles, Inputs);
+
+    // Upgrade the symbol tables of input files.
+    AllBuffers.clear();
+    std::unique_ptr<IRSymtabFileCacheTest> IRSymTabCache =
+        std::make_unique<IRSymtabFileCacheTest>();
+    IRSymTabCache->upgrade(InputFiles);
+
+    // * If InputKind == ValidAndUpgradable, verify the input files are cached
+    //   and their symbol tables are upgraded.
+    // * If InputKind != ValidAndUpgradable, verify the input files are cached
+    //   and their symbol tables are not upgraded.
+    for (unsigned i = 0; i < Inputs.size(); ++i) {
+      // Verify the input is cached.
+      Optional<MemoryBufferRef> Object =
+          IRSymTabCache->getMemBuffer(InputFiles[i]);
+      ASSERT_TRUE(Object.hasValue());
+
+      // Verify the input symbol table is upgraded.
+      object::IRSymtabFile *SymtabFile = IRSymTabCache->get(*Object);
+      if (Inputs[i] == InputKind::ValidAndUpgradable)
+        ASSERT_TRUE(SymtabFile);
+      else
+        ASSERT_FALSE(SymtabFile);
+      (void)SymtabFile;
+    }
+
+    // Clean up.
+    for (auto &F : InputFiles) {
+      std::error_code EC = sys::fs::remove(F);
+      ASSERT_TRUE(NoError(EC));
+    }
+  }
+};
+
+TEST_F(PreUpgradeIRSymbolTableTest, AllUpgrade) {
+  const std::vector<InputKind> Inputs(10, InputKind::ValidAndUpgradable);
+  testPreUpgradeForInputFiles(Inputs);
+}
+
+TEST_F(PreUpgradeIRSymbolTableTest, AllNonUpgrade) {
+  const std::vector<InputKind> Inputs(10, InputKind::ValidAndNonUpgradable);
+  testPreUpgradeForInputFiles(Inputs);
+}
+
+TEST_F(PreUpgradeIRSymbolTableTest, AllInvalid) {
+  const std::vector<InputKind> Inputs(10, InputKind::Invalid);
+  testPreUpgradeForInputFiles(Inputs);
+}
+
+TEST_F(PreUpgradeIRSymbolTableTest, MixedInputs) {
+  const std::vector<InputKind> Inputs1(5, InputKind::ValidAndUpgradable);
+  const std::vector<InputKind> Inputs2(5, InputKind::ValidAndNonUpgradable);
+  const std::vector<InputKind> Inputs3(5, InputKind::Invalid);
+  std::vector<InputKind> MixedInputs;
+  MixedInputs.insert(MixedInputs.end(), Inputs1.begin(), Inputs1.end());
+  MixedInputs.insert(MixedInputs.end(), Inputs2.begin(), Inputs2.end());
+  MixedInputs.insert(MixedInputs.end(), Inputs3.begin(), Inputs3.end());
+  testPreUpgradeForInputFiles(MixedInputs);
+}
+
+#endif
+
+} // End anonymous namespace.