[IRReader] Expose getLazyIRModule

[scott.linder]

Summary

Currently there is no way to lazy-load an in-memory IR module without first writing it to disk. This patch just exposes the existing implementation of getLazyIRModule.

This is effectively a revert of rL212364; I don't have all of the context for the original change, but I don't see why this function can't be exposed now, especially with the stronger type signature it currently has.

[scott.linder]

Rebase and ping

[scott.linder]

Ping

[aprantl]

I'm not sure if this is intentionally kept private but this looks harmless to me. Would be good to get an okay from someone more familiar with the interfaces.

[tejohnson]

The original change predates my involvement with LLVM, but it sounds like the only reason was just cleanup since it wasn't used elsewhere. I don't see any issue with adding this interface (similar to how we have exposed both parseIR and parseIRFile).

LGTM with a request below.

include/llvm/IRReader/IRReader.h

35

Please add a comment that this takes ownership of the Buffer. That is one important change since the original modification that made this static.

include/llvm/IRReader/IRReader.h

 #define LLVM_IRREADER_IRREADER_H
 
 #include "llvm/ADT/StringRef.h"
 #include <memory>
 
 namespace llvm {
 
 class StringRef;
+class MemoryBuffer;
 class MemoryBufferRef;
 class Module;
 class SMDiagnostic;
 class LLVMContext;
 
+/// If the given MemoryBuffer holds a bitcode image, return a Module
+/// for it which does lazy deserialization of function bodies.  Otherwise,
+/// attempt to parse it as LLVM Assembly and return a fully populated
+/// Module. The ShouldLazyLoadMetadata flag is passed down to the bitcode
+/// reader to optionally enable lazy metadata loading.
+std::unique_ptr<Module> getLazyIRModule(std::unique_ptr<MemoryBuffer> Buffer,
+                                        SMDiagnostic &Err, LLVMContext &Context,
+                                        bool ShouldLazyLoadMetadata = false);
+
 /// If the given file holds a bitcode image, return a Module
 /// for it which does lazy deserialization of function bodies.  Otherwise,
 /// attempt to parse it as LLVM Assembly and return a fully populated
 /// Module. The ShouldLazyLoadMetadata flag is passed down to the bitcode
 /// reader to optionally enable lazy metadata loading.
 std::unique_ptr<Module>
 getLazyIRFileModule(StringRef Filename, SMDiagnostic &Err, LLVMContext &Context,
                     bool ShouldLazyLoadMetadata = false);

lib/IRReader/IRReader.cpp

namespace llvm {
   extern bool TimePassesIsEnabled;
 }
 
 static const char *const TimeIRParsingGroupName = "irparse";
 static const char *const TimeIRParsingGroupDescription = "LLVM IR Parsing";
 static const char *const TimeIRParsingName = "parse";
 static const char *const TimeIRParsingDescription = "Parse IR";
 
-static std::unique_ptr<Module>
-getLazyIRModule(std::unique_ptr<MemoryBuffer> Buffer, SMDiagnostic &Err,
+std::unique_ptr<Module>
+llvm::getLazyIRModule(std::unique_ptr<MemoryBuffer> Buffer, SMDiagnostic &Err,
                       LLVMContext &Context, bool ShouldLazyLoadMetadata) {
   if (isBitcode((const unsigned char *)Buffer->getBufferStart(),
                 (const unsigned char *)Buffer->getBufferEnd())) {
     Expected<std::unique_ptr<Module>> ModuleOrErr = getOwningLazyBitcodeModule(
         std::move(Buffer), Context, ShouldLazyLoadMetadata);
     if (Error E = ModuleOrErr.takeError()) {
       handleAllErrors(std::move(E), [&](ErrorInfoBase &EIB) {
         Err = SMDiagnostic(Buffer->getBufferIdentifier(), SourceMgr::DK_Error,
                            EIB.message());