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 c362a1774399f98d2a7f84b1dfd5f82f33701b5e..7ef78d73da1750ddef8d34f184cddc7e70d8a483 100644 (file)
--- 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
 
 #ifndef LLVM_ASMPARSER_PARSER_H
 #define LLVM_ASMPARSER_PARSER_H
 

-#include "llvm/ADT/StringRef.h"
-#include <memory>
+#include "llvm/Support/MemoryBuffer.h"

 
 namespace llvm {
 
 class Module;
 
 namespace llvm {
 
 class Module;

-class MemoryBuffer;

 class SMDiagnostic;
 class LLVMContext;
 
 class SMDiagnostic;
 class LLVMContext;
 


@@ -55,8 +53,8 @@ std::unique_ptr<Module> parseAssemblyString(StringRef AsmString,
 /// @param F The MemoryBuffer containing assembly
 /// @param Err Error result info.
 /// @param Context Context in which to allocate globals info.
 /// @param F The MemoryBuffer containing assembly
 /// @param Err Error result info.
 /// @param Context Context in which to allocate globals info.

-std::unique_ptr<Module> parseAssembly(std::unique_ptr<MemoryBuffer> F,
-                                      SMDiagnostic &Err, LLVMContext &Context);
+std::unique_ptr<Module> 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
 
 /// 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<Module> parseAssembly(std::unique_ptr<MemoryBuffer> F,
 /// @param M The module to add data to.
 /// @param Err Error result info.
 /// @return true on error.
 /// @param M The module to add data to.
 /// @param Err Error result info.
 /// @return true on error.

-bool parseAssemblyInto(std::unique_ptr<MemoryBuffer> F, Module &M,
-                       SMDiagnostic &Err);
+bool parseAssemblyInto(MemoryBufferRef F, Module &M, SMDiagnostic &Err);

 
 } // End llvm namespace
 
 
 } // End llvm namespace
 

diff --git a/include/llvm/Bitcode/ReaderWriter.h b/include/llvm/Bitcode/ReaderWriter.h
index 6fb77565979b58865615f8b1c40293eb3eb1b50e..c1eca8d9eafd127506899d9a01b58c3cb5c2faf9 100644 (file)
--- 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"
 #define LLVM_BITCODE_READERWRITER_H
 
 #include "llvm/Support/ErrorOr.h"

+#include "llvm/Support/MemoryBuffer.h"

 #include <string>
 
 namespace llvm {
   class BitstreamWriter;
 #include <string>
 
 namespace llvm {
   class BitstreamWriter;

-  class MemoryBuffer;

   class DataStreamer;
   class LLVMContext;
   class Module;
   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
                                    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.
                                      LLVMContext &Context);
 
   /// Read the specified bitcode file, returning the module.

-  /// This method *never* takes ownership of Buffer.
-  ErrorOr<Module *> parseBitcodeFile(MemoryBuffer *Buffer,
+  ErrorOr<Module *> parseBitcodeFile(MemoryBufferRef Buffer,

                                      LLVMContext &Context);
 
   /// WriteBitcodeToFile - Write the specified module to the specified
                                      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 a1216a174282b4b0b7883d116ac67d50ff2a4da8..4afdbb05f8541fa2e08d56e7140224713c1c19cd 100644 (file)
--- 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;
   /// Make sure the entire Module has been completely read.
   ///
   virtual std::error_code MaterializeModule(Module *M) = 0;

-
-  virtual void releaseBuffer() = 0;

 };
 
 } // End llvm namespace
 };
 
 } // End llvm namespace

diff --git a/include/llvm/IR/Module.h b/include/llvm/IR/Module.h
index 1fdbf5d878b85f006a4937782333b30fedb87ff8..51d43af6365ffbaa28781314a5062748dc2aeedc 100644 (file)
--- 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.
   /// 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
 
 /// @}
 /// @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 c3ccffefa84cb97d85954df0dbd6d3ba706cf9fa..2d9ace0b62a0426ba8bb3d77bab9c6eb133cf3a6 100644 (file)
--- 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
 
 #ifndef LLVM_IRREADER_IRREADER_H
 #define LLVM_IRREADER_IRREADER_H
 

-#include "llvm/ADT/StringRef.h"
-#include <memory>
+#include "llvm/Support/MemoryBuffer.h"

 #include <string>
 
 namespace llvm {
 
 class Module;
 #include <string>
 
 namespace llvm {
 
 class Module;

-class MemoryBuffer;

 class SMDiagnostic;
 class LLVMContext;
 
 class SMDiagnostic;
 class LLVMContext;
 


@@ -36,8 +34,8 @@ std::unique_ptr<Module> 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
 
 /// 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<Module> parseIR(MemoryBuffer *Buffer, SMDiagnostic &Err,
+/// a Module for it.
+std::unique_ptr<Module> parseIR(MemoryBufferRef Buffer, SMDiagnostic &Err,

                                 LLVMContext &Context);
 
 /// If the given file holds a bitcode image, return a Module for it.
                                 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 acea48a8bf8b2db80bc39bc06cfabc3b0eb18617..827d896686dbbb23a3040670f80caecd36047b51 100644 (file)
--- a/include/llvm/Support/MemoryBuffer.h
+++ b/include/llvm/Support/MemoryBuffer.h
@@ -102,6 +102,9 @@ public:
                                     StringRef BufferName = "",
                                     bool RequiresNullTerminator = true);
 
                                     StringRef BufferName = "",
                                     bool RequiresNullTerminator = true);
 

+  static std::unique_ptr<MemoryBuffer>
+  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,
   /// 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 d2384bd978d0adaa38fe708e46635005068bbf8d..08159075ff6400ec2d8d605084522ead135fc09a 100644 (file)
--- a/lib/AsmParser/Parser.cpp
+++ b/lib/AsmParser/Parser.cpp
@@ -21,22 +21,21 @@
 #include <system_error>
 using namespace llvm;
 
 #include <system_error>
 using namespace llvm;
 

-bool llvm::parseAssemblyInto(std::unique_ptr<MemoryBuffer> F, Module &M,
-                             SMDiagnostic &Err) {
+bool llvm::parseAssemblyInto(MemoryBufferRef F, Module &M, SMDiagnostic &Err) {

   SourceMgr SM;
   SourceMgr SM;

-  StringRef Buf = F->getBuffer();
-  SM.AddNewSourceBuffer(std::move(F), SMLoc());
+  std::unique_ptr<MemoryBuffer> 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<Module> llvm::parseAssembly(std::unique_ptr<MemoryBuffer> F,
+std::unique_ptr<Module> llvm::parseAssembly(MemoryBufferRef F,

                                             SMDiagnostic &Err,
                                             LLVMContext &Context) {
   std::unique_ptr<Module> M =
                                             SMDiagnostic &Err,
                                             LLVMContext &Context) {
   std::unique_ptr<Module> M =

-      make_unique<Module>(F->getBufferIdentifier(), Context);
+      make_unique<Module>(F.getBufferIdentifier(), Context);

 
 

-  if (parseAssemblyInto(std::move(F), *M, Err))
+  if (parseAssemblyInto(F, *M, Err))

     return nullptr;
 
   return std::move(M);
     return nullptr;
 
   return std::move(M);


@@ -53,14 +52,12 @@ std::unique_ptr<Module> llvm::parseAssemblyFile(StringRef Filename,
     return nullptr;
   }
 
     return nullptr;
   }
 

-  return parseAssembly(std::move(FileOrErr.get()), Err, Context);
+  return parseAssembly(FileOrErr.get()->getMemBufferRef(), Err, Context);

 }
 
 std::unique_ptr<Module> llvm::parseAssemblyString(StringRef AsmString,
                                                   SMDiagnostic &Err,
                                                   LLVMContext &Context) {
 }
 
 std::unique_ptr<Module> llvm::parseAssemblyString(StringRef AsmString,
                                                   SMDiagnostic &Err,
                                                   LLVMContext &Context) {

-  std::unique_ptr<MemoryBuffer> F(
-      MemoryBuffer::getMemBuffer(AsmString, "<string>"));
-
-  return parseAssembly(std::move(F), Err, Context);
+  MemoryBufferRef F(AsmString, "<string>");
+  return parseAssembly(F, Err, Context);

 }
 }

diff --git a/lib/Bitcode/Reader/BitReader.cpp b/lib/Bitcode/Reader/BitReader.cpp
index b5886c16fa4463a92d6bfc174cdbd3bcb87239c2..e21d29ac374da4c85ed32232ac20c9c373168a02 100644 (file)
--- 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<Module *> ModuleOrErr =
                                    LLVMModuleRef *OutModule,
                                    char **OutMessage) {
   ErrorOr<Module *> 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());
   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 e5dfa723b04df5c610c4a74767ed15bbe7774774..8dc0aa32315ad0bbc8814ecd93e8e1ec4193b63f 100644 (file)
--- 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;
 }
 
   return M;
 }
 

-ErrorOr<Module *> llvm::parseBitcodeFile(MemoryBuffer *Buffer,
+ErrorOr<Module *> llvm::parseBitcodeFile(MemoryBufferRef Buffer,

                                          LLVMContext &Context) {
                                          LLVMContext &Context) {

+  std::unique_ptr<MemoryBuffer> Buf = MemoryBuffer::getMemBuffer(Buffer, false);

   ErrorOr<Module *> ModuleOrErr =
   ErrorOr<Module *> ModuleOrErr =

-      getLazyBitcodeModuleImpl(Buffer, Context, true);
+      getLazyBitcodeModuleImpl(Buf.get(), Context, true);

   if (!ModuleOrErr)
     return ModuleOrErr;
   if (!ModuleOrErr)
     return ModuleOrErr;

+  Buf.release(); // The BitcodeReader owns it now.

   Module *M = ModuleOrErr.get();
   // Read in the entire module, and destroy the BitcodeReader.
   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;
   }
     delete M;
     return EC;
   }


@@ -3583,12 +3585,11 @@ ErrorOr<Module *> llvm::parseBitcodeFile(MemoryBuffer *Buffer,
   return M;
 }
 
   return M;
 }
 

-std::string llvm::getBitcodeTargetTriple(MemoryBuffer *Buffer,
+std::string llvm::getBitcodeTargetTriple(MemoryBufferRef Buffer,

                                          LLVMContext &Context) {
                                          LLVMContext &Context) {

-  BitcodeReader *R = new BitcodeReader(Buffer, Context);
+  std::unique_ptr<MemoryBuffer> Buf = MemoryBuffer::getMemBuffer(Buffer, false);
+  auto R = llvm::make_unique<BitcodeReader>(Buf.get(), Context);

   ErrorOr<std::string> Triple = R->parseTriple();
   ErrorOr<std::string> Triple = R->parseTriple();

-  R->releaseBuffer();
-  delete R;

   if (Triple.getError())
     return "";
   return Triple.get();
   if (Triple.getError())
     return "";
   return Triple.get();

diff --git a/lib/Bitcode/Reader/BitcodeReader.h b/lib/Bitcode/Reader/BitcodeReader.h
index 6d4e0a2dfe90bf47985a104f7e065b7217caa2f3..c9525661ec12967bc0ec006b72683b982a231224 100644 (file)
--- a/lib/Bitcode/Reader/BitcodeReader.h
+++ b/lib/Bitcode/Reader/BitcodeReader.h
@@ -221,7 +221,7 @@ public:
 
   void FreeState();
 
 
   void FreeState();
 

-  void releaseBuffer() override;
+  void releaseBuffer();

 
   bool isMaterializable(const GlobalValue *GV) const override;
   bool isDematerializable(const GlobalValue *GV) const override;
 
   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 f1b1f9a2acc877f094343c5c0bfbbe1919891346..98e4706019c0a1cd61cd8082949fef9d0997d14c 100644 (file)
--- a/lib/IR/Module.cpp
+++ b/lib/IR/Module.cpp
@@ -413,13 +413,10 @@ std::error_code Module::materializeAll() {
   return Materializer->MaterializeModule(this);
 }
 
   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 (std::error_code EC = materializeAll())
     return EC;
 

-  if (ReleaseBuffer)
-    Materializer->releaseBuffer();
-

   Materializer.reset();
   return std::error_code();
 }
   Materializer.reset();
   return std::error_code();
 }

diff --git a/lib/IRReader/IRReader.cpp b/lib/IRReader/IRReader.cpp
index 259b41af24fe4d0cc5e3af638e859a557f6117cd..5c3124821a752d1b03147a28ddf00993b739b201 100644 (file)
--- a/lib/IRReader/IRReader.cpp
+++ b/lib/IRReader/IRReader.cpp
@@ -46,7 +46,7 @@ getLazyIRModule(std::unique_ptr<MemoryBuffer> Buffer, SMDiagnostic &Err,
     return std::unique_ptr<Module>(ModuleOrErr.get());
   }
 
     return std::unique_ptr<Module>(ModuleOrErr.get());
   }
 

-  return parseAssembly(std::move(Buffer), Err, Context);
+  return parseAssembly(Buffer->getMemBufferRef(), Err, Context);

 }
 
 std::unique_ptr<Module> llvm::getLazyIRFileModule(StringRef Filename,
 }
 
 std::unique_ptr<Module> llvm::getLazyIRFileModule(StringRef Filename,


@@ -63,24 +63,22 @@ std::unique_ptr<Module> llvm::getLazyIRFileModule(StringRef Filename,
   return getLazyIRModule(std::move(FileOrErr.get()), Err, Context);
 }
 
   return getLazyIRModule(std::move(FileOrErr.get()), Err, Context);
 }
 

-std::unique_ptr<Module> llvm::parseIR(MemoryBuffer *Buffer, SMDiagnostic &Err,
+std::unique_ptr<Module> llvm::parseIR(MemoryBufferRef Buffer, SMDiagnostic &Err,

                                       LLVMContext &Context) {
   NamedRegionTimer T(TimeIRParsingName, TimeIRParsingGroupName,
                      TimePassesIsEnabled);
                                       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<Module *> ModuleOrErr = parseBitcodeFile(Buffer, Context);
     if (std::error_code EC = ModuleOrErr.getError()) {
     ErrorOr<Module *> 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<Module>(ModuleOrErr.get());
   }
 
                          EC.message());
       return nullptr;
     }
     return std::unique_ptr<Module>(ModuleOrErr.get());
   }
 

-  return parseAssembly(std::unique_ptr<MemoryBuffer>(MemoryBuffer::getMemBuffer(
-                           Buffer->getBuffer(), Buffer->getBufferIdentifier())),
-                       Err, Context);
+  return parseAssembly(Buffer, Err, Context);

 }
 
 std::unique_ptr<Module> llvm::parseIRFile(StringRef Filename, SMDiagnostic &Err,
 }
 
 std::unique_ptr<Module> llvm::parseIRFile(StringRef Filename, SMDiagnostic &Err,


@@ -93,7 +91,7 @@ std::unique_ptr<Module> llvm::parseIRFile(StringRef Filename, SMDiagnostic &Err,
     return nullptr;
   }
 
     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<MemoryBuffer> MB(unwrap(MemBuf));
   SMDiagnostic Diag;
 
   std::unique_ptr<MemoryBuffer> 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) {
 
   if(!*OutM) {
     if (OutMessage) {

diff --git a/lib/LTO/LTOModule.cpp b/lib/LTO/LTOModule.cpp
index f9d270d32071c55d6acdbae4caeb603141e918dd..76b5e197a62e70f0cf7b5903fa9ac47658cb9c60 100644 (file)
--- 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) {
 
 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);
 }
 
   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) {
 LTOModule *LTOModule::makeLTOModule(MemoryBufferRef Buffer,
                                     TargetOptions options,
                                     std::string &errMsg) {

-  StringRef Data = Buffer.getBuffer();
-  StringRef FileName = Buffer.getBufferIdentifier();
-  std::unique_ptr<MemoryBuffer> MemBuf(
-      makeBuffer(Data.begin(), Data.size(), FileName));
-  if (!MemBuf)
-    return nullptr;
-
-  ErrorOr<Module *> MOrErr = parseBitcodeFile(MemBuf.get(), getGlobalContext());
+  ErrorOr<Module *> MOrErr = parseBitcodeFile(Buffer, getGlobalContext());

   if (std::error_code EC = MOrErr.getError()) {
     errMsg = EC.message();
     return nullptr;
   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 2ef359c7f00d132d3bad4db09fe09f6b543ee8b0..964c7ed691d45d68c51a5214f4b03d1979daf2d3 100644 (file)
--- a/lib/Object/IRObjectFile.cpp
+++ b/lib/Object/IRObjectFile.cpp
@@ -268,10 +268,7 @@ ErrorOr<IRObjectFile *>
 llvm::object::IRObjectFile::createIRObjectFile(MemoryBufferRef Object,
                                                LLVMContext &Context) {
 
 llvm::object::IRObjectFile::createIRObjectFile(MemoryBufferRef Object,
                                                LLVMContext &Context) {
 

-  StringRef Data = Object.getBuffer();
-  StringRef FileName = Object.getBufferIdentifier();
-  std::unique_ptr<MemoryBuffer> Buff(
-      MemoryBuffer::getMemBuffer(Data, FileName, false));
+  std::unique_ptr<MemoryBuffer> Buff(MemoryBuffer::getMemBuffer(Object, false));

 
   ErrorOr<Module *> MOrErr = getLazyBitcodeModule(Buff.get(), Context);
   if (std::error_code EC = MOrErr.getError())
 
   ErrorOr<Module *> 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 27edce67361fb483edf3bb05d2b5df82788f8688..9bb6b42466bfac5727900e7926fd1c746225f960 100644 (file)
--- a/lib/Support/MemoryBuffer.cpp
+++ b/lib/Support/MemoryBuffer.cpp
@@ -103,6 +103,12 @@ MemoryBuffer *MemoryBuffer::getMemBuffer(StringRef InputData,
       MemoryBufferMem(InputData, RequiresNullTerminator);
 }
 
       MemoryBufferMem(InputData, RequiresNullTerminator);
 }
 

+std::unique_ptr<MemoryBuffer>
+MemoryBuffer::getMemBuffer(MemoryBufferRef Ref, bool RequiresNullTerminator) {
+  return std::unique_ptr<MemoryBuffer>(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].
 /// 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 c796c389bec16dc3fec6aa131f239d0eab8ab8e7..992a5b0839ddb134c46da0b8ddc56a724697262c 100644 (file)
--- a/tools/verify-uselistorder/verify-uselistorder.cpp
+++ b/tools/verify-uselistorder/verify-uselistorder.cpp
@@ -157,7 +157,8 @@ std::unique_ptr<Module> TempFile::readBitcode(LLVMContext &Context) const {
   }
 
   MemoryBuffer *Buffer = BufferOr.get().get();
   }
 
   MemoryBuffer *Buffer = BufferOr.get().get();

-  ErrorOr<Module *> ModuleOr = parseBitcodeFile(Buffer, Context);
+  ErrorOr<Module *> ModuleOr =
+      parseBitcodeFile(Buffer->getMemBufferRef(), Context);

   if (!ModuleOr) {
     DEBUG(dbgs() << "error: " << ModuleOr.getError().message() << "\n");
     return nullptr;
   if (!ModuleOr) {
     DEBUG(dbgs() << "error: " << ModuleOr.getError().message() << "\n");
     return nullptr;