[ThinLTO/gold] Handle bitcode archives

[tejohnson]

Summary

Several changes were required for ThinLTO links involving bitcode
archive static libraries. With this patch clang/llvm bootstraps with
ThinLTO and gold.

The first is that the gold callbacks get_input_file and
release_input_file can normally be used to get file information for
each constituent bitcode file within an archive. However, these
interfaces lock the underlying file and can't be for each archive
constituent for ThinLTO backends where we get all the input files up
front and don't release any until after the backend threads complete.
However, it is sufficient to only get and release once per file, and
then each consituent bitcode file can be accessed via get_view. This
required saving some information to identify which file handle is the
"leader" for each claimed file sharing the same file descriptor, and
other information so that get_input_file isn't necessary later when
processing the backends.

Second, the module paths in the index need to distinguish between
different constituent bitcode files within the same archive file,
otherwise they will all end up with the same archive file path.
Do this by appending the offset within the archive for the start of the
bitcode file, returned by get_input_file when we claim each bitcode file,
and saving that along with the file handle.

Third, rather than have the function importer try to load a file based
on the module path identifier (which now contains a suffix to
distinguish different bitcode files within an archive), use a custom
module loader. This is the same approach taken in libLTO, and I am using
the support refactored into the new LTO.h header in r270509. The module
loader parses the bitcode files out of the memory buffers returned from
gold via the get_view callback and saved in a map. This also means that
we call the function importer directly, rather than add it to the pass
pipeline (which was in the plan to do already for other reasons).

[tejohnson]

• Remove inadvertent change

[pcc]

Thanks for discovering that issue with the gold plugin API, that's nasty. It reminds me that I'll probably have to be more careful with memory ownership in D20268.

Can you please also see if this works if you pass --no-map-whole-files to gold?

tools/gold/gold-plugin.cpp

522

Nit: maybe "/" + std::to_string(file->offset) to avoid possibility of collisions with real files?

[pcc]

And can you add a test case please?

[tejohnson]

In D20559#438033, @pcc wrote:

Thanks for discovering that issue with the gold plugin API, that's nasty. It reminds me that I'll probably have to be more careful with memory ownership in D20268.

Can you please also see if this works if you pass --no-map-whole-files to gold?

Will do. I am first tracking down a runtime error in the llvm-tblgen binary built using this patch with latest clang+llvm sources (it seems related to ThinLTO since it goes away when I disable some amount of importing, but I wasn't getting this with my fixes on a slightly older revision, so I don't think it is caused by this patch directly)

And can you add a test case please?

Will do.

tools/gold/gold-plugin.cpp

522

The same name is used to generate save temps files (so they don't all just use the archive name), so I wanted it to be a legal file name. What if I put in something like ".llvm." in between? This is similar to the naming scheme for symbols used during promotion.

That being said, in working to track down the tblgen failure, I am finding the name generated just from the offset not very useful, so I am planning to grab the SourceFileName out of the Module and include its basename as well.

[tejohnson]

In D20559#439159, @tejohnson wrote:

I am first tracking down a runtime error in the llvm-tblgen binary built using this patch with latest clang+llvm sources (it seems related to ThinLTO since it goes away when I disable some amount of importing, but I wasn't getting this with my fixes on a slightly older revision, so I don't think it is caused by this patch directly)

Confirmed not due to this patch - I can repro at head without this patch, working around it by linking llvm-tblgen with the archive library constituent .o files directly. While I track that down (possibly just exposed by ThinLTO's larger optimization scope) I will see if I can figure out a way to work around it here to do more testing of this patch.

[tejohnson]

In D20559#439478, @tejohnson wrote:

In D20559#439159, @tejohnson wrote:

I am first tracking down a runtime error in the llvm-tblgen binary built using this patch with latest clang+llvm sources (it seems related to ThinLTO since it goes away when I disable some amount of importing, but I wasn't getting this with my fixes on a slightly older revision, so I don't think it is caused by this patch directly)

Confirmed not due to this patch - I can repro at head without this patch, working around it by linking llvm-tblgen with the archive library constituent .o files directly. While I track that down (possibly just exposed by ThinLTO's larger optimization scope) I will see if I can figure out a way to work around it here to do more testing of this patch.

I was able to test this and get a successful bootstrap of clang with ThinLTO and gold by temporarily reducing the importing threshold enough to avoid the apparent bug.

Can you please also see if this works if you pass --no-map-whole-files to gold?

Confirmed this works, as well as --no-keep-files-mapped.

[tejohnson]

Make name used for archive members more meaningful by including the
source file name. Also include the string ".llvm." to lessen likelihood
of clashing with real file.

Add test.

[pcc]

LGTM, thanks for testing those things!

tools/gold/gold-plugin.cpp

522

Sounds good. As I mentioned before I think at some point we will need to revisit our representation of paths in the index. For save-temps I think we should use some separate mechanism to produce more developer-friendly paths that can be correlated with the index path representation. That does seem low priority for the moment though.

tools/gold/CMakeLists.txt

 set(LLVM_EXPORTED_SYMBOL_FILE ${CMAKE_CURRENT_SOURCE_DIR}/gold.exports)
 
 if( LLVM_ENABLE_PIC AND LLVM_BINUTILS_INCDIR )
   include_directories( ${LLVM_BINUTILS_INCDIR} )
 
   # Because off_t is used in the public API, the largefile parts are required for
   # ABI compatibility.
   add_definitions( -D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64 )
 
   set(LLVM_LINK_COMPONENTS
      ${LLVM_TARGETS_TO_BUILD}
      Linker
+     LTO
      BitWriter
      IPO
      )
 
   add_llvm_loadable_module(LLVMgold
     gold-plugin.cpp
     )
 
 endif()
 

tools/gold/gold-plugin.cpp

 #include "llvm/IR/AutoUpgrade.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DiagnosticInfo.h"
 #include "llvm/IR/DiagnosticPrinter.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/LegacyPassManager.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/Verifier.h"
+#include "llvm/LTO/LTO.h"
 #include "llvm/Linker/IRMover.h"
 #include "llvm/MC/SubtargetFeature.h"
 #include "llvm/Object/IRObjectFile.h"
 #include "llvm/Object/ModuleSummaryIndexObjectFile.h"
 #include "llvm/Support/Host.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"

 
 static ld_plugin_release_input_file release_input_file = nullptr;
 static ld_plugin_get_input_file get_input_file = nullptr;
 static ld_plugin_message message = discard_message;
 
 namespace {
 struct claimed_file {
   void *handle;
+  void *leader_handle;
   std::vector<ld_plugin_symbol> syms;
+  off_t filesize;
+  std::string name;
 };
 
 /// RAII wrapper to manage opening and releasing of a ld_plugin_input_file.
 struct PluginInputFile {
   void *Handle;
   std::unique_ptr<ld_plugin_input_file> File;
 
   PluginInputFile(void *Handle) : Handle(Handle) {
struct ResolutionInfo {
   GlobalValue::VisibilityTypes Visibility = GlobalValue::DefaultVisibility;
   bool CommonInternal = false;
   bool UseCommon = false;
 };
 
 /// Class to own information used by a task or during its cleanup for a
 /// ThinLTO backend instantiation.
 class ThinLTOTaskInfo {
-  /// The input file holding the module bitcode read by the ThinLTO task.
-  PluginInputFile InputFile;
-
   /// The output stream the task will codegen into.
   std::unique_ptr<raw_fd_ostream> OS;
 
   /// The file name corresponding to the output stream, used during cleanup.
   std::string Filename;
 
   /// Flag indicating whether the output file is a temp file that must be
   /// added to the cleanup list during cleanup.
   bool TempOutFile;
 
 public:
-  ThinLTOTaskInfo(PluginInputFile InputFile, std::unique_ptr<raw_fd_ostream> OS,
-                  std::string Filename, bool TempOutFile)
-      : InputFile(std::move(InputFile)), OS(std::move(OS)), Filename(Filename),
-        TempOutFile(TempOutFile) {}
+  ThinLTOTaskInfo(std::unique_ptr<raw_fd_ostream> OS, std::string Filename,
+                  bool TempOutFile)
+      : OS(std::move(OS)), Filename(Filename), TempOutFile(TempOutFile) {}
 
   /// Performs task related cleanup activities that must be done
   /// single-threaded (i.e. call backs to gold).
   void cleanup();
 };
 }
 
 static ld_plugin_add_symbols add_symbols = nullptr;
 static ld_plugin_get_symbols get_symbols = nullptr;
 static ld_plugin_add_input_file add_input_file = nullptr;
 static ld_plugin_set_extra_library_path set_extra_library_path = nullptr;
 static ld_plugin_get_view get_view = nullptr;
 static Optional<Reloc::Model> RelocationModel;
 static std::string output_name = "";
 static std::list<claimed_file> Modules;
+static DenseMap<int, void *> FDToLeaderHandle;
 static StringMap<ResolutionInfo> ResInfo;
 static std::vector<std::string> Cleanup;
 static llvm::TargetOptions TargetOpts;
 static std::string DefaultTriple = sys::getDefaultTargetTriple();
 
 namespace options {
   enum OutputType {
     OT_NORMAL,
if (EC) {
     return LDPS_ERR;
   }
   std::unique_ptr<object::IRObjectFile> Obj = std::move(*ObjOrErr);
 
   Modules.resize(Modules.size() + 1);
   claimed_file &cf = Modules.back();
 
   cf.handle = file->handle;
+  // Keep track of the first handle for each file descriptor, since there are
+  // multiple in the case of an archive. This is used later in the case of
+  // ThinLTO parallel backends to ensure that each file is only opened and
+  // released once.
+  auto LeaderHandle =
+      FDToLeaderHandle.insert(std::make_pair(file->fd, file->handle)).first;
+  cf.leader_handle = LeaderHandle->second;
+  // Save the filesize since for parallel ThinLTO backends we can only
+  // invoke get_input_file once per archive (only for the leader handle).
+  cf.filesize = file->filesize;
+  // In the case of an archive library, all but the first member must have a
+  // non-zero offset, which we can append to the file name to obtain a
+  // unique name.
+  cf.name = file->name;
+  if (file->offset)
+    cf.name += "." + std::to_string(file->offset);
 
   // If we are doing ThinLTO compilation, don't need to process the symbols.
   // Later we simply build a combined index file after all files are claimed.
   if (options::thinlto && options::thinlto_index_only)
     return LDPS_OK;
 
   for (auto &Sym : Obj->symbols()) {
     uint32_t Symflags = Sym.getFlags();
static const void *getSymbolsAndView(claimed_file &F) {
   const void *View;
   if (get_view(F.handle, &View) != LDPS_OK)
     message(LDPL_FATAL, "Failed to get a view of file");
 
   return View;
 }
 
 static std::unique_ptr<ModuleSummaryIndex>
-getModuleSummaryIndexForFile(claimed_file &F, ld_plugin_input_file &Info) {
+getModuleSummaryIndexForFile(claimed_file &F) {
   const void *View = getSymbolsAndView(F);
   if (!View)
     return nullptr;
 
-  MemoryBufferRef BufferRef(StringRef((const char *)View, Info.filesize),
-                            Info.name);
+  MemoryBufferRef BufferRef(StringRef((const char *)View, F.filesize), F.name);
 
   // Don't bother trying to build an index if there is no summary information
   // in this bitcode file.
   if (!object::ModuleSummaryIndexObjectFile::hasGlobalValueSummaryInMemBuffer(
           BufferRef, diagnosticHandler))
     return std::unique_ptr<ModuleSummaryIndex>(nullptr);
 
   ErrorOr<std::unique_ptr<object::ModuleSummaryIndexObjectFile>> ObjOrErr =
       object::ModuleSummaryIndexObjectFile::create(BufferRef,
                                                    diagnosticHandler);
 
   if (std::error_code EC = ObjOrErr.getError())
     message(LDPL_FATAL,
             "Could not read module summary index bitcode from file : %s",
             EC.message().c_str());
 
   object::ModuleSummaryIndexObjectFile &Obj = **ObjOrErr;
 
   return Obj.takeIndex();
 }
 
-static std::unique_ptr<Module>
-getModuleForFile(LLVMContext &Context, claimed_file &F, const void *View,
-                 ld_plugin_input_file &Info, raw_fd_ostream *ApiFile,
-                 StringSet<> &Internalize, StringSet<> &Maybe,
-                 std::vector<GlobalValue *> &Keep,
-                 StringMap<unsigned> &Realign) {
-  MemoryBufferRef BufferRef(StringRef((const char *)View, Info.filesize),
-                            Info.name);
+static std::unique_ptr<Module> getModuleForFile(
+    LLVMContext &Context, claimed_file &F, const void *View, StringRef Name,
+    raw_fd_ostream *ApiFile, StringSet<> &Internalize, StringSet<> &Maybe,
+    std::vector<GlobalValue *> &Keep, StringMap<unsigned> &Realign) {
+  MemoryBufferRef BufferRef(StringRef((const char *)View, F.filesize), Name);
   ErrorOr<std::unique_ptr<object::IRObjectFile>> ObjOrErr =
       object::IRObjectFile::create(BufferRef, Context);
 
   if (std::error_code EC = ObjOrErr.getError())
     message(LDPL_FATAL, "Could not read bitcode from file : %s",
             EC.message().c_str());
 
   object::IRObjectFile &Obj = **ObjOrErr;
class CodeGen {
 
   /// The target machine for generating code for this module.
   std::unique_ptr<TargetMachine> TM;
 
   /// Filename to use as base when save-temps is enabled, used to get
   /// a unique and identifiable save-temps output file for each ThinLTO backend.
   std::string SaveTempsFilename;
 
+  /// Map from a module name to the corresponding buffer holding a view of the
+  /// bitcode provided via the get_view gold callback.
+  StringMap<MemoryBufferRef> *ModuleMap;
+
 public:
   /// Constructor used by full LTO.
   CodeGen(std::unique_ptr<llvm::Module> M)
-      : M(std::move(M)), OS(nullptr), TaskID(-1), CombinedIndex(nullptr) {
+      : M(std::move(M)), OS(nullptr), TaskID(-1), CombinedIndex(nullptr),
+        ModuleMap(nullptr) {
     initTargetMachine();
   }
   /// Constructor used by ThinLTO.
   CodeGen(std::unique_ptr<llvm::Module> M, raw_fd_ostream *OS, int TaskID,
-          const ModuleSummaryIndex *CombinedIndex, std::string Filename)
+          const ModuleSummaryIndex *CombinedIndex, std::string Filename,
+          StringMap<MemoryBufferRef> *ModuleMap)
       : M(std::move(M)), OS(OS), TaskID(TaskID), CombinedIndex(CombinedIndex),
-        SaveTempsFilename(Filename) {
+        SaveTempsFilename(Filename), ModuleMap(ModuleMap) {
     assert(options::thinlto == !!CombinedIndex &&
            "Expected module summary index iff performing ThinLTO");
     initTargetMachine();
   }
 
   /// Invoke LTO passes and the code generator for the module.
   void runAll();
 
std::unique_ptr<TargetMachine> CodeGen::createTargetMachine() {
   return std::unique_ptr<TargetMachine>(TheTarget->createTargetMachine(
       TripleStr, options::mcpu, FeaturesString, Options, RelocationModel,
       CodeModel::Default, CGOptLevel));
 }
 
 void CodeGen::runLTOPasses() {
   M->setDataLayout(TM->createDataLayout());
 
+  if (CombinedIndex) {
+    // First collect the import list.
+    FunctionImporter::ImportMapTy ImportList;
+    ComputeCrossModuleImportForModule(M->getModuleIdentifier(), *CombinedIndex,
+                                      ImportList);
+
+    // Create a loader that will parse the bitcode from the buffers
+    // in the ModuleMap.
+    ModuleLoader Loader(M->getContext(), *ModuleMap);
+
+    // Perform function importing.
+    FunctionImporter Importer(*CombinedIndex, Loader);
+    Importer.importFunctions(*M, ImportList);
+  }
+
   legacy::PassManager passes;
   passes.add(createTargetTransformInfoWrapperPass(TM->getTargetIRAnalysis()));
 
   PassManagerBuilder PMB;
   PMB.LibraryInfo = new TargetLibraryInfoImpl(Triple(TM->getTargetTriple()));
   PMB.Inliner = createFunctionInliningPass();
   // Unconditionally verify input since it is not verified before this
   // point and has unknown origin.
   PMB.VerifyInput = true;
   PMB.VerifyOutput = !options::DisableVerify;
   PMB.LoopVectorize = true;
   PMB.SLPVectorize = true;
   PMB.OptLevel = options::OptLevel;
-  PMB.ModuleSummary = CombinedIndex;
   if (options::thinlto)
     PMB.populateThinLTOPassManager(passes);
   else
     PMB.populateLTOPassManager(passes);
   passes.run(*M);
 }
 
 /// Open a file and return the new file descriptor given a base input
void CodeGen::runAll() {
   // Otherwise attempt split code gen.
   else
     runSplitCodeGen(OptFilename);
 }
 
 /// Links the module in \p View from file \p F into the combined module
 /// saved in the IRMover \p L. Returns true on error, false on success.
 static bool linkInModule(LLVMContext &Context, IRMover &L, claimed_file &F,
-                         const void *View, ld_plugin_input_file &File,
+                         const void *View, StringRef Name,
                          raw_fd_ostream *ApiFile, StringSet<> &Internalize,
                          StringSet<> &Maybe) {
   std::vector<GlobalValue *> Keep;
   StringMap<unsigned> Realign;
   std::unique_ptr<Module> M = getModuleForFile(
-      Context, F, View, File, ApiFile, Internalize, Maybe, Keep, Realign);
+      Context, F, View, Name, ApiFile, Internalize, Maybe, Keep, Realign);
   if (!M.get())
     return false;
   if (!options::triple.empty())
     M->setTargetTriple(options::triple.c_str());
   else if (M->getTargetTriple().empty()) {
     M->setTargetTriple(DefaultTriple);
   }
 
   if (L.move(std::move(M), Keep, [](GlobalValue &, IRMover::ValueAdder) {}))
     return true;
 
   for (const auto &I : Realign) {
     GlobalValue *Dst = L.getModule().getNamedValue(I.first());
     if (!Dst)
       continue;
     cast<GlobalVariable>(Dst)->setAlignment(I.second);
   }
 
   return false;
 }
 
 /// Perform the ThinLTO backend on a single module, invoking the LTO and codegen
 /// pipelines.
 static void thinLTOBackendTask(claimed_file &F, const void *View,
-                               ld_plugin_input_file &File,
-                               raw_fd_ostream *ApiFile,
+                               StringRef Name, raw_fd_ostream *ApiFile,
                                const ModuleSummaryIndex &CombinedIndex,
-                               raw_fd_ostream *OS, unsigned TaskID) {
+                               raw_fd_ostream *OS, unsigned TaskID,
+                               StringMap<MemoryBufferRef> &ModuleMap) {
   // Need to use a separate context for each task
   LLVMContext Context;
   Context.setDiscardValueNames(options::TheOutputType !=
                                options::OT_SAVE_TEMPS);
   Context.enableDebugTypeODRUniquing(); // Merge debug info types.
   Context.setDiagnosticHandler(diagnosticHandlerForContext, nullptr, true);
 
-  std::unique_ptr<llvm::Module> NewModule(new llvm::Module(File.name, Context));
+  std::unique_ptr<llvm::Module> NewModule(new llvm::Module(Name, Context));
   IRMover L(*NewModule.get());
 
   StringSet<> Dummy;
-  if (linkInModule(Context, L, F, View, File, ApiFile, Dummy, Dummy))
+  if (linkInModule(Context, L, F, View, Name, ApiFile, Dummy, Dummy))
     message(LDPL_FATAL, "Failed to rename module for ThinLTO");
   if (renameModuleForThinLTO(*NewModule, CombinedIndex))
     message(LDPL_FATAL, "Failed to rename module for ThinLTO");
 
-  CodeGen codeGen(std::move(NewModule), OS, TaskID, &CombinedIndex, File.name);
+  CodeGen codeGen(std::move(NewModule), OS, TaskID, &CombinedIndex, Name,
+                  &ModuleMap);
   codeGen.runAll();
 }
 
 /// Launch each module's backend pipeline in a separate task in a thread pool.
 static void thinLTOBackends(raw_fd_ostream *ApiFile,
-                            const ModuleSummaryIndex &CombinedIndex) {
+                            const ModuleSummaryIndex &CombinedIndex,
+                            StringMap<MemoryBufferRef> &ModuleMap) {
   unsigned TaskCount = 0;
   std::vector<ThinLTOTaskInfo> Tasks;
   Tasks.reserve(Modules.size());
   unsigned int MaxThreads = options::Parallelism
                                 ? options::Parallelism
                                 : thread::hardware_concurrency();
 
   // Create ThreadPool in nested scope so that threads will be joined
   // on destruction.
   {
     ThreadPool ThinLTOThreadPool(MaxThreads);
     for (claimed_file &F : Modules) {
       // Do all the gold callbacks in the main thread, since gold is not thread
       // safe by default.
-      PluginInputFile InputFile(F.handle);
       const void *View = getSymbolsAndView(F);
       if (!View)
         continue;
 
       SmallString<128> Filename;
       if (!options::obj_path.empty())
         // Note that openOutputFile will append a unique ID for each task
         Filename = options::obj_path;
       else if (options::TheOutputType == options::OT_SAVE_TEMPS) {
         // Use the input file name so that we get a unique and identifiable
         // output file for each ThinLTO backend task.
-        Filename = InputFile.file().name;
+        Filename = F.name;
         Filename += ".thinlto.o";
       }
       bool TempOutFile = Filename.empty();
 
       SmallString<128> NewFilename;
       int FD = openOutputFile(Filename, TempOutFile, NewFilename,
                               // Only append the TaskID if we will use the
                               // non-unique obj_path.
                               !options::obj_path.empty() ? TaskCount : -1);
       TaskCount++;
       std::unique_ptr<raw_fd_ostream> OS =
           llvm::make_unique<raw_fd_ostream>(FD, true);
 
       // Enqueue the task
-      ThinLTOThreadPool.async(thinLTOBackendTask, std::ref(F), View,
-                              std::ref(InputFile.file()), ApiFile,
-                              std::ref(CombinedIndex), OS.get(), TaskCount);
+      ThinLTOThreadPool.async(thinLTOBackendTask, std::ref(F), View, F.name,
+                              ApiFile, std::ref(CombinedIndex), OS.get(),
+                              TaskCount, std::ref(ModuleMap));
 
       // Record the information needed by the task or during its cleanup
       // to a ThinLTOTaskInfo instance. For information needed by the task
       // the unique_ptr ownership is transferred to the ThinLTOTaskInfo.
-      Tasks.emplace_back(std::move(InputFile), std::move(OS),
-                         NewFilename.c_str(), TempOutFile);
+      Tasks.emplace_back(std::move(OS), NewFilename.c_str(), TempOutFile);
     }
   }
 
   for (auto &Task : Tasks)
     Task.cleanup();
 }
 
 /// Parse the thinlto_prefix_replace option into the \p OldPrefix and
static std::string getThinLTOOutputFile(const std::string &Path,
   }
   return NewPath.str();
 }
 
 /// Perform ThinLTO link, which creates the combined index file.
 /// Also, either launch backend threads or (under thinlto-index-only)
 /// emit individual index files for distributed backends and exit.
 static ld_plugin_status thinLTOLink(raw_fd_ostream *ApiFile) {
+  // Map from a module name to the corresponding buffer holding a view of the
+  // bitcode provided via the get_view gold callback.
+  StringMap<MemoryBufferRef> ModuleMap;
+  // Map to own RAII objects that manage the file opening and releasing
+  // interfaces with gold.
+  DenseMap<void *, std::unique_ptr<PluginInputFile>> HandleToInputFile;
+
   ModuleSummaryIndex CombinedIndex;
   uint64_t NextModuleId = 0;
   for (claimed_file &F : Modules) {
-    PluginInputFile InputFile(F.handle);
+    if (!HandleToInputFile.count(F.leader_handle))
+      HandleToInputFile.insert(std::make_pair(
+          F.leader_handle, llvm::make_unique<PluginInputFile>(F.handle)));
+    // Pass this into getModuleSummaryIndexForFile
+    const void *View = getSymbolsAndView(F);
+    if (!View)
+      continue;
+
+    MemoryBufferRef ModuleBuffer(StringRef((const char *)View, F.filesize),
+                                 F.name);
+    assert(ModuleMap.find(ModuleBuffer.getBufferIdentifier()) ==
+               ModuleMap.end() &&
+           "Expect unique Buffer Identifier");
+    ModuleMap[ModuleBuffer.getBufferIdentifier()] = ModuleBuffer;
 
-    std::unique_ptr<ModuleSummaryIndex> Index =
-        getModuleSummaryIndexForFile(F, InputFile.file());
+    std::unique_ptr<ModuleSummaryIndex> Index = getModuleSummaryIndexForFile(F);
 
     // Skip files without a module summary.
     if (Index)
       CombinedIndex.mergeFrom(std::move(Index), ++NextModuleId);
   }
 
   if (options::thinlto_emit_imports_files && !options::thinlto_index_only)
     message(LDPL_WARNING,
if (options::thinlto_index_only) {
     // extract the old and new prefixes.
     std::string OldPrefix, NewPrefix;
     getThinLTOOldAndNewPrefix(OldPrefix, NewPrefix);
 
     // For each input bitcode file, generate an individual index that
     // contains summaries only for its own global values, and for any that
     // should be imported.
     for (claimed_file &F : Modules) {
-      PluginInputFile InputFile(F.handle);
       std::error_code EC;
 
       std::string NewModulePath =
-          getThinLTOOutputFile(InputFile.file().name, OldPrefix, NewPrefix);
+          getThinLTOOutputFile(F.name, OldPrefix, NewPrefix);
       raw_fd_ostream OS((Twine(NewModulePath) + ".thinlto.bc").str(), EC,
                         sys::fs::OpenFlags::F_None);
       if (EC)
         message(LDPL_FATAL, "Unable to open %s.thinlto.bc for writing: %s",
                 NewModulePath.c_str(), EC.message().c_str());
       // Build a map of module to the GUIDs and summary objects that should
       // be written to its index.
       std::map<std::string, GVSummaryMapTy> ModuleToSummariesForIndex;
-      gatherImportedSummariesForModule(InputFile.file().name,
-                                       ModuleToDefinedGVSummaries, ImportLists,
-                                       ModuleToSummariesForIndex);
+      gatherImportedSummariesForModule(F.name, ModuleToDefinedGVSummaries,
+                                       ImportLists, ModuleToSummariesForIndex);
       WriteIndexToFile(CombinedIndex, OS, &ModuleToSummariesForIndex);
 
       if (options::thinlto_emit_imports_files) {
-        if ((EC = EmitImportsFiles(
-                 InputFile.file().name,
+        if ((EC = EmitImportsFiles(F.name,
                                    (Twine(NewModulePath) + ".imports").str(),
                                    ImportLists)))
           message(LDPL_FATAL, "Unable to open %s.imports",
                   NewModulePath.c_str(), EC.message().c_str());
       }
     }
 
     cleanup_hook();
     exit(0);
   }
 
   // Create OS in nested scope so that it will be closed on destruction.
   {
     std::error_code EC;
     raw_fd_ostream OS(output_name + ".thinlto.bc", EC,
                       sys::fs::OpenFlags::F_None);
     if (EC)
       message(LDPL_FATAL, "Unable to open %s.thinlto.bc for writing: %s",
               output_name.data(), EC.message().c_str());
     WriteIndexToFile(CombinedIndex, OS);
   }
 
-  thinLTOBackends(ApiFile, CombinedIndex);
+  thinLTOBackends(ApiFile, CombinedIndex, ModuleMap);
   return LDPS_OK;
 }
 
 /// gold informs us that all symbols have been read. At this point, we use
 /// get_symbols to see if any of our definitions have been overridden by a
 /// native object file. Then, perform optimization and codegen.
 static ld_plugin_status allSymbolsReadHook(raw_fd_ostream *ApiFile) {
   if (Modules.empty())
static ld_plugin_status allSymbolsReadHook(raw_fd_ostream *ApiFile) {
   Context.setDiagnosticHandler(diagnosticHandlerForContext, nullptr, true);
 
   std::unique_ptr<Module> Combined(new Module("ld-temp.o", Context));
   IRMover L(*Combined);
 
   StringSet<> Internalize;
   StringSet<> Maybe;
   for (claimed_file &F : Modules) {
+    // RAII object to manage the file opening and releasing interfaces with
+    // gold.
     PluginInputFile InputFile(F.handle);
     const void *View = getSymbolsAndView(F);
     if (!View)
       continue;
-    if (linkInModule(Context, L, F, View, InputFile.file(), ApiFile,
-                     Internalize, Maybe))
+    if (linkInModule(Context, L, F, View, F.name, ApiFile, Internalize, Maybe))
       message(LDPL_FATAL, "Failed to link module");
   }
 
   for (const auto &Name : Internalize) {
     GlobalValue *GV = Combined->getNamedValue(Name.first());
     if (GV)
       internalize(*GV);
   }

tools/llvm-readobj/COFFDumper.cpp

private:
 
   CVTypeDumper CVTD;
 };
 
 class COFFObjectDumpDelegate : public SymbolDumpDelegate {
 public:
   COFFObjectDumpDelegate(COFFDumper &CD, const SectionRef &SR,
                          const COFFObjectFile *Obj, StringRef SectionContents)
-      : CD(CD), SR(SR), Obj(Obj), SectionContents(SectionContents) {
+      : CD(CD), SR(SR), SectionContents(SectionContents) {
     Sec = Obj->getCOFFSection(SR);
   }
 
   uint32_t getRecordOffset(ArrayRef<uint8_t> Record) override {
     return Record.data() - SectionContents.bytes_begin();
   }
 
   void printRelocatedField(StringRef Label, uint32_t RelocOffset,
StringRef getFileNameForFileOffset(uint32_t FileOffset) override {
     return CD.getFileNameForFileOffset(FileOffset);
   }
 
   StringRef getStringTable() override { return CD.CVStringTable; }
 
 private:
   COFFDumper &CD;
   const SectionRef &SR;
-  const COFFObjectFile *Obj;
   const coff_section *Sec;
   StringRef SectionContents;
 };
 
 } // end namespace
 
 namespace llvm {