From: Peter Collingbourne Date: Tue, 8 Nov 2016 06:03:43 +0000 (+0000) Subject: IR, Bitcode: Change bitcode reader to no longer own its memory buffer. X-Git-Tag: llvmorg-4.0.0-rc1~5267 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=e2dcf7c3a12d5e623048d6e77d5b320dfb553ace;p=platform%2Fupstream%2Fllvm.git IR, Bitcode: Change bitcode reader to no longer own its memory buffer. Unique ownership is just one possible ownership pattern for the memory buffer underlying the bitcode reader. In practice, as this patch shows, ownership can often reside at a higher level. With the upcoming change to allow multiple modules in a single bitcode file, it will no longer be appropriate for modules to generally have unique ownership of their memory buffer. The C API exposes the ownership relation via the LLVMGetBitcodeModuleInContext and LLVMGetBitcodeModuleInContext2 functions, so we still need some way for the module to own the memory buffer. This patch does so by adding an owned memory buffer field to Module, and using it in a few other places where it is convenient. Differential Revision: https://reviews.llvm.org/D26384 llvm-svn: 286214 --- diff --git a/clang/lib/CodeGen/CodeGenAction.cpp b/clang/lib/CodeGen/CodeGenAction.cpp index 657af24e739b..c63e95b6ecb1 100644 --- a/clang/lib/CodeGen/CodeGenAction.cpp +++ b/clang/lib/CodeGen/CodeGenAction.cpp @@ -772,7 +772,7 @@ CodeGenAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) { } ErrorOr> ModuleOrErr = - getLazyBitcodeModule(std::move(*BCBuf), *VMContext); + getOwningLazyBitcodeModule(std::move(*BCBuf), *VMContext); if (std::error_code EC = ModuleOrErr.getError()) { CI.getDiagnostics().Report(diag::err_cannot_open_file) << LinkBCFile << EC.message(); diff --git a/llvm/include/llvm/Bitcode/ReaderWriter.h b/llvm/include/llvm/Bitcode/ReaderWriter.h index 178dbda0789f..38a7be8538af 100644 --- a/llvm/include/llvm/Bitcode/ReaderWriter.h +++ b/llvm/include/llvm/Bitcode/ReaderWriter.h @@ -39,13 +39,19 @@ namespace llvm { /// Read the header of the specified bitcode buffer and prepare for lazy /// deserialization of function bodies. If ShouldLazyLoadMetadata is true, - /// lazily load metadata as well. If successful, this moves Buffer. On - /// error, this *does not* move Buffer. + /// lazily load metadata as well. ErrorOr> - getLazyBitcodeModule(std::unique_ptr &&Buffer, - LLVMContext &Context, + getLazyBitcodeModule(MemoryBufferRef Buffer, LLVMContext &Context, bool ShouldLazyLoadMetadata = false); + /// Like getLazyBitcodeModule, except that the module takes ownership of + /// the memory buffer if successful. If successful, this moves Buffer. On + /// error, this *does not* move Buffer. + ErrorOr> + getOwningLazyBitcodeModule(std::unique_ptr &&Buffer, + LLVMContext &Context, + bool ShouldLazyLoadMetadata = false); + /// Read the header of the specified bitcode buffer and extract just the /// triple information. If successful, this returns a string. On error, this /// returns "". diff --git a/llvm/include/llvm/IR/Module.h b/llvm/include/llvm/IR/Module.h index f51d02ee1225..81b56a24b271 100644 --- a/llvm/include/llvm/IR/Module.h +++ b/llvm/include/llvm/IR/Module.h @@ -33,6 +33,7 @@ template class Optional; class FunctionType; class GVMaterializer; class LLVMContext; +class MemoryBuffer; class RandomNumberGenerator; class StructType; template class SmallPtrSetImpl; @@ -158,6 +159,9 @@ private: std::string GlobalScopeAsm; ///< Inline Asm at global scope. ValueSymbolTable *ValSymTab; ///< Symbol table for values ComdatSymTabType ComdatSymTab; ///< Symbol table for COMDATs + std::unique_ptr + OwnedMemoryBuffer; ///< Memory buffer directly owned by this + ///< module, for legacy clients only. std::unique_ptr Materializer; ///< Used to materialize GlobalValues std::string ModuleID; ///< Human readable identifier for the module @@ -802,6 +806,9 @@ public: /// \brief Returns profile summary metadata Metadata *getProfileSummary(); /// @} + + /// Take ownership of the given memory buffer. + void setOwnedMemoryBuffer(std::unique_ptr MB); }; /// \brief Given "llvm.used" or "llvm.compiler.used" as a global name, collect diff --git a/llvm/lib/Bitcode/Reader/BitReader.cpp b/llvm/lib/Bitcode/Reader/BitReader.cpp index 9ac3cb95d086..8527bcf7c3ba 100644 --- a/llvm/lib/Bitcode/Reader/BitReader.cpp +++ b/llvm/lib/Bitcode/Reader/BitReader.cpp @@ -101,7 +101,7 @@ LLVMBool LLVMGetBitcodeModuleInContext(LLVMContextRef ContextRef, std::unique_ptr Owner(unwrap(MemBuf)); ErrorOr> ModuleOrErr = - getLazyBitcodeModule(std::move(Owner), Ctx); + getOwningLazyBitcodeModule(std::move(Owner), Ctx); Owner.release(); Ctx.setDiagnosticHandler(OldDiagnosticHandler, OldDiagnosticContext, true); @@ -124,7 +124,7 @@ LLVMBool LLVMGetBitcodeModuleInContext2(LLVMContextRef ContextRef, std::unique_ptr Owner(unwrap(MemBuf)); ErrorOr> ModuleOrErr = - getLazyBitcodeModule(std::move(Owner), Ctx); + getOwningLazyBitcodeModule(std::move(Owner), Ctx); Owner.release(); if (ModuleOrErr.getError()) { diff --git a/llvm/lib/Bitcode/Reader/BitcodeReader.cpp b/llvm/lib/Bitcode/Reader/BitcodeReader.cpp index a5f040bfa36a..e5c481209506 100644 --- a/llvm/lib/Bitcode/Reader/BitcodeReader.cpp +++ b/llvm/lib/Bitcode/Reader/BitcodeReader.cpp @@ -230,9 +230,9 @@ private: class BitcodeReaderBase { protected: - BitcodeReaderBase(MemoryBuffer *Buffer) : Buffer(Buffer) {} + BitcodeReaderBase(MemoryBufferRef Buffer) : Buffer(Buffer) {} - std::unique_ptr Buffer; + MemoryBufferRef Buffer; BitstreamBlockInfo BlockInfo; BitstreamCursor Stream; @@ -244,10 +244,10 @@ protected: }; std::error_code BitcodeReaderBase::initStream() { - const unsigned char *BufPtr = (const unsigned char*)Buffer->getBufferStart(); - const unsigned char *BufEnd = BufPtr+Buffer->getBufferSize(); + const unsigned char *BufPtr = (const unsigned char*)Buffer.getBufferStart(); + const unsigned char *BufEnd = BufPtr+Buffer.getBufferSize(); - if (Buffer->getBufferSize() & 3) + if (Buffer.getBufferSize() & 3) return error("Invalid bitcode signature"); // If we have a wrapper header, parse it and ignore the non-bc file contents. @@ -360,15 +360,10 @@ public: std::error_code error(BitcodeError E, const Twine &Message); std::error_code error(const Twine &Message) override; - BitcodeReader(MemoryBuffer *Buffer, LLVMContext &Context); - ~BitcodeReader() override { freeState(); } + BitcodeReader(MemoryBufferRef Buffer, LLVMContext &Context); std::error_code materializeForwardReferencedFunctions(); - void freeState(); - - void releaseBuffer(); - std::error_code materialize(GlobalValue *GV) override; std::error_code materializeModule() override; std::vector getIdentifiedStructTypes() const override; @@ -585,13 +580,8 @@ public: std::error_code error(const Twine &Message); ModuleSummaryIndexBitcodeReader( - MemoryBuffer *Buffer, DiagnosticHandlerFunction DiagnosticHandler, + MemoryBufferRef Buffer, DiagnosticHandlerFunction DiagnosticHandler, bool CheckGlobalValSummaryPresenceOnly = false); - ~ModuleSummaryIndexBitcodeReader() { freeState(); } - - void freeState(); - - void releaseBuffer(); /// Check if the parser has encountered a summary section. bool foundGlobalValSummary() { return SeenGlobalValSummary; } @@ -661,7 +651,7 @@ std::error_code BitcodeReader::error(const Twine &Message) { Message); } -BitcodeReader::BitcodeReader(MemoryBuffer *Buffer, LLVMContext &Context) +BitcodeReader::BitcodeReader(MemoryBufferRef Buffer, LLVMContext &Context) : BitcodeReaderBase(Buffer), Context(Context), ValueList(Context), MetadataList(Context) {} @@ -698,24 +688,6 @@ std::error_code BitcodeReader::materializeForwardReferencedFunctions() { return std::error_code(); } -void BitcodeReader::freeState() { - Buffer = nullptr; - std::vector().swap(TypeList); - ValueList.clear(); - MetadataList.clear(); - std::vector().swap(ComdatList); - - std::vector().swap(MAttributes); - std::vector().swap(FunctionBBs); - std::vector().swap(FunctionsWithBodies); - DeferredFunctionInfo.clear(); - DeferredMetadataInfo.clear(); - MDKindMap.clear(); - - assert(BasicBlockFwdRefs.empty() && "Unresolved blockaddress fwd references"); - BasicBlockFwdRefQueue.clear(); -} - //===----------------------------------------------------------------------===// // Helper functions to implement forward reference resolution, etc. //===----------------------------------------------------------------------===// @@ -5887,8 +5859,6 @@ std::error_code BitcodeReader::findFunctionInStream( // GVMaterializer implementation //===----------------------------------------------------------------------===// -void BitcodeReader::releaseBuffer() { Buffer.release(); } - std::error_code BitcodeReader::materialize(GlobalValue *GV) { Function *F = dyn_cast(GV); // If it's not a function or is already material, ignore the request. @@ -6006,16 +5976,12 @@ std::error_code ModuleSummaryIndexBitcodeReader::error(const Twine &Message) { } ModuleSummaryIndexBitcodeReader::ModuleSummaryIndexBitcodeReader( - MemoryBuffer *Buffer, DiagnosticHandlerFunction DiagnosticHandler, + MemoryBufferRef Buffer, DiagnosticHandlerFunction DiagnosticHandler, bool CheckGlobalValSummaryPresenceOnly) : BitcodeReaderBase(Buffer), DiagnosticHandler(std::move(DiagnosticHandler)), CheckGlobalValSummaryPresenceOnly(CheckGlobalValSummaryPresenceOnly) {} -void ModuleSummaryIndexBitcodeReader::freeState() { Buffer = nullptr; } - -void ModuleSummaryIndexBitcodeReader::releaseBuffer() { Buffer.release(); } - std::pair ModuleSummaryIndexBitcodeReader::getGUIDFromValueId(unsigned ValueId) { auto VGI = ValueIdToCallGraphGUIDMap.find(ValueId); @@ -6219,7 +6185,7 @@ std::error_code ModuleSummaryIndexBitcodeReader::parseModule() { break; if (TheIndex->modulePaths().empty()) // We always seed the index with the module. - TheIndex->addModulePath(Buffer->getBufferIdentifier(), 0); + TheIndex->addModulePath(Buffer.getBufferIdentifier(), 0); if (TheIndex->modulePaths().size() != 1) return error("Don't expect multiple modules defined?"); auto &Hash = TheIndex->modulePaths().begin()->second.second; @@ -6359,7 +6325,7 @@ std::error_code ModuleSummaryIndexBitcodeReader::parseEntireSummary() { // module path string table entry with an empty (0) ID to take // ownership. FS->setModulePath( - TheIndex->addModulePath(Buffer->getBufferIdentifier(), 0)->first()); + TheIndex->addModulePath(Buffer.getBufferIdentifier(), 0)->first()); static int RefListStartIndex = 4; int CallGraphEdgeStartIndex = RefListStartIndex + NumRefs; assert(Record.size() >= RefListStartIndex + NumRefs && @@ -6398,7 +6364,7 @@ std::error_code ModuleSummaryIndexBitcodeReader::parseEntireSummary() { // module path string table entry with an empty (0) ID to take // ownership. AS->setModulePath( - TheIndex->addModulePath(Buffer->getBufferIdentifier(), 0)->first()); + TheIndex->addModulePath(Buffer.getBufferIdentifier(), 0)->first()); GlobalValue::GUID AliaseeGUID = getGUIDFromValueId(AliaseeID).first; auto *AliaseeSummary = TheIndex->getGlobalValueSummary(AliaseeGUID); @@ -6419,7 +6385,7 @@ std::error_code ModuleSummaryIndexBitcodeReader::parseEntireSummary() { std::unique_ptr FS = llvm::make_unique(Flags); FS->setModulePath( - TheIndex->addModulePath(Buffer->getBufferIdentifier(), 0)->first()); + TheIndex->addModulePath(Buffer.getBufferIdentifier(), 0)->first()); for (unsigned I = 2, E = Record.size(); I != E; ++I) { unsigned RefValueId = Record[I]; GlobalValue::GUID RefGUID = getGUIDFromValueId(RefValueId).first; @@ -6677,77 +6643,68 @@ const std::error_category &llvm::BitcodeErrorCategory() { // External interface //===----------------------------------------------------------------------===// +/// \brief Get a lazy one-at-time loading module from bitcode. +/// +/// This isn't always used in a lazy context. In particular, it's also used by +/// \a parseBitcodeFile(). If this is truly lazy, then we need to eagerly pull +/// in forward-referenced functions from block address references. +/// +/// \param[in] MaterializeAll Set to \c true if we should materialize +/// everything. static ErrorOr> -getBitcodeModuleImpl(StringRef Name, BitcodeReader *R, LLVMContext &Context, - bool MaterializeAll, bool ShouldLazyLoadMetadata) { - std::unique_ptr M = llvm::make_unique(Name, Context); - M->setMaterializer(R); +getLazyBitcodeModuleImpl(MemoryBufferRef Buffer, LLVMContext &Context, + bool MaterializeAll, + bool ShouldLazyLoadMetadata = false) { + BitcodeReader *R = new BitcodeReader(Buffer, Context); - auto cleanupOnError = [&](std::error_code EC) { - R->releaseBuffer(); // Never take ownership on error. - return EC; - }; + std::unique_ptr M = + llvm::make_unique(Buffer.getBufferIdentifier(), Context); + M->setMaterializer(R); // Delay parsing Metadata if ShouldLazyLoadMetadata is true. if (std::error_code EC = R->parseBitcodeInto(M.get(), ShouldLazyLoadMetadata)) - return cleanupOnError(EC); + return EC; if (MaterializeAll) { // Read in the entire module, and destroy the BitcodeReader. if (std::error_code EC = M->materializeAll()) - return cleanupOnError(EC); + return EC; } else { // Resolve forward references from blockaddresses. if (std::error_code EC = R->materializeForwardReferencedFunctions()) - return cleanupOnError(EC); + return EC; } return std::move(M); } -/// \brief Get a lazy one-at-time loading module from bitcode. -/// -/// This isn't always used in a lazy context. In particular, it's also used by -/// \a parseBitcodeFile(). If this is truly lazy, then we need to eagerly pull -/// in forward-referenced functions from block address references. -/// -/// \param[in] MaterializeAll Set to \c true if we should materialize -/// everything. -static ErrorOr> -getLazyBitcodeModuleImpl(std::unique_ptr &&Buffer, - LLVMContext &Context, bool MaterializeAll, - bool ShouldLazyLoadMetadata = false) { - BitcodeReader *R = new BitcodeReader(Buffer.get(), Context); - - ErrorOr> Ret = - getBitcodeModuleImpl(Buffer->getBufferIdentifier(), R, Context, - MaterializeAll, ShouldLazyLoadMetadata); - if (!Ret) - return Ret; - - Buffer.release(); // The BitcodeReader owns it now. - return Ret; -} - ErrorOr> -llvm::getLazyBitcodeModule(std::unique_ptr &&Buffer, +llvm::getLazyBitcodeModule(MemoryBufferRef Buffer, LLVMContext &Context, bool ShouldLazyLoadMetadata) { - return getLazyBitcodeModuleImpl(std::move(Buffer), Context, false, + return getLazyBitcodeModuleImpl(Buffer, Context, false, ShouldLazyLoadMetadata); } +ErrorOr> +llvm::getOwningLazyBitcodeModule(std::unique_ptr &&Buffer, + LLVMContext &Context, + bool ShouldLazyLoadMetadata) { + auto MOrErr = getLazyBitcodeModule(*Buffer, Context, ShouldLazyLoadMetadata); + if (MOrErr) + (*MOrErr)->setOwnedMemoryBuffer(std::move(Buffer)); + return MOrErr; +} + ErrorOr> llvm::parseBitcodeFile(MemoryBufferRef Buffer, LLVMContext &Context) { - std::unique_ptr Buf = MemoryBuffer::getMemBuffer(Buffer, false); - return getLazyBitcodeModuleImpl(std::move(Buf), Context, true); + return getLazyBitcodeModuleImpl(Buffer, Context, true); // TODO: Restore the use-lists to the in-memory state when the bitcode was // written. We must defer until the Module has been fully materialized. } std::string llvm::getBitcodeTargetTriple(MemoryBufferRef Buffer, LLVMContext &Context) { - std::unique_ptr Buf = MemoryBuffer::getMemBuffer(Buffer, false); - auto R = llvm::make_unique(Buf.release(), Context); - ErrorOr Triple = R->parseTriple(); + BitcodeReader R(Buffer, Context); + ErrorOr Triple = R.parseTriple(); if (Triple.getError()) return ""; return Triple.get(); @@ -6755,9 +6712,8 @@ std::string llvm::getBitcodeTargetTriple(MemoryBufferRef Buffer, bool llvm::isBitcodeContainingObjCCategory(MemoryBufferRef Buffer, LLVMContext &Context) { - std::unique_ptr Buf = MemoryBuffer::getMemBuffer(Buffer, false); - auto R = llvm::make_unique(Buf.release(), Context); - ErrorOr hasObjCCategory = R->hasObjCCategory(); + BitcodeReader R(Buffer, Context); + ErrorOr hasObjCCategory = R.hasObjCCategory(); if (hasObjCCategory.getError()) return false; return hasObjCCategory.get(); @@ -6765,8 +6721,7 @@ bool llvm::isBitcodeContainingObjCCategory(MemoryBufferRef Buffer, std::string llvm::getBitcodeProducerString(MemoryBufferRef Buffer, LLVMContext &Context) { - std::unique_ptr Buf = MemoryBuffer::getMemBuffer(Buffer, false); - BitcodeReader R(Buf.release(), Context); + BitcodeReader R(Buffer, Context); ErrorOr ProducerString = R.parseIdentificationBlock(); if (ProducerString.getError()) return ""; @@ -6777,20 +6732,13 @@ std::string llvm::getBitcodeProducerString(MemoryBufferRef Buffer, ErrorOr> llvm::getModuleSummaryIndex( MemoryBufferRef Buffer, const DiagnosticHandlerFunction &DiagnosticHandler) { - std::unique_ptr Buf = MemoryBuffer::getMemBuffer(Buffer, false); - ModuleSummaryIndexBitcodeReader R(Buf.get(), DiagnosticHandler); + ModuleSummaryIndexBitcodeReader R(Buffer, DiagnosticHandler); auto Index = llvm::make_unique(); - auto cleanupOnError = [&](std::error_code EC) { - R.releaseBuffer(); // Never take ownership on error. - return EC; - }; - if (std::error_code EC = R.parseSummaryIndexInto(Index.get())) - return cleanupOnError(EC); + return EC; - Buf.release(); // The ModuleSummaryIndexBitcodeReader owns it now. return std::move(Index); } @@ -6798,17 +6746,10 @@ ErrorOr> llvm::getModuleSummaryIndex( bool llvm::hasGlobalValueSummary( MemoryBufferRef Buffer, const DiagnosticHandlerFunction &DiagnosticHandler) { - std::unique_ptr Buf = MemoryBuffer::getMemBuffer(Buffer, false); - ModuleSummaryIndexBitcodeReader R(Buf.get(), DiagnosticHandler, true); + ModuleSummaryIndexBitcodeReader R(Buffer, DiagnosticHandler, true); - auto cleanupOnError = [&](std::error_code EC) { - R.releaseBuffer(); // Never take ownership on error. + if (R.parseSummaryIndexInto(nullptr)) return false; - }; - - if (std::error_code EC = R.parseSummaryIndexInto(nullptr)) - return cleanupOnError(EC); - Buf.release(); // The ModuleSummaryIndexBitcodeReader owns it now. return R.foundGlobalValSummary(); } diff --git a/llvm/lib/IR/Module.cpp b/llvm/lib/IR/Module.cpp index ae81b25b9517..9824a1dfda2f 100644 --- a/llvm/lib/IR/Module.cpp +++ b/llvm/lib/IR/Module.cpp @@ -25,6 +25,7 @@ #include "llvm/IR/LLVMContext.h" #include "llvm/IR/TypeFinder.h" #include "llvm/Support/Dwarf.h" +#include "llvm/Support/MemoryBuffer.h" #include "llvm/Support/Path.h" #include "llvm/Support/RandomNumberGenerator.h" #include @@ -519,6 +520,10 @@ Metadata *Module::getProfileSummary() { return getModuleFlag("ProfileSummary"); } +void Module::setOwnedMemoryBuffer(std::unique_ptr MB) { + OwnedMemoryBuffer = std::move(MB); +} + GlobalVariable *llvm::collectUsedGlobalVariables( const Module &M, SmallPtrSetImpl &Set, bool CompilerUsed) { const char *Name = CompilerUsed ? "llvm.compiler.used" : "llvm.used"; diff --git a/llvm/lib/IRReader/IRReader.cpp b/llvm/lib/IRReader/IRReader.cpp index 9b243fc571d0..1ac4b3c4ad2c 100644 --- a/llvm/lib/IRReader/IRReader.cpp +++ b/llvm/lib/IRReader/IRReader.cpp @@ -34,7 +34,7 @@ getLazyIRModule(std::unique_ptr Buffer, SMDiagnostic &Err, LLVMContext &Context, bool ShouldLazyLoadMetadata) { if (isBitcode((const unsigned char *)Buffer->getBufferStart(), (const unsigned char *)Buffer->getBufferEnd())) { - ErrorOr> ModuleOrErr = getLazyBitcodeModule( + ErrorOr> ModuleOrErr = getOwningLazyBitcodeModule( std::move(Buffer), Context, ShouldLazyLoadMetadata); if (std::error_code EC = ModuleOrErr.getError()) { Err = SMDiagnostic(Buffer->getBufferIdentifier(), SourceMgr::DK_Error, diff --git a/llvm/lib/LTO/LTO.cpp b/llvm/lib/LTO/LTO.cpp index 20da6d9f018c..ed95ac6598c3 100644 --- a/llvm/lib/LTO/LTO.cpp +++ b/llvm/lib/LTO/LTO.cpp @@ -105,9 +105,8 @@ llvm::loadModuleFromBuffer(const MemoryBufferRef &Buffer, LLVMContext &Context, SMDiagnostic Err; ErrorOr> ModuleOrErr(nullptr); if (Lazy) { - ModuleOrErr = - getLazyBitcodeModule(MemoryBuffer::getMemBuffer(Buffer, false), Context, - /* ShouldLazyLoadMetadata */ Lazy); + ModuleOrErr = getLazyBitcodeModule(Buffer, Context, + /* ShouldLazyLoadMetadata */ Lazy); } else { ModuleOrErr = parseBitcodeFile(Buffer, Context); } diff --git a/llvm/lib/LTO/LTOBackend.cpp b/llvm/lib/LTO/LTOBackend.cpp index b00c37f7254c..0885c0b8484b 100644 --- a/llvm/lib/LTO/LTOBackend.cpp +++ b/llvm/lib/LTO/LTOBackend.cpp @@ -352,8 +352,7 @@ Error lto::thinBackend(Config &Conf, unsigned Task, AddStreamFn AddStream, auto ModuleLoader = [&](StringRef Identifier) { assert(Mod.getContext().isODRUniquingDebugTypes() && "ODR Type uniquing should be enabled on the context"); - return std::move(getLazyBitcodeModule(MemoryBuffer::getMemBuffer( - ModuleMap[Identifier], false), + return std::move(getLazyBitcodeModule(ModuleMap[Identifier], Mod.getContext(), /*ShouldLazyLoadMetadata=*/true) .get()); diff --git a/llvm/lib/LTO/LTOModule.cpp b/llvm/lib/LTO/LTOModule.cpp index 5b46feb15b91..96a88241cc9c 100644 --- a/llvm/lib/LTO/LTOModule.cpp +++ b/llvm/lib/LTO/LTOModule.cpp @@ -185,10 +185,8 @@ parseBitcodeFileImpl(MemoryBufferRef Buffer, LLVMContext &Context, } // Parse lazily. - std::unique_ptr LightweightBuf = - MemoryBuffer::getMemBuffer(*MBOrErr, false); - ErrorOr> M = getLazyBitcodeModule( - std::move(LightweightBuf), Context, true /*ShouldLazyLoadMetadata*/); + ErrorOr> M = + getLazyBitcodeModule(*MBOrErr, Context, true /*ShouldLazyLoadMetadata*/); if (std::error_code EC = M.getError()) return EC; return std::move(*M); diff --git a/llvm/lib/Object/IRObjectFile.cpp b/llvm/lib/Object/IRObjectFile.cpp index a757fed81247..8769f8fe54a5 100644 --- a/llvm/lib/Object/IRObjectFile.cpp +++ b/llvm/lib/Object/IRObjectFile.cpp @@ -317,11 +317,8 @@ llvm::object::IRObjectFile::create(MemoryBufferRef Object, if (!BCOrErr) return BCOrErr.getError(); - std::unique_ptr Buff = - MemoryBuffer::getMemBuffer(BCOrErr.get(), false); - ErrorOr> MOrErr = - getLazyBitcodeModule(std::move(Buff), Context, + getLazyBitcodeModule(*BCOrErr, Context, /*ShouldLazyLoadMetadata*/ true); if (std::error_code EC = MOrErr.getError()) return EC; diff --git a/llvm/tools/llvm-dis/llvm-dis.cpp b/llvm/tools/llvm-dis/llvm-dis.cpp index 69533ccac520..c26b68d7abb8 100644 --- a/llvm/tools/llvm-dis/llvm-dis.cpp +++ b/llvm/tools/llvm-dis/llvm-dis.cpp @@ -143,8 +143,8 @@ static Expected> openInputFile(LLVMContext &Context) { if (!MBOrErr) return errorCodeToError(MBOrErr.getError()); ErrorOr> MOrErr = - getLazyBitcodeModule(std::move(*MBOrErr), Context, - /*ShouldLazyLoadMetadata=*/true); + getOwningLazyBitcodeModule(std::move(*MBOrErr), Context, + /*ShouldLazyLoadMetadata=*/true); if (!MOrErr) return errorCodeToError(MOrErr.getError()); if (MaterializeMetadata) diff --git a/llvm/unittests/Bitcode/BitReaderTest.cpp b/llvm/unittests/Bitcode/BitReaderTest.cpp index e4b90cc6855d..b19895e2764d 100644 --- a/llvm/unittests/Bitcode/BitReaderTest.cpp +++ b/llvm/unittests/Bitcode/BitReaderTest.cpp @@ -53,10 +53,8 @@ static std::unique_ptr getLazyModuleFromAssembly(LLVMContext &Context, SmallString<1024> &Mem, const char *Assembly) { writeModuleToBuffer(parseAssembly(Context, Assembly), Mem); - std::unique_ptr Buffer = - MemoryBuffer::getMemBuffer(Mem.str(), "test", false); ErrorOr> ModuleOrErr = - getLazyBitcodeModule(std::move(Buffer), Context); + getLazyBitcodeModule(MemoryBufferRef(Mem.str(), "test"), Context); return std::move(ModuleOrErr.get()); }