Update getLazyBitcodeModule to use ErrorOr for error handling.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@199125 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/include/llvm/Bitcode/ReaderWriter.h b/include/llvm/Bitcode/ReaderWriter.h
index 134d49a1229b0a8ea20e826ec343b7d7b1588a29..3a6b205055f096024deb31a3e77a8761b1517a41 100644 (file)
--- a/include/llvm/Bitcode/ReaderWriter.h
+++ b/include/llvm/Bitcode/ReaderWriter.h
@@ -14,6 +14,7 @@
 #ifndef LLVM_BITCODE_READERWRITER_H
 #define LLVM_BITCODE_READERWRITER_H
 
 #ifndef LLVM_BITCODE_READERWRITER_H
 #define LLVM_BITCODE_READERWRITER_H
 

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

 #include <string>
 
 namespace llvm {
 #include <string>
 
 namespace llvm {


@@ -25,14 +26,11 @@ namespace llvm {
   class ModulePass;
   class raw_ostream;
 
   class ModulePass;
   class raw_ostream;
 

-  /// getLazyBitcodeModule - Read the header of the specified bitcode buffer
-  /// and prepare for lazy deserialization of function bodies.  If successful,
-  /// this takes ownership of 'buffer' and returns a non-null pointer.  On
-  /// error, this returns null, *does not* take ownership of Buffer, and fills
-  /// in *ErrMsg with an error description if ErrMsg is non-null.
-  Module *getLazyBitcodeModule(MemoryBuffer *Buffer,
-                               LLVMContext &Context,
-                               std::string *ErrMsg = 0);
+  /// Read the header of the specified bitcode buffer and prepare for lazy
+  /// deserialization of function bodies.  If successful, this takes ownership
+  /// of 'buffer. On error, this *does not* take ownership of Buffer.
+  ErrorOr<Module *> getLazyBitcodeModule(MemoryBuffer *Buffer,
+                                         LLVMContext &Context);

 
   /// getStreamedBitcodeModule - Read the header of the specified stream
   /// and prepare for lazy deserialization and streaming of function bodies.
 
   /// getStreamedBitcodeModule - Read the header of the specified stream
   /// and prepare for lazy deserialization and streaming of function bodies.

diff --git a/lib/Bitcode/Reader/BitReader.cpp b/lib/Bitcode/Reader/BitReader.cpp
index 23630e552541906c0ae1bb9de2756edec351b213..4136cec7c3278b30cff6bcc8185acf8d241c2eba 100644 (file)
--- a/lib/Bitcode/Reader/BitReader.cpp
+++ b/lib/Bitcode/Reader/BitReader.cpp
@@ -51,15 +51,18 @@ LLVMBool LLVMGetBitcodeModuleInContext(LLVMContextRef ContextRef,
                                        LLVMModuleRef *OutM,
                                        char **OutMessage) {
   std::string Message;
                                        LLVMModuleRef *OutM,
                                        char **OutMessage) {
   std::string Message;

+  ErrorOr<Module *> ModuleOrErr =
+      getLazyBitcodeModule(unwrap(MemBuf), *unwrap(ContextRef));

 
 

-  *OutM = wrap(getLazyBitcodeModule(unwrap(MemBuf), *unwrap(ContextRef),
-                                    &Message));
-  if (!*OutM) {
+  if (error_code EC = ModuleOrErr.getError()) {
+    *OutM = wrap((Module *)NULL);

     if (OutMessage)
     if (OutMessage)

-      *OutMessage = strdup(Message.c_str());
+      *OutMessage = strdup(EC.message().c_str());

     return 1;
   }
 
     return 1;
   }
 

+  *OutM = wrap(ModuleOrErr.get());
+

   return 0;
 
 }
   return 0;
 
 }

diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp
index 37515eb6f285457d4f64f6c1515ca45ad672853f..39a0dfa50063b7c2b6830aa5492bfbeffb5dcaa9 100644 (file)
--- a/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -3274,18 +3274,14 @@ const error_category &BitcodeReader::BitcodeErrorCategory() {
 
 /// getLazyBitcodeModule - lazy function-at-a-time loading from a file.
 ///
 
 /// getLazyBitcodeModule - lazy function-at-a-time loading from a file.
 ///

-Module *llvm::getLazyBitcodeModule(MemoryBuffer *Buffer,
-                                   LLVMContext& Context,
-                                   std::string *ErrMsg) {
+ErrorOr<Module *> llvm::getLazyBitcodeModule(MemoryBuffer *Buffer,
+                                             LLVMContext &Context) {

   Module *M = new Module(Buffer->getBufferIdentifier(), Context);
   BitcodeReader *R = new BitcodeReader(Buffer, Context);
   M->setMaterializer(R);
   if (error_code EC = R->ParseBitcodeInto(M)) {
   Module *M = new Module(Buffer->getBufferIdentifier(), Context);
   BitcodeReader *R = new BitcodeReader(Buffer, Context);
   M->setMaterializer(R);
   if (error_code EC = R->ParseBitcodeInto(M)) {

-    if (ErrMsg)
-      *ErrMsg = EC.message();
-

     delete M;  // Also deletes R.
     delete M;  // Also deletes R.

-    return 0;
+    return EC;

   }
   // Have the BitcodeReader dtor delete 'Buffer'.
   R->setBufferOwned(true);
   }
   // Have the BitcodeReader dtor delete 'Buffer'.
   R->setBufferOwned(true);


@@ -3317,8 +3313,13 @@ Module *llvm::getStreamedBitcodeModule(const std::string &name,
 /// If an error occurs, return null and fill in *ErrMsg if non-null.
 Module *llvm::ParseBitcodeFile(MemoryBuffer *Buffer, LLVMContext& Context,
                                std::string *ErrMsg){
 /// If an error occurs, return null and fill in *ErrMsg if non-null.
 Module *llvm::ParseBitcodeFile(MemoryBuffer *Buffer, LLVMContext& Context,
                                std::string *ErrMsg){

-  Module *M = getLazyBitcodeModule(Buffer, Context, ErrMsg);
-  if (!M) return 0;
+  ErrorOr<Module *> ModuleOrErr = getLazyBitcodeModule(Buffer, Context);
+  if (error_code EC = ModuleOrErr.getError()) {
+    if (ErrMsg)
+      *ErrMsg = EC.message();
+    return 0;
+  }
+  Module *M = ModuleOrErr.get();

 
   // Don't let the BitcodeReader dtor delete 'Buffer', regardless of whether
   // there was an error.
 
   // Don't let the BitcodeReader dtor delete 'Buffer', regardless of whether
   // there was an error.

diff --git a/lib/IRReader/IRReader.cpp b/lib/IRReader/IRReader.cpp
index 0e60ca7b32fcca90d054fbf62cb9985b66ae65a0..7356fd005adf8666ff9b78129cec20b435dd947e 100644 (file)
--- a/lib/IRReader/IRReader.cpp
+++ b/lib/IRReader/IRReader.cpp
@@ -36,15 +36,16 @@ Module *llvm::getLazyIRModule(MemoryBuffer *Buffer, SMDiagnostic &Err,
   if (isBitcode((const unsigned char *)Buffer->getBufferStart(),
                 (const unsigned char *)Buffer->getBufferEnd())) {
     std::string ErrMsg;
   if (isBitcode((const unsigned char *)Buffer->getBufferStart(),
                 (const unsigned char *)Buffer->getBufferEnd())) {
     std::string ErrMsg;

-    Module *M = getLazyBitcodeModule(Buffer, Context, &ErrMsg);
-    if (M == 0) {
+    ErrorOr<Module *> ModuleOrErr = getLazyBitcodeModule(Buffer, Context);
+    if (error_code EC = ModuleOrErr.getError()) {

       Err = SMDiagnostic(Buffer->getBufferIdentifier(), SourceMgr::DK_Error,
       Err = SMDiagnostic(Buffer->getBufferIdentifier(), SourceMgr::DK_Error,

-                         ErrMsg);
+                         EC.message());

       // ParseBitcodeFile does not take ownership of the Buffer in the
       // case of an error.
       delete Buffer;
       // ParseBitcodeFile does not take ownership of the Buffer in the
       // case of an error.
       delete Buffer;

+      return NULL;

     }
     }

-    return M;
+    return ModuleOrErr.get();

   }
 
   return ParseAssembly(Buffer, 0, Err, Context);
   }
 
   return ParseAssembly(Buffer, 0, Err, Context);

diff --git a/lib/LTO/LTOModule.cpp b/lib/LTO/LTOModule.cpp
index 49f95a640271fcded30b859da46c3feb2fcb9c45..dcfd59e7526f91c148735e82aa964c636c73058e 100644 (file)
--- a/lib/LTO/LTOModule.cpp
+++ b/lib/LTO/LTOModule.cpp
@@ -135,12 +135,14 @@ LTOModule *LTOModule::makeLTOModule(MemoryBuffer *buffer,
                                     TargetOptions options,
                                     std::string &errMsg) {
   // parse bitcode buffer
                                     TargetOptions options,
                                     std::string &errMsg) {
   // parse bitcode buffer

-  OwningPtr<Module> m(getLazyBitcodeModule(buffer, getGlobalContext(),
-                                           &errMsg));
-  if (!m) {
+  ErrorOr<Module *> ModuleOrErr =
+      getLazyBitcodeModule(buffer, getGlobalContext());
+  if (error_code EC = ModuleOrErr.getError()) {
+    errMsg = EC.message();

     delete buffer;
     return NULL;
   }
     delete buffer;
     return NULL;
   }

+  OwningPtr<Module> m(ModuleOrErr.get());

 
   std::string TripleStr = m->getTargetTriple();
   if (TripleStr.empty())
 
   std::string TripleStr = m->getTargetTriple();
   if (TripleStr.empty())

diff --git a/unittests/Bitcode/BitReaderTest.cpp b/unittests/Bitcode/BitReaderTest.cpp
index 4070de7b7c158c5534b567fec1d460fd06829150..eca88454307396d571dd9fe6ef831b4fcbcc1e0f 100644 (file)
--- a/unittests/Bitcode/BitReaderTest.cpp
+++ b/unittests/Bitcode/BitReaderTest.cpp
@@ -54,8 +54,9 @@ TEST(BitReaderTest, MaterializeFunctionsForBlockAddr) { // PR11677
   SmallString<1024> Mem;
   writeModuleToBuffer(Mem);
   MemoryBuffer *Buffer = MemoryBuffer::getMemBuffer(Mem.str(), "test", false);
   SmallString<1024> Mem;
   writeModuleToBuffer(Mem);
   MemoryBuffer *Buffer = MemoryBuffer::getMemBuffer(Mem.str(), "test", false);

-  std::string errMsg;
-  OwningPtr<Module> m(getLazyBitcodeModule(Buffer, getGlobalContext(), &errMsg));
+  ErrorOr<Module *> ModuleOrErr =
+      getLazyBitcodeModule(Buffer, getGlobalContext());
+  OwningPtr<Module> m(ModuleOrErr.get());

   PassManager passes;
   passes.add(createVerifierPass());
   passes.run(*m);
   PassManager passes;
   passes.add(createVerifierPass());
   passes.run(*m);

diff --git a/unittests/ExecutionEngine/JIT/JITTest.cpp b/unittests/ExecutionEngine/JIT/JITTest.cpp
index 47907e1935ce1bdc073281d7069e94c6b9e7c69d..1c631a8051e87983995ac479f9c280e84cdc07be 100644 (file)
--- a/unittests/ExecutionEngine/JIT/JITTest.cpp
+++ b/unittests/ExecutionEngine/JIT/JITTest.cpp
@@ -631,13 +631,14 @@ ExecutionEngine *getJITFromBitcode(
   // c_str() is null-terminated like MemoryBuffer::getMemBuffer requires.
   MemoryBuffer *BitcodeBuffer =
     MemoryBuffer::getMemBuffer(Bitcode, "Bitcode for test");
   // c_str() is null-terminated like MemoryBuffer::getMemBuffer requires.
   MemoryBuffer *BitcodeBuffer =
     MemoryBuffer::getMemBuffer(Bitcode, "Bitcode for test");

-  std::string errMsg;
-  M = getLazyBitcodeModule(BitcodeBuffer, Context, &errMsg);
-  if (M == NULL) {
-    ADD_FAILURE() << errMsg;
+  ErrorOr<Module*> ModuleOrErr = getLazyBitcodeModule(BitcodeBuffer, Context);
+  if (error_code EC = ModuleOrErr.getError()) {
+    ADD_FAILURE() << EC.message();

     delete BitcodeBuffer;
     return NULL;
   }
     delete BitcodeBuffer;
     return NULL;
   }

+  M = ModuleOrErr.get();
+  std::string errMsg;

   ExecutionEngine *TheJIT = EngineBuilder(M)
     .setEngineKind(EngineKind::JIT)
     .setErrorStr(&errMsg)
   ExecutionEngine *TheJIT = EngineBuilder(M)
     .setEngineKind(EngineKind::JIT)
     .setErrorStr(&errMsg)