Do not require a Context to extract the FunctionIndex from Bitcode

[mehdi_amini]

Summary

The LLVMContext was only used for Diagnostic. Pass a DiagnosticHandler
instead.

[mehdi_amini]

Remove no longer used LLVMContext in createCombinedFunctionIndex

[tejohnson]

Thanks for the cleanup!

[mehdi_amini]

r253540

[chapuni]

You forgot to modify gold-plugin. Could you confirm my change r253553, please?

include/llvm/Bitcode/ReaderWriter.h

std::string getBitcodeProducerString(
       DiagnosticHandlerFunction DiagnosticHandler = nullptr);
 
   /// Read the specified bitcode file, returning the module.
   ErrorOr<std::unique_ptr<Module>>
   parseBitcodeFile(MemoryBufferRef Buffer, LLVMContext &Context,
                    DiagnosticHandlerFunction DiagnosticHandler = nullptr);
 
   /// Check if the given bitcode buffer contains a function summary block.
-  bool hasFunctionSummary(MemoryBufferRef Buffer, LLVMContext &Context,
+  bool hasFunctionSummary(MemoryBufferRef Buffer,
                           DiagnosticHandlerFunction DiagnosticHandler);
 
   /// Parse the specified bitcode buffer, returning the function info index.
   /// If ExportingModule is true, check for functions in the index from this
   /// module when the combined index is built during parsing and set flag.
   /// If IsLazy is true, parse the entire function summary into
   /// the index. Otherwise skip the function summary section, and only create
   /// an index object with a map from function name to function summary offset.
   /// The index is used to perform lazy function summary reading later.
-  ErrorOr<std::unique_ptr<FunctionInfoIndex>>
-  getFunctionInfoIndex(MemoryBufferRef Buffer, LLVMContext &Context,
-                       DiagnosticHandlerFunction DiagnosticHandler,
-                       const Module *ExportingModule = nullptr,
-                       bool IsLazy = false);
+  ErrorOr<std::unique_ptr<FunctionInfoIndex>> getFunctionInfoIndex(
+      MemoryBufferRef Buffer, DiagnosticHandlerFunction DiagnosticHandler,
+      const Module *ExportingModule = nullptr, bool IsLazy = false);
 
   /// This method supports lazy reading of function summary data from the
   /// combined index during function importing. When reading the combined index
   /// file, getFunctionInfoIndex is first invoked with IsLazy=true.
   /// Then this method is called for each function considered for importing,
   /// to parse the summary information for the given function name into
   /// the index.
-  std::error_code
-  readFunctionSummary(MemoryBufferRef Buffer, LLVMContext &Context,
-                      DiagnosticHandlerFunction DiagnosticHandler,
-                      StringRef FunctionName,
-                      std::unique_ptr<FunctionInfoIndex> Index);
+  std::error_code readFunctionSummary(
+      MemoryBufferRef Buffer, DiagnosticHandlerFunction DiagnosticHandler,
+      StringRef FunctionName, std::unique_ptr<FunctionInfoIndex> Index);
 
   /// \brief Write the specified module to the specified raw output stream.
   ///
   /// For streams where it matters, the given stream should be in "binary"
   /// mode.
   ///
   /// If \c ShouldPreserveUseListOrder, encode the use-list order for each \a
   /// Value in \c M.  These will be reconstructed exactly when \a M is

include/llvm/Object/FunctionIndexObjectFile.h

 //===- FunctionIndexObjectFile.h - Function index file implementation -----===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file declares the FunctionIndexObjectFile template class.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_OBJECT_FUNCTIONINDEXOBJECTFILE_H
 #define LLVM_OBJECT_FUNCTIONINDEXOBJECTFILE_H
 
+#include "llvm/IR/DiagnosticInfo.h"
 #include "llvm/Object/SymbolicFile.h"
 
 namespace llvm {
 class FunctionInfoIndex;
 class Module;
 
 namespace object {
 class ObjectFile;
public:
   /// \brief Finds and returns bitcode in the given memory buffer (which may
   /// be either a bitcode file or a native object file with embedded bitcode),
   /// or an error code if not found.
   static ErrorOr<MemoryBufferRef>
   findBitcodeInMemBuffer(MemoryBufferRef Object);
 
   /// \brief Looks for function summary in the given memory buffer,
   /// returns true if found, else false.
-  static bool hasFunctionSummaryInMemBuffer(MemoryBufferRef Object,
-                                            LLVMContext &Context);
+  static bool
+  hasFunctionSummaryInMemBuffer(MemoryBufferRef Object,
+                                DiagnosticHandlerFunction DiagnosticHandler);
 
   /// \brief Parse function index in the given memory buffer.
   /// Return new FunctionIndexObjectFile instance containing parsed function
   /// summary/index.
   static ErrorOr<std::unique_ptr<FunctionIndexObjectFile>>
-  create(MemoryBufferRef Object, LLVMContext &Context,
+  create(MemoryBufferRef Object, DiagnosticHandlerFunction DiagnosticHandler,
          const Module *ExportingModule = nullptr, bool IsLazy = false);
 
   /// \brief Parse the function summary information for function with the
   /// given name out of the given buffer. Parsed information is
   /// stored on the index object saved in this object.
-  std::error_code findFunctionSummaryInMemBuffer(MemoryBufferRef Object,
-                                                 LLVMContext &Context,
-                                                 StringRef FunctionName);
+  std::error_code
+  findFunctionSummaryInMemBuffer(MemoryBufferRef Object,
+                                 DiagnosticHandlerFunction DiagnosticHandler,
 };
 }
 }
 
 #endif

lib/Bitcode/Reader/BitcodeReader.cpp

class FunctionIndexBitcodeReader {
   /// summary records.
   DenseMap<uint64_t, StringRef> ModuleIdMap;
 
 public:
   std::error_code error(BitcodeError E, const Twine &Message);
   std::error_code error(BitcodeError E);
   std::error_code error(const Twine &Message);
 
-  FunctionIndexBitcodeReader(MemoryBuffer *Buffer, LLVMContext &Context,
+  FunctionIndexBitcodeReader(MemoryBuffer *Buffer,
                              DiagnosticHandlerFunction DiagnosticHandler,
                              bool IsLazy = false,
                              bool CheckFuncSummaryPresenceOnly = false);
-  FunctionIndexBitcodeReader(LLVMContext &Context,
-                             DiagnosticHandlerFunction DiagnosticHandler,
+  FunctionIndexBitcodeReader(DiagnosticHandlerFunction DiagnosticHandler,
                              bool IsLazy = false,
                              bool CheckFuncSummaryPresenceOnly = false);
   ~FunctionIndexBitcodeReader() { freeState(); }
 
   void freeState();
 
   void releaseBuffer();
 
return ::error(DiagnosticHandler,
                  make_error_code(BitcodeError::CorruptedBitcode), Message);
 }
 
 std::error_code FunctionIndexBitcodeReader::error(BitcodeError E) {
   return ::error(DiagnosticHandler, make_error_code(E));
 }
 
 FunctionIndexBitcodeReader::FunctionIndexBitcodeReader(
-    MemoryBuffer *Buffer, LLVMContext &Context,
-    DiagnosticHandlerFunction DiagnosticHandler, bool IsLazy,
-    bool CheckFuncSummaryPresenceOnly)
-    : DiagnosticHandler(getDiagHandler(DiagnosticHandler, Context)),
-      Buffer(Buffer), IsLazy(IsLazy),
+    MemoryBuffer *Buffer, DiagnosticHandlerFunction DiagnosticHandler,
+    bool IsLazy, bool CheckFuncSummaryPresenceOnly)
+    : DiagnosticHandler(DiagnosticHandler), Buffer(Buffer), IsLazy(IsLazy),
       CheckFuncSummaryPresenceOnly(CheckFuncSummaryPresenceOnly) {}
 
 FunctionIndexBitcodeReader::FunctionIndexBitcodeReader(
-    LLVMContext &Context, DiagnosticHandlerFunction DiagnosticHandler,
-    bool IsLazy, bool CheckFuncSummaryPresenceOnly)
-    : DiagnosticHandler(getDiagHandler(DiagnosticHandler, Context)),
-      Buffer(nullptr), IsLazy(IsLazy),
+    DiagnosticHandlerFunction DiagnosticHandler, bool IsLazy,
+    bool CheckFuncSummaryPresenceOnly)
+    : DiagnosticHandler(DiagnosticHandler), Buffer(nullptr), IsLazy(IsLazy),
       CheckFuncSummaryPresenceOnly(CheckFuncSummaryPresenceOnly) {}
 
 void FunctionIndexBitcodeReader::freeState() { Buffer = nullptr; }
 
 void FunctionIndexBitcodeReader::releaseBuffer() { Buffer.release(); }
 
 // Specialized value symbol table parser used when reading function index
 // blocks where we don't actually create global values.

 }
 
 // Parse the specified bitcode buffer, returning the function info index.
 // If IsLazy is false, parse the entire function summary into
 // the index. Otherwise skip the function summary section, and only create
 // an index object with a map from function name to function summary offset.
 // The index is used to perform lazy function summary reading later.
 ErrorOr<std::unique_ptr<FunctionInfoIndex>>
-llvm::getFunctionInfoIndex(MemoryBufferRef Buffer, LLVMContext &Context,
+llvm::getFunctionInfoIndex(MemoryBufferRef Buffer,
                            DiagnosticHandlerFunction DiagnosticHandler,
                            const Module *ExportingModule, bool IsLazy) {
   std::unique_ptr<MemoryBuffer> Buf = MemoryBuffer::getMemBuffer(Buffer, false);
-  FunctionIndexBitcodeReader R(Buf.get(), Context, DiagnosticHandler, IsLazy);
+  FunctionIndexBitcodeReader R(Buf.get(), DiagnosticHandler, IsLazy);
 
   std::unique_ptr<FunctionInfoIndex> Index =
       llvm::make_unique<FunctionInfoIndex>(ExportingModule);
 
   auto cleanupOnError = [&](std::error_code EC) {
     R.releaseBuffer(); // Never take ownership on error.
     return EC;
   };
 
   if (std::error_code EC = R.parseSummaryIndexInto(nullptr, Index.get()))
     return cleanupOnError(EC);
 
   Buf.release(); // The FunctionIndexBitcodeReader owns it now.
   return std::move(Index);
 }
 
 // Check if the given bitcode buffer contains a function summary block.
-bool llvm::hasFunctionSummary(MemoryBufferRef Buffer, LLVMContext &Context,
+bool llvm::hasFunctionSummary(MemoryBufferRef Buffer,
                               DiagnosticHandlerFunction DiagnosticHandler) {
   std::unique_ptr<MemoryBuffer> Buf = MemoryBuffer::getMemBuffer(Buffer, false);
-  FunctionIndexBitcodeReader R(Buf.get(), Context, DiagnosticHandler, false,
-                               true);
+  FunctionIndexBitcodeReader R(Buf.get(), DiagnosticHandler, false, true);
 
   auto cleanupOnError = [&](std::error_code EC) {
     R.releaseBuffer(); // Never take ownership on error.
     return false;
   };
 
   if (std::error_code EC = R.parseSummaryIndexInto(nullptr, nullptr))
     return cleanupOnError(EC);
 
   Buf.release(); // The FunctionIndexBitcodeReader owns it now.
   return R.foundFuncSummary();
 }
 
 // This method supports lazy reading of function summary data from the combined
 // index during ThinLTO function importing. When reading the combined index
 // file, getFunctionInfoIndex is first invoked with IsLazy=true.
 // Then this method is called for each function considered for importing,
 // to parse the summary information for the given function name into
 // the index.
-std::error_code
-llvm::readFunctionSummary(MemoryBufferRef Buffer, LLVMContext &Context,
-                          DiagnosticHandlerFunction DiagnosticHandler,
-                          StringRef FunctionName,
-                          std::unique_ptr<FunctionInfoIndex> Index) {
+std::error_code llvm::readFunctionSummary(
+    MemoryBufferRef Buffer, DiagnosticHandlerFunction DiagnosticHandler,
+    StringRef FunctionName, std::unique_ptr<FunctionInfoIndex> Index) {
   std::unique_ptr<MemoryBuffer> Buf = MemoryBuffer::getMemBuffer(Buffer, false);
-  FunctionIndexBitcodeReader R(Buf.get(), Context, DiagnosticHandler);
+  FunctionIndexBitcodeReader R(Buf.get(), DiagnosticHandler);
 
   auto cleanupOnError = [&](std::error_code EC) {
     R.releaseBuffer(); // Never take ownership on error.
     return EC;
   };
 
   // Lookup the given function name in the FunctionMap, which may
   // contain a list of function infos in the case of a COMDAT. Walk through

lib/Object/FunctionIndexObjectFile.cpp

FunctionIndexObjectFile::findBitcodeInMemBuffer(MemoryBufferRef Object) {
   default:
     return object_error::invalid_file_type;
   }
 }
 
 // Looks for function index in the given memory buffer.
 // returns true if found, else false.
 bool FunctionIndexObjectFile::hasFunctionSummaryInMemBuffer(
-    MemoryBufferRef Object, LLVMContext &Context) {
+    MemoryBufferRef Object, DiagnosticHandlerFunction DiagnosticHandler) {
   ErrorOr<MemoryBufferRef> BCOrErr = findBitcodeInMemBuffer(Object);
   if (!BCOrErr)
     return false;
 
-  return hasFunctionSummary(BCOrErr.get(), Context, nullptr);
+  return hasFunctionSummary(BCOrErr.get(), DiagnosticHandler);
 }
 
 // Parse function index in the given memory buffer.
 // Return new FunctionIndexObjectFile instance containing parsed
 // function summary/index.
 ErrorOr<std::unique_ptr<FunctionIndexObjectFile>>
-FunctionIndexObjectFile::create(MemoryBufferRef Object, LLVMContext &Context,
+FunctionIndexObjectFile::create(MemoryBufferRef Object,
+                                DiagnosticHandlerFunction DiagnosticHandler,
                                 const Module *ExportingModule, bool IsLazy) {
   std::unique_ptr<FunctionInfoIndex> Index;
 
   ErrorOr<MemoryBufferRef> BCOrErr = findBitcodeInMemBuffer(Object);
   if (!BCOrErr)
     return BCOrErr.getError();
 
   ErrorOr<std::unique_ptr<FunctionInfoIndex>> IOrErr = getFunctionInfoIndex(
-      BCOrErr.get(), Context, nullptr, ExportingModule, IsLazy);
+      BCOrErr.get(), DiagnosticHandler, ExportingModule, IsLazy);
 
   if (std::error_code EC = IOrErr.getError())
     return EC;
 
   Index = std::move(IOrErr.get());
 
   return llvm::make_unique<FunctionIndexObjectFile>(Object, std::move(Index));
 }
 
 // Parse the function summary information for function with the
 // given name out of the given buffer. Parsed information is
 // stored on the index object saved in this object.
 std::error_code FunctionIndexObjectFile::findFunctionSummaryInMemBuffer(
-    MemoryBufferRef Object, LLVMContext &Context, StringRef FunctionName) {
+    MemoryBufferRef Object, DiagnosticHandlerFunction DiagnosticHandler,
+    StringRef FunctionName) {
   sys::fs::file_magic Type = sys::fs::identify_magic(Object.getBuffer());
   switch (Type) {
   case sys::fs::file_magic::bitcode: {
-    return readFunctionSummary(Object, Context, nullptr, FunctionName,
+    return readFunctionSummary(Object, DiagnosticHandler, FunctionName,
                                std::move(Index));
   }
   default:
     return object_error::invalid_file_type;
   }
 }

tools/llvm-link/llvm-link.cpp

loadIndex(LLVMContext &Context, const Module *ExportingModule = nullptr) {
   assert(!FunctionIndex.empty());
   ErrorOr<std::unique_ptr<MemoryBuffer>> FileOrErr =
       MemoryBuffer::getFileOrSTDIN(FunctionIndex);
   std::error_code EC = FileOrErr.getError();
   if (EC)
     return EC;
   MemoryBufferRef BufferRef = (FileOrErr.get())->getMemBufferRef();
   ErrorOr<std::unique_ptr<object::FunctionIndexObjectFile>> ObjOrErr =
-      object::FunctionIndexObjectFile::create(BufferRef, Context,
+      object::FunctionIndexObjectFile::create(BufferRef, diagnosticHandler,
                                               ExportingModule);
   EC = ObjOrErr.getError();
   if (EC)
     return EC;
 
   object::FunctionIndexObjectFile &Obj = **ObjOrErr;
   return Obj.takeIndex();
 }

tools/llvm-lto/llvm-lto.cpp

 // This program takes in a list of bitcode files, links them, performs link-time
 // optimization, and outputs an object file.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/StringSet.h"
 #include "llvm/Bitcode/ReaderWriter.h"
 #include "llvm/CodeGen/CommandFlags.h"
+#include "llvm/IR/DiagnosticPrinter.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/LTO/LTOCodeGenerator.h"
 #include "llvm/LTO/LTOModule.h"
 #include "llvm/Object/FunctionIndexObjectFile.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/PrettyStackTrace.h"
case LTO_DS_ERROR:
     break;
   case LTO_DS_WARNING:
     errs() << "warning: ";
     break;
   }
   errs() << Msg << "\n";
 }
 
+static void diagnosticHandler(const DiagnosticInfo &DI) {
+  raw_ostream &OS = errs();
+  OS << "llvm-lto: ";
+  switch (DI.getSeverity()) {
+  case DS_Error:
+    OS << "error: ";
+    break;
+  case DS_Warning:
+    OS << "warning: ";
+    break;
+  case DS_Remark:
+    OS << "remark: ";
+    break;
+  case DS_Note:
+    OS << "note: ";
+    break;
+  }
+
+  DiagnosticPrinterRawOStream DP(OS);
+  DI.print(DP);
+  OS << '\n';
+
+  if (DI.getSeverity() == DS_Error)
+    exit(1);
+}
+
 static std::unique_ptr<LTOModule>
 getLocalLTOModule(StringRef Path, std::unique_ptr<MemoryBuffer> &Buffer,
                   const TargetOptions &Options, std::string &Error) {
   ErrorOr<std::unique_ptr<MemoryBuffer>> BufferOrErr =
       MemoryBuffer::getFile(Path);
   if (std::error_code EC = BufferOrErr.getError()) {
     Error = EC.message();
     return nullptr;
static int listSymbols(StringRef Command, const TargetOptions &Options) {
   }
   return 0;
 }
 
 /// Parse the function index out of an IR file and return the function
 /// index object if found, or nullptr if not.
 static std::unique_ptr<FunctionInfoIndex>
 getFunctionIndexForFile(StringRef Path, std::string &Error,
-                        LLVMContext &Context) {
+                        DiagnosticHandlerFunction DiagnosticHandler) {
   std::unique_ptr<MemoryBuffer> Buffer;
   ErrorOr<std::unique_ptr<MemoryBuffer>> BufferOrErr =
       MemoryBuffer::getFile(Path);
   if (std::error_code EC = BufferOrErr.getError()) {
     Error = EC.message();
     return nullptr;
   }
   Buffer = std::move(BufferOrErr.get());
   ErrorOr<std::unique_ptr<object::FunctionIndexObjectFile>> ObjOrErr =
       object::FunctionIndexObjectFile::create(Buffer->getMemBufferRef(),
-                                              Context);
+                                              DiagnosticHandler);
   if (std::error_code EC = ObjOrErr.getError()) {
     Error = EC.message();
     return nullptr;
   }
   return (*ObjOrErr)->takeIndex();
 }
 
 /// Create a combined index file from the input IR files and write it.
 ///
 /// This is meant to enable testing of ThinLTO combined index generation,
 /// currently available via the gold plugin via -thinlto.
 static int createCombinedFunctionIndex(StringRef Command) {
   LLVMContext Context;
   FunctionInfoIndex CombinedIndex;
   uint64_t NextModuleId = 0;
   for (auto &Filename : InputFilenames) {
     std::string Error;
     std::unique_ptr<FunctionInfoIndex> Index =
-        getFunctionIndexForFile(Filename, Error, Context);
+        getFunctionIndexForFile(Filename, Error, diagnosticHandler);
     if (!Index) {
       errs() << Command << ": error loading file '" << Filename
              << "': " << Error << "\n";
       return 1;
     }
     CombinedIndex.mergeFrom(std::move(Index), ++NextModuleId);
   }
   std::error_code EC;