From d9445c49ad47c227f5981ad1f8f211dff9aaa9f1 Mon Sep 17 00:00:00 2001 From: Peter Collingbourne Date: Sun, 13 Nov 2016 07:00:17 +0000 Subject: [PATCH] Bitcode: Change module reader functions to return an llvm::Expected. Differential Revision: https://reviews.llvm.org/D26562 llvm-svn: 286752 --- clang/lib/CodeGen/CGOpenMPRuntime.cpp | 3 +- clang/lib/CodeGen/CodeGenAction.cpp | 10 +++-- llvm/include/llvm/Bitcode/BitcodeReader.h | 8 ++-- llvm/include/llvm/Object/IRObjectFile.h | 4 +- llvm/include/llvm/Transforms/IPO/FunctionImport.h | 10 +++-- llvm/lib/Bitcode/Reader/BitReader.cpp | 49 ++++++++-------------- llvm/lib/Bitcode/Reader/BitcodeReader.cpp | 18 ++++---- llvm/lib/CodeGen/ParallelCG.cpp | 2 +- llvm/lib/IRReader/IRReader.cpp | 20 +++++---- llvm/lib/LTO/LTO.cpp | 46 ++++++++------------ llvm/lib/LTO/LTOBackend.cpp | 8 ++-- llvm/lib/LTO/LTOModule.cpp | 14 +++---- llvm/lib/Object/IRObjectFile.cpp | 10 ++--- llvm/lib/Object/SymbolicFile.cpp | 8 ++-- llvm/lib/Transforms/IPO/FunctionImport.cpp | 5 ++- llvm/tools/llvm-dis/llvm-dis.cpp | 6 +-- .../verify-uselistorder/verify-uselistorder.cpp | 6 +-- llvm/unittests/Bitcode/BitReaderTest.cpp | 4 +- 18 files changed, 106 insertions(+), 125 deletions(-) diff --git a/clang/lib/CodeGen/CGOpenMPRuntime.cpp b/clang/lib/CodeGen/CGOpenMPRuntime.cpp index 89c5955..6e663bb 100644 --- a/clang/lib/CodeGen/CGOpenMPRuntime.cpp +++ b/clang/lib/CodeGen/CGOpenMPRuntime.cpp @@ -3012,7 +3012,8 @@ void CGOpenMPRuntime::loadOffloadInfoMetadata() { return; llvm::LLVMContext C; - auto ME = llvm::parseBitcodeFile(Buf.get()->getMemBufferRef(), C); + auto ME = expectedToErrorOrAndEmitErrors( + C, llvm::parseBitcodeFile(Buf.get()->getMemBufferRef(), C)); if (ME.getError()) return; diff --git a/clang/lib/CodeGen/CodeGenAction.cpp b/clang/lib/CodeGen/CodeGenAction.cpp index 8ffe9d4..5d8252bc 100644 --- a/clang/lib/CodeGen/CodeGenAction.cpp +++ b/clang/lib/CodeGen/CodeGenAction.cpp @@ -771,11 +771,13 @@ CodeGenAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) { return nullptr; } - ErrorOr> ModuleOrErr = + Expected> ModuleOrErr = getOwningLazyBitcodeModule(std::move(*BCBuf), *VMContext); - if (std::error_code EC = ModuleOrErr.getError()) { - CI.getDiagnostics().Report(diag::err_cannot_open_file) << LinkBCFile - << EC.message(); + if (!ModuleOrErr) { + handleAllErrors(ModuleOrErr.takeError(), [&](ErrorInfoBase &EIB) { + CI.getDiagnostics().Report(diag::err_cannot_open_file) + << LinkBCFile << EIB.message(); + }); LinkModules.clear(); return nullptr; } diff --git a/llvm/include/llvm/Bitcode/BitcodeReader.h b/llvm/include/llvm/Bitcode/BitcodeReader.h index 765b17d..bbc42f8 100644 --- a/llvm/include/llvm/Bitcode/BitcodeReader.h +++ b/llvm/include/llvm/Bitcode/BitcodeReader.h @@ -43,14 +43,14 @@ 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. - ErrorOr> + Expected> 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> + Expected> getOwningLazyBitcodeModule(std::unique_ptr &&Buffer, LLVMContext &Context, bool ShouldLazyLoadMetadata = false); @@ -70,8 +70,8 @@ namespace llvm { Expected getBitcodeProducerString(MemoryBufferRef Buffer); /// Read the specified bitcode file, returning the module. - ErrorOr> parseBitcodeFile(MemoryBufferRef Buffer, - LLVMContext &Context); + Expected> parseBitcodeFile(MemoryBufferRef Buffer, + LLVMContext &Context); /// Check if the given bitcode buffer contains a summary block. Expected hasGlobalValueSummary(MemoryBufferRef Buffer); diff --git a/llvm/include/llvm/Object/IRObjectFile.h b/llvm/include/llvm/Object/IRObjectFile.h index 9fe011e..4522363 100644 --- a/llvm/include/llvm/Object/IRObjectFile.h +++ b/llvm/include/llvm/Object/IRObjectFile.h @@ -75,8 +75,8 @@ public: static ErrorOr findBitcodeInMemBuffer(MemoryBufferRef Object); - static ErrorOr> create(MemoryBufferRef Object, - LLVMContext &Context); + static Expected> create(MemoryBufferRef Object, + LLVMContext &Context); }; } } diff --git a/llvm/include/llvm/Transforms/IPO/FunctionImport.h b/llvm/include/llvm/Transforms/IPO/FunctionImport.h index 7d9c31e..7867d80 100644 --- a/llvm/include/llvm/Transforms/IPO/FunctionImport.h +++ b/llvm/include/llvm/Transforms/IPO/FunctionImport.h @@ -44,10 +44,12 @@ public: /// The set contains an entry for every global value the module exports. typedef std::unordered_set ExportSetTy; + /// A function of this type is used to load modules referenced by the index. + typedef std::function>(StringRef Identifier)> + ModuleLoaderTy; + /// Create a Function Importer. - FunctionImporter( - const ModuleSummaryIndex &Index, - std::function(StringRef Identifier)> ModuleLoader) + FunctionImporter(const ModuleSummaryIndex &Index, ModuleLoaderTy ModuleLoader) : Index(Index), ModuleLoader(std::move(ModuleLoader)) {} /// Import functions in Module \p M based on the supplied import list. @@ -63,7 +65,7 @@ private: const ModuleSummaryIndex &Index; /// Factory function to load a Module for a given identifier - std::function(StringRef Identifier)> ModuleLoader; + ModuleLoaderTy ModuleLoader; }; /// The function importing pass diff --git a/llvm/lib/Bitcode/Reader/BitReader.cpp b/llvm/lib/Bitcode/Reader/BitReader.cpp index 8aa82bf..6385430 100644 --- a/llvm/lib/Bitcode/Reader/BitReader.cpp +++ b/llvm/lib/Bitcode/Reader/BitReader.cpp @@ -34,13 +34,6 @@ LLVMBool LLVMParseBitcode2(LLVMMemoryBufferRef MemBuf, return LLVMParseBitcodeInContext2(LLVMGetGlobalContext(), MemBuf, OutModule); } -static void diagnosticHandler(const DiagnosticInfo &DI, void *C) { - auto *Message = reinterpret_cast(C); - raw_string_ostream Stream(*Message); - DiagnosticPrinterRawOStream DP(Stream); - DI.print(DP); -} - LLVMBool LLVMParseBitcodeInContext(LLVMContextRef ContextRef, LLVMMemoryBufferRef MemBuf, LLVMModuleRef *OutModule, @@ -48,17 +41,12 @@ LLVMBool LLVMParseBitcodeInContext(LLVMContextRef ContextRef, MemoryBufferRef Buf = unwrap(MemBuf)->getMemBufferRef(); LLVMContext &Ctx = *unwrap(ContextRef); - LLVMContext::DiagnosticHandlerTy OldDiagnosticHandler = - Ctx.getDiagnosticHandler(); - void *OldDiagnosticContext = Ctx.getDiagnosticContext(); - std::string Message; - Ctx.setDiagnosticHandler(diagnosticHandler, &Message, true); - - ErrorOr> ModuleOrErr = parseBitcodeFile(Buf, Ctx); - - Ctx.setDiagnosticHandler(OldDiagnosticHandler, OldDiagnosticContext, true); - - if (ModuleOrErr.getError()) { + Expected> ModuleOrErr = parseBitcodeFile(Buf, Ctx); + if (Error Err = ModuleOrErr.takeError()) { + std::string Message; + handleAllErrors(std::move(Err), [&](ErrorInfoBase &EIB) { + Message = EIB.message(); + }); if (OutMessage) *OutMessage = strdup(Message.c_str()); *OutModule = wrap((Module *)nullptr); @@ -75,7 +63,8 @@ LLVMBool LLVMParseBitcodeInContext2(LLVMContextRef ContextRef, MemoryBufferRef Buf = unwrap(MemBuf)->getMemBufferRef(); LLVMContext &Ctx = *unwrap(ContextRef); - ErrorOr> ModuleOrErr = parseBitcodeFile(Buf, Ctx); + ErrorOr> ModuleOrErr = + expectedToErrorOrAndEmitErrors(Ctx, parseBitcodeFile(Buf, Ctx)); if (ModuleOrErr.getError()) { *OutModule = wrap((Module *)nullptr); return 1; @@ -92,23 +81,19 @@ LLVMBool LLVMGetBitcodeModuleInContext(LLVMContextRef ContextRef, LLVMMemoryBufferRef MemBuf, LLVMModuleRef *OutM, char **OutMessage) { LLVMContext &Ctx = *unwrap(ContextRef); - LLVMContext::DiagnosticHandlerTy OldDiagnosticHandler = - Ctx.getDiagnosticHandler(); - void *OldDiagnosticContext = Ctx.getDiagnosticContext(); - - std::string Message; - Ctx.setDiagnosticHandler(diagnosticHandler, &Message, true); std::unique_ptr Owner(unwrap(MemBuf)); - - ErrorOr> ModuleOrErr = + Expected> ModuleOrErr = getOwningLazyBitcodeModule(std::move(Owner), Ctx); Owner.release(); - Ctx.setDiagnosticHandler(OldDiagnosticHandler, OldDiagnosticContext, true); - if (ModuleOrErr.getError()) { - *OutM = wrap((Module *)nullptr); + if (Error Err = ModuleOrErr.takeError()) { + std::string Message; + handleAllErrors(std::move(Err), [&](ErrorInfoBase &EIB) { + Message = EIB.message(); + }); if (OutMessage) *OutMessage = strdup(Message.c_str()); + *OutM = wrap((Module *)nullptr); return 1; } @@ -123,8 +108,8 @@ LLVMBool LLVMGetBitcodeModuleInContext2(LLVMContextRef ContextRef, LLVMContext &Ctx = *unwrap(ContextRef); std::unique_ptr Owner(unwrap(MemBuf)); - ErrorOr> ModuleOrErr = - getOwningLazyBitcodeModule(std::move(Owner), Ctx); + ErrorOr> ModuleOrErr = expectedToErrorOrAndEmitErrors( + 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 2c81d13..bf1f6a5 100644 --- a/llvm/lib/Bitcode/Reader/BitcodeReader.cpp +++ b/llvm/lib/Bitcode/Reader/BitcodeReader.cpp @@ -6571,13 +6571,13 @@ const std::error_category &llvm::BitcodeErrorCategory() { /// /// \param[in] MaterializeAll Set to \c true if we should materialize /// everything. -static ErrorOr> +static Expected> getLazyBitcodeModuleImpl(MemoryBufferRef Buffer, LLVMContext &Context, bool MaterializeAll, bool ShouldLazyLoadMetadata = false) { Expected StreamOrErr = initStream(Buffer); if (!StreamOrErr) - return errorToErrorCodeAndEmitErrors(Context, StreamOrErr.takeError()); + return StreamOrErr.takeError(); BitcodeReader *R = new BitcodeReader(std::move(*StreamOrErr), Context); @@ -6587,28 +6587,28 @@ getLazyBitcodeModuleImpl(MemoryBufferRef Buffer, LLVMContext &Context, // Delay parsing Metadata if ShouldLazyLoadMetadata is true. if (Error Err = R->parseBitcodeInto(M.get(), ShouldLazyLoadMetadata)) - return errorToErrorCodeAndEmitErrors(Context, std::move(Err)); + return std::move(Err); if (MaterializeAll) { // Read in the entire module, and destroy the BitcodeReader. if (Error Err = M->materializeAll()) - return errorToErrorCodeAndEmitErrors(Context, std::move(Err)); + return std::move(Err); } else { // Resolve forward references from blockaddresses. if (Error Err = R->materializeForwardReferencedFunctions()) - return errorToErrorCodeAndEmitErrors(Context, std::move(Err)); + return std::move(Err); } return std::move(M); } -ErrorOr> +Expected> llvm::getLazyBitcodeModule(MemoryBufferRef Buffer, LLVMContext &Context, bool ShouldLazyLoadMetadata) { return getLazyBitcodeModuleImpl(Buffer, Context, false, ShouldLazyLoadMetadata); } -ErrorOr> +Expected> llvm::getOwningLazyBitcodeModule(std::unique_ptr &&Buffer, LLVMContext &Context, bool ShouldLazyLoadMetadata) { @@ -6618,8 +6618,8 @@ llvm::getOwningLazyBitcodeModule(std::unique_ptr &&Buffer, return MOrErr; } -ErrorOr> llvm::parseBitcodeFile(MemoryBufferRef Buffer, - LLVMContext &Context) { +Expected> llvm::parseBitcodeFile(MemoryBufferRef Buffer, + LLVMContext &Context) { 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. diff --git a/llvm/lib/CodeGen/ParallelCG.cpp b/llvm/lib/CodeGen/ParallelCG.cpp index 19c7297..50dd44f 100644 --- a/llvm/lib/CodeGen/ParallelCG.cpp +++ b/llvm/lib/CodeGen/ParallelCG.cpp @@ -79,7 +79,7 @@ std::unique_ptr llvm::splitCodeGen( CodegenThreadPool.async( [TMFactory, FileType, ThreadOS](const SmallString<0> &BC) { LLVMContext Ctx; - ErrorOr> MOrErr = parseBitcodeFile( + Expected> MOrErr = parseBitcodeFile( MemoryBufferRef(StringRef(BC.data(), BC.size()), ""), Ctx); diff --git a/llvm/lib/IRReader/IRReader.cpp b/llvm/lib/IRReader/IRReader.cpp index c6ad312..cb29a25 100644 --- a/llvm/lib/IRReader/IRReader.cpp +++ b/llvm/lib/IRReader/IRReader.cpp @@ -34,11 +34,13 @@ 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 = getOwningLazyBitcodeModule( + Expected> ModuleOrErr = getOwningLazyBitcodeModule( std::move(Buffer), Context, ShouldLazyLoadMetadata); - if (std::error_code EC = ModuleOrErr.getError()) { - Err = SMDiagnostic(Buffer->getBufferIdentifier(), SourceMgr::DK_Error, - EC.message()); + if (Error E = ModuleOrErr.takeError()) { + handleAllErrors(std::move(E), [&](ErrorInfoBase &EIB) { + Err = SMDiagnostic(Buffer->getBufferIdentifier(), SourceMgr::DK_Error, + EIB.message()); + }); return nullptr; } return std::move(ModuleOrErr.get()); @@ -69,11 +71,13 @@ std::unique_ptr llvm::parseIR(MemoryBufferRef Buffer, SMDiagnostic &Err, TimePassesIsEnabled); if (isBitcode((const unsigned char *)Buffer.getBufferStart(), (const unsigned char *)Buffer.getBufferEnd())) { - ErrorOr> ModuleOrErr = + Expected> ModuleOrErr = parseBitcodeFile(Buffer, Context); - if (std::error_code EC = ModuleOrErr.getError()) { - Err = SMDiagnostic(Buffer.getBufferIdentifier(), SourceMgr::DK_Error, - EC.message()); + if (Error E = ModuleOrErr.takeError()) { + handleAllErrors(std::move(E), [&](ErrorInfoBase &EIB) { + Err = SMDiagnostic(Buffer.getBufferIdentifier(), SourceMgr::DK_Error, + EIB.message()); + }); return nullptr; } return std::move(ModuleOrErr.get()); diff --git a/llvm/lib/LTO/LTO.cpp b/llvm/lib/LTO/LTO.cpp index cf40bfd..f867582 100644 --- a/llvm/lib/LTO/LTO.cpp +++ b/llvm/lib/LTO/LTO.cpp @@ -104,17 +104,16 @@ std::unique_ptr llvm::loadModuleFromBuffer(const MemoryBufferRef &Buffer, LLVMContext &Context, bool Lazy) { SMDiagnostic Err; - ErrorOr> ModuleOrErr(nullptr); - if (Lazy) { - ModuleOrErr = getLazyBitcodeModule(Buffer, Context, - /* ShouldLazyLoadMetadata */ Lazy); - } else { - ModuleOrErr = parseBitcodeFile(Buffer, Context); - } - if (std::error_code EC = ModuleOrErr.getError()) { - Err = SMDiagnostic(Buffer.getBufferIdentifier(), SourceMgr::DK_Error, - EC.message()); - Err.print("ThinLTO", errs()); + Expected> ModuleOrErr = + Lazy ? getLazyBitcodeModule(Buffer, Context, + /* ShouldLazyLoadMetadata */ true) + : parseBitcodeFile(Buffer, Context); + if (!ModuleOrErr) { + handleAllErrors(ModuleOrErr.takeError(), [&](ErrorInfoBase &EIB) { + SMDiagnostic Err = SMDiagnostic(Buffer.getBufferIdentifier(), + SourceMgr::DK_Error, EIB.message()); + Err.print("ThinLTO", errs()); + }); report_fatal_error("Can't load module, abort."); } return std::move(ModuleOrErr.get()); @@ -204,25 +203,13 @@ void llvm::thinLTOInternalizeAndPromoteInIndex( Expected> InputFile::create(MemoryBufferRef Object) { std::unique_ptr File(new InputFile); - std::string Msg; - auto DiagHandler = [](const DiagnosticInfo &DI, void *MsgP) { - auto *Msg = reinterpret_cast(MsgP); - raw_string_ostream OS(*Msg); - DiagnosticPrinterRawOStream DP(OS); - DI.print(DP); - }; - File->Ctx.setDiagnosticHandler(DiagHandler, static_cast(&Msg)); - ErrorOr> IRObj = + Expected> IRObj = IRObjectFile::create(Object, File->Ctx); - if (!Msg.empty()) - return make_error(Msg, inconvertibleErrorCode()); if (!IRObj) - return errorCodeToError(IRObj.getError()); + return IRObj.takeError(); File->Obj = std::move(*IRObj); - File->Ctx.setDiagnosticHandler(nullptr, nullptr); - for (const auto &C : File->Obj->getModule().getComdatSymbolTable()) { auto P = File->ComdatMap.insert(std::make_pair(&C.second, File->Comdats.size())); @@ -346,10 +333,10 @@ Error LTO::addRegularLTO(std::unique_ptr Input, llvm::make_unique("ld-temp.o", RegularLTO.Ctx); RegularLTO.Mover = llvm::make_unique(*RegularLTO.CombinedModule); } - ErrorOr> ObjOrErr = + Expected> ObjOrErr = IRObjectFile::create(Input->Obj->getMemoryBufferRef(), RegularLTO.Ctx); if (!ObjOrErr) - return errorCodeToError(ObjOrErr.getError()); + return ObjOrErr.takeError(); std::unique_ptr Obj = std::move(*ObjOrErr); Module &M = Obj->getModule(); @@ -571,9 +558,10 @@ public: MapVector &ModuleMap) { auto RunThinBackend = [&](AddStreamFn AddStream) { LTOLLVMContext BackendContext(Conf); - ErrorOr> MOrErr = + Expected> MOrErr = parseBitcodeFile(MBRef, BackendContext); - assert(MOrErr && "Unable to load module in thread?"); + if (!MOrErr) + return MOrErr.takeError(); return thinBackend(Conf, Task, AddStream, **MOrErr, CombinedIndex, ImportList, DefinedGlobals, ModuleMap); diff --git a/llvm/lib/LTO/LTOBackend.cpp b/llvm/lib/LTO/LTOBackend.cpp index 739d367..be9009e 100644 --- a/llvm/lib/LTO/LTOBackend.cpp +++ b/llvm/lib/LTO/LTOBackend.cpp @@ -237,7 +237,7 @@ void splitCodeGen(Config &C, TargetMachine *TM, AddStreamFn AddStream, CodegenThreadPool.async( [&](const SmallString<0> &BC, unsigned ThreadId) { LTOLLVMContext Ctx(C); - ErrorOr> MOrErr = parseBitcodeFile( + Expected> MOrErr = parseBitcodeFile( MemoryBufferRef(StringRef(BC.data(), BC.size()), "ld-temp.o"), Ctx); if (!MOrErr) @@ -353,10 +353,8 @@ 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(ModuleMap[Identifier], - Mod.getContext(), - /*ShouldLazyLoadMetadata=*/true) - .get()); + return getLazyBitcodeModule(ModuleMap[Identifier], Mod.getContext(), + /*ShouldLazyLoadMetadata=*/true); }; FunctionImporter Importer(CombinedIndex, ModuleLoader); diff --git a/llvm/lib/LTO/LTOModule.cpp b/llvm/lib/LTO/LTOModule.cpp index ef1c93a..876b43d 100644 --- a/llvm/lib/LTO/LTOModule.cpp +++ b/llvm/lib/LTO/LTOModule.cpp @@ -184,18 +184,14 @@ parseBitcodeFileImpl(MemoryBufferRef Buffer, LLVMContext &Context, if (!ShouldBeLazy) { // Parse the full file. - ErrorOr> M = parseBitcodeFile(*MBOrErr, Context); - if (std::error_code EC = M.getError()) - return EC; - return std::move(*M); + return expectedToErrorOrAndEmitErrors(Context, + parseBitcodeFile(*MBOrErr, Context)); } // Parse lazily. - ErrorOr> M = - getLazyBitcodeModule(*MBOrErr, Context, true /*ShouldLazyLoadMetadata*/); - if (std::error_code EC = M.getError()) - return EC; - return std::move(*M); + return expectedToErrorOrAndEmitErrors( + Context, + getLazyBitcodeModule(*MBOrErr, Context, true /*ShouldLazyLoadMetadata*/)); } ErrorOr> diff --git a/llvm/lib/Object/IRObjectFile.cpp b/llvm/lib/Object/IRObjectFile.cpp index c2b4b28..535ddb9 100644 --- a/llvm/lib/Object/IRObjectFile.cpp +++ b/llvm/lib/Object/IRObjectFile.cpp @@ -310,18 +310,18 @@ ErrorOr IRObjectFile::findBitcodeInMemBuffer(MemoryBufferRef Ob } } -ErrorOr> +Expected> llvm::object::IRObjectFile::create(MemoryBufferRef Object, LLVMContext &Context) { ErrorOr BCOrErr = findBitcodeInMemBuffer(Object); if (!BCOrErr) - return BCOrErr.getError(); + return errorCodeToError(BCOrErr.getError()); - ErrorOr> MOrErr = + Expected> MOrErr = getLazyBitcodeModule(*BCOrErr, Context, /*ShouldLazyLoadMetadata*/ true); - if (std::error_code EC = MOrErr.getError()) - return EC; + if (!MOrErr) + return MOrErr.takeError(); std::unique_ptr &M = MOrErr.get(); return llvm::make_unique(BCOrErr.get(), std::move(M)); diff --git a/llvm/lib/Object/SymbolicFile.cpp b/llvm/lib/Object/SymbolicFile.cpp index 31d41e6..bedca66 100644 --- a/llvm/lib/Object/SymbolicFile.cpp +++ b/llvm/lib/Object/SymbolicFile.cpp @@ -35,7 +35,7 @@ Expected> SymbolicFile::createSymbolicFile( switch (Type) { case sys::fs::file_magic::bitcode: if (Context) - return errorOrToExpected(IRObjectFile::create(Object, *Context)); + return IRObjectFile::create(Object, *Context); LLVM_FALLTHROUGH; case sys::fs::file_magic::unknown: case sys::fs::file_magic::archive: @@ -73,9 +73,9 @@ Expected> SymbolicFile::createSymbolicFile( if (!BCData) return std::move(Obj); - return errorOrToExpected(IRObjectFile::create( - MemoryBufferRef(BCData->getBuffer(), - Object.getBufferIdentifier()), *Context)); + return IRObjectFile::create( + MemoryBufferRef(BCData->getBuffer(), Object.getBufferIdentifier()), + *Context); } } llvm_unreachable("Unexpected Binary File Type"); diff --git a/llvm/lib/Transforms/IPO/FunctionImport.cpp b/llvm/lib/Transforms/IPO/FunctionImport.cpp index 2a351b3..3bebc60 100644 --- a/llvm/lib/Transforms/IPO/FunctionImport.cpp +++ b/llvm/lib/Transforms/IPO/FunctionImport.cpp @@ -624,7 +624,10 @@ Expected FunctionImporter::importFunctions( // Get the module for the import const auto &FunctionsToImportPerModule = ImportList.find(Name); assert(FunctionsToImportPerModule != ImportList.end()); - std::unique_ptr SrcModule = ModuleLoader(Name); + Expected> SrcModuleOrErr = ModuleLoader(Name); + if (!SrcModuleOrErr) + return SrcModuleOrErr.takeError(); + std::unique_ptr SrcModule = std::move(*SrcModuleOrErr); assert(&DestModule.getContext() == &SrcModule->getContext() && "Context mismatch"); diff --git a/llvm/tools/llvm-dis/llvm-dis.cpp b/llvm/tools/llvm-dis/llvm-dis.cpp index 1df9d83..ada6641 100644 --- a/llvm/tools/llvm-dis/llvm-dis.cpp +++ b/llvm/tools/llvm-dis/llvm-dis.cpp @@ -142,9 +142,9 @@ static ExitOnError ExitOnErr; static std::unique_ptr openInputFile(LLVMContext &Context) { std::unique_ptr MB = ExitOnErr(errorOrToExpected(MemoryBuffer::getFileOrSTDIN(InputFilename))); - std::unique_ptr M = ExitOnErr(errorOrToExpected( - getOwningLazyBitcodeModule(std::move(MB), Context, - /*ShouldLazyLoadMetadata=*/true))); + std::unique_ptr M = + ExitOnErr(getOwningLazyBitcodeModule(std::move(MB), Context, + /*ShouldLazyLoadMetadata=*/true)); if (MaterializeMetadata) ExitOnErr(M->materializeMetadata()); else diff --git a/llvm/tools/verify-uselistorder/verify-uselistorder.cpp b/llvm/tools/verify-uselistorder/verify-uselistorder.cpp index 0982c2b..e391f78 100644 --- a/llvm/tools/verify-uselistorder/verify-uselistorder.cpp +++ b/llvm/tools/verify-uselistorder/verify-uselistorder.cpp @@ -160,11 +160,11 @@ std::unique_ptr TempFile::readBitcode(LLVMContext &Context) const { } MemoryBuffer *Buffer = BufferOr.get().get(); - ErrorOr> ModuleOr = + Expected> ModuleOr = parseBitcodeFile(Buffer->getMemBufferRef(), Context); if (!ModuleOr) { - errs() << "verify-uselistorder: error: " << ModuleOr.getError().message() - << "\n"; + logAllUnhandledErrors(ModuleOr.takeError(), errs(), + "verify-uselistorder: error: "); return nullptr; } return std::move(ModuleOr.get()); diff --git a/llvm/unittests/Bitcode/BitReaderTest.cpp b/llvm/unittests/Bitcode/BitReaderTest.cpp index 56bcc72..0003a2b 100644 --- a/llvm/unittests/Bitcode/BitReaderTest.cpp +++ b/llvm/unittests/Bitcode/BitReaderTest.cpp @@ -55,8 +55,10 @@ static std::unique_ptr getLazyModuleFromAssembly(LLVMContext &Context, SmallString<1024> &Mem, const char *Assembly) { writeModuleToBuffer(parseAssembly(Context, Assembly), Mem); - ErrorOr> ModuleOrErr = + Expected> ModuleOrErr = getLazyBitcodeModule(MemoryBufferRef(Mem.str(), "test"), Context); + if (!ModuleOrErr) + report_fatal_error("Could not parse bitcode module"); return std::move(ModuleOrErr.get()); } -- 2.7.4