From: Rafael Espindola Date: Tue, 26 Aug 2014 21:49:01 +0000 (+0000) Subject: Pass a MemoryBufferRef when we can avoid taking ownership. X-Git-Url: http://plrg.eecs.uci.edu/git/?p=oota-llvm.git;a=commitdiff_plain;h=2292996e1a2c10bb62e1ebf8b0e658291bc7724d Pass a MemoryBufferRef when we can avoid taking ownership. The attached patch simplifies a few interfaces that don't need to take ownership of a buffer. For example, both parseAssembly and parseBitcodeFile will parse the entire buffer before returning. There is no need to take ownership. Using a MemoryBufferRef makes it obvious in the type signature that there is no ownership transfer. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@216488 91177308-0d34-0410-b5e6-96231b3b80d8 --- diff --git a/include/llvm/AsmParser/Parser.h b/include/llvm/AsmParser/Parser.h index c362a177439..7ef78d73da1 100644 --- a/include/llvm/AsmParser/Parser.h +++ b/include/llvm/AsmParser/Parser.h @@ -14,13 +14,11 @@ #ifndef LLVM_ASMPARSER_PARSER_H #define LLVM_ASMPARSER_PARSER_H -#include "llvm/ADT/StringRef.h" -#include +#include "llvm/Support/MemoryBuffer.h" namespace llvm { class Module; -class MemoryBuffer; class SMDiagnostic; class LLVMContext; @@ -55,8 +53,8 @@ std::unique_ptr parseAssemblyString(StringRef AsmString, /// @param F The MemoryBuffer containing assembly /// @param Err Error result info. /// @param Context Context in which to allocate globals info. -std::unique_ptr parseAssembly(std::unique_ptr F, - SMDiagnostic &Err, LLVMContext &Context); +std::unique_ptr parseAssembly(MemoryBufferRef F, SMDiagnostic &Err, + LLVMContext &Context); /// This function is the low-level interface to the LLVM Assembly Parser. /// This is kept as an independent function instead of being inlined into @@ -67,8 +65,7 @@ std::unique_ptr parseAssembly(std::unique_ptr F, /// @param M The module to add data to. /// @param Err Error result info. /// @return true on error. -bool parseAssemblyInto(std::unique_ptr F, Module &M, - SMDiagnostic &Err); +bool parseAssemblyInto(MemoryBufferRef F, Module &M, SMDiagnostic &Err); } // End llvm namespace diff --git a/include/llvm/Bitcode/ReaderWriter.h b/include/llvm/Bitcode/ReaderWriter.h index 6fb77565979..c1eca8d9eaf 100644 --- a/include/llvm/Bitcode/ReaderWriter.h +++ b/include/llvm/Bitcode/ReaderWriter.h @@ -15,11 +15,11 @@ #define LLVM_BITCODE_READERWRITER_H #include "llvm/Support/ErrorOr.h" +#include "llvm/Support/MemoryBuffer.h" #include namespace llvm { class BitstreamWriter; - class MemoryBuffer; class DataStreamer; class LLVMContext; class Module; @@ -42,14 +42,13 @@ namespace llvm { std::string *ErrMsg = nullptr); /// Read the header of the specified bitcode buffer and extract just the - /// triple information. If successful, this returns a string and *does not* - /// take ownership of 'buffer'. On error, this returns "". - std::string getBitcodeTargetTriple(MemoryBuffer *Buffer, + /// triple information. If successful, this returns a string. On error, this + /// returns "". + std::string getBitcodeTargetTriple(MemoryBufferRef Buffer, LLVMContext &Context); /// Read the specified bitcode file, returning the module. - /// This method *never* takes ownership of Buffer. - ErrorOr parseBitcodeFile(MemoryBuffer *Buffer, + ErrorOr parseBitcodeFile(MemoryBufferRef Buffer, LLVMContext &Context); /// WriteBitcodeToFile - Write the specified module to the specified diff --git a/include/llvm/IR/GVMaterializer.h b/include/llvm/IR/GVMaterializer.h index a1216a17428..4afdbb05f85 100644 --- a/include/llvm/IR/GVMaterializer.h +++ b/include/llvm/IR/GVMaterializer.h @@ -54,8 +54,6 @@ public: /// Make sure the entire Module has been completely read. /// virtual std::error_code MaterializeModule(Module *M) = 0; - - virtual void releaseBuffer() = 0; }; } // End llvm namespace diff --git a/include/llvm/IR/Module.h b/include/llvm/IR/Module.h index 1fdbf5d878b..51d43af6365 100644 --- a/include/llvm/IR/Module.h +++ b/include/llvm/IR/Module.h @@ -483,7 +483,7 @@ public: /// Make sure all GlobalValues in this Module are fully read and clear the /// Materializer. If the module is corrupt, this DOES NOT clear the old /// Materializer. - std::error_code materializeAllPermanently(bool ReleaseBuffer = false); + std::error_code materializeAllPermanently(); /// @} /// @name Direct access to the globals list, functions list, and symbol table diff --git a/include/llvm/IRReader/IRReader.h b/include/llvm/IRReader/IRReader.h index c3ccffefa84..2d9ace0b62a 100644 --- a/include/llvm/IRReader/IRReader.h +++ b/include/llvm/IRReader/IRReader.h @@ -15,14 +15,12 @@ #ifndef LLVM_IRREADER_IRREADER_H #define LLVM_IRREADER_IRREADER_H -#include "llvm/ADT/StringRef.h" -#include +#include "llvm/Support/MemoryBuffer.h" #include namespace llvm { class Module; -class MemoryBuffer; class SMDiagnostic; class LLVMContext; @@ -36,8 +34,8 @@ std::unique_ptr getLazyIRFileModule(StringRef Filename, /// If the given MemoryBuffer holds a bitcode image, return a Module /// for it. Otherwise, attempt to parse it as LLVM Assembly and return -/// a Module for it. This function *never* takes ownership of Buffer. -std::unique_ptr parseIR(MemoryBuffer *Buffer, SMDiagnostic &Err, +/// a Module for it. +std::unique_ptr parseIR(MemoryBufferRef Buffer, SMDiagnostic &Err, LLVMContext &Context); /// If the given file holds a bitcode image, return a Module for it. diff --git a/include/llvm/Support/MemoryBuffer.h b/include/llvm/Support/MemoryBuffer.h index acea48a8bf8..827d896686d 100644 --- a/include/llvm/Support/MemoryBuffer.h +++ b/include/llvm/Support/MemoryBuffer.h @@ -102,6 +102,9 @@ public: StringRef BufferName = "", bool RequiresNullTerminator = true); + static std::unique_ptr + getMemBuffer(MemoryBufferRef Ref, bool RequiresNullTerminator = true); + /// Open the specified memory range as a MemoryBuffer, copying the contents /// and taking ownership of it. InputData does not have to be null terminated. static MemoryBuffer *getMemBufferCopy(StringRef InputData, diff --git a/lib/AsmParser/Parser.cpp b/lib/AsmParser/Parser.cpp index d2384bd978d..08159075ff6 100644 --- a/lib/AsmParser/Parser.cpp +++ b/lib/AsmParser/Parser.cpp @@ -21,22 +21,21 @@ #include using namespace llvm; -bool llvm::parseAssemblyInto(std::unique_ptr F, Module &M, - SMDiagnostic &Err) { +bool llvm::parseAssemblyInto(MemoryBufferRef F, Module &M, SMDiagnostic &Err) { SourceMgr SM; - StringRef Buf = F->getBuffer(); - SM.AddNewSourceBuffer(std::move(F), SMLoc()); + std::unique_ptr Buf = MemoryBuffer::getMemBuffer(F, false); + SM.AddNewSourceBuffer(std::move(Buf), SMLoc()); - return LLParser(Buf, SM, Err, &M).Run(); + return LLParser(F.getBuffer(), SM, Err, &M).Run(); } -std::unique_ptr llvm::parseAssembly(std::unique_ptr F, +std::unique_ptr llvm::parseAssembly(MemoryBufferRef F, SMDiagnostic &Err, LLVMContext &Context) { std::unique_ptr M = - make_unique(F->getBufferIdentifier(), Context); + make_unique(F.getBufferIdentifier(), Context); - if (parseAssemblyInto(std::move(F), *M, Err)) + if (parseAssemblyInto(F, *M, Err)) return nullptr; return std::move(M); @@ -53,14 +52,12 @@ std::unique_ptr llvm::parseAssemblyFile(StringRef Filename, return nullptr; } - return parseAssembly(std::move(FileOrErr.get()), Err, Context); + return parseAssembly(FileOrErr.get()->getMemBufferRef(), Err, Context); } std::unique_ptr llvm::parseAssemblyString(StringRef AsmString, SMDiagnostic &Err, LLVMContext &Context) { - std::unique_ptr F( - MemoryBuffer::getMemBuffer(AsmString, "")); - - return parseAssembly(std::move(F), Err, Context); + MemoryBufferRef F(AsmString, ""); + return parseAssembly(F, Err, Context); } diff --git a/lib/Bitcode/Reader/BitReader.cpp b/lib/Bitcode/Reader/BitReader.cpp index b5886c16fa4..e21d29ac374 100644 --- a/lib/Bitcode/Reader/BitReader.cpp +++ b/lib/Bitcode/Reader/BitReader.cpp @@ -31,7 +31,7 @@ LLVMBool LLVMParseBitcodeInContext(LLVMContextRef ContextRef, LLVMModuleRef *OutModule, char **OutMessage) { ErrorOr ModuleOrErr = - parseBitcodeFile(unwrap(MemBuf), *unwrap(ContextRef)); + parseBitcodeFile(unwrap(MemBuf)->getMemBufferRef(), *unwrap(ContextRef)); if (std::error_code EC = ModuleOrErr.getError()) { if (OutMessage) *OutMessage = strdup(EC.message().c_str()); diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp index e5dfa723b04..8dc0aa32315 100644 --- a/lib/Bitcode/Reader/BitcodeReader.cpp +++ b/lib/Bitcode/Reader/BitcodeReader.cpp @@ -3564,15 +3564,17 @@ Module *llvm::getStreamedBitcodeModule(const std::string &name, return M; } -ErrorOr llvm::parseBitcodeFile(MemoryBuffer *Buffer, +ErrorOr llvm::parseBitcodeFile(MemoryBufferRef Buffer, LLVMContext &Context) { + std::unique_ptr Buf = MemoryBuffer::getMemBuffer(Buffer, false); ErrorOr ModuleOrErr = - getLazyBitcodeModuleImpl(Buffer, Context, true); + getLazyBitcodeModuleImpl(Buf.get(), Context, true); if (!ModuleOrErr) return ModuleOrErr; + Buf.release(); // The BitcodeReader owns it now. Module *M = ModuleOrErr.get(); // Read in the entire module, and destroy the BitcodeReader. - if (std::error_code EC = M->materializeAllPermanently(true)) { + if (std::error_code EC = M->materializeAllPermanently()) { delete M; return EC; } @@ -3583,12 +3585,11 @@ ErrorOr llvm::parseBitcodeFile(MemoryBuffer *Buffer, return M; } -std::string llvm::getBitcodeTargetTriple(MemoryBuffer *Buffer, +std::string llvm::getBitcodeTargetTriple(MemoryBufferRef Buffer, LLVMContext &Context) { - BitcodeReader *R = new BitcodeReader(Buffer, Context); + std::unique_ptr Buf = MemoryBuffer::getMemBuffer(Buffer, false); + auto R = llvm::make_unique(Buf.get(), Context); ErrorOr Triple = R->parseTriple(); - R->releaseBuffer(); - delete R; if (Triple.getError()) return ""; return Triple.get(); diff --git a/lib/Bitcode/Reader/BitcodeReader.h b/lib/Bitcode/Reader/BitcodeReader.h index 6d4e0a2dfe9..c9525661ec1 100644 --- a/lib/Bitcode/Reader/BitcodeReader.h +++ b/lib/Bitcode/Reader/BitcodeReader.h @@ -221,7 +221,7 @@ public: void FreeState(); - void releaseBuffer() override; + void releaseBuffer(); bool isMaterializable(const GlobalValue *GV) const override; bool isDematerializable(const GlobalValue *GV) const override; diff --git a/lib/IR/Module.cpp b/lib/IR/Module.cpp index f1b1f9a2acc..98e4706019c 100644 --- a/lib/IR/Module.cpp +++ b/lib/IR/Module.cpp @@ -413,13 +413,10 @@ std::error_code Module::materializeAll() { return Materializer->MaterializeModule(this); } -std::error_code Module::materializeAllPermanently(bool ReleaseBuffer) { +std::error_code Module::materializeAllPermanently() { if (std::error_code EC = materializeAll()) return EC; - if (ReleaseBuffer) - Materializer->releaseBuffer(); - Materializer.reset(); return std::error_code(); } diff --git a/lib/IRReader/IRReader.cpp b/lib/IRReader/IRReader.cpp index 259b41af24f..5c3124821a7 100644 --- a/lib/IRReader/IRReader.cpp +++ b/lib/IRReader/IRReader.cpp @@ -46,7 +46,7 @@ getLazyIRModule(std::unique_ptr Buffer, SMDiagnostic &Err, return std::unique_ptr(ModuleOrErr.get()); } - return parseAssembly(std::move(Buffer), Err, Context); + return parseAssembly(Buffer->getMemBufferRef(), Err, Context); } std::unique_ptr llvm::getLazyIRFileModule(StringRef Filename, @@ -63,24 +63,22 @@ std::unique_ptr llvm::getLazyIRFileModule(StringRef Filename, return getLazyIRModule(std::move(FileOrErr.get()), Err, Context); } -std::unique_ptr llvm::parseIR(MemoryBuffer *Buffer, SMDiagnostic &Err, +std::unique_ptr llvm::parseIR(MemoryBufferRef Buffer, SMDiagnostic &Err, LLVMContext &Context) { NamedRegionTimer T(TimeIRParsingName, TimeIRParsingGroupName, TimePassesIsEnabled); - if (isBitcode((const unsigned char *)Buffer->getBufferStart(), - (const unsigned char *)Buffer->getBufferEnd())) { + if (isBitcode((const unsigned char *)Buffer.getBufferStart(), + (const unsigned char *)Buffer.getBufferEnd())) { ErrorOr ModuleOrErr = parseBitcodeFile(Buffer, Context); if (std::error_code EC = ModuleOrErr.getError()) { - Err = SMDiagnostic(Buffer->getBufferIdentifier(), SourceMgr::DK_Error, + Err = SMDiagnostic(Buffer.getBufferIdentifier(), SourceMgr::DK_Error, EC.message()); return nullptr; } return std::unique_ptr(ModuleOrErr.get()); } - return parseAssembly(std::unique_ptr(MemoryBuffer::getMemBuffer( - Buffer->getBuffer(), Buffer->getBufferIdentifier())), - Err, Context); + return parseAssembly(Buffer, Err, Context); } std::unique_ptr llvm::parseIRFile(StringRef Filename, SMDiagnostic &Err, @@ -93,7 +91,7 @@ std::unique_ptr llvm::parseIRFile(StringRef Filename, SMDiagnostic &Err, return nullptr; } - return parseIR(FileOrErr.get().get(), Err, Context); + return parseIR(FileOrErr.get()->getMemBufferRef(), Err, Context); } //===----------------------------------------------------------------------===// @@ -106,7 +104,8 @@ LLVMBool LLVMParseIRInContext(LLVMContextRef ContextRef, SMDiagnostic Diag; std::unique_ptr MB(unwrap(MemBuf)); - *OutM = wrap(parseIR(MB.get(), Diag, *unwrap(ContextRef)).release()); + *OutM = + wrap(parseIR(MB->getMemBufferRef(), Diag, *unwrap(ContextRef)).release()); if(!*OutM) { if (OutMessage) { diff --git a/lib/LTO/LTOModule.cpp b/lib/LTO/LTOModule.cpp index f9d270d3207..76b5e197a62 100644 --- a/lib/LTO/LTOModule.cpp +++ b/lib/LTO/LTOModule.cpp @@ -65,7 +65,8 @@ bool LTOModule::isBitcodeFile(const char *path) { bool LTOModule::isBitcodeForTarget(MemoryBuffer *buffer, StringRef triplePrefix) { - std::string Triple = getBitcodeTargetTriple(buffer, getGlobalContext()); + std::string Triple = + getBitcodeTargetTriple(buffer->getMemBufferRef(), getGlobalContext()); return StringRef(Triple).startswith(triplePrefix); } @@ -112,14 +113,7 @@ LTOModule *LTOModule::createFromBuffer(const void *mem, size_t length, LTOModule *LTOModule::makeLTOModule(MemoryBufferRef Buffer, TargetOptions options, std::string &errMsg) { - StringRef Data = Buffer.getBuffer(); - StringRef FileName = Buffer.getBufferIdentifier(); - std::unique_ptr MemBuf( - makeBuffer(Data.begin(), Data.size(), FileName)); - if (!MemBuf) - return nullptr; - - ErrorOr MOrErr = parseBitcodeFile(MemBuf.get(), getGlobalContext()); + ErrorOr MOrErr = parseBitcodeFile(Buffer, getGlobalContext()); if (std::error_code EC = MOrErr.getError()) { errMsg = EC.message(); return nullptr; diff --git a/lib/Object/IRObjectFile.cpp b/lib/Object/IRObjectFile.cpp index 2ef359c7f00..964c7ed691d 100644 --- a/lib/Object/IRObjectFile.cpp +++ b/lib/Object/IRObjectFile.cpp @@ -268,10 +268,7 @@ ErrorOr llvm::object::IRObjectFile::createIRObjectFile(MemoryBufferRef Object, LLVMContext &Context) { - StringRef Data = Object.getBuffer(); - StringRef FileName = Object.getBufferIdentifier(); - std::unique_ptr Buff( - MemoryBuffer::getMemBuffer(Data, FileName, false)); + std::unique_ptr Buff(MemoryBuffer::getMemBuffer(Object, false)); ErrorOr MOrErr = getLazyBitcodeModule(Buff.get(), Context); if (std::error_code EC = MOrErr.getError()) diff --git a/lib/Support/MemoryBuffer.cpp b/lib/Support/MemoryBuffer.cpp index 27edce67361..9bb6b42466b 100644 --- a/lib/Support/MemoryBuffer.cpp +++ b/lib/Support/MemoryBuffer.cpp @@ -103,6 +103,12 @@ MemoryBuffer *MemoryBuffer::getMemBuffer(StringRef InputData, MemoryBufferMem(InputData, RequiresNullTerminator); } +std::unique_ptr +MemoryBuffer::getMemBuffer(MemoryBufferRef Ref, bool RequiresNullTerminator) { + return std::unique_ptr(getMemBuffer( + Ref.getBuffer(), Ref.getBufferIdentifier(), RequiresNullTerminator)); +} + /// getMemBufferCopy - Open the specified memory range as a MemoryBuffer, /// copying the contents and taking ownership of it. This has no requirements /// on EndPtr[0]. diff --git a/tools/verify-uselistorder/verify-uselistorder.cpp b/tools/verify-uselistorder/verify-uselistorder.cpp index c796c389bec..992a5b0839d 100644 --- a/tools/verify-uselistorder/verify-uselistorder.cpp +++ b/tools/verify-uselistorder/verify-uselistorder.cpp @@ -157,7 +157,8 @@ std::unique_ptr TempFile::readBitcode(LLVMContext &Context) const { } MemoryBuffer *Buffer = BufferOr.get().get(); - ErrorOr ModuleOr = parseBitcodeFile(Buffer, Context); + ErrorOr ModuleOr = + parseBitcodeFile(Buffer->getMemBufferRef(), Context); if (!ModuleOr) { DEBUG(dbgs() << "error: " << ModuleOr.getError().message() << "\n"); return nullptr;