[Error] Add source location to cantFail

[hintonda]

Summary

Add llvm_cantFail macro, a drop in replacement for llvm::cantFail,
that adds source location, similar to assert, for !NDEBUG builds.

Refactor to extract error handling code and place it and new annotated
versions of cantFail that are called by the new macro in a detail
namespace, and change all instances in llvm to use the new macro.

[hintonda]

• Replace macro magic with matching 3-parameter template functions.

[lhames]

Hi Don,

This is a great idea!

I think it would actually be reasonable to have 'cantFail' be the macro though, and move the existing functions (which become an implementation detail) into a detail namespace: We want cantFail to be succinct as part of its value is clarifying flow when we know (from the surrounding context) that errors will not be generated.

[hintonda]

• Replace macro magic with matching 3-parameter template functions.
• Refactor cantFail move into detail namespace. Change macro name to

[hintonda]

• Add back original llvm::cantFail signatures so they'll still be

[hintonda]

Append "_annotated" suffix to detail functions.
Add "llvm_" prefix to macros.
Revert changes to all non-llvm project files.
Update calls in llvm to use new macro.

[hintonda]

@lhames, I think I've applied all your verbal changes, but please let me
know if I missed anything.

Essentially, previous behavior is maintained, but users can opt-in to the
new behavior, adding file and line numbers, by switching to the new macro.
I also updated all of llvm, but excluded other projects for the time being.
Most of them use llvm::cantFail, and could be updated as needed via a
script, e.g., something like this would do it:

find clang -type f \( -name "*.cpp" -o -name "*.h" \) -exec grep -l "cantFail" \{\} \; | xargs sed -i.bak 's/llvm::cantFail/llvm_cantFail/'

llvm/examples/Kaleidoscope/BuildingAJIT/Chapter1/KaleidoscopeJIT.h

 public:
   KaleidoscopeJIT(JITTargetMachineBuilder JTMB, DataLayout DL)
       : ObjectLayer(ES,
                     []() { return std::make_unique<SectionMemoryManager>(); }),
         CompileLayer(ES, ObjectLayer, ConcurrentIRCompiler(std::move(JTMB))),
         DL(std::move(DL)), Mangle(ES, this->DL),
         Ctx(std::make_unique<LLVMContext>()) {
     ES.getMainJITDylib().addGenerator(
-        cantFail(DynamicLibrarySearchGenerator::GetForCurrentProcess(
+        llvm_cantFail(DynamicLibrarySearchGenerator::GetForCurrentProcess(
             DL.getGlobalPrefix())));
   }
 
   static Expected<std::unique_ptr<KaleidoscopeJIT>> Create() {
     auto JTMB = JITTargetMachineBuilder::detectHost();
 
     if (!JTMB)
       return JTMB.takeError();

llvm/examples/Kaleidoscope/BuildingAJIT/Chapter2/KaleidoscopeJIT.h

public:
   KaleidoscopeJIT(JITTargetMachineBuilder JTMB, DataLayout DL)
       : ObjectLayer(ES,
                     []() { return std::make_unique<SectionMemoryManager>(); }),
         CompileLayer(ES, ObjectLayer, ConcurrentIRCompiler(std::move(JTMB))),
         OptimizeLayer(ES, CompileLayer, optimizeModule),
         DL(std::move(DL)), Mangle(ES, this->DL),
         Ctx(std::make_unique<LLVMContext>()) {
     ES.getMainJITDylib().addGenerator(
-        cantFail(DynamicLibrarySearchGenerator::GetForCurrentProcess(
+        llvm_cantFail(DynamicLibrarySearchGenerator::GetForCurrentProcess(
             DL.getGlobalPrefix())));
   }
 
   const DataLayout &getDataLayout() const { return DL; }
 
   LLVMContext &getContext() { return *Ctx.getContext(); }
 
   static Expected<std::unique_ptr<KaleidoscopeJIT>> Create() {

llvm/examples/Kaleidoscope/BuildingAJIT/Chapter3/KaleidoscopeJIT.h

KaleidoscopeJIT()
                           Resolvers[K]};
                     }),
         CompileLayer(AcknowledgeORCv1Deprecation, ObjectLayer,
                      SimpleCompiler(*TM)),
         OptimizeLayer(AcknowledgeORCv1Deprecation, CompileLayer,
                       [this](std::unique_ptr<Module> M) {
                         return optimizeModule(std::move(M));
                       }),
-        CompileCallbackManager(cantFail(orc::createLocalCompileCallbackManager(
+        CompileCallbackManager(llvm_cantFail(orc::createLocalCompileCallbackManager(
             TM->getTargetTriple(), ES, 0))),
         CODLayer(
             AcknowledgeORCv1Deprecation, ES, OptimizeLayer,
             [&](orc::VModuleKey K) { return Resolvers[K]; },
             [&](orc::VModuleKey K, std::shared_ptr<SymbolResolver> R) {
               Resolvers[K] = std::move(R);
             },
             [](Function &F) { return std::set<Function *>({&F}); },
Resolvers[K] = createLegacyLookupResolver(
             return Sym;
           else if (auto Err = Sym.takeError())
             return std::move(Err);
           if (auto SymAddr =
                   RTDyldMemoryManager::getSymbolAddressInProcess(Name))
             return JITSymbol(SymAddr, JITSymbolFlags::Exported);
           return nullptr;
         },
-        [](Error Err) { cantFail(std::move(Err), "lookupFlags failed"); });
+        [](Error Err) { llvm_cantFail(std::move(Err), "lookupFlags failed"); });
 
     // Add the module to the JIT with the new key.
-    cantFail(CODLayer.addModule(K, std::move(M)));
+    llvm_cantFail(CODLayer.addModule(K, std::move(M)));
     return K;
   }
 
   JITSymbol findSymbol(const std::string Name) {
     std::string MangledName;
     raw_string_ostream MangledNameStream(MangledName);
     Mangler::getNameWithPrefix(MangledNameStream, Name, DL);
     return CODLayer.findSymbol(MangledNameStream.str(), true);
   }
 
   void removeModule(VModuleKey K) {
-    cantFail(CODLayer.removeModule(K));
+    llvm_cantFail(CODLayer.removeModule(K));
   }
 
 private:
   std::unique_ptr<Module> optimizeModule(std::unique_ptr<Module> M) {
     // Create a function pass manager.
     auto FPM = std::make_unique<legacy::FunctionPassManager>(M.get());
 
     // Add some optimizations.

llvm/examples/Kaleidoscope/BuildingAJIT/Chapter3/toy.cpp

if (FnAST->codegen()) {
       InitializeModule();
 
       // Search the JIT for the __anon_expr symbol.
       auto ExprSymbol = TheJIT->findSymbol("__anon_expr");
       assert(ExprSymbol && "Function not found");
 
       // Get the symbol's address and cast it to the right type (takes no
       // arguments, returns a double) so we can call it as a native function.
-      double (*FP)() = (double (*)())(intptr_t)cantFail(ExprSymbol.getAddress());
+      double (*FP)() = (double (*)())(intptr_t)llvm_cantFail(ExprSymbol.getAddress());
       fprintf(stderr, "Evaluated to %f\n", FP());
 
       // Delete the anonymous expression module from the JIT.
       TheJIT->removeModule(H);
     }
   } else {
     // Skip token for error recovery.
     getNextToken();

llvm/examples/Kaleidoscope/BuildingAJIT/Chapter4/KaleidoscopeJIT.h

KaleidoscopeJIT()
                 return Sym;
               else if (auto Err = Sym.takeError())
                 return std::move(Err);
               if (auto SymAddr =
                       RTDyldMemoryManager::getSymbolAddressInProcess(Name))
                 return JITSymbol(SymAddr, JITSymbolFlags::Exported);
               return nullptr;
             },
-            [](Error Err) { cantFail(std::move(Err), "lookupFlags failed"); })),
+            [](Error Err) { llvm_cantFail(std::move(Err), "lookupFlags failed"); })),
         TM(EngineBuilder().selectTarget()), DL(TM->createDataLayout()),
         ObjectLayer(AcknowledgeORCv1Deprecation, ES,
                     [this](VModuleKey K) {
                       return LegacyRTDyldObjectLinkingLayer::Resources{
                           std::make_shared<SectionMemoryManager>(), Resolver};
                     }),
         CompileLayer(AcknowledgeORCv1Deprecation, ObjectLayer,
                      SimpleCompiler(*TM)),
         OptimizeLayer(AcknowledgeORCv1Deprecation, CompileLayer,
                       [this](std::unique_ptr<Module> M) {
                         return optimizeModule(std::move(M));
                       }),
-        CompileCallbackMgr(cantFail(orc::createLocalCompileCallbackManager(
+        CompileCallbackMgr(llvm_cantFail(orc::createLocalCompileCallbackManager(
             TM->getTargetTriple(), ES, 0))) {
     auto IndirectStubsMgrBuilder =
       orc::createLocalIndirectStubsManagerBuilder(TM->getTargetTriple());
     IndirectStubsMgr = IndirectStubsMgrBuilder();
     llvm::sys::DynamicLibrary::LoadLibraryPermanently(nullptr);
   }
 
   TargetMachine &getTargetMachine() { return *TM; }
 
   VModuleKey addModule(std::unique_ptr<Module> M) {
     // Add the module to the JIT with a new VModuleKey.
     auto K = ES.allocateVModule();
-    cantFail(OptimizeLayer.addModule(K, std::move(M)));
+    llvm_cantFail(OptimizeLayer.addModule(K, std::move(M)));
     return K;
   }
 
   Error addFunctionAST(std::unique_ptr<FunctionAST> FnAST) {
     // Move ownership of FnAST to a shared pointer - C++11 lambdas don't support
     // capture-by-move, which is be required for unique_ptr.
     auto SharedFnAST = std::shared_ptr<FunctionAST>(std::move(FnAST));
 
Error addFunctionAST(std::unique_ptr<FunctionAST> FnAST) {
     //     The JIT runtime (the resolver block) will use the return address of
     //     this function as the address to continue at once it has reset the
     //     CPU state to what it was immediately before the call.
     auto CompileAction = [this, SharedFnAST]() {
       auto M = irgenAndTakeOwnership(*SharedFnAST, "$impl");
       addModule(std::move(M));
       auto Sym = findSymbol(SharedFnAST->getName() + "$impl");
       assert(Sym && "Couldn't find compiled function?");
-      JITTargetAddress SymAddr = cantFail(Sym.getAddress());
+      JITTargetAddress SymAddr = llvm_cantFail(Sym.getAddress());
       if (auto Err = IndirectStubsMgr->updatePointer(
               mangle(SharedFnAST->getName()), SymAddr)) {
         logAllUnhandledErrors(std::move(Err), errs(),
                               "Error updating function pointer: ");
         exit(1);
       }
 
       return SymAddr;
     };
 
     // Create a CompileCallback using the CompileAction - this is the re-entry
     // point into the compiler for functions that haven't been compiled yet.
-    auto CCAddr = cantFail(
+    auto CCAddr = llvm_cantFail(
         CompileCallbackMgr->getCompileCallback(std::move(CompileAction)));
 
     // Create an indirect stub. This serves as the functions "canonical
     // definition" - an unchanging (constant address) entry point to the
     // function implementation.
     // Initially we point the stub's function-pointer at the compile callback
     // that we just created. When the compile action for the callback is run we
     // will update the stub's function pointer to point at the function
     // implementation that we just implemented.
     if (auto Err = IndirectStubsMgr->createStub(
             mangle(SharedFnAST->getName()), CCAddr, JITSymbolFlags::Exported))
       return Err;
 
     return Error::success();
   }
 
   JITSymbol findSymbol(const std::string Name) {
     return OptimizeLayer.findSymbol(mangle(Name), true);
   }
 
   void removeModule(VModuleKey K) {
-    cantFail(OptimizeLayer.removeModule(K));
+    llvm_cantFail(OptimizeLayer.removeModule(K));
   }
 
 private:
   std::string mangle(const std::string &Name) {
     std::string MangledName;
     raw_string_ostream MangledNameStream(MangledName);
     Mangler::getNameWithPrefix(MangledNameStream, Name, DL);
     return MangledNameStream.str();

llvm/examples/Kaleidoscope/BuildingAJIT/Chapter4/toy.cpp

if (FnAST->codegen()) {
       InitializeModule();
 
       // Search the JIT for the __anon_expr symbol.
       auto ExprSymbol = TheJIT->findSymbol("__anon_expr");
       assert(ExprSymbol && "Function not found");
 
       // Get the symbol's address and cast it to the right type (takes no
       // arguments, returns a double) so we can call it as a native function.
-      double (*FP)() = (double (*)())(intptr_t)cantFail(ExprSymbol.getAddress());
+      double (*FP)() = (double (*)())(intptr_t)llvm_cantFail(ExprSymbol.getAddress());
       fprintf(stderr, "Evaluated to %f\n", FP());
 
       // Delete the anonymous expression module from the JIT.
       TheJIT->removeModule(H);
     }
   } else {
     // Skip token for error recovery.
     getNextToken();

llvm/examples/Kaleidoscope/BuildingAJIT/Chapter5/KaleidoscopeJIT.h

KaleidoscopeJIT(ExecutionSession &ES, MyRemote &Remote)
             ES,
             [this](const std::string &Name) -> JITSymbol {
               if (auto Sym = IndirectStubsMgr->findStub(Name, false))
                 return Sym;
               if (auto Sym = OptimizeLayer.findSymbol(Name, false))
                 return Sym;
               else if (auto Err = Sym.takeError())
                 return std::move(Err);
-              if (auto Addr = cantFail(this->Remote.getSymbolAddress(Name)))
+              if (auto Addr = llvm_cantFail(this->Remote.getSymbolAddress(Name)))
                 return JITSymbol(Addr, JITSymbolFlags::Exported);
               return nullptr;
             },
-            [](Error Err) { cantFail(std::move(Err), "lookupFlags failed"); })),
+            [](Error Err) { llvm_cantFail(std::move(Err), "lookupFlags failed"); })),
         TM(EngineBuilder().selectTarget(Triple(Remote.getTargetTriple()), "",
                                         "", SmallVector<std::string, 0>())),
         DL(TM->createDataLayout()),
         ObjectLayer(AcknowledgeORCv1Deprecation, ES,
                     [this](VModuleKey K) {
                       return LegacyRTDyldObjectLinkingLayer::Resources{
-                          cantFail(this->Remote.createRemoteMemoryManager()),
+                          llvm_cantFail(this->Remote.createRemoteMemoryManager()),
                           Resolver};
                     }),
         CompileLayer(AcknowledgeORCv1Deprecation, ObjectLayer,
                      SimpleCompiler(*TM)),
         OptimizeLayer(AcknowledgeORCv1Deprecation, CompileLayer,
                       [this](std::unique_ptr<Module> M) {
                         return optimizeModule(std::move(M));
                       }),
         Remote(Remote) {
     auto CCMgrOrErr = Remote.enableCompileCallbacks(0);
     if (!CCMgrOrErr) {
       logAllUnhandledErrors(CCMgrOrErr.takeError(), errs(),
                             "Error enabling remote compile callbacks:");
       exit(1);
     }
     CompileCallbackMgr = &*CCMgrOrErr;
-    IndirectStubsMgr = cantFail(Remote.createIndirectStubsManager());
+    IndirectStubsMgr = llvm_cantFail(Remote.createIndirectStubsManager());
     llvm::sys::DynamicLibrary::LoadLibraryPermanently(nullptr);
   }
 
   TargetMachine &getTargetMachine() { return *TM; }
 
   VModuleKey addModule(std::unique_ptr<Module> M) {
     // Add the module with a new VModuleKey.
     auto K = ES.allocateVModule();
-    cantFail(OptimizeLayer.addModule(K, std::move(M)));
+    llvm_cantFail(OptimizeLayer.addModule(K, std::move(M)));
     return K;
   }
 
   Error addFunctionAST(std::unique_ptr<FunctionAST> FnAST) {
     // Move ownership of FnAST to a shared pointer - C++11 lambdas don't support
     // capture-by-move, which is be required for unique_ptr.
     auto SharedFnAST = std::shared_ptr<FunctionAST>(std::move(FnAST));
 
Error addFunctionAST(std::unique_ptr<FunctionAST> FnAST) {
     //     The JIT runtime (the resolver block) will use the return address of
     //     this function as the address to continue at once it has reset the
     //     CPU state to what it was immediately before the call.
     auto CompileAction = [this, SharedFnAST]() {
       auto M = irgenAndTakeOwnership(*SharedFnAST, "$impl");
       addModule(std::move(M));
       auto Sym = findSymbol(SharedFnAST->getName() + "$impl");
       assert(Sym && "Couldn't find compiled function?");
-      JITTargetAddress SymAddr = cantFail(Sym.getAddress());
+      JITTargetAddress SymAddr = llvm_cantFail(Sym.getAddress());
       if (auto Err = IndirectStubsMgr->updatePointer(
               mangle(SharedFnAST->getName()), SymAddr)) {
         logAllUnhandledErrors(std::move(Err), errs(),
                               "Error updating function pointer: ");
         exit(1);
       }
 
       return SymAddr;
     };
 
     // Create a CompileCallback suing the CompileAction - this is the re-entry
     // point into the compiler for functions that haven't been compiled yet.
-    auto CCAddr = cantFail(
+    auto CCAddr = llvm_cantFail(
         CompileCallbackMgr->getCompileCallback(std::move(CompileAction)));
 
     // Create an indirect stub. This serves as the functions "canonical
     // definition" - an unchanging (constant address) entry point to the
     // function implementation.
     // Initially we point the stub's function-pointer at the compile callback
     // that we just created. In the compile action for the callback we will
     // update the stub's function pointer to point at the function
Error executeRemoteExpr(JITTargetAddress ExprAddr) {
     return Remote.callVoidVoid(ExprAddr);
   }
 
   JITSymbol findSymbol(const std::string Name) {
     return OptimizeLayer.findSymbol(mangle(Name), true);
   }
 
   void removeModule(VModuleKey K) {
-    cantFail(OptimizeLayer.removeModule(K));
+    llvm_cantFail(OptimizeLayer.removeModule(K));
   }
 
 private:
   std::string mangle(const std::string &Name) {
     std::string MangledName;
     raw_string_ostream MangledNameStream(MangledName);
     Mangler::getNameWithPrefix(MangledNameStream, Name, DL);
     return MangledNameStream.str();

llvm/examples/Kaleidoscope/BuildingAJIT/Chapter5/toy.cpp

if (FnAST->codegen()) {
       InitializeModule();
 
       // Search the JIT for the __anon_expr symbol.
       auto ExprSymbol = TheJIT->findSymbol("__anon_expr");
       assert(ExprSymbol && "Function not found");
 
       // Get the symbol's address and cast it to the right type (takes no
       // arguments, returns a double) so we can call it as a native function.
-      ExitOnErr(TheJIT->executeRemoteExpr(cantFail(ExprSymbol.getAddress())));
+      ExitOnErr(TheJIT->executeRemoteExpr(llvm_cantFail(ExprSymbol.getAddress())));
 
       // Delete the anonymous expression module from the JIT.
       TheJIT->removeModule(H);
     }
   } else {
     // Skip token for error recovery.
     getNextToken();
   }

llvm/examples/Kaleidoscope/Chapter4/toy.cpp

if (FnAST->codegen()) {
       InitializeModuleAndPassManager();
 
       // Search the JIT for the __anon_expr symbol.
       auto ExprSymbol = TheJIT->findSymbol("__anon_expr");
       assert(ExprSymbol && "Function not found");
 
       // Get the symbol's address and cast it to the right type (takes no
       // arguments, returns a double) so we can call it as a native function.
-      double (*FP)() = (double (*)())(intptr_t)cantFail(ExprSymbol.getAddress());
+      double (*FP)() = (double (*)())(intptr_t)llvm_cantFail(ExprSymbol.getAddress());
       fprintf(stderr, "Evaluated to %f\n", FP());
 
       // Delete the anonymous expression module from the JIT.
       TheJIT->removeModule(H);
     }
   } else {
     // Skip token for error recovery.
     getNextToken();

llvm/examples/Kaleidoscope/Chapter5/toy.cpp

if (FnAST->codegen()) {
       InitializeModuleAndPassManager();
 
       // Search the JIT for the __anon_expr symbol.
       auto ExprSymbol = TheJIT->findSymbol("__anon_expr");
       assert(ExprSymbol && "Function not found");
 
       // Get the symbol's address and cast it to the right type (takes no
       // arguments, returns a double) so we can call it as a native function.
-      double (*FP)() = (double (*)())(intptr_t)cantFail(ExprSymbol.getAddress());
+      double (*FP)() = (double (*)())(intptr_t)llvm_cantFail(ExprSymbol.getAddress());
       fprintf(stderr, "Evaluated to %f\n", FP());
 
       // Delete the anonymous expression module from the JIT.
       TheJIT->removeModule(H);
     }
   } else {
     // Skip token for error recovery.
     getNextToken();

llvm/examples/Kaleidoscope/Chapter6/toy.cpp

if (FnAST->codegen()) {
       InitializeModuleAndPassManager();
 
       // Search the JIT for the __anon_expr symbol.
       auto ExprSymbol = TheJIT->findSymbol("__anon_expr");
       assert(ExprSymbol && "Function not found");
 
       // Get the symbol's address and cast it to the right type (takes no
       // arguments, returns a double) so we can call it as a native function.
-      double (*FP)() = (double (*)())(intptr_t)cantFail(ExprSymbol.getAddress());
+      double (*FP)() = (double (*)())(intptr_t)llvm_cantFail(ExprSymbol.getAddress());
       fprintf(stderr, "Evaluated to %f\n", FP());
 
       // Delete the anonymous expression module from the JIT.
       TheJIT->removeModule(H);
     }
   } else {
     // Skip token for error recovery.
     getNextToken();

llvm/examples/Kaleidoscope/Chapter7/toy.cpp

if (FnAST->codegen()) {
       InitializeModuleAndPassManager();
 
       // Search the JIT for the __anon_expr symbol.
       auto ExprSymbol = TheJIT->findSymbol("__anon_expr");
       assert(ExprSymbol && "Function not found");
 
       // Get the symbol's address and cast it to the right type (takes no
       // arguments, returns a double) so we can call it as a native function.
-      double (*FP)() = (double (*)())(intptr_t)cantFail(ExprSymbol.getAddress());
+      double (*FP)() = (double (*)())(intptr_t)llvm_cantFail(ExprSymbol.getAddress());
       fprintf(stderr, "Evaluated to %f\n", FP());
 
       // Delete the anonymous expression module from the JIT.
       TheJIT->removeModule(H);
     }
   } else {
     // Skip token for error recovery.
     getNextToken();

llvm/examples/Kaleidoscope/include/KaleidoscopeJIT.h

 public:
   using ObjLayerT = LegacyRTDyldObjectLinkingLayer;
   using CompileLayerT = LegacyIRCompileLayer<ObjLayerT, SimpleCompiler>;
 
   KaleidoscopeJIT()
       : Resolver(createLegacyLookupResolver(
             ES,
             [this](const std::string &Name) { return findMangledSymbol(Name); },
-            [](Error Err) { cantFail(std::move(Err), "lookupFlags failed"); })),
+            [](Error Err) { llvm_cantFail(std::move(Err), "lookupFlags failed"); })),
         TM(EngineBuilder().selectTarget()), DL(TM->createDataLayout()),
         ObjectLayer(AcknowledgeORCv1Deprecation, ES,
                     [this](VModuleKey) {
                       return ObjLayerT::Resources{
                           std::make_shared<SectionMemoryManager>(), Resolver};
                     }),
         CompileLayer(AcknowledgeORCv1Deprecation, ObjectLayer,
                      SimpleCompiler(*TM)) {
     llvm::sys::DynamicLibrary::LoadLibraryPermanently(nullptr);
   }
 
   TargetMachine &getTargetMachine() { return *TM; }
 
   VModuleKey addModule(std::unique_ptr<Module> M) {
     auto K = ES.allocateVModule();
-    cantFail(CompileLayer.addModule(K, std::move(M)));
+    llvm_cantFail(CompileLayer.addModule(K, std::move(M)));
     ModuleKeys.push_back(K);
     return K;
   }
 
   void removeModule(VModuleKey K) {
     ModuleKeys.erase(find(ModuleKeys, K));
-    cantFail(CompileLayer.removeModule(K));
+    llvm_cantFail(CompileLayer.removeModule(K));
   }
 
   JITSymbol findSymbol(const std::string Name) {
     return findMangledSymbol(mangle(Name));
   }
 
 private:
   std::string mangle(const std::string &Name) {

llvm/include/llvm/ExecutionEngine/Orc/Core.h

public:
   /// instance. Individual calls to this method may resolve a subset of the
   /// symbols, but all symbols must have been resolved prior to calling emit.
   ///
   /// This method will return an error if any symbols being resolved have been
   /// moved to the error state due to the failure of a dependency. If this
   /// method returns an error then clients should log it and call
   /// failMaterialize. If no dependencies have been registered for the
   /// symbols covered by this MaterializationResponsibiility then this method
-  /// is guaranteed to return Error::success() and can be wrapped with cantFail.
+  /// is guaranteed to return Error::success() and can be wrapped with llvm_cantFail.
   Error notifyResolved(const SymbolMap &Symbols);
 
   /// Notifies the target JITDylib (and any pending queries on that JITDylib)
   /// that all symbols covered by this MaterializationResponsibility instance
   /// have been emitted.
   ///
   /// This method will return an error if any symbols being resolved have been
   /// moved to the error state due to the failure of a dependency. If this
   /// method returns an error then clients should log it and call
   /// failMaterialize. If no dependencies have been registered for the
   /// symbols covered by this MaterializationResponsibiility then this method
-  /// is guaranteed to return Error::success() and can be wrapped with cantFail.
+  /// is guaranteed to return Error::success() and can be wrapped with llvm_cantFail.
   Error notifyEmitted();
 
   /// Adds new symbols to the JITDylib and this responsibility instance.
   ///        JITDylib entries start out in the materializing state.
   ///
   ///   This method can be used by materialization units that want to add
   /// additional symbols at materialization time (e.g. stubs, compile
   /// callbacks, metadata).

llvm/include/llvm/ExecutionEngine/Orc/RPC/RPCUtils.h

Error appendCallAsync(HandlerT Handler, const ArgTs &... Args) {
 
     // Look up the function ID.
     FunctionIdT FnId;
     if (auto FnIdOrErr = getRemoteFunctionId<Func>(LazyAutoNegotiation, false))
       FnId = *FnIdOrErr;
     else {
       // Negotiation failed. Notify the handler then return the negotiate-failed
       // error.
-      cantFail(Handler(make_error<ResponseAbandoned>()));
+      llvm_cantFail(Handler(make_error<ResponseAbandoned>()));
       return FnIdOrErr.takeError();
     }
 
     SequenceNumberT SeqNo; // initialized in locked scope below.
     {
       // Lock the pending responses map and sequence number manager.
       std::lock_guard<std::mutex> Lock(ResponsesMutex);
 

llvm/include/llvm/MC/MCDwarf.h

if (!Header.RootFile.Name.empty())
       return;
     Header.setRootFile(Directory, FileName, Checksum, Source);
   }
 
   unsigned getFile(StringRef Directory, StringRef FileName,
                    Optional<MD5::MD5Result> Checksum, uint16_t DwarfVersion,
                    Optional<StringRef> Source) {
     HasSplitLineTable = true;
-    return cantFail(Header.tryGetFile(Directory, FileName, Checksum, Source,
+    return llvm_cantFail(Header.tryGetFile(Directory, FileName, Checksum, Source,
                                       DwarfVersion));
   }
 
   void Emit(MCStreamer &MCOS, MCDwarfLineTableParams Params,
             MCSection *Section) const;
 };
 
 class MCDwarfLineTable {
public:
   Expected<unsigned> tryGetFile(StringRef &Directory, StringRef &FileName,
                                 Optional<MD5::MD5Result> Checksum,
                                 Optional<StringRef> Source,
                                 uint16_t DwarfVersion,
                                 unsigned FileNumber = 0);
   unsigned getFile(StringRef &Directory, StringRef &FileName,
                    Optional<MD5::MD5Result> Checksum, Optional<StringRef> Source,
                    uint16_t DwarfVersion, unsigned FileNumber = 0) {
-    return cantFail(tryGetFile(Directory, FileName, Checksum, Source,
+    return llvm_cantFail(tryGetFile(Directory, FileName, Checksum, Source,
                                DwarfVersion, FileNumber));
   }
 
   void setRootFile(StringRef Directory, StringRef FileName,
                    Optional<MD5::MD5Result> Checksum, Optional<StringRef> Source) {
     Header.CompilationDir = Directory;
     Header.RootFile.Name = FileName;
     Header.RootFile.DirIndex = 0;

llvm/include/llvm/MC/MCStreamer.h

public:
 
   /// Associate a filename with a specified logical file number.  This
   /// implements the DWARF2 '.file 4 "foo.c"' assembler directive.
   unsigned EmitDwarfFileDirective(unsigned FileNo, StringRef Directory,
                                   StringRef Filename,
                                   Optional<MD5::MD5Result> Checksum = None,
                                   Optional<StringRef> Source = None,
                                   unsigned CUID = 0) {
-    return cantFail(
+    return llvm_cantFail(
         tryEmitDwarfFileDirective(FileNo, Directory, Filename, Checksum,
                                   Source, CUID));
   }
 
   /// Associate a filename with a specified logical file number.
   /// Also associate a directory, optional checksum, and optional source
   /// text with the logical file.  This implements the DWARF2
   /// '.file 4 "dir/foo.c"' assembler directive, and the DWARF5

llvm/include/llvm/Support/Error.h

 #endif
 };
 
 /// Report a serious error, calling any installed error handler. See
 /// ErrorHandling.h.
 LLVM_ATTRIBUTE_NORETURN void report_fatal_error(Error Err,
                                                 bool gen_crash_diag = true);
 
+namespace detail {
+
+inline LLVM_ATTRIBUTE_NORETURN void handleError(Error Err, const char *Msg,
+                                                const char *file = nullptr,
+                                                unsigned line = 0) {
+  if (!Msg)
+    Msg = "Failure value returned from cantFail wrapped call";
+#ifndef NDEBUG
+  std::string Str;
+  raw_string_ostream OS(Str);
+  OS << Err << "\n" << Msg;
+  if (file)
+    OS << " at " << file << ":" << line;
+  Msg = OS.str().c_str();
+#endif
+  llvm_unreachable(Msg);
+}
+
+inline void cantFail_annotated(const char *file, unsigned line, Error Err,
+                               const char *Msg = nullptr) {
+  if (Err)
+    handleError(std::move(Err), Msg, file, line);
+}
+
+template <typename T>
+T cantFail_annotated(const char *file, unsigned line, Expected<T> ValOrErr,
+                     const char *Msg = nullptr) {
+  if (ValOrErr)
+    return std::move(*ValOrErr);
+  handleError(std::move(ValOrErr.takeError()), Msg, file, line);
+}
+
+template <typename T>
+T &cantFail_annotated(const char *file, unsigned line, Expected<T &> ValOrErr,
+                      const char *Msg = nullptr) {
+  if (ValOrErr)
+    return *ValOrErr;
+  handleError(std::move(ValOrErr.takeError()), Msg, file, line);
+}
+
+} // namespace detail
+
 /// Report a fatal error if Err is a failure value.
 ///
 /// This function can be used to wrap calls to fallible functions ONLY when it
 /// is known that the Error will always be a success value. E.g.
 ///
 ///   @code{.cpp}
 ///   // foo only attempts the fallible operation if DoFallibleOperation is
 ///   // true. If DoFallibleOperation is false then foo always returns
 ///   // Error::success().
 ///   Error foo(bool DoFallibleOperation);
 ///
 ///   cantFail(foo(false));
 ///   @endcode
 inline void cantFail(Error Err, const char *Msg = nullptr) {
-  if (Err) {
-    if (!Msg)
-      Msg = "Failure value returned from cantFail wrapped call";
-#ifndef NDEBUG
-    std::string Str;
-    raw_string_ostream OS(Str);
-    OS << Msg << "\n" << Err;
-    Msg = OS.str().c_str();
-#endif
-    llvm_unreachable(Msg);
-  }
+  if (Err)
+    detail::handleError(std::move(Err), Msg);
 }
 
 /// Report a fatal error if ValOrErr is a failure value, otherwise unwraps and
 /// returns the contained value.
 ///
 /// This function can be used to wrap calls to fallible functions ONLY when it
 /// is known that the Error will always be a success value. E.g.
 ///
 ///   @code{.cpp}
 ///   // foo only attempts the fallible operation if DoFallibleOperation is
 ///   // true. If DoFallibleOperation is false then foo always returns an int.
 ///   Expected<int> foo(bool DoFallibleOperation);
 ///
 ///   int X = cantFail(foo(false));
 ///   @endcode
 template <typename T>
 T cantFail(Expected<T> ValOrErr, const char *Msg = nullptr) {
   if (ValOrErr)
     return std::move(*ValOrErr);
-  else {
-    if (!Msg)
-      Msg = "Failure value returned from cantFail wrapped call";
-#ifndef NDEBUG
-    std::string Str;
-    raw_string_ostream OS(Str);
-    auto E = ValOrErr.takeError();
-    OS << Msg << "\n" << E;
-    Msg = OS.str().c_str();
-#endif
-    llvm_unreachable(Msg);
-  }
+  detail::handleError(std::move(ValOrErr.takeError()), Msg);
 }
 
 /// Report a fatal error if ValOrErr is a failure value, otherwise unwraps and
 /// returns the contained reference.
 ///
 /// This function can be used to wrap calls to fallible functions ONLY when it
 /// is known that the Error will always be a success value. E.g.
 ///
 ///   @code{.cpp}
 ///   // foo only attempts the fallible operation if DoFallibleOperation is
 ///   // true. If DoFallibleOperation is false then foo always returns a Bar&.
 ///   Expected<Bar&> foo(bool DoFallibleOperation);
 ///
 ///   Bar &X = cantFail(foo(false));
 ///   @endcode
 template <typename T>
-T& cantFail(Expected<T&> ValOrErr, const char *Msg = nullptr) {
+T &cantFail(Expected<T &> ValOrErr, const char *Msg = nullptr) {
   if (ValOrErr)
     return *ValOrErr;
-  else {
-    if (!Msg)
-      Msg = "Failure value returned from cantFail wrapped call";
+  detail::handleError(std::move(ValOrErr.takeError()), Msg);
+}
+
 #ifndef NDEBUG
-    std::string Str;
-    raw_string_ostream OS(Str);
-    auto E = ValOrErr.takeError();
-    OS << Msg << "\n" << E;
-    Msg = OS.str().c_str();
+#define llvm_cantFail(...)                                                     \
+  ::llvm::detail::cantFail_annotated(__FILE__, __LINE__, __VA_ARGS__)
+#else
+#define llvm_cantFail(...)                                                     \
+  ::llvm::detail::cantFail_annotated(nullptr, 0, __VA_ARGS__)
 #endif
-    llvm_unreachable(Msg);
-  }
-}
 
 /// Helper for testing applicability of, and applying, handlers for
 /// ErrorInfo types.
 template <typename HandlerT>
 class ErrorHandlerTraits
     : public ErrorHandlerTraits<decltype(
           &std::remove_reference<HandlerT>::type::operator())> {};
 
Error handleErrors(Error E, HandlerTs &&... Hs) {
   return handleErrorImpl(std::move(Payload), std::forward<HandlerTs>(Hs)...);
 }
 
 /// Behaves the same as handleErrors, except that by contract all errors
 /// *must* be handled by the given handlers (i.e. there must be no remaining
 /// errors after running the handlers, or llvm_unreachable is called).
 template <typename... HandlerTs>
 void handleAllErrors(Error E, HandlerTs &&... Handlers) {
-  cantFail(handleErrors(std::move(E), std::forward<HandlerTs>(Handlers)...));
+  llvm_cantFail(handleErrors(std::move(E), std::forward<HandlerTs>(Handlers)...));
 }
 
 /// Check that E is a non-error, then drop it.
 /// If E is an error, llvm_unreachable will be called.
 inline void handleAllErrors(Error E) {
-  cantFail(std::move(E));
+  llvm_cantFail(std::move(E));
 }
 
 /// Handle any errors (if present) in an Expected<T>, then try a recovery path.
 ///
 /// If the incoming value is a success value it is returned unmodified. If it
 /// is a failure value then it the contained error is passed to handleErrors.
 /// If handleErrors is able to handle the error then the RecoveryPath functor
 /// is called to supply the final result. If handleErrors is not able to

llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

if (const GlobalVariable *GV =
     OS.AddComment("Type");
     OS.EmitIntValue(getTypeIndex(DIGV->getType()).getIndex(), 4);
     OS.AddComment("Value");
 
     // Encoded integers shouldn't need more than 10 bytes.
     uint8_t data[10];
     BinaryStreamWriter Writer(data, llvm::support::endianness::little);
     CodeViewRecordIO IO(Writer);
-    cantFail(IO.mapEncodedInteger(Val));
+    llvm_cantFail(IO.mapEncodedInteger(Val));
     StringRef SRef((char *)data, Writer.getOffset());
     OS.EmitBinaryData(SRef);
 
     OS.AddComment("Name");
     const DIScope *Scope = DIGV->getScope();
     // For static data members, get the scope from the declaration.
     if (const auto *MemberDecl = dyn_cast_or_null<DIDerivedType>(
             DIGV->getRawStaticDataMemberDeclaration()))
       Scope = MemberDecl->getScope();
     emitNullTerminatedSymbolName(OS,
                                  getFullyQualifiedName(Scope, DIGV->getName()));
     endSymbolRecord(SConstantEnd);
   }
 }

llvm/lib/DebugInfo/CodeView/ContinuationRecordBuilder.cpp

 static void addPadding(BinaryStreamWriter &Writer) {
   uint32_t Align = Writer.getOffset() % 4;
   if (Align == 0)
     return;
 
   int PaddingBytes = 4 - Align;
   while (PaddingBytes > 0) {
     uint8_t Pad = static_cast<uint8_t>(LF_PAD0 + PaddingBytes);
-    cantFail(Writer.writeInteger(Pad));
+    llvm_cantFail(Writer.writeInteger(Pad));
     --PaddingBytes;
   }
 }
 
 static SegmentInjection InjectFieldList(TypeLeafKind::LF_FIELDLIST);
 static SegmentInjection InjectMethodOverloadList(TypeLeafKind::LF_METHODLIST);
 
 static constexpr uint32_t ContinuationLength = sizeof(ContinuationRecord);
const SegmentInjection *FLI =
           : &InjectMethodOverloadList;
   const uint8_t *FLIB = reinterpret_cast<const uint8_t *>(FLI);
   InjectedSegmentBytes =
       ArrayRef<uint8_t>(FLIB, FLIB + sizeof(SegmentInjection));
 
   // Seed the first record with an appropriate record prefix.
   RecordPrefix Prefix(getTypeLeafKind(RecordKind));
   CVType Type(&Prefix, sizeof(Prefix));
-  cantFail(Mapping.visitTypeBegin(Type));
+  llvm_cantFail(Mapping.visitTypeBegin(Type));
 
-  cantFail(SegmentWriter.writeObject(Prefix));
+  llvm_cantFail(SegmentWriter.writeObject(Prefix));
 }
 
 template <typename RecordType>
 void ContinuationRecordBuilder::writeMemberType(RecordType &Record) {
   assert(Kind.hasValue());
 
   uint32_t OriginalOffset = SegmentWriter.getOffset();
   CVMemberRecord CVMR;
   CVMR.Kind = static_cast<TypeLeafKind>(Record.getKind());
 
   // Member Records aren't length-prefixed, they only have a 2-byte TypeLeafKind
   // at the beginning.
-  cantFail(SegmentWriter.writeEnum(CVMR.Kind));
+  llvm_cantFail(SegmentWriter.writeEnum(CVMR.Kind));
 
   // Let the Mapping handle the rest.
-  cantFail(Mapping.visitMemberBegin(CVMR));
-  cantFail(Mapping.visitKnownMember(CVMR, Record));
-  cantFail(Mapping.visitMemberEnd(CVMR));
+  llvm_cantFail(Mapping.visitMemberBegin(CVMR));
+  llvm_cantFail(Mapping.visitKnownMember(CVMR, Record));
+  llvm_cantFail(Mapping.visitMemberEnd(CVMR));
 
   // Make sure it's padded to 4 bytes.
   addPadding(SegmentWriter);
   assert(getCurrentSegmentLength() % 4 == 0);
 
   // The maximum length of a single segment is 64KB minus the size to insert a
   // continuation.  So if we are over that, inject a continuation between the
   // previous member and the member that was just written, then end the previous
CVType ContinuationRecordBuilder::createSegmentRecord(
   }
 
   return CVType(Data);
 }
 
 std::vector<CVType> ContinuationRecordBuilder::end(TypeIndex Index) {
   RecordPrefix Prefix(getTypeLeafKind(*Kind));
   CVType Type(&Prefix, sizeof(Prefix));
-  cantFail(Mapping.visitTypeEnd(Type));
+  llvm_cantFail(Mapping.visitTypeEnd(Type));
 
   // We're now done, and we have a series of segments each beginning at an
   // offset specified in the SegmentOffsets array.  We now need to iterate
   // over each segment and post-process them in the following two ways:
   // 1) Each top-level record has a RecordPrefix whose type is either
   //    LF_FIELDLIST or LF_METHODLIST, but the Length field is still 0.
   //    Those should all be set to the correct length now.
   // 2) Each continuation record has an IndexRef field which we set to the

llvm/lib/DebugInfo/CodeView/RecordName.cpp

 StringRef llvm::codeview::getSymbolName(CVSymbol Sym) {
   if (Sym.kind() == SymbolKind::S_CONSTANT) {
     // S_CONSTANT is preceded by an APSInt, which has a variable length.  So we
     // have to do a full deserialization.
     BinaryStreamReader Reader(Sym.content(), llvm::support::little);
     // The container doesn't matter for single records.
     SymbolRecordMapping Mapping(Reader, CodeViewContainer::ObjectFile);
     ConstantSym Const(SymbolKind::S_CONSTANT);
-    cantFail(Mapping.visitSymbolBegin(Sym));
-    cantFail(Mapping.visitKnownRecord(Sym, Const));
-    cantFail(Mapping.visitSymbolEnd(Sym));
+    llvm_cantFail(Mapping.visitSymbolBegin(Sym));
+    llvm_cantFail(Mapping.visitKnownRecord(Sym, Const));
+    llvm_cantFail(Mapping.visitSymbolEnd(Sym));
     return Const.Name;
   }
 
   int Offset = getSymbolNameOffset(Sym);
   if (Offset == -1)
     return StringRef();
 
   StringRef StringData = toStringRef(Sym.content()).drop_front(Offset);
   return StringData.split('\0').first;
 }

llvm/lib/DebugInfo/CodeView/SimpleTypeSerializer.cpp

 #include "llvm/DebugInfo/CodeView/SimpleTypeSerializer.h"
 
 using namespace llvm;
 using namespace llvm::codeview;
 
 static void addPadding(BinaryStreamWriter &Writer) {
   uint32_t Align = Writer.getOffset() % 4;
   if (Align == 0)
     return;
 
   int PaddingBytes = 4 - Align;
   while (PaddingBytes > 0) {
     uint8_t Pad = static_cast<uint8_t>(LF_PAD0 + PaddingBytes);
-    cantFail(Writer.writeInteger(Pad));
+    llvm_cantFail(Writer.writeInteger(Pad));
     --PaddingBytes;
   }
 }
 
 SimpleTypeSerializer::SimpleTypeSerializer() : ScratchBuffer(MaxRecordLength) {}
 
 SimpleTypeSerializer::~SimpleTypeSerializer() {}
 
 template <typename T>
 ArrayRef<uint8_t> SimpleTypeSerializer::serialize(T &Record) {
   BinaryStreamWriter Writer(ScratchBuffer, support::little);
   TypeRecordMapping Mapping(Writer);
 
   // Write the record prefix first with a dummy length but real kind.
   RecordPrefix DummyPrefix(uint16_t(Record.getKind()));
-  cantFail(Writer.writeObject(DummyPrefix));
+  llvm_cantFail(Writer.writeObject(DummyPrefix));
 
   RecordPrefix *Prefix = reinterpret_cast<RecordPrefix *>(ScratchBuffer.data());
   CVType CVT(Prefix, sizeof(RecordPrefix));
 
-  cantFail(Mapping.visitTypeBegin(CVT));
-  cantFail(Mapping.visitKnownRecord(CVT, Record));
-  cantFail(Mapping.visitTypeEnd(CVT));
+  llvm_cantFail(Mapping.visitTypeBegin(CVT));
+  llvm_cantFail(Mapping.visitKnownRecord(CVT, Record));
+  llvm_cantFail(Mapping.visitTypeEnd(CVT));
 
   addPadding(Writer);
 
   // Update the size and kind after serialization.
   Prefix->RecordKind = CVT.kind();
   Prefix->RecordLen = Writer.getOffset() - sizeof(uint16_t);
 
   return {ScratchBuffer.data(), Writer.getOffset()};

llvm/lib/DebugInfo/CodeView/SymbolRecordHelpers.cpp

 #include "llvm/ADT/SmallVector.h"
 #include "llvm/DebugInfo/CodeView/SymbolDeserializer.h"
 
 using namespace llvm;
 using namespace llvm::codeview;
 
 template <typename RecordT> static RecordT createRecord(const CVSymbol &sym) {
   RecordT record(static_cast<SymbolRecordKind>(sym.kind()));
-  cantFail(SymbolDeserializer::deserializeAs<RecordT>(sym, record));
+  llvm_cantFail(SymbolDeserializer::deserializeAs<RecordT>(sym, record));
   return record;
 }
 
 uint32_t llvm::codeview::getScopeEndOffset(const CVSymbol &Sym) {
   assert(symbolOpensScope(Sym.kind()));
   switch (Sym.kind()) {
   case SymbolKind::S_GPROC32:
   case SymbolKind::S_LPROC32:

llvm/lib/DebugInfo/CodeView/TypeIndexDiscovery.cpp

if (Refs.empty())
     return;
 
   RecordData = RecordData.drop_front(sizeof(RecordPrefix));
 
   BinaryStreamReader Reader(RecordData, support::little);
   for (const auto &Ref : Refs) {
     Reader.setOffset(Ref.Offset);
     FixedStreamArray<TypeIndex> Run;
-    cantFail(Reader.readArray(Run, Ref.Count));
+    llvm_cantFail(Reader.readArray(Run, Ref.Count));
     Indices.append(Run.begin(), Run.end());
   }
 }
 
 void llvm::codeview::discoverTypeIndices(const CVType &Type,
                                          SmallVectorImpl<TypeIndex> &Indices) {
   return discoverTypeIndices(Type.RecordData, Indices);
 }

llvm/lib/DebugInfo/CodeView/TypeStreamMerger.cpp

Error TypeStreamMerger::doit(const CVTypeArray &Types) {
   if (LastError)
     return std::move(*LastError);
   return Error::success();
 }
 
 Error TypeStreamMerger::remapAllTypes(const CVTypeArray &Types) {
   BinaryStreamRef Stream = Types.getUnderlyingStream();
   ArrayRef<uint8_t> Buffer;
-  cantFail(Stream.readBytes(0, Stream.getLength(), Buffer));
+  llvm_cantFail(Stream.readBytes(0, Stream.getLength(), Buffer));
 
   return forEachCodeViewRecord<CVType>(
       Buffer, [this](const CVType &T) { return remapType(T); });
 }
 
 Error TypeStreamMerger::remapType(const CVType &Type) {
   auto R = shouldRemapType(Type);
   if (!R)

llvm/lib/DebugInfo/DWARF/DWARFDebugLoc.cpp

while (Continue) {
     case dwarf::DW_LLE_start_length:
       E.Value0 = Data.getRelocatedAddress(C);
       E.Value1 = Data.getULEB128(C);
       break;
     case dwarf::DW_LLE_startx_endx:
     case dwarf::DW_LLE_default_location:
     case dwarf::DW_LLE_start_end:
     default:
-      cantFail(C.takeError());
+      llvm_cantFail(C.takeError());
       return createStringError(errc::illegal_byte_sequence,
                                "LLE of kind %x not supported", (int)E.Kind);
     }
 
     if (E.Kind != dwarf::DW_LLE_base_address &&
         E.Kind != dwarf::DW_LLE_base_addressx &&
         E.Kind != dwarf::DW_LLE_end_of_list) {
       unsigned Bytes = Version >= 5 ? Data.getULEB128(C) : Data.getU16(C);

llvm/lib/DebugInfo/MSF/MSFBuilder.cpp

while (BI < Layout.SB->NumBlocks) {
     uint8_t ThisByte = 0;
     for (uint32_t I = 0; I < 8; ++I) {
       bool IsFree =
           (BI < Layout.SB->NumBlocks) ? Layout.FreePageMap.test(BI) : true;
       uint8_t Mask = uint8_t(IsFree) << I;
       ThisByte |= Mask;
       ++BI;
     }
-    cantFail(FpmWriter.writeObject(ThisByte));
+    llvm_cantFail(FpmWriter.writeObject(ThisByte));
   }
   assert(FpmWriter.bytesRemaining() == 0);
 }
 
 Expected<FileBufferByteStream> MSFBuilder::commit(StringRef Path,
                                                   MSFLayout &Layout) {
   Expected<MSFLayout> L = generateLayout();
   if (!L)

llvm/lib/DebugInfo/MSF/MappedBlockStream.cpp

WritableMappedBlockStream::createFpmStream(const MSFLayout &Layout,
   MSFStreamLayout FullLayout(getFpmStreamLayout(Layout, true, AltFpm));
   auto Result =
       createStream(Layout.SB->BlockSize, FullLayout, MsfData, Allocator);
   if (!Result)
     return Result;
   std::vector<uint8_t> InitData(Layout.SB->BlockSize, 0xFF);
   BinaryStreamWriter Initializer(*Result);
   while (Initializer.bytesRemaining() > 0)
-    cantFail(Initializer.writeBytes(InitData));
+    llvm_cantFail(Initializer.writeBytes(InitData));
   return createStream(Layout.SB->BlockSize, MinLayout, MsfData, Allocator);
 }
 
 Error WritableMappedBlockStream::readBytes(uint32_t Offset, uint32_t Size,
                                            ArrayRef<uint8_t> &Buffer) {
   return ReadInterface.readBytes(Offset, Size, Buffer);
 }
 

llvm/lib/DebugInfo/PDB/Native/GSIStreamBuilder.cpp

static std::vector<ulittle32_t> computeAddrMap(ArrayRef<CVSymbol> Records) {
   DeserializedPublics.reserve(Records.size());
   PublicsByAddr.reserve(Records.size());
   SymOffsets.reserve(Records.size());
 
   uint32_t SymOffset = 0;
   for (const CVSymbol &Sym : Records) {
     assert(Sym.kind() == SymbolKind::S_PUB32);
     DeserializedPublics.push_back(
-        cantFail(SymbolDeserializer::deserializeAs<PublicSym32>(Sym)));
+        llvm_cantFail(SymbolDeserializer::deserializeAs<PublicSym32>(Sym)));
     PublicsByAddr.emplace_back(&Sym, &DeserializedPublics.back());
     SymOffsets.push_back(SymOffset);
     SymOffset += Sym.length();
   }
   llvm::stable_sort(PublicsByAddr, comparePubSymByAddrAndName);
 
   // Fill in the symbol offsets in the appropriate order.
   std::vector<ulittle32_t> AddrMap;

llvm/lib/DebugInfo/PDB/Native/NativeEnumGlobals.cpp

 
 using namespace llvm;
 using namespace llvm::codeview;
 using namespace llvm::pdb;
 
 NativeEnumGlobals::NativeEnumGlobals(NativeSession &PDBSession,
                                      std::vector<codeview::SymbolKind> Kinds)
     : Index(0), Session(PDBSession) {
-  GlobalsStream &GS = cantFail(Session.getPDBFile().getPDBGlobalsStream());
-  SymbolStream &SS = cantFail(Session.getPDBFile().getPDBSymbolStream());
+  GlobalsStream &GS = llvm_cantFail(Session.getPDBFile().getPDBGlobalsStream());
+  SymbolStream &SS = llvm_cantFail(Session.getPDBFile().getPDBSymbolStream());
   for (uint32_t Off : GS.getGlobalsTable()) {
     CVSymbol S = SS.readRecord(Off);
     if (!llvm::is_contained(Kinds, S.kind()))
       continue;
     MatchOffsets.push_back(Off);
   }
 }
 

llvm/lib/DebugInfo/PDB/Native/NativeEnumInjectedSources.cpp

public:
   NativeInjectedSource(const SrcHeaderBlockEntry &Entry,
                        PDBFile &File, const PDBStringTable &Strings)
       : Entry(Entry), Strings(Strings), File(File) {}
 
   uint32_t getCrc32() const override { return Entry.CRC; }
   uint64_t getCodeByteSize() const override { return Entry.FileSize; }
 
   std::string getFileName() const override {
-    StringRef Ret = cantFail(Strings.getStringForID(Entry.FileNI),
+    StringRef Ret = llvm_cantFail(Strings.getStringForID(Entry.FileNI),
                              "InjectedSourceStream should have rejected this");
     return Ret;
   }
 
   std::string getObjectFileName() const override {
-    StringRef Ret = cantFail(Strings.getStringForID(Entry.ObjNI),
+    StringRef Ret = llvm_cantFail(Strings.getStringForID(Entry.ObjNI),
                              "InjectedSourceStream should have rejected this");
     return Ret;
   }
 
   std::string getVirtualFileName() const override {
-    StringRef Ret = cantFail(Strings.getStringForID(Entry.VFileNI),
+    StringRef Ret = llvm_cantFail(Strings.getStringForID(Entry.VFileNI),
                              "InjectedSourceStream should have rejected this");
     return Ret;
   }
 
   uint32_t getCompression() const override { return Entry.Compression; }
 
   std::string getCode() const override {
     // Get name of stream storing the data.
     StringRef VName =
-        cantFail(Strings.getStringForID(Entry.VFileNI),
+        llvm_cantFail(Strings.getStringForID(Entry.VFileNI),
                  "InjectedSourceStream should have rejected this");
     std::string StreamName = ("/src/files/" + VName).str();
 
     // Find stream with that name and read its data.
     // FIXME: Consider validating (or even loading) all this in
     // InjectedSourceStream so that no error can happen here.
     auto ExpectedFileStream = File.safelyCreateNamedStream(StreamName);
     if (!ExpectedFileStream) {

llvm/lib/DebugInfo/PDB/Native/NativeTypeEnum.cpp

private:
   Optional<TypeIndex> ContinuationIndex;
   uint32_t Index = 0;
 };
 } // namespace
 
 NativeEnumEnumEnumerators::NativeEnumEnumEnumerators(
     NativeSession &Session, const NativeTypeEnum &ClassParent)
     : Session(Session), ClassParent(ClassParent) {
-  TpiStream &Tpi = cantFail(Session.getPDBFile().getPDBTpiStream());
+  TpiStream &Tpi = llvm_cantFail(Session.getPDBFile().getPDBTpiStream());
   LazyRandomTypeCollection &Types = Tpi.typeCollection();
 
   ContinuationIndex = ClassParent.getEnumRecord().FieldList;
   while (ContinuationIndex) {
     CVType FieldList = Types.getType(*ContinuationIndex);
     assert(FieldList.kind() == LF_FIELDLIST);
     ContinuationIndex.reset();
-    cantFail(visitMemberRecordStream(FieldList.data(), *this));
+    llvm_cantFail(visitMemberRecordStream(FieldList.data(), *this));
   }
 }
 
 Error NativeEnumEnumEnumerators::visitKnownMember(CVMemberRecord &CVM,
                                                   EnumeratorRecord &Record) {
   Enumerators.push_back(Record);
   return Error::success();
 }

llvm/lib/DebugInfo/PDB/Native/NativeTypeFunctionSig.cpp

void NativeTypeFunctionSig::initialize() {
   } else {
     initializeArgList(Proc.ArgumentList);
   }
 }
 
 NativeTypeFunctionSig::~NativeTypeFunctionSig() {}
 
 void NativeTypeFunctionSig::initializeArgList(codeview::TypeIndex ArgListTI) {
-  TpiStream &Tpi = cantFail(Session.getPDBFile().getPDBTpiStream());
+  TpiStream &Tpi = llvm_cantFail(Session.getPDBFile().getPDBTpiStream());
   CVType CVT = Tpi.typeCollection().getType(ArgListTI);
 
-  cantFail(TypeDeserializer::deserializeAs<ArgListRecord>(CVT, ArgList));
+  llvm_cantFail(TypeDeserializer::deserializeAs<ArgListRecord>(CVT, ArgList));
 }
 
 void NativeTypeFunctionSig::dump(raw_ostream &OS, int Indent,
                                  PdbSymbolIdField ShowIdFields,
                                  PdbSymbolIdField RecurseIdFields) const {
 
   NativeRawSymbol::dump(OS, Indent, ShowIdFields, RecurseIdFields);
 

llvm/lib/DebugInfo/PDB/Native/PDBFile.cpp

 
 bool PDBFile::hasPDBIpiStream() const {
   if (!hasPDBInfoStream())
     return false;
 
   if (StreamIPI >= getNumStreams())
     return false;
 
-  auto &InfoStream = cantFail(const_cast<PDBFile *>(this)->getPDBInfoStream());
+  auto &InfoStream = llvm_cantFail(const_cast<PDBFile *>(this)->getPDBInfoStream());
   return InfoStream.containsIdStream();
 }
 
 bool PDBFile::hasPDBPublicsStream() {
   auto DbiS = getPDBDbiStream();
   if (!DbiS) {
     consumeError(DbiS.takeError());
     return false;

llvm/lib/DebugInfo/PDB/Native/PDBFileBuilder.cpp

if (!NamedStreams.get(Name, SN))
     return llvm::make_error<pdb::RawError>(raw_error_code::no_stream);
   return SN;
 }
 
 void PDBFileBuilder::commitSrcHeaderBlock(WritableBinaryStream &MsfBuffer,
                                           const msf::MSFLayout &Layout) {
   assert(!InjectedSourceTable.empty());
 
-  uint32_t SN = cantFail(getNamedStreamIndex("/src/headerblock"));
+  uint32_t SN = llvm_cantFail(getNamedStreamIndex("/src/headerblock"));
   auto Stream = WritableMappedBlockStream::createIndexedStream(
       Layout, MsfBuffer, SN, Allocator);
   BinaryStreamWriter Writer(*Stream);
 
   SrcHeaderBlockHeader Header;
   ::memset(&Header, 0, sizeof(Header));
   Header.Version = static_cast<uint32_t>(PdbRaw_SrcHeaderBlockVer::SrcVerOne);
   Header.Size = Writer.bytesRemaining();
 
-  cantFail(Writer.writeObject(Header));
-  cantFail(InjectedSourceTable.commit(Writer));
+  llvm_cantFail(Writer.writeObject(Header));
+  llvm_cantFail(InjectedSourceTable.commit(Writer));
 
   assert(Writer.bytesRemaining() == 0);
 }
 
 void PDBFileBuilder::commitInjectedSources(WritableBinaryStream &MsfBuffer,
                                            const msf::MSFLayout &Layout) {
   if (InjectedSourceTable.empty())
     return;
 
   commitSrcHeaderBlock(MsfBuffer, Layout);
 
   for (const auto &IS : InjectedSources) {
-    uint32_t SN = cantFail(getNamedStreamIndex(IS.StreamName));
+    uint32_t SN = llvm_cantFail(getNamedStreamIndex(IS.StreamName));
 
     auto SourceStream = WritableMappedBlockStream::createIndexedStream(
         Layout, MsfBuffer, SN, Allocator);
     BinaryStreamWriter SourceWriter(*SourceStream);
     assert(SourceWriter.bytesRemaining() == IS.Content->getBufferSize());
-    cantFail(SourceWriter.writeBytes(
+    llvm_cantFail(SourceWriter.writeBytes(
         arrayRefFromStringRef(IS.Content->getBuffer())));
   }
 }
 
 Error PDBFileBuilder::commit(StringRef Filename, codeview::GUID *Guid) {
   assert(!Filename.empty());
   if (auto EC = finalizeMsfLayout())
     return EC;

llvm/lib/DebugInfo/PDB/Native/SymbolCache.cpp

uint32_t SymbolCache::getNumCompilands() const {
   return Dbi->modules().getModuleCount();
 }
 
 SymIndexId SymbolCache::getOrCreateGlobalSymbolByOffset(uint32_t Offset) {
   auto Iter = GlobalOffsetToSymbolId.find(Offset);
   if (Iter != GlobalOffsetToSymbolId.end())
     return Iter->second;
 
-  SymbolStream &SS = cantFail(Session.getPDBFile().getPDBSymbolStream());
+  SymbolStream &SS = llvm_cantFail(Session.getPDBFile().getPDBSymbolStream());
   CVSymbol CVS = SS.readRecord(Offset);
   SymIndexId Id = 0;
   switch (CVS.kind()) {
   case SymbolKind::S_UDT: {
-    UDTSym US = cantFail(SymbolDeserializer::deserializeAs<UDTSym>(CVS));
+    UDTSym US = llvm_cantFail(SymbolDeserializer::deserializeAs<UDTSym>(CVS));
     Id = createSymbol<NativeTypeTypedef>(std::move(US));
     break;
   }
   default:
     Id = createSymbolPlaceholder();
     break;
   }
   if (Id != 0) {

llvm/lib/ExecutionEngine/MCJIT/MCJIT.cpp

 
 std::unique_ptr<MemoryBuffer> MCJIT::emitObject(Module *M) {
   assert(M && "Can not emit a null module");
 
   std::lock_guard<sys::Mutex> locked(lock);
 
   // Materialize all globals in the module if they have not been
   // materialized already.
-  cantFail(M->materializeAll());
+  llvm_cantFail(M->materializeAll());
 
   // This must be a module which has already been added but not loaded to this
   // MCJIT instance, since these conditions are tested by our caller,
   // generateCodeForModule.
 
   legacy::PassManager PM;
 
   // The RuntimeDyld will take ownership of this shortly

llvm/lib/ExecutionEngine/Orc/CompileUtils.cpp

if (ObjCache)
     ObjCache->notifyObjectCompiled(&M, ObjBuffer.getMemBufferRef());
 }
 
 ConcurrentIRCompiler::ConcurrentIRCompiler(JITTargetMachineBuilder JTMB,
                                            ObjectCache *ObjCache)
     : JTMB(std::move(JTMB)), ObjCache(ObjCache) {}
 
 std::unique_ptr<MemoryBuffer> ConcurrentIRCompiler::operator()(Module &M) {
-  auto TM = cantFail(JTMB.createTargetMachine());
+  auto TM = llvm_cantFail(JTMB.createTargetMachine());
   SimpleCompiler C(*TM, ObjCache);
   return C(M);
 }
 
 } // end namespace orc
 } // end namespace llvm

llvm/lib/ExecutionEngine/Orc/Core.cpp

 
 StringRef AbsoluteSymbolsMaterializationUnit::getName() const {
   return "<Absolute Symbols>";
 }
 
 void AbsoluteSymbolsMaterializationUnit::materialize(
     MaterializationResponsibility R) {
   // No dependencies, so these calls can't fail.
-  cantFail(R.notifyResolved(Symbols));
-  cantFail(R.notifyEmitted());
+  llvm_cantFail(R.notifyResolved(Symbols));
+  llvm_cantFail(R.notifyEmitted());
 }
 
 void AbsoluteSymbolsMaterializationUnit::discard(const JITDylib &JD,
                                                  const SymbolStringPtr &Name) {
   assert(Symbols.count(Name) && "Symbol is not part of this MU");
   Symbols.erase(Name);
 }
 
ReexportsGenerator::tryToGenerate(JITDylib &JD, const SymbolNameSet &Names) {
   for (auto &KV : *Flags) {
     if (Allow && !Allow(KV.first))
       continue;
     AliasMap[KV.first] = SymbolAliasMapEntry(KV.first, KV.second);
     Added.insert(KV.first);
   }
 
   if (!Added.empty())
-    cantFail(JD.define(reexports(SourceJD, AliasMap, MatchNonExported)));
+    llvm_cantFail(JD.define(reexports(SourceJD, AliasMap, MatchNonExported)));
 
   return Added;
 }
 
 JITDylib::DefinitionGenerator::~DefinitionGenerator() {}
 
 void JITDylib::removeGenerator(DefinitionGenerator &G) {
   ES.runSessionLocked([&]() {
for (auto &DG : DefGenerators) {
     // unresolved symbols then lodge the query against them.
     if (!NewDefs->empty()) {
       for (auto &D : *NewDefs)
         Unresolved.erase(D);
 
       // Lodge query. This can not fail as any new definitions were added
       // by the generator under the session locked. Since they can't have
       // started materializing yet the can not have failed.
-      cantFail(lodgeQueryImpl(Q, *NewDefs, MatchNonExported, MUs));
+      llvm_cantFail(lodgeQueryImpl(Q, *NewDefs, MatchNonExported, MUs));
 
       assert(NewDefs->empty() &&
              "All fallback defs should have been found by lookupImpl");
     }
   }
 
   return Error::success();
 }

llvm/lib/ExecutionEngine/Orc/ExecutionUtils.cpp

if (void *Addr = Dylib.getAddressOfSymbol(Tmp.c_str())) {
       NewSymbols[Name] = JITEvaluatedSymbol(
           static_cast<JITTargetAddress>(reinterpret_cast<uintptr_t>(Addr)),
           JITSymbolFlags::Exported);
     }
   }
 
   // Add any new symbols to JD. Since the generator is only called for symbols
   // that are not already defined, this will never trigger a duplicate
-  // definition error, so we can wrap this call in a 'cantFail'.
+  // definition error, so we can wrap this call in a 'llvm_cantFail'.
   if (!NewSymbols.empty())
-    cantFail(JD.define(absoluteSymbols(std::move(NewSymbols))));
+    llvm_cantFail(JD.define(absoluteSymbols(std::move(NewSymbols))));
 
   return Added;
 }
 
 Expected<std::unique_ptr<StaticLibraryDefinitionGenerator>>
 StaticLibraryDefinitionGenerator::Load(ObjectLayer &L, const char *FileName) {
   auto ArchiveBuffer = errorOrToExpected(MemoryBuffer::getFile(FileName));
 

llvm/lib/ExecutionEngine/Orc/IndirectionUtils.cpp

public:
 
   StringRef getName() const override { return "<Compile Callbacks>"; }
 
 private:
   void materialize(MaterializationResponsibility R) override {
     SymbolMap Result;
     Result[Name] = JITEvaluatedSymbol(Compile(), JITSymbolFlags::Exported);
     // No dependencies, so these calls cannot fail.
-    cantFail(R.notifyResolved(Result));
-    cantFail(R.notifyEmitted());
+    llvm_cantFail(R.notifyResolved(Result));
+    llvm_cantFail(R.notifyEmitted());
   }
 
   void discard(const JITDylib &JD, const SymbolStringPtr &Name) override {
     llvm_unreachable("Discard should never occur on a LMU?");
   }
 
   SymbolStringPtr Name;
   CompileFunction Compile;

 Expected<JITTargetAddress>
 JITCompileCallbackManager::getCompileCallback(CompileFunction Compile) {
   if (auto TrampolineAddr = TP->getTrampoline()) {
     auto CallbackName =
         ES.intern(std::string("cc") + std::to_string(++NextCallbackId));
 
     std::lock_guard<std::mutex> Lock(CCMgrMutex);
     AddrToSymbol[*TrampolineAddr] = CallbackName;
-    cantFail(CallbacksJD.define(
+    llvm_cantFail(CallbacksJD.define(
         std::make_unique<CompileCallbackMaterializationUnit>(
             std::move(CallbackName), std::move(Compile),
             ES.allocateVModule())));
     return *TrampolineAddr;
   } else
     return TrampolineAddr.takeError();
 }
 

llvm/lib/ExecutionEngine/Orc/LazyReexports.cpp

if (auto Err = ISManager.createStubs(StubInits)) {
     return;
   }
 
   SymbolMap Stubs;
   for (auto &Alias : RequestedAliases)
     Stubs[Alias.first] = ISManager.findStub(*Alias.first, false);
 
   // No registered dependencies, so these calls cannot fail.
-  cantFail(R.notifyResolved(Stubs));
-  cantFail(R.notifyEmitted());
+  llvm_cantFail(R.notifyResolved(Stubs));
+  llvm_cantFail(R.notifyEmitted());
 }
 
 void LazyReexportsMaterializationUnit::discard(const JITDylib &JD,
                                                const SymbolStringPtr &Name) {
   assert(CallableAliases.count(Name) &&
          "Symbol not covered by this MaterializationUnit");
   CallableAliases.erase(Name);
 }

llvm/lib/ExecutionEngine/Orc/OrcMCJITReplacement.h

std::vector<std::string> CtorNames, DtorNames;
       }
     }
 
     auto K = ES.allocateVModule();
 
     UnexecutedConstructors[K] = std::move(CtorNames);
     UnexecutedDestructors[K] = std::move(DtorNames);
 
-    cantFail(LazyEmitLayer.addModule(K, std::move(M)));
+    llvm_cantFail(LazyEmitLayer.addModule(K, std::move(M)));
   }
 
   void addObjectFile(std::unique_ptr<object::ObjectFile> O) override {
-    cantFail(ObjectLayer.addObject(
+    llvm_cantFail(ObjectLayer.addObject(
         ES.allocateVModule(), MemoryBuffer::getMemBufferCopy(O->getData())));
   }
 
   void addObjectFile(object::OwningBinary<object::ObjectFile> O) override {
     std::unique_ptr<object::ObjectFile> Obj;
     std::unique_ptr<MemoryBuffer> ObjBuffer;
     std::tie(Obj, ObjBuffer) = O.takeBinary();
-    cantFail(ObjectLayer.addObject(ES.allocateVModule(), std::move(ObjBuffer)));
+    llvm_cantFail(ObjectLayer.addObject(ES.allocateVModule(), std::move(ObjBuffer)));
   }
 
   void addArchive(object::OwningBinary<object::Archive> A) override {
     Archives.push_back(std::move(A));
   }
 
   bool removeModule(Module *M) override {
     auto I = Modules.begin();
     for (auto E = Modules.end(); I != E; ++I)
       if (I->get() == M)
         break;
     if (I == Modules.end())
       return false;
     Modules.erase(I);
     return true;
   }
 
   uint64_t getSymbolAddress(StringRef Name) {
-    return cantFail(findSymbol(Name).getAddress());
+    return llvm_cantFail(findSymbol(Name).getAddress());
   }
 
   JITSymbol findSymbol(StringRef Name) {
     return findMangledSymbol(mangle(Name));
   }
 
   void finalizeObject() override {
     // This is deprecated - Aim to remove in ExecutionEngine.
for (object::OwningBinary<object::Archive> &OB : Archives) {
             OptionalChild->getAsBinary();
         if (!ChildBinOrErr) {
           // TODO: Actually report errors helpfully.
           consumeError(ChildBinOrErr.takeError());
           continue;
         }
         std::unique_ptr<object::Binary> &ChildBin = ChildBinOrErr.get();
         if (ChildBin->isObject()) {
-          cantFail(ObjectLayer.addObject(
+          llvm_cantFail(ObjectLayer.addObject(
               ES.allocateVModule(),
               MemoryBuffer::getMemBufferCopy(ChildBin->getData())));
           if (auto Sym = ObjectLayer.findSymbol(Name, true))
             return Sym;
         }
       }
     }
     return nullptr;

llvm/lib/ExecutionEngine/Orc/OrcMCJITReplacement.cpp

OrcMCJITReplacement::runFunction(Function *F,
 
   llvm_unreachable("Full-featured argument passing not supported yet!");
 }
 
 void OrcMCJITReplacement::runStaticConstructorsDestructors(bool isDtors) {
   auto &CtorDtorsMap = isDtors ? UnexecutedDestructors : UnexecutedConstructors;
 
   for (auto &KV : CtorDtorsMap)
-    cantFail(LegacyCtorDtorRunner<LazyEmitLayerT>(
+    llvm_cantFail(LegacyCtorDtorRunner<LazyEmitLayerT>(
                  AcknowledgeORCv1Deprecation, std::move(KV.second), KV.first)
                  .runViaLayer(LazyEmitLayer));
 
   CtorDtorsMap.clear();
 }
 
 } // End namespace orc.
 } // End namespace llvm.

llvm/lib/ExecutionEngine/Orc/ThreadSafeModule.cpp

SmallVector<char, 1> ClonedModuleBuffer;
       BCWriter.writeStrtab();
     }
 
     MemoryBufferRef ClonedModuleBufferRef(
         StringRef(ClonedModuleBuffer.data(), ClonedModuleBuffer.size()),
         "cloned module buffer");
     ThreadSafeContext NewTSCtx(std::make_unique<LLVMContext>());
 
-    auto ClonedModule = cantFail(
+    auto ClonedModule = llvm_cantFail(
         parseBitcodeFile(ClonedModuleBufferRef, *NewTSCtx.getContext()));
     ClonedModule->setModuleIdentifier(M.getName());
     return ThreadSafeModule(std::move(ClonedModule), std::move(NewTSCtx));
   });
 }
 
 } // end namespace orc
 } // end namespace llvm

llvm/lib/ObjectYAML/CodeViewYAMLTypeHashing.cpp

 } // end namespace llvm
 
 DebugHSection llvm::CodeViewYAML::fromDebugH(ArrayRef<uint8_t> DebugH) {
   assert(DebugH.size() >= 8);
   assert((DebugH.size() - 8) % 8 == 0);
 
   BinaryStreamReader Reader(DebugH, llvm::support::little);
   DebugHSection DHS;
-  cantFail(Reader.readInteger(DHS.Magic));
-  cantFail(Reader.readInteger(DHS.Version));
-  cantFail(Reader.readInteger(DHS.HashAlgorithm));
+  llvm_cantFail(Reader.readInteger(DHS.Magic));
+  llvm_cantFail(Reader.readInteger(DHS.Version));
+  llvm_cantFail(Reader.readInteger(DHS.HashAlgorithm));
 
   while (Reader.bytesRemaining() != 0) {
     ArrayRef<uint8_t> S;
-    cantFail(Reader.readBytes(S, 8));
+    llvm_cantFail(Reader.readBytes(S, 8));
     DHS.Hashes.emplace_back(S);
   }
   assert(Reader.bytesRemaining() == 0);
   return DHS;
 }
 
 ArrayRef<uint8_t> llvm::CodeViewYAML::toDebugH(const DebugHSection &DebugH,
                                                BumpPtrAllocator &Alloc) {
   uint32_t Size = 8 + 8 * DebugH.Hashes.size();
   uint8_t *Data = Alloc.Allocate<uint8_t>(Size);
   MutableArrayRef<uint8_t> Buffer(Data, Size);
   BinaryStreamWriter Writer(Buffer, llvm::support::little);
 
-  cantFail(Writer.writeInteger(DebugH.Magic));
-  cantFail(Writer.writeInteger(DebugH.Version));
-  cantFail(Writer.writeInteger(DebugH.HashAlgorithm));
+  llvm_cantFail(Writer.writeInteger(DebugH.Magic));
+  llvm_cantFail(Writer.writeInteger(DebugH.Version));
+  llvm_cantFail(Writer.writeInteger(DebugH.HashAlgorithm));
   SmallString<8> Hash;
   for (const auto &H : DebugH.Hashes) {
     Hash.clear();
     raw_svector_ostream OS(Hash);
     H.Hash.writeAsBinary(OS);
     assert((Hash.size() == 8) && "Invalid hash size!");
-    cantFail(Writer.writeFixedString(Hash));
+    llvm_cantFail(Writer.writeFixedString(Hash));
   }
   assert(Writer.bytesRemaining() == 0);
   return Buffer;
 }

llvm/lib/Remarks/RemarkParser.cpp

 namespace {
 // Wrapper that holds the state needed to interact with the C API.
 struct CParser {
   std::unique_ptr<RemarkParser> TheParser;
   Optional<std::string> Err;
 
   CParser(Format ParserFormat, StringRef Buf,
           Optional<ParsedStringTable> StrTab = None)
-      : TheParser(cantFail(
+      : TheParser(llvm_cantFail(
             StrTab ? createRemarkParser(ParserFormat, Buf, std::move(*StrTab))
                    : createRemarkParser(ParserFormat, Buf))) {}
 
   void handleError(Error E) { Err.emplace(toString(std::move(E))); }
   bool hasError() const { return Err.hasValue(); }
   const char *getMessage() const { return Err ? Err->c_str() : nullptr; };
 };
 } // namespace

llvm/lib/XRay/Profile.cpp

 
 Profile::Profile(const Profile &O) {
   // We need to re-create all the tries from the original (O), into the current
   // Profile being initialized, through the Block instances we see.
   for (const auto &Block : O) {
     Blocks.push_back({Block.Thread, {}});
     auto &B = Blocks.back();
     for (const auto &PathData : Block.PathData)
-      B.PathData.push_back({internPath(cantFail(O.expandPath(PathData.first))),
+      B.PathData.push_back({internPath(llvm_cantFail(O.expandPath(PathData.first))),
                             PathData.second});
   }
 }
 
 Profile &Profile::operator=(const Profile &O) {
   Profile P = O;
   *this = std::move(P);
   return *this;
for (const auto &P : {std::ref(L), std::ref(R)})
     for (const auto &Block : P.get()) {
       ThreadProfileIndexMap::iterator It;
       std::tie(It, std::ignore) = ThreadProfileIndex.insert(
           {Block.Thread, PathDataMapPtr{new PathDataMap()}});
       for (const auto &PathAndData : Block.PathData) {
         auto &PathID = PathAndData.first;
         auto &Data = PathAndData.second;
         auto NewPathID =
-            Merged.internPath(cantFail(P.get().expandPath(PathID)));
+            Merged.internPath(llvm_cantFail(P.get().expandPath(PathID)));
         PathDataMap::iterator PathDataIt;
         bool Inserted;
         std::tie(PathDataIt, Inserted) = It->second->insert({NewPathID, Data});
         if (!Inserted) {
           auto &ExistingData = PathDataIt->second;
           ExistingData.CallCount += Data.CallCount;
           ExistingData.CumulativeLocalTime += Data.CumulativeLocalTime;
         }
       }
     }
 
   for (const auto &IndexedThreadBlock : ThreadProfileIndex) {
     PathDataVector PathAndData;
     PathAndData.reserve(IndexedThreadBlock.second->size());
     copy(*IndexedThreadBlock.second, std::back_inserter(PathAndData));
-    cantFail(
+    llvm_cantFail(
         Merged.addBlock({IndexedThreadBlock.first, std::move(PathAndData)}));
   }
   return Merged;
 }
 
 Profile mergeProfilesByStack(const Profile &L, const Profile &R) {
   Profile Merged;
   using PathDataMap = DenseMap<Profile::PathID, Profile::Data>;
   PathDataMap PathData;
   using PathDataVector = decltype(Profile::Block::PathData);
   for (const auto &P : {std::ref(L), std::ref(R)})
     for (const auto &Block : P.get())
       for (const auto &PathAndData : Block.PathData) {
         auto &PathId = PathAndData.first;
         auto &Data = PathAndData.second;
         auto NewPathID =
-            Merged.internPath(cantFail(P.get().expandPath(PathId)));
+            Merged.internPath(llvm_cantFail(P.get().expandPath(PathId)));
         PathDataMap::iterator PathDataIt;
         bool Inserted;
         std::tie(PathDataIt, Inserted) = PathData.insert({NewPathID, Data});
         if (!Inserted) {
           auto &ExistingData = PathDataIt->second;
           ExistingData.CallCount += Data.CallCount;
           ExistingData.CumulativeLocalTime += Data.CumulativeLocalTime;
         }
       }
 
   // In the end there's a single Block, for thread 0.
   PathDataVector Block;
   Block.reserve(PathData.size());
   copy(PathData, std::back_inserter(Block));
-  cantFail(Merged.addBlock({0, std::move(Block)}));
+  llvm_cantFail(Merged.addBlock({0, std::move(Block)}));
   return Merged;
 }
 
 Expected<Profile> loadProfile(StringRef Filename) {
   Expected<sys::fs::file_t> FdOrErr = sys::fs::openNativeFileForRead(Filename);
   if (!FdOrErr)
     return FdOrErr.takeError();
 

llvm/tools/llvm-exegesis/lib/Assembler.cpp

 
 object::OwningBinary<object::ObjectFile>
 getObjectFromBuffer(StringRef InputData) {
   // Storing the generated assembly into a MemoryBuffer that owns the memory.
   std::unique_ptr<MemoryBuffer> Buffer =
       MemoryBuffer::getMemBufferCopy(InputData);
   // Create the ObjectFile from the MemoryBuffer.
   std::unique_ptr<object::ObjectFile> Obj =
-      cantFail(object::ObjectFile::createObjectFile(Buffer->getMemBufferRef()));
+      llvm_cantFail(object::ObjectFile::createObjectFile(Buffer->getMemBufferRef()));
   // Returning both the MemoryBuffer and the ObjectFile.
   return object::OwningBinary<object::ObjectFile>(std::move(Obj),
                                                   std::move(Buffer));
 }
 
 object::OwningBinary<object::ObjectFile> getObjectFromFile(StringRef Filename) {
-  return cantFail(object::ObjectFile::createObjectFile(Filename));
+  return llvm_cantFail(object::ObjectFile::createObjectFile(Filename));
 }
 
 namespace {
 
 // Implementation of this class relies on the fact that a single object with a
 // single function will be loaded into memory.
 class TrackingSectionMemoryManager : public SectionMemoryManager {
 public:

llvm/tools/llvm-objdump/COFFDump.cpp

 void printCOFFSymbolTable(const object::COFFImportFile *i) {
   unsigned Index = 0;
   bool IsCode = i->getCOFFImportHeader()->getType() == COFF::IMPORT_CODE;
 
   for (const object::BasicSymbolRef &Sym : i->symbols()) {
     std::string Name;
     raw_string_ostream NS(Name);
 
-    cantFail(Sym.printName(NS));
+    llvm_cantFail(Sym.printName(NS));
     NS.flush();
 
     outs() << "[" << format("%2d", Index) << "]"
            << "(sec " << format("%2d", 0) << ")"
            << "(fl 0x00)" // Flag bits, which COFF doesn't have.
            << "(ty " << format("%3x", (IsCode && Index) ? 32 : 0) << ")"
            << "(scl " << format("%3x", 0) << ") "
            << "(nx " << 0 << ") "

llvm/tools/llvm-pdbutil/DumpOutputStyle.cpp

static StatCollection getSymbolStats(const SymbolGroup &SG,
 
   for (const auto &SS : SG.getDebugSubsections()) {
     // For object files, all symbols are spread across multiple Symbol
     // subsections of a given .debug$S section.
     if (SS.kind() != DebugSubsectionKind::Symbols)
       continue;
     DebugSymbolsSubsectionRef Symbols;
     BinaryStreamReader Reader(SS.getRecordData());
-    cantFail(Symbols.initialize(Reader));
+    llvm_cantFail(Symbols.initialize(Reader));
     for (const auto &S : Symbols) {
       Stats.update(S.kind(), S.length());
       CumulativeStats.update(S.kind(), S.length());
     }
   }
   return Stats;
 }
 

 static Expected<std::pair<std::unique_ptr<MappedBlockStream>,
                           ArrayRef<llvm::object::coff_section>>>
 loadSectionHeaders(PDBFile &File, DbgHeaderType Type) {
   if (!File.hasPDBDbiStream())
     return make_error<StringError>(
         "Section headers require a DBI Stream, which could not be loaded",
         inconvertibleErrorCode());
 
-  auto &Dbi = cantFail(File.getPDBDbiStream());
+  auto &Dbi = llvm_cantFail(File.getPDBDbiStream());
   uint32_t SI = Dbi.getDebugStreamIndex(Type);
 
   if (SI == kInvalidStreamIndex)
     return make_error<StringError>(
         "PDB does not contain the requested image section header type",
         inconvertibleErrorCode());
 
   auto Stream = File.createIndexedStream(SI);
   if (!Stream)
     return make_error<StringError>("Could not load the required stream data",
                                    inconvertibleErrorCode());
 
   ArrayRef<object::coff_section> Headers;
   if (Stream->getLength() % sizeof(object::coff_section) != 0)
     return make_error<StringError>(
         "Section header array size is not a multiple of section header size",
         inconvertibleErrorCode());
 
   uint32_t NumHeaders = Stream->getLength() / sizeof(object::coff_section);
   BinaryStreamReader Reader(*Stream);
-  cantFail(Reader.readArray(Headers, NumHeaders));
+  llvm_cantFail(Reader.readArray(Headers, NumHeaders));
   return std::make_pair(std::move(Stream), Headers);
 }
 
 static std::vector<std::string> getSectionNames(PDBFile &File) {
   auto ExpectedHeaders = loadSectionHeaders(File, DbgHeaderType::SectionHdr);
   if (!ExpectedHeaders)
     return {};
 
if (File.isPdb())
     Scope.emplace(P, 2);
 
   iterateSymbolGroups(File, Scope, [&](uint32_t Modi, const SymbolGroup &SG) {
     StatCollection SS = getSymbolStats(SG, SymStats);
     StatCollection CS = getChunkStats(SG, ChunkStats);
 
     if (SG.getFile().isPdb()) {
       AutoIndent Indent(P);
-      auto Modules = cantFail(File.pdb().getPDBDbiStream()).modules();
+      auto Modules = llvm_cantFail(File.pdb().getPDBDbiStream()).modules();
       uint32_t ModCount = Modules.getModuleCount();
       DbiModuleDescriptor Desc = Modules.getModuleDescriptor(Modi);
       uint32_t StreamIdx = Desc.getModuleStreamIndex();
 
       if (StreamIdx == kInvalidStreamIndex) {
         P.formatLine("Mod {0} (debug info not present): [{1}]",
                      fmt_align(Modi, AlignStyle::Right, NumDigits(ModCount)),
                      Desc.getModuleName());
Error DumpOutputStyle::dumpUdtStats() {
   StringMap<StatCollection::Stat> NamespacedStats;
 
   size_t LongestNamespace = 0;
   auto HandleOneSymbol = [&](const CVSymbol &Sym) {
     if (Sym.kind() != SymbolKind::S_UDT)
       return;
     UdtStats.update(SymbolKind::S_UDT, Sym.length());
 
-    UDTSym UDT = cantFail(SymbolDeserializer::deserializeAs<UDTSym>(Sym));
+    UDTSym UDT = llvm_cantFail(SymbolDeserializer::deserializeAs<UDTSym>(Sym));
 
     uint32_t Kind = 0;
     uint32_t RecordSize = 0;
 
     if (UDT.Type.isNoneType())
       Kind = kNoneUdtKind;
     else if (UDT.Type.isSimple())
       Kind = kSimpleUdtKind;
auto HandleOneSymbol = [&](const CVSymbol &Sym) {
 
     LongestNamespace = std::max(LongestNamespace, Scope.size());
     NamespacedStats[Scope].update(RecordSize);
   };
 
   P.NewLine();
 
   if (File.isPdb()) {
-    auto &SymbolRecords = cantFail(getPdb().getPDBSymbolStream());
+    auto &SymbolRecords = llvm_cantFail(getPdb().getPDBSymbolStream());
     auto ExpGlobals = getPdb().getPDBGlobalsStream();
     if (!ExpGlobals)
       return ExpGlobals.takeError();
 
     for (uint32_t PubSymOff : ExpGlobals->getGlobalsTable()) {
       CVSymbol Sym = SymbolRecords.readRecord(PubSymOff);
       HandleOneSymbol(Sym);
     }
   } else {
     for (const auto &Sec : File.symbol_groups()) {
       for (const auto &SS : Sec.getDebugSubsections()) {
         if (SS.kind() != DebugSubsectionKind::Symbols)
           continue;
 
         DebugSymbolsSubsectionRef Symbols;
         BinaryStreamReader Reader(SS.getRecordData());
-        cantFail(Symbols.initialize(Reader));
+        llvm_cantFail(Symbols.initialize(Reader));
         for (const auto &S : Symbols)
           HandleOneSymbol(S);
       }
     }
   }
 
   LongestNamespace += StringRef(" namespace ''").size();
   size_t LongestTypeLeafKind = getLongestTypeLeafName(UdtTargetStats);
P.NewLine();
       P.formatLine("Signature: {0}", IS->getSignature());
       P.formatLine("Hash Version: {0}", IS->getHashVersion());
       P.formatLine("Name Buffer Size: {0}", IS->getByteSize());
       P.NewLine();
     }
 
     BinaryStreamRef NameBuffer = IS->getStringTable().getBuffer();
     ArrayRef<uint8_t> Contents;
-    cantFail(NameBuffer.readBytes(0, NameBuffer.getLength(), Contents));
+    llvm_cantFail(NameBuffer.readBytes(0, NameBuffer.getLength(), Contents));
     P.formatBinary("Name Buffer", Contents, 0);
     P.NewLine();
     {
       P.printLine("Hash Table:");
       AutoIndent Indent(P);
       P.formatLine("Bucket Count: {0}", IS->name_ids().size());
       for (const auto &Entry : enumerate(IS->name_ids()))
         P.formatLine("Bucket[{0}] : {1}", Entry.index(),
iterateModuleSubsections<DebugStringTableSubsectionRef>(
       File, PrintScope{P, 4},
       [&](uint32_t Modi, const SymbolGroup &Strings,
           DebugStringTableSubsectionRef &Strings2) {
         BinaryStreamRef StringTableBuffer = Strings2.getBuffer();
         BinaryStreamReader Reader(StringTableBuffer);
         while (Reader.bytesRemaining() > 0) {
           StringRef Str;
           uint32_t Offset = Reader.getOffset();
-          cantFail(Reader.readCString(Str));
+          llvm_cantFail(Reader.readCString(Str));
           if (Str.empty())
             continue;
 
           P.formatLine("{0} | {1}", fmt_align(Offset, AlignStyle::Right, 4),
                        Str);
         }
       });
   return Error::success();
Error DumpOutputStyle::dumpGSIRecords() {
 
   if (!getPdb().hasPDBSymbolStream()) {
     printStreamNotPresent("GSI Common Symbol");
     return Error::success();
   }
 
   AutoIndent Indent(P);
 
-  auto &Records = cantFail(getPdb().getPDBSymbolStream());
+  auto &Records = llvm_cantFail(getPdb().getPDBSymbolStream());
   auto &Types = File.types();
   auto &Ids = File.ids();
 
   P.printLine("Records");
   SymbolVisitorCallbackPipeline Pipeline;
   SymbolDeserializer Deserializer(nullptr, CodeViewContainer::Pdb);
   MinimalSymbolDumper Dumper(P, opts::dump::DumpSymRecordBytes, Ids, Types);
 
Error DumpOutputStyle::dumpGlobals() {
   AutoIndent Indent(P);
   ExitOnError Err("Error dumping globals stream: ");
   auto &Globals = Err(getPdb().getPDBGlobalsStream());
 
   if (opts::dump::DumpGlobalNames.empty()) {
     const GSIHashTable &Table = Globals.getGlobalsTable();
     Err(dumpSymbolsFromGSI(Table, opts::dump::DumpGlobalExtras));
   } else {
-    SymbolStream &SymRecords = cantFail(getPdb().getPDBSymbolStream());
+    SymbolStream &SymRecords = llvm_cantFail(getPdb().getPDBSymbolStream());
     auto &Types = File.types();
     auto &Ids = File.ids();
 
     SymbolVisitorCallbackPipeline Pipeline;
     SymbolDeserializer Deserializer(nullptr, CodeViewContainer::Pdb);
     MinimalSymbolDumper Dumper(P, opts::dump::DumpSymRecordBytes, Ids, Types);
 
     Pipeline.addCallbackToPipeline(Deserializer);

llvm/tools/llvm-pdbutil/ExplainOutputStyle.cpp

void ExplainOutputStyle::explainPdbFpmBlockOffset() {
   if (DescribedBlockStart > File.pdb().getBlockCount()) {
     P.printLine("Address is in extraneous FPM space.");
     return;
   }
 
   P.formatLine("Address describes the allocation status of blocks [{0},{1})",
                DescribedBlockStart, DescribedBlockStart + 8);
   ArrayRef<uint8_t> Bytes;
-  cantFail(File.pdb().getMsfBuffer().readBytes(FileOffset, 1, Bytes));
+  llvm_cantFail(File.pdb().getMsfBuffer().readBytes(FileOffset, 1, Bytes));
   P.formatLine("Status = {0} (Note: 0 = allocated, 1 = free)",
                toBinaryString(Bytes[0]));
 }
 
 void ExplainOutputStyle::explainPdbBlockMapOffset() {
   uint64_t BlockMapOffset = File.pdb().getBlockMapOffset();
   uint32_t OffsetInBlock = FileOffset - BlockMapOffset;
   P.formatLine("Address is at offset {0} of the directory block list",
void ExplainOutputStyle::explainPdbStreamOffset(uint32_t Stream) {
   const auto &Layout = File.pdb().getStreamLayout(Stream);
   uint32_t StreamOff =
       getOffsetInStream(Layout.Blocks, FileOffset, File.pdb().getBlockSize());
   P.formatLine("Address is at offset {0}/{1} of Stream {2} ({3}){4}.",
                StreamOff, Layout.Length, Stream, S.getLongName(),
                (StreamOff > Layout.Length) ? " in unused space" : "");
   switch (S.getPurpose()) {
   case StreamPurpose::DBI: {
-    DbiStream &Dbi = cantFail(File.pdb().getPDBDbiStream());
+    DbiStream &Dbi = llvm_cantFail(File.pdb().getPDBDbiStream());
     explainStreamOffset(Dbi, StreamOff);
     break;
   }
   case StreamPurpose::PDB: {
-    InfoStream &Info = cantFail(File.pdb().getPDBInfoStream());
+    InfoStream &Info = llvm_cantFail(File.pdb().getPDBInfoStream());
     explainStreamOffset(Info, StreamOff);
     break;
   }
   case StreamPurpose::IPI:
   case StreamPurpose::TPI:
   case StreamPurpose::ModuleStream:
   case StreamPurpose::NamedStream:
   default:

 }
 
 static void explainDbiModiSubstreamOffset(LinePrinter &P, DbiStream &Dbi,
                                           uint32_t Offset) {
   VarStreamArray<DbiModuleDescriptor> ModuleDescriptors;
   BinaryStreamRef ModiSubstreamData = Dbi.getModiSubstreamData().StreamData;
   BinaryStreamReader Reader(ModiSubstreamData);
 
-  cantFail(Reader.readArray(ModuleDescriptors, ModiSubstreamData.getLength()));
+  llvm_cantFail(Reader.readArray(ModuleDescriptors, ModiSubstreamData.getLength()));
   auto Prev = ModuleDescriptors.begin();
   assert(Prev.offset() == 0);
   auto Current = Prev;
   uint32_t Index = 0;
   while (true) {
     Prev = Current;
     ++Current;
     if (Current == ModuleDescriptors.end() || Offset < Current.offset())

llvm/tools/llvm-pdbutil/InputFile.cpp

if (!ContentsOrErr) {
     consumeError(ContentsOrErr.takeError());
     return false;
   }
 
   Reader = BinaryStreamReader(*ContentsOrErr, support::little);
   uint32_t Magic;
   if (Reader.bytesRemaining() < sizeof(uint32_t))
     return false;
-  cantFail(Reader.readInteger(Magic));
+  llvm_cantFail(Reader.readInteger(Magic));
   if (Magic != COFF::DEBUG_SECTION_MAGIC)
     return false;
   return true;
 }
 
 static inline bool isDebugSSection(object::SectionRef Section,
                                    DebugSubsectionArray &Subsections) {
   BinaryStreamReader Reader;
   if (!isCodeViewDebugSubsection(Section, ".debug$S", Reader))
     return false;
 
-  cantFail(Reader.readArray(Subsections, Reader.bytesRemaining()));
+  llvm_cantFail(Reader.readArray(Subsections, Reader.bytesRemaining()));
   return true;
 }
 
 static bool isDebugTSection(SectionRef Section, CVTypeArray &Types) {
   BinaryStreamReader Reader;
   if (!isCodeViewDebugSubsection(Section, ".debug$T", Reader) &&
       !isCodeViewDebugSubsection(Section, ".debug$P", Reader))
     return false;
-  cantFail(Reader.readArray(Types, Reader.bytesRemaining()));
+  llvm_cantFail(Reader.readArray(Types, Reader.bytesRemaining()));
   return true;
 }
 
 static std::string formatChecksumKind(FileChecksumKind Kind) {
   switch (Kind) {
     RETURN_CASE(FileChecksumKind, None, "None");
     RETURN_CASE(FileChecksumKind, MD5, "MD5");
     RETURN_CASE(FileChecksumKind, SHA1, "SHA-1");
InputFile::getOrCreateTypeCollection(TypeCollectionKind Kind) {
   if (Kind == kIds) {
     assert(isPdb() && pdb().hasPDBIpiStream());
   }
 
   // If the collection was already initialized, we should have just returned it
   // in step 1.
   if (isPdb()) {
     TypeCollectionPtr &Collection = (Kind == kIds) ? Ids : Types;
-    auto &Stream = cantFail((Kind == kIds) ? pdb().getPDBIpiStream()
+    auto &Stream = llvm_cantFail((Kind == kIds) ? pdb().getPDBIpiStream()
                                            : pdb().getPDBTpiStream());
 
     auto &Array = Stream.typeArray();
     uint32_t Count = Stream.getNumTypeRecords();
     auto Offsets = Stream.getTypeIndexOffsets();
     Collection =
         std::make_unique<LazyRandomTypeCollection>(Array, Count, Offsets);
     return *Collection;
while (++Iter != End) {
     return;
   }
 }
 
 bool SymbolGroupIterator::isEnd() const {
   if (!Value.File)
     return true;
   if (Value.File->isPdb()) {
-    auto &Dbi = cantFail(Value.File->pdb().getPDBDbiStream());
+    auto &Dbi = llvm_cantFail(Value.File->pdb().getPDBDbiStream());
     uint32_t Count = Dbi.modules().getModuleCount();
     assert(Index <= Count);
     return Index == Count;
   }
 
   assert(SectionIter.hasValue());
   return *SectionIter == Value.File->obj().section_end();
 }

llvm/tools/llvm-pdbutil/LinePrinter.cpp

void LinePrinter::formatMsfStreamBlocks(
   uint32_t L = StreamLayout.Length;
 
   while (L > 0) {
     NewLine();
     assert(!Blocks.empty());
     OS << formatv("Block {0} (\n", uint32_t(Blocks.front()));
     uint32_t UsedBytes = std::min(L, File.getBlockSize());
     ArrayRef<uint8_t> BlockData =
-        cantFail(File.getBlockData(Blocks.front(), File.getBlockSize()));
+        llvm_cantFail(File.getBlockData(Blocks.front(), File.getBlockSize()));
     uint64_t BaseOffset = Blocks.front();
     BaseOffset *= File.getBlockSize();
     OS << format_bytes_with_ascii(BlockData, BaseOffset, 32, 4,
                                   CurrentIndent + IndentSpaces, true);
     NewLine();
     OS << ")";
     NewLine();
     L -= UsedBytes;

llvm/tools/llvm-pdbutil/TypeReferenceTracker.cpp

TypeReferenceTracker::TypeReferenceTracker(InputFile &File)
   if (Ids) {
     NumIdRecords = getNumRecordsInCollection(*Ids);
     IdReferenced.resize(NumIdRecords, false);
   }
 
   // Get the TpiStream pointer for forward decl resolution if this is a pdb.
   // Build the hash map to enable resolving forward decls.
   if (File.isPdb()) {
-    Tpi = &cantFail(File.pdb().getPDBTpiStream());
+    Tpi = &llvm_cantFail(File.pdb().getPDBTpiStream());
     Tpi->buildHashMap();
   }
 }
 
 void TypeReferenceTracker::mark() {
   // Walk type roots:
   // - globals
   // - modi symbols
   // - LF_UDT_MOD_SRC_LINE? VC always links these in.
   for (SymbolGroup SG : File.symbol_groups()) {
     if (File.isObj()) {
       for (const auto &SS : SG.getDebugSubsections()) {
         // FIXME: Are there other type-referencing subsections? Inlinees?
         // Probably for IDs.
         if (SS.kind() != DebugSubsectionKind::Symbols)
           continue;
 
         CVSymbolArray Symbols;
         BinaryStreamReader Reader(SS.getRecordData());
-        cantFail(Reader.readArray(Symbols, Reader.getLength()));
+        llvm_cantFail(Reader.readArray(Symbols, Reader.getLength()));
         for (const CVSymbol &S : Symbols)
           addTypeRefsFromSymbol(S);
       }
     } else if (SG.hasDebugStream()) {
       for (const CVSymbol &S : SG.getPdbModuleStream().getSymbolArray())
         addTypeRefsFromSymbol(S);
     }
   }
 
   // Walk globals and mark types referenced from globals.
   if (File.isPdb() && File.pdb().hasPDBGlobalsStream()) {
-    SymbolStream &SymStream = cantFail(File.pdb().getPDBSymbolStream());
-    GlobalsStream &GS = cantFail(File.pdb().getPDBGlobalsStream());
+    SymbolStream &SymStream = llvm_cantFail(File.pdb().getPDBSymbolStream());
+    GlobalsStream &GS = llvm_cantFail(File.pdb().getPDBGlobalsStream());
     for (uint32_t PubSymOff : GS.getGlobalsTable()) {
       CVSymbol Sym = SymStream.readRecord(PubSymOff);
       addTypeRefsFromSymbol(Sym);
     }
   }
 
   // FIXME: Should we walk Ids?
 }
if (Tpi) {
       default:
         break;
       case LF_CLASS:
       case LF_INTERFACE:
       case LF_STRUCTURE:
       case LF_UNION:
       case LF_ENUM:
         addOneTypeRef(TiRefKind::TypeRef,
-                      cantFail(Tpi->findFullDeclForForwardRef(RefTI)));
+                      llvm_cantFail(Tpi->findFullDeclForForwardRef(RefTI)));
         break;
       }
     }
   }
 }

llvm/tools/llvm-pdbutil/llvm-pdbutil.cpp

if (to_integer(opts::exportstream::Stream, Index)) {
       }
       Success = true;
       outs() << "Dumping contents of stream index " << Index << " to file "
              << OutFileName << ".\n";
     }
   }
 
   if (!Success) {
-    InfoStream &IS = cantFail(File.getPDBInfoStream());
+    InfoStream &IS = llvm_cantFail(File.getPDBInfoStream());
     Index = ExitOnErr(IS.getNamedStreamIndex(opts::exportstream::Stream));
     outs() << "Dumping contents of stream '" << opts::exportstream::Stream
            << "' (index " << Index << ") to file " << OutFileName << ".\n";
   }
 
   SourceStream = File.createIndexedStream(Index);
   auto OutFile = ExitOnErr(
       FileOutputBuffer::create(OutFileName, SourceStream->getLength()));

llvm/tools/llvm-rc/ResourceFileWriter.cpp

struct /* VS_FIXEDFILEINFO */ {
     ulittle32_t FileDateMS = ulittle32_t(0);
     ulittle32_t FileDateLS = ulittle32_t(0);
   } FixedInfo;
 
   // First, VS_VERSIONINFO.
   auto LengthLoc = writeInt<uint16_t>(0);
   writeInt<uint16_t>(sizeof(FixedInfo));
   writeInt<uint16_t>(0);
-  cantFail(writeCString("VS_VERSION_INFO"));
+  llvm_cantFail(writeCString("VS_VERSION_INFO"));
   padStream(sizeof(uint32_t));
 
   using VersionInfoFixed = VersionInfoResource::VersionInfoFixed;
   auto GetField = [&](VersionInfoFixed::VersionInfoFixedType Type) {
     static const SmallVector<uint32_t, 4> DefaultOut{0, 0, 0, 0};
     if (!FixedData.IsTypePresent[(int)Type])
       return DefaultOut;
     return FixedData.FixedInfo[(int)Type];

llvm/tools/llvm-readobj/COFFImportDumper.cpp

void dumpCOFFImportFile(const COFFImportFile *File, ScopedPrinter &Writer) {
   case COFF::IMPORT_NAME_UNDECORATE:
     Writer.printString("Name type", "undecorate");
     break;
   }
 
   for (const object::BasicSymbolRef &Sym : File->symbols()) {
     raw_ostream &OS = Writer.startLine();
     OS << "Symbol: ";
-    cantFail(Sym.printName(OS));
+    llvm_cantFail(Sym.printName(OS));
     OS << "\n";
   }
 }
 
 } // namespace llvm

llvm/tools/llvm-readobj/ELFDumper.cpp

private:
   bool checkPTDynamic(const Elf_Phdr &Phdr, const Elf_Shdr &Sec);
   void printProgramHeaders(const ELFO *Obj);
   void printSectionMapping(const ELFO *Obj);
 };
 
 template <class ELFT>
 void DumpStyle<ELFT>::reportUniqueWarning(Error Err) const {
   handleAllErrors(std::move(Err), [&](const ErrorInfoBase &EI) {
-    cantFail(WarningHandler(EI.message()),
+    llvm_cantFail(WarningHandler(EI.message()),
              "WarningHandler should always return ErrorSuccess");
   });
 }
 
 template <typename ELFT> class LLVMStyle : public DumpStyle<ELFT> {
 public:
   TYPEDEF_ELF_TYPES(ELFT)
 

llvm/tools/obj2yaml/coff2yaml.cpp

for (const auto &S : Obj.sections()) {
     }
 
     ArrayRef<uint8_t> sectionData;
     if ((*SectionNameOrErr) != ".debug$S")
       continue;
 
     const object::coff_section *COFFSection = Obj.getCOFFSection(S);
 
-    cantFail(Obj.getSectionContents(COFFSection, sectionData));
+    llvm_cantFail(Obj.getSectionContents(COFFSection, sectionData));
 
     BinaryStreamReader Reader(sectionData, support::little);
     uint32_t Magic;
 
     Err(Reader.readInteger(Magic));
     assert(Magic == COFF::DEBUG_SECTION_MAGIC && "Invalid .debug$S section!");
 
     codeview::DebugSubsectionArray Subsections;
NewYAMLSection.Header.PointerToRelocations =
         COFFSection->PointerToRelocations;
     NewYAMLSection.Header.SizeOfRawData = COFFSection->SizeOfRawData;
     uint32_t Shift = (COFFSection->Characteristics >> 20) & 0xF;
     NewYAMLSection.Alignment = (1U << Shift) >> 1;
     assert(NewYAMLSection.Alignment <= 8192);
 
     ArrayRef<uint8_t> sectionData;
     if (!ObjSection.isBSS())
-      cantFail(Obj.getSectionContents(COFFSection, sectionData));
+      llvm_cantFail(Obj.getSectionContents(COFFSection, sectionData));
     NewYAMLSection.SectionData = yaml::BinaryRef(sectionData);
 
     if (NewYAMLSection.Name == ".debug$S")
       NewYAMLSection.DebugS = CodeViewYAML::fromDebugS(sectionData, SC);
     else if (NewYAMLSection.Name == ".debug$T")
       NewYAMLSection.DebugT = CodeViewYAML::fromDebugT(sectionData,
                                                        NewYAMLSection.Name);
     else if (NewYAMLSection.Name == ".debug$P")

llvm/unittests/ADT/FallibleIteratorTest.cpp

TEST(FallibleIteratorTest, BasicSuccess) {
 
   FallibleCollectionWalker begin(C, 0);
   FallibleCollectionWalker end(C, 2);
 
   Error Err = Error::success();
   for (auto &Elem :
        make_fallible_range<FallibleCollectionWalker>(begin, end, Err))
     EXPECT_TRUE(Elem.isValid());
-  cantFail(std::move(Err));
+  llvm_cantFail(std::move(Err));
 }
 
 TEST(FallibleIteratorTest, BasicFailure) {
 
   // Check that a iteration failure (due to the InvalidLink state on element one
   // of the fallible collection) breaks out of the loop and raises an Error.
 
   FallibleCollection C({{ValidItem, ValidLink}, {ValidItem, InvalidLink}});
FallibleCollection C({{ValidItem, ValidLink},
                         {InvalidItem, InvalidLink}});
 
   FallibleCollectionWalkerWithStructDeref begin(C, 0);
 
   {
     Error Err = Error::success();
     auto I = make_fallible_itr(begin, Err);
     EXPECT_TRUE(I->isValid());
-    cantFail(std::move(Err));
+    llvm_cantFail(std::move(Err));
   }
 
   {
     Error Err = Error::success();
     const auto I = make_fallible_itr(begin, Err);
     EXPECT_TRUE(I->isValid());
-    cantFail(std::move(Err));
+    llvm_cantFail(std::move(Err));
   }
 }
 
 TEST(FallibleIteratorTest, CheckDerefToExpectedSupport) {
 
   // Check that the fallible_iterator wrapper forwards value types, in
   // particular llvm::Expected, correctly.
 
TEST(FallibleIteratorTest, CheckDerefToExpectedSupport) {
   Expected<Item> V2 = *I;
   EXPECT_THAT_ERROR(V2.takeError(), Failed());
   ++I;
   EXPECT_NE(I, E); // Implicitly check error.
   Expected<Item> V3 = *I;
   EXPECT_THAT_ERROR(V3.takeError(), Succeeded());
   ++I;
   EXPECT_EQ(I, E);
-  cantFail(std::move(Err));
+  llvm_cantFail(std::move(Err));
 }
 
 } // namespace

llvm/unittests/ExecutionEngine/Orc/CoreAPIsTest.cpp

auto OnCompletion = [&](Expected<SymbolMap> Result) {
     EXPECT_NE(I, Resolved.end()) << "Could not find symbol definition";
     EXPECT_EQ(I->second.getAddress(), FooAddr)
         << "Resolution returned incorrect result";
     OnCompletionRun = true;
   };
 
   std::shared_ptr<MaterializationResponsibility> FooMR;
 
-  cantFail(JD.define(std::make_unique<SimpleMaterializationUnit>(
+  llvm_cantFail(JD.define(std::make_unique<SimpleMaterializationUnit>(
       SymbolFlagsMap({{Foo, FooSym.getFlags()}}),
       [&](MaterializationResponsibility R) {
         FooMR = std::make_shared<MaterializationResponsibility>(std::move(R));
       })));
 
   ES.lookup(JITDylibSearchList({{&JD, false}}), {Foo}, SymbolState::Ready,
             OnCompletion, NoDependenciesToRegister);
 
   EXPECT_FALSE(OnCompletionRun) << "Should not have been resolved yet";
 
-  cantFail(FooMR->notifyResolved({{Foo, FooSym}}));
+  llvm_cantFail(FooMR->notifyResolved({{Foo, FooSym}}));
 
   EXPECT_FALSE(OnCompletionRun) << "Should not be ready yet";
 
-  cantFail(FooMR->notifyEmitted());
+  llvm_cantFail(FooMR->notifyEmitted());
 
   EXPECT_TRUE(OnCompletionRun) << "Should have been marked ready";
 }
 
 TEST_F(CoreAPIsStandardTest, ExecutionSessionFailQuery) {
   bool OnCompletionRun = false;
 
   auto OnCompletion = [&](Expected<SymbolMap> Result) {
TEST_F(CoreAPIsStandardTest, ExecutionSessionFailQuery) {
 
   EXPECT_TRUE(OnCompletionRun) << "OnCompletionCallback was not run";
 }
 
 TEST_F(CoreAPIsStandardTest, EmptyLookup) {
   bool OnCompletionRun = false;
 
   auto OnCompletion = [&](Expected<SymbolMap> Result) {
-    cantFail(std::move(Result));
+    llvm_cantFail(std::move(Result));
     OnCompletionRun = true;
   };
 
   ES.lookup(JITDylibSearchList({{&JD, false}}), {}, SymbolState::Ready,
             OnCompletion, NoDependenciesToRegister);
 
   EXPECT_TRUE(OnCompletionRun) << "OnCompletion was not run for empty query";
 }
 
 TEST_F(CoreAPIsStandardTest, RemoveSymbolsTest) {
   // Test that:
   // (1) Missing symbols generate a SymbolsNotFound error.
   // (2) Materializing symbols generate a SymbolCouldNotBeRemoved error.
   // (3) Removal of unmaterialized symbols triggers discard on the
   //     materialization unit.
   // (4) Removal of symbols destroys empty materialization units.
   // (5) Removal of materialized symbols works.
 
   // Foo will be fully materialized.
-  cantFail(JD.define(absoluteSymbols({{Foo, FooSym}})));
+  llvm_cantFail(JD.define(absoluteSymbols({{Foo, FooSym}})));
 
   // Bar will be unmaterialized.
   bool BarDiscarded = false;
   bool BarMaterializerDestructed = false;
-  cantFail(JD.define(std::make_unique<SimpleMaterializationUnit>(
+  llvm_cantFail(JD.define(std::make_unique<SimpleMaterializationUnit>(
       SymbolFlagsMap({{Bar, BarSym.getFlags()}}),
       [this](MaterializationResponsibility R) {
         ADD_FAILURE() << "Unexpected materialization of \"Bar\"";
-        cantFail(R.notifyResolved({{Bar, BarSym}}));
-        cantFail(R.notifyEmitted());
+        llvm_cantFail(R.notifyResolved({{Bar, BarSym}}));
+        llvm_cantFail(R.notifyEmitted());
       },
       [&](const JITDylib &JD, const SymbolStringPtr &Name) {
         EXPECT_EQ(Name, Bar) << "Expected \"Bar\" to be discarded";
         if (Name == Bar)
           BarDiscarded = true;
       },
       [&]() { BarMaterializerDestructed = true; })));
 
   // Baz will be in the materializing state initially, then
   // materialized for the final removal attempt.
   Optional<MaterializationResponsibility> BazR;
-  cantFail(JD.define(std::make_unique<SimpleMaterializationUnit>(
+  llvm_cantFail(JD.define(std::make_unique<SimpleMaterializationUnit>(
       SymbolFlagsMap({{Baz, BazSym.getFlags()}}),
       [&](MaterializationResponsibility R) { BazR.emplace(std::move(R)); },
       [](const JITDylib &JD, const SymbolStringPtr &Name) {
         ADD_FAILURE() << "\"Baz\" discarded unexpectedly";
       })));
 
   bool OnCompletionRun = false;
   ES.lookup(
       JITDylibSearchList({{&JD, false}}), {Foo, Baz}, SymbolState::Ready,
       [&](Expected<SymbolMap> Result) {
-        cantFail(Result.takeError());
+        llvm_cantFail(Result.takeError());
         OnCompletionRun = true;
       },
       NoDependenciesToRegister);
 
   {
     // Attempt 1: Search for a missing symbol, Qux.
     auto Err = JD.remove({Foo, Bar, Baz, Qux});
     EXPECT_TRUE(!!Err) << "Expected failure";
     EXPECT_TRUE(Err.isA<SymbolsNotFound>())
         << "Expected a SymbolsNotFound error";
     consumeError(std::move(Err));
   }
 
   {
     // Attempt 2: Search for a symbol that is still materializing, Baz.
     auto Err = JD.remove({Foo, Bar, Baz});
     EXPECT_TRUE(!!Err) << "Expected failure";
     EXPECT_TRUE(Err.isA<SymbolsCouldNotBeRemoved>())
         << "Expected a SymbolsNotFound error";
     consumeError(std::move(Err));
   }
 
-  cantFail(BazR->notifyResolved({{Baz, BazSym}}));
-  cantFail(BazR->notifyEmitted());
+  llvm_cantFail(BazR->notifyResolved({{Baz, BazSym}}));
+  llvm_cantFail(BazR->notifyEmitted());
   {
     // Attempt 3: Search now that all symbols are fully materialized
     // (Foo, Baz), or not yet materialized (Bar).
     auto Err = JD.remove({Foo, Bar, Baz});
     EXPECT_FALSE(!!Err) << "Expected failure";
   }
 
   EXPECT_TRUE(BarDiscarded) << "\"Bar\" should have been discarded";
   EXPECT_TRUE(BarMaterializerDestructed)
       << "\"Bar\"'s materializer should have been destructed";
   EXPECT_TRUE(OnCompletionRun) << "OnCompletion should have been run";
 }
 
 TEST_F(CoreAPIsStandardTest, ChainedJITDylibLookup) {
-  cantFail(JD.define(absoluteSymbols({{Foo, FooSym}})));
+  llvm_cantFail(JD.define(absoluteSymbols({{Foo, FooSym}})));
 
   auto &JD2 = ES.createJITDylib("JD2");
 
   bool OnCompletionRun = false;
 
   auto Q = std::make_shared<AsynchronousSymbolQuery>(
       SymbolNameSet({Foo}), SymbolState::Ready,
       [&](Expected<SymbolMap> Result) {
-        cantFail(std::move(Result));
+        llvm_cantFail(std::move(Result));
         OnCompletionRun = true;
       });
 
-  cantFail(JD2.legacyLookup(Q, cantFail(JD.legacyLookup(Q, {Foo}))));
+  llvm_cantFail(JD2.legacyLookup(Q, cantFail(JD.legacyLookup(Q, {Foo}))));
 
   EXPECT_TRUE(OnCompletionRun) << "OnCompletion was not run for empty query";
 }
 
 TEST_F(CoreAPIsStandardTest, LookupWithHiddenSymbols) {
   auto BarHiddenFlags = BarSym.getFlags() & ~JITSymbolFlags::Exported;
   auto BarHiddenSym = JITEvaluatedSymbol(BarSym.getAddress(), BarHiddenFlags);
 
-  cantFail(JD.define(absoluteSymbols({{Foo, FooSym}, {Bar, BarHiddenSym}})));
+  llvm_cantFail(JD.define(absoluteSymbols({{Foo, FooSym}, {Bar, BarHiddenSym}})));
 
   auto &JD2 = ES.createJITDylib("JD2");
-  cantFail(JD2.define(absoluteSymbols({{Bar, QuxSym}})));
+  llvm_cantFail(JD2.define(absoluteSymbols({{Bar, QuxSym}})));
 
   /// Try a blocking lookup.
-  auto Result = cantFail(
+  auto Result = llvm_cantFail(
       ES.lookup(JITDylibSearchList({{&JD, false}, {&JD2, false}}), {Foo, Bar}));
 
   EXPECT_EQ(Result.size(), 2U) << "Unexpected number of results";
   EXPECT_EQ(Result.count(Foo), 1U) << "Missing result for \"Foo\"";
   EXPECT_EQ(Result.count(Bar), 1U) << "Missing result for \"Bar\"";
   EXPECT_EQ(Result[Bar].getAddress(), QuxSym.getAddress())
       << "Wrong result for \"Bar\"";
 }
 
 TEST_F(CoreAPIsStandardTest, LookupFlagsTest) {
   // Test that lookupFlags works on a predefined symbol, and does not trigger
   // materialization of a lazy symbol. Make the lazy symbol weak to test that
   // the weak flag is propagated correctly.
 
   BarSym.setFlags(static_cast<JITSymbolFlags::FlagNames>(
       JITSymbolFlags::Exported | JITSymbolFlags::Weak));
   auto MU = std::make_unique<SimpleMaterializationUnit>(
       SymbolFlagsMap({{Bar, BarSym.getFlags()}}),
       [](MaterializationResponsibility R) {
         llvm_unreachable("Symbol materialized on flags lookup");
       });
 
-  cantFail(JD.define(absoluteSymbols({{Foo, FooSym}})));
-  cantFail(JD.define(std::move(MU)));
+  llvm_cantFail(JD.define(absoluteSymbols({{Foo, FooSym}})));
+  llvm_cantFail(JD.define(std::move(MU)));
 
   SymbolNameSet Names({Foo, Bar, Baz});
 
-  auto SymbolFlags = cantFail(JD.lookupFlags(Names));
+  auto SymbolFlags = llvm_cantFail(JD.lookupFlags(Names));
 
   EXPECT_EQ(SymbolFlags.size(), 2U)
       << "Returned symbol flags contains unexpected results";
   EXPECT_EQ(SymbolFlags.count(Foo), 1U) << "Missing lookupFlags result for Foo";
   EXPECT_EQ(SymbolFlags[Foo], FooSym.getFlags())
       << "Incorrect flags returned for Foo";
   EXPECT_EQ(SymbolFlags.count(Bar), 1U)
       << "Missing  lookupFlags result for Bar";
TEST_F(CoreAPIsStandardTest, LookupWithGeneratorFailure) {
   EXPECT_THAT_ERROR(
       ES.lookup(JITDylibSearchList({{&JD, false}}), SymbolNameSet({Foo}))
           .takeError(),
       Failed<StringError>())
       << "Generator failure did not propagate through lookup";
 }
 
 TEST_F(CoreAPIsStandardTest, TestBasicAliases) {
-  cantFail(JD.define(absoluteSymbols({{Foo, FooSym}, {Bar, BarSym}})));
-  cantFail(JD.define(symbolAliases({{Baz, {Foo, JITSymbolFlags::Exported}},
+  llvm_cantFail(JD.define(absoluteSymbols({{Foo, FooSym}, {Bar, BarSym}})));
+  llvm_cantFail(JD.define(symbolAliases({{Baz, {Foo, JITSymbolFlags::Exported}},
                                     {Qux, {Bar, JITSymbolFlags::Weak}}})));
-  cantFail(JD.define(absoluteSymbols({{Qux, QuxSym}})));
+  llvm_cantFail(JD.define(absoluteSymbols({{Qux, QuxSym}})));
 
   auto Result = ES.lookup(JITDylibSearchList({{&JD, false}}), {Baz, Qux});
   EXPECT_TRUE(!!Result) << "Unexpected lookup failure";
   EXPECT_EQ(Result->count(Baz), 1U) << "No result for \"baz\"";
   EXPECT_EQ(Result->count(Qux), 1U) << "No result for \"qux\"";
   EXPECT_EQ((*Result)[Baz].getAddress(), FooSym.getAddress())
       << "\"Baz\"'s address should match \"Foo\"'s";
   EXPECT_EQ((*Result)[Qux].getAddress(), QuxSym.getAddress())
       << "The \"Qux\" alias should have been overriden";
 }
 
 TEST_F(CoreAPIsStandardTest, TestChainedAliases) {
-  cantFail(JD.define(absoluteSymbols({{Foo, FooSym}})));
-  cantFail(JD.define(symbolAliases(
+  llvm_cantFail(JD.define(absoluteSymbols({{Foo, FooSym}})));
+  llvm_cantFail(JD.define(symbolAliases(
       {{Baz, {Bar, BazSym.getFlags()}}, {Bar, {Foo, BarSym.getFlags()}}})));
 
   auto Result = ES.lookup(JITDylibSearchList({{&JD, false}}), {Bar, Baz});
   EXPECT_TRUE(!!Result) << "Unexpected lookup failure";
   EXPECT_EQ(Result->count(Bar), 1U) << "No result for \"bar\"";
   EXPECT_EQ(Result->count(Baz), 1U) << "No result for \"baz\"";
   EXPECT_EQ((*Result)[Bar].getAddress(), FooSym.getAddress())
       << "\"Bar\"'s address should match \"Foo\"'s";
   EXPECT_EQ((*Result)[Baz].getAddress(), FooSym.getAddress())
       << "\"Baz\"'s address should match \"Foo\"'s";
 }
 
 TEST_F(CoreAPIsStandardTest, TestBasicReExports) {
   // Test that the basic use case of re-exporting a single symbol from another
   // JITDylib works.
-  cantFail(JD.define(absoluteSymbols({{Foo, FooSym}})));
+  llvm_cantFail(JD.define(absoluteSymbols({{Foo, FooSym}})));
 
   auto &JD2 = ES.createJITDylib("JD2");
 
-  cantFail(JD2.define(reexports(JD, {{Bar, {Foo, BarSym.getFlags()}}})));
+  llvm_cantFail(JD2.define(reexports(JD, {{Bar, {Foo, BarSym.getFlags()}}})));
 
-  auto Result = cantFail(ES.lookup(JITDylibSearchList({{&JD2, false}}), Bar));
+  auto Result = llvm_cantFail(ES.lookup(JITDylibSearchList({{&JD2, false}}), Bar));
   EXPECT_EQ(Result.getAddress(), FooSym.getAddress())
       << "Re-export Bar for symbol Foo should match FooSym's address";
 }
 
 TEST_F(CoreAPIsStandardTest, TestThatReExportsDontUnnecessarilyMaterialize) {
   // Test that re-exports do not materialize symbols that have not been queried
   // for.
-  cantFail(JD.define(absoluteSymbols({{Foo, FooSym}})));
+  llvm_cantFail(JD.define(absoluteSymbols({{Foo, FooSym}})));
 
   bool BarMaterialized = false;
   auto BarMU = std::make_unique<SimpleMaterializationUnit>(
       SymbolFlagsMap({{Bar, BarSym.getFlags()}}),
       [&](MaterializationResponsibility R) {
         BarMaterialized = true;
-        cantFail(R.notifyResolved({{Bar, BarSym}}));
-        cantFail(R.notifyEmitted());
+        llvm_cantFail(R.notifyResolved({{Bar, BarSym}}));
+        llvm_cantFail(R.notifyEmitted());
       });
 
-  cantFail(JD.define(BarMU));
+  llvm_cantFail(JD.define(BarMU));
 
   auto &JD2 = ES.createJITDylib("JD2");
 
-  cantFail(JD2.define(reexports(
+  llvm_cantFail(JD2.define(reexports(
       JD, {{Baz, {Foo, BazSym.getFlags()}}, {Qux, {Bar, QuxSym.getFlags()}}})));
 
-  auto Result = cantFail(ES.lookup(JITDylibSearchList({{&JD2, false}}), Baz));
+  auto Result = llvm_cantFail(ES.lookup(JITDylibSearchList({{&JD2, false}}), Baz));
   EXPECT_EQ(Result.getAddress(), FooSym.getAddress())
       << "Re-export Baz for symbol Foo should match FooSym's address";
 
   EXPECT_FALSE(BarMaterialized) << "Bar should not have been materialized";
 }
 
 TEST_F(CoreAPIsStandardTest, TestReexportsGenerator) {
   // Test that a re-exports generator can dynamically generate reexports.
 
   auto &JD2 = ES.createJITDylib("JD2");
-  cantFail(JD2.define(absoluteSymbols({{Foo, FooSym}, {Bar, BarSym}})));
+  llvm_cantFail(JD2.define(absoluteSymbols({{Foo, FooSym}, {Bar, BarSym}})));
 
   auto Filter = [this](SymbolStringPtr Name) { return Name != Bar; };
 
   JD.addGenerator(std::make_unique<ReexportsGenerator>(JD2, false, Filter));
 
-  auto Flags = cantFail(JD.lookupFlags({Foo, Bar, Baz}));
+  auto Flags = llvm_cantFail(JD.lookupFlags({Foo, Bar, Baz}));
   EXPECT_EQ(Flags.size(), 1U) << "Unexpected number of results";
   EXPECT_EQ(Flags[Foo], FooSym.getFlags()) << "Unexpected flags for Foo";
 
-  auto Result = cantFail(ES.lookup(JITDylibSearchList({{&JD, false}}), Foo));
+  auto Result = llvm_cantFail(ES.lookup(JITDylibSearchList({{&JD, false}}), Foo));
 
   EXPECT_EQ(Result.getAddress(), FooSym.getAddress())
       << "Incorrect reexported symbol address";
 }
 
 TEST_F(CoreAPIsStandardTest, TestTrivialCircularDependency) {
   Optional<MaterializationResponsibility> FooR;
   auto FooMU = std::make_unique<SimpleMaterializationUnit>(
       SymbolFlagsMap({{Foo, FooSym.getFlags()}}),
       [&](MaterializationResponsibility R) { FooR.emplace(std::move(R)); });
 
-  cantFail(JD.define(FooMU));
+  llvm_cantFail(JD.define(FooMU));
 
   bool FooReady = false;
   auto OnCompletion = [&](Expected<SymbolMap> Result) {
-    cantFail(std::move(Result));
+    llvm_cantFail(std::move(Result));
     FooReady = true;
   };
 
   ES.lookup(JITDylibSearchList({{&JD, false}}), {Foo}, SymbolState::Ready,
             OnCompletion, NoDependenciesToRegister);
 
   FooR->addDependenciesForAll({{&JD, SymbolNameSet({Foo})}});
   EXPECT_THAT_ERROR(FooR->notifyResolved({{Foo, FooSym}}), Succeeded())
auto BarMU = std::make_unique<SimpleMaterializationUnit>(
       SymbolFlagsMap({{Bar, BarSym.getFlags()}}),
       [&](MaterializationResponsibility R) { BarR.emplace(std::move(R)); });
 
   auto BazMU = std::make_unique<SimpleMaterializationUnit>(
       SymbolFlagsMap({{Baz, BazSym.getFlags()}}),
       [&](MaterializationResponsibility R) { BazR.emplace(std::move(R)); });
 
   // Define the symbols.
-  cantFail(JD.define(FooMU));
-  cantFail(JD.define(BarMU));
-  cantFail(JD.define(BazMU));
+  llvm_cantFail(JD.define(FooMU));
+  llvm_cantFail(JD.define(BarMU));
+  llvm_cantFail(JD.define(BazMU));
 
   // Query each of the symbols to trigger materialization.
   bool FooResolved = false;
   bool FooReady = false;
 
   auto OnFooResolution = [&](Expected<SymbolMap> Result) {
-    cantFail(std::move(Result));
+    llvm_cantFail(std::move(Result));
     FooResolved = true;
   };
 
   auto OnFooReady = [&](Expected<SymbolMap> Result) {
-    cantFail(std::move(Result));
+    llvm_cantFail(std::move(Result));
     FooReady = true;
   };
 
   // Issue lookups for Foo. Use NoDependenciesToRegister: We're going to add
   // the dependencies manually below.
   ES.lookup(JITDylibSearchList({{&JD, false}}), {Foo}, SymbolState::Resolved,
             std::move(OnFooResolution), NoDependenciesToRegister);
 
   ES.lookup(JITDylibSearchList({{&JD, false}}), {Foo}, SymbolState::Ready,
             std::move(OnFooReady), NoDependenciesToRegister);
 
   bool BarResolved = false;
   bool BarReady = false;
   auto OnBarResolution = [&](Expected<SymbolMap> Result) {
-    cantFail(std::move(Result));
+    llvm_cantFail(std::move(Result));
     BarResolved = true;
   };
 
   auto OnBarReady = [&](Expected<SymbolMap> Result) {
-    cantFail(std::move(Result));
+    llvm_cantFail(std::move(Result));
     BarReady = true;
   };
 
   ES.lookup(JITDylibSearchList({{&JD, false}}), {Bar}, SymbolState::Resolved,
             std::move(OnBarResolution), NoDependenciesToRegister);
 
   ES.lookup(JITDylibSearchList({{&JD, false}}), {Bar}, SymbolState::Ready,
             std::move(OnBarReady), NoDependenciesToRegister);
 
   bool BazResolved = false;
   bool BazReady = false;
 
   auto OnBazResolution = [&](Expected<SymbolMap> Result) {
-    cantFail(std::move(Result));
+    llvm_cantFail(std::move(Result));
     BazResolved = true;
   };
 
   auto OnBazReady = [&](Expected<SymbolMap> Result) {
-    cantFail(std::move(Result));
+    llvm_cantFail(std::move(Result));
     BazReady = true;
   };
 
   ES.lookup(JITDylibSearchList({{&JD, false}}), {Baz}, SymbolState::Resolved,
             std::move(OnBazResolution), NoDependenciesToRegister);
 
   ES.lookup(JITDylibSearchList({{&JD, false}}), {Baz}, SymbolState::Ready,
             std::move(OnBazReady), NoDependenciesToRegister);
auto FooMU = std::make_unique<SimpleMaterializationUnit>(
       SymbolFlagsMap({{Foo, FooSym.getFlags()}}),
       [&](MaterializationResponsibility R) { FooR.emplace(std::move(R)); });
 
   auto BarMU = std::make_unique<SimpleMaterializationUnit>(
       SymbolFlagsMap({{Bar, BarSym.getFlags()}}),
       [&](MaterializationResponsibility R) { BarR.emplace(std::move(R)); });
 
   // Define the symbols.
-  cantFail(JD.define(FooMU));
-  cantFail(JD.define(BarMU));
+  llvm_cantFail(JD.define(FooMU));
+  llvm_cantFail(JD.define(BarMU));
 
   bool OnFooReadyRun = false;
   auto OnFooReady = [&](Expected<SymbolMap> Result) {
     EXPECT_THAT_EXPECTED(std::move(Result), Failed());
     OnFooReadyRun = true;
   };
 
   ES.lookup(JITDylibSearchList({{&JD, false}}), {Foo}, SymbolState::Ready,
auto FooMU = std::make_unique<SimpleMaterializationUnit>(
       SymbolFlagsMap({{Foo, FooSym.getFlags()}}),
       [&](MaterializationResponsibility R) { FooR.emplace(std::move(R)); });
 
   auto BarMU = std::make_unique<SimpleMaterializationUnit>(
       SymbolFlagsMap({{Bar, BarSym.getFlags()}}),
       [&](MaterializationResponsibility R) { BarR.emplace(std::move(R)); });
 
   // Define the symbols.
-  cantFail(JD.define(FooMU));
-  cantFail(JD.define(BarMU));
+  llvm_cantFail(JD.define(FooMU));
+  llvm_cantFail(JD.define(BarMU));
 
   bool OnFooReadyRun = false;
   auto OnFooReady = [&](Expected<SymbolMap> Result) {
     EXPECT_THAT_EXPECTED(std::move(Result), Failed());
     OnFooReadyRun = true;
   };
 
   ES.lookup(JITDylibSearchList({{&JD, false}}), {Foo}, SymbolState::Ready,
auto FooMU = std::make_unique<SimpleMaterializationUnit>(
       SymbolFlagsMap({{Foo, FooSym.getFlags()}}),
       [&](MaterializationResponsibility R) { FooR.emplace(std::move(R)); });
 
   auto BarMU = std::make_unique<SimpleMaterializationUnit>(
       SymbolFlagsMap({{Bar, BarSym.getFlags()}}),
       [&](MaterializationResponsibility R) { BarR.emplace(std::move(R)); });
 
   // Define the symbols.
-  cantFail(JD.define(FooMU));
-  cantFail(JD.define(BarMU));
+  llvm_cantFail(JD.define(FooMU));
+  llvm_cantFail(JD.define(BarMU));
 
   bool OnFooReadyRun = false;
   auto OnFooReady = [&](Expected<SymbolMap> Result) {
     EXPECT_THAT_EXPECTED(std::move(Result), Failed());
     OnFooReadyRun = true;
   };
 
   ES.lookup(JITDylibSearchList({{&JD, false}}), {Foo}, SymbolState::Ready,
auto FooMU = std::make_unique<SimpleMaterializationUnit>(
       SymbolFlagsMap({{Foo, FooSym.getFlags()}}),
       [&](MaterializationResponsibility R) { FooR.emplace(std::move(R)); });
 
   auto BarMU = std::make_unique<SimpleMaterializationUnit>(
       SymbolFlagsMap({{Bar, BarSym.getFlags()}}),
       [&](MaterializationResponsibility R) { BarR.emplace(std::move(R)); });
 
   // Define the symbols.
-  cantFail(JD.define(FooMU));
-  cantFail(JD.define(BarMU));
+  llvm_cantFail(JD.define(FooMU));
+  llvm_cantFail(JD.define(BarMU));
 
   bool OnFooReadyRun = false;
   auto OnFooReady = [&](Expected<SymbolMap> Result) {
     EXPECT_THAT_EXPECTED(std::move(Result), Failed());
     OnFooReadyRun = true;
   };
 
   ES.lookup(JITDylibSearchList({{&JD, false}}), {Foo}, SymbolState::Ready,
TEST_F(CoreAPIsStandardTest, FailMaterializerWithUnqueriedSymbols) {
   auto MU = std::make_unique<SimpleMaterializationUnit>(
       SymbolFlagsMap(
           {{Foo, JITSymbolFlags::Exported}, {Bar, JITSymbolFlags::Exported}}),
       [&](MaterializationResponsibility R) {
         MaterializerRun = true;
         R.failMaterialization();
       });
 
-  cantFail(JD.define(std::move(MU)));
+  llvm_cantFail(JD.define(std::move(MU)));
 
   // Issue a query for Foo, but not bar.
   EXPECT_THAT_EXPECTED(ES.lookup({&JD}, {Foo}), Failed())
       << "Expected lookup to fail.";
 
   // Check that the materializer (and therefore failMaterialization) ran.
   EXPECT_TRUE(MaterializerRun) << "Expected materializer to have run by now";
 
auto MU = std::make_unique<SimpleMaterializationUnit>(
         llvm_unreachable("Unexpected call to materialize");
       },
       [&](const JITDylib &JD, SymbolStringPtr Name) {
         EXPECT_TRUE(Name == Foo || Name == Bar)
             << "Discard of unexpected symbol?";
       },
       [&]() { DestructorRun = true; });
 
-  cantFail(JD.define(MU));
+  llvm_cantFail(JD.define(MU));
 
-  cantFail(JD.define(absoluteSymbols({{Foo, FooSym}})));
+  llvm_cantFail(JD.define(absoluteSymbols({{Foo, FooSym}})));
 
   EXPECT_FALSE(DestructorRun)
       << "MaterializationUnit should not have been destroyed yet";
 
-  cantFail(JD.define(absoluteSymbols({{Bar, BarSym}})));
+  llvm_cantFail(JD.define(absoluteSymbols({{Bar, BarSym}})));
 
   EXPECT_TRUE(DestructorRun)
       << "MaterializationUnit should have been destroyed";
 }
 
 TEST_F(CoreAPIsStandardTest, AddAndMaterializeLazySymbol) {
   bool FooMaterialized = false;
   bool BarDiscarded = false;
 
   JITSymbolFlags WeakExported(JITSymbolFlags::Exported);
   WeakExported |= JITSymbolFlags::Weak;
 
   auto MU = std::make_unique<SimpleMaterializationUnit>(
       SymbolFlagsMap({{Foo, JITSymbolFlags::Exported}, {Bar, WeakExported}}),
       [&](MaterializationResponsibility R) {
         assert(BarDiscarded && "Bar should have been discarded by this point");
-        cantFail(R.notifyResolved(SymbolMap({{Foo, FooSym}})));
-        cantFail(R.notifyEmitted());
+        llvm_cantFail(R.notifyResolved(SymbolMap({{Foo, FooSym}})));
+        llvm_cantFail(R.notifyEmitted());
         FooMaterialized = true;
       },
       [&](const JITDylib &JD, SymbolStringPtr Name) {
         EXPECT_EQ(Name, Bar) << "Expected Name to be Bar";
         BarDiscarded = true;
       });
 
-  cantFail(JD.define(MU));
-  cantFail(JD.define(absoluteSymbols({{Bar, BarSym}})));
+  llvm_cantFail(JD.define(MU));
+  llvm_cantFail(JD.define(absoluteSymbols({{Bar, BarSym}})));
 
   SymbolNameSet Names({Foo});
 
   bool OnCompletionRun = false;
 
   auto OnCompletion = [&](Expected<SymbolMap> Result) {
     EXPECT_TRUE(!!Result) << "Resolution unexpectedly returned error";
     auto I = Result->find(Foo);

 TEST_F(CoreAPIsStandardTest, TestBasicWeakSymbolMaterialization) {
   // Test that weak symbols are materialized correctly when we look them up.
   BarSym.setFlags(BarSym.getFlags() | JITSymbolFlags::Weak);
 
   bool BarMaterialized = false;
   auto MU1 = std::make_unique<SimpleMaterializationUnit>(
       SymbolFlagsMap({{Foo, FooSym.getFlags()}, {Bar, BarSym.getFlags()}}),
       [&](MaterializationResponsibility R) {
-        cantFail(R.notifyResolved(SymbolMap({{Foo, FooSym}, {Bar, BarSym}})));
-        cantFail(R.notifyEmitted());
+        llvm_cantFail(R.notifyResolved(SymbolMap({{Foo, FooSym}, {Bar, BarSym}})));
+        llvm_cantFail(R.notifyEmitted());
         BarMaterialized = true;
       });
 
   bool DuplicateBarDiscarded = false;
   auto MU2 = std::make_unique<SimpleMaterializationUnit>(
       SymbolFlagsMap({{Bar, BarSym.getFlags()}}),
       [&](MaterializationResponsibility R) {
         ADD_FAILURE() << "Attempt to materialize Bar from the wrong unit";
         R.failMaterialization();
       },
       [&](const JITDylib &JD, SymbolStringPtr Name) {
         EXPECT_EQ(Name, Bar) << "Expected \"Bar\" to be discarded";
         DuplicateBarDiscarded = true;
       });
 
-  cantFail(JD.define(MU1));
-  cantFail(JD.define(MU2));
+  llvm_cantFail(JD.define(MU1));
+  llvm_cantFail(JD.define(MU2));
 
   bool OnCompletionRun = false;
 
   auto OnCompletion = [&](Expected<SymbolMap> Result) {
-    cantFail(std::move(Result));
+    llvm_cantFail(std::move(Result));
     OnCompletionRun = true;
   };
 
   ES.lookup(JITDylibSearchList({{&JD, false}}), {Bar}, SymbolState::Ready,
             std::move(OnCompletion), NoDependenciesToRegister);
 
   EXPECT_TRUE(OnCompletionRun) << "OnCompletion not run";
   EXPECT_TRUE(BarMaterialized) << "Bar was not materialized at all";
   EXPECT_TRUE(DuplicateBarDiscarded)
       << "Duplicate bar definition not discarded";
 }
 
 TEST_F(CoreAPIsStandardTest, DefineMaterializingSymbol) {
   bool ExpectNoMoreMaterialization = false;
   ES.setDispatchMaterialization(
       [&](JITDylib &JD, std::unique_ptr<MaterializationUnit> MU) {
         if (ExpectNoMoreMaterialization)
           ADD_FAILURE() << "Unexpected materialization";
         MU->doMaterialize(JD);
       });
 
   auto MU = std::make_unique<SimpleMaterializationUnit>(
       SymbolFlagsMap({{Foo, FooSym.getFlags()}}),
       [&](MaterializationResponsibility R) {
-        cantFail(
+        llvm_cantFail(
             R.defineMaterializing(SymbolFlagsMap({{Bar, BarSym.getFlags()}})));
-        cantFail(R.notifyResolved(SymbolMap({{Foo, FooSym}, {Bar, BarSym}})));
-        cantFail(R.notifyEmitted());
+        llvm_cantFail(R.notifyResolved(SymbolMap({{Foo, FooSym}, {Bar, BarSym}})));
+        llvm_cantFail(R.notifyEmitted());
       });
 
-  cantFail(JD.define(MU));
-  cantFail(ES.lookup(JITDylibSearchList({{&JD, false}}), Foo));
+  llvm_cantFail(JD.define(MU));
+  llvm_cantFail(ES.lookup(JITDylibSearchList({{&JD, false}}), Foo));
 
   // Assert that materialization is complete by now.
   ExpectNoMoreMaterialization = true;
 
   // Look up bar to verify that no further materialization happens.
-  auto BarResult = cantFail(ES.lookup(JITDylibSearchList({{&JD, false}}), Bar));
+  auto BarResult = llvm_cantFail(ES.lookup(JITDylibSearchList({{&JD, false}}), Bar));
   EXPECT_EQ(BarResult.getAddress(), BarSym.getAddress())
       << "Expected Bar == BarSym";
 }
 
 TEST_F(CoreAPIsStandardTest, GeneratorTest) {
-  cantFail(JD.define(absoluteSymbols({{Foo, FooSym}})));
+  llvm_cantFail(JD.define(absoluteSymbols({{Foo, FooSym}})));
 
   class TestGenerator : public JITDylib::DefinitionGenerator {
   public:
     TestGenerator(SymbolMap Symbols) : Symbols(std::move(Symbols)) {}
     Expected<SymbolNameSet> tryToGenerate(JITDylib &JD,
                                           const SymbolNameSet &Names) {
       SymbolMap NewDefs;
       SymbolNameSet NewNames;
 
       for (auto &Name : Names) {
         if (Symbols.count(Name)) {
           NewDefs[Name] = Symbols[Name];
           NewNames.insert(Name);
         }
       }
-      cantFail(JD.define(absoluteSymbols(std::move(NewDefs))));
+      llvm_cantFail(JD.define(absoluteSymbols(std::move(NewDefs))));
       return NewNames;
     };
 
   private:
     SymbolMap Symbols;
   };
 
   JD.addGenerator(std::make_unique<TestGenerator>(SymbolMap({{Bar, BarSym}})));
 
   auto Result =
-      cantFail(ES.lookup(JITDylibSearchList({{&JD, false}}), {Foo, Bar}));
+      llvm_cantFail(ES.lookup(JITDylibSearchList({{&JD, false}}), {Foo, Bar}));
 
   EXPECT_EQ(Result.count(Bar), 1U) << "Expected to find fallback def for 'bar'";
   EXPECT_EQ(Result[Bar].getAddress(), BarSym.getAddress())
       << "Expected fallback def for Bar to be equal to BarSym";
 }
 
 TEST_F(CoreAPIsStandardTest, FailResolution) {
   auto MU = std::make_unique<SimpleMaterializationUnit>(
       SymbolFlagsMap({{Foo, JITSymbolFlags::Exported | JITSymbolFlags::Weak},
                       {Bar, JITSymbolFlags::Exported | JITSymbolFlags::Weak}}),
       [&](MaterializationResponsibility R) {
         R.failMaterialization();
       });
 
-  cantFail(JD.define(MU));
+  llvm_cantFail(JD.define(MU));
 
   SymbolNameSet Names({Foo, Bar});
   auto Result = ES.lookup(JITDylibSearchList({{&JD, false}}), Names);
 
   EXPECT_FALSE(!!Result) << "Expected failure";
   if (!Result) {
     handleAllErrors(
         Result.takeError(),
handleAllErrors(
           }
           ADD_FAILURE() << "Expected a FailedToResolve error. Got:\n" << ErrMsg;
         });
   }
 }
 
 TEST_F(CoreAPIsStandardTest, FailEmissionAfterResolution) {
 
-  cantFail(JD.define(absoluteSymbols({{Baz, BazSym}})));
+  llvm_cantFail(JD.define(absoluteSymbols({{Baz, BazSym}})));
 
   auto MU = std::make_unique<SimpleMaterializationUnit>(
       SymbolFlagsMap({{Foo, FooSym.getFlags()}, {Bar, BarSym.getFlags()}}),
       [&](MaterializationResponsibility R) {
-        cantFail(R.notifyResolved(SymbolMap({{Foo, FooSym}, {Bar, BarSym}})));
+        llvm_cantFail(R.notifyResolved(SymbolMap({{Foo, FooSym}, {Bar, BarSym}})));
 
         ES.lookup(
             JITDylibSearchList({{&JD, false}}), SymbolNameSet({Baz}),
             SymbolState::Resolved,
             [&R](Expected<SymbolMap> Result) {
               // Called when "baz" is resolved. We don't actually depend
               // on or care about baz, but use it to trigger failure of
               // this materialization before Baz has been finalized in
               // order to test that error propagation is correct in this
               // scenario.
-              cantFail(std::move(Result));
+              llvm_cantFail(std::move(Result));
               R.failMaterialization();
             },
             [&](const SymbolDependenceMap &Deps) {
               R.addDependenciesForAll(Deps);
             });
       });
 
-  cantFail(JD.define(MU));
+  llvm_cantFail(JD.define(MU));
 
   SymbolNameSet Names({Foo, Bar});
   auto Result = ES.lookup(JITDylibSearchList({{&JD, false}}), Names);
 
   EXPECT_THAT_EXPECTED(std::move(Result), Failed())
       << "Unexpected success while trying to test error propagation";
 }
 
 TEST_F(CoreAPIsStandardTest, FailAfterPartialResolution) {
 
-  cantFail(JD.define(absoluteSymbols({{Foo, FooSym}})));
+  llvm_cantFail(JD.define(absoluteSymbols({{Foo, FooSym}})));
 
   // Fail materialization of bar.
   auto BarMU = std::make_unique<SimpleMaterializationUnit>(
       SymbolFlagsMap({{Bar, BarSym.getFlags()}}),
       [&](MaterializationResponsibility R) { R.failMaterialization(); });
 
-  cantFail(JD.define(std::move(BarMU)));
+  llvm_cantFail(JD.define(std::move(BarMU)));
 
   bool QueryHandlerRun = false;
   ES.lookup(
       JITDylibSearchList({{&JD, false}}), SymbolNameSet({Foo, Bar}),
       SymbolState::Resolved,
       [&](Expected<SymbolMap> Result) {
         EXPECT_THAT_EXPECTED(std::move(Result), Failed())
             << "Expected query to fail";
         QueryHandlerRun = true;
       },
       NoDependenciesToRegister);
   EXPECT_TRUE(QueryHandlerRun) << "Query handler never ran";
 }
 
 TEST_F(CoreAPIsStandardTest, TestLookupWithUnthreadedMaterialization) {
   auto MU = std::make_unique<SimpleMaterializationUnit>(
       SymbolFlagsMap({{Foo, JITSymbolFlags::Exported}}),
       [&](MaterializationResponsibility R) {
-        cantFail(R.notifyResolved({{Foo, FooSym}}));
-        cantFail(R.notifyEmitted());
+        llvm_cantFail(R.notifyResolved({{Foo, FooSym}}));
+        llvm_cantFail(R.notifyEmitted());
       });
 
-  cantFail(JD.define(MU));
+  llvm_cantFail(JD.define(MU));
 
   auto FooLookupResult =
-      cantFail(ES.lookup(JITDylibSearchList({{&JD, false}}), Foo));
+      llvm_cantFail(ES.lookup(JITDylibSearchList({{&JD, false}}), Foo));
 
   EXPECT_EQ(FooLookupResult.getAddress(), FooSym.getAddress())
       << "lookup returned an incorrect address";
   EXPECT_EQ(FooLookupResult.getFlags(), FooSym.getFlags())
       << "lookup returned incorrect flags";
 }
 
 TEST_F(CoreAPIsStandardTest, TestLookupWithThreadedMaterialization) {
 #if LLVM_ENABLE_THREADS
 
   std::thread MaterializationThread;
   ES.setDispatchMaterialization(
       [&](JITDylib &JD, std::unique_ptr<MaterializationUnit> MU) {
         MaterializationThread =
             std::thread([MU = std::move(MU), &JD] { MU->doMaterialize(JD); });
       });
 
-  cantFail(JD.define(absoluteSymbols({{Foo, FooSym}})));
+  llvm_cantFail(JD.define(absoluteSymbols({{Foo, FooSym}})));
 
   auto FooLookupResult =
-      cantFail(ES.lookup(JITDylibSearchList({{&JD, false}}), Foo));
+      llvm_cantFail(ES.lookup(JITDylibSearchList({{&JD, false}}), Foo));
 
   EXPECT_EQ(FooLookupResult.getAddress(), FooSym.getAddress())
       << "lookup returned an incorrect address";
   EXPECT_EQ(FooLookupResult.getFlags(), FooSym.getFlags())
       << "lookup returned incorrect flags";
   MaterializationThread.join();
 #endif
 }
auto MU = std::make_unique<SimpleMaterializationUnit>(
       [&](MaterializationResponsibility R) {
         auto Requested = R.getRequestedSymbols();
         EXPECT_EQ(Requested.size(), 1U) << "Expected one symbol requested";
         EXPECT_EQ(*Requested.begin(), Foo) << "Expected \"Foo\" requested";
 
         auto NewMU = std::make_unique<SimpleMaterializationUnit>(
             SymbolFlagsMap({{Bar, BarSym.getFlags()}}),
             [&](MaterializationResponsibility R2) {
-              cantFail(R2.notifyResolved(SymbolMap({{Bar, BarSym}})));
-              cantFail(R2.notifyEmitted());
+              llvm_cantFail(R2.notifyResolved(SymbolMap({{Bar, BarSym}})));
+              llvm_cantFail(R2.notifyEmitted());
               BarMaterialized = true;
             });
 
         R.replace(std::move(NewMU));
 
-        cantFail(R.notifyResolved(SymbolMap({{Foo, FooSym}})));
-        cantFail(R.notifyEmitted());
+        llvm_cantFail(R.notifyResolved(SymbolMap({{Foo, FooSym}})));
+        llvm_cantFail(R.notifyEmitted());
 
         FooMaterialized = true;
       });
 
-  cantFail(JD.define(MU));
+  llvm_cantFail(JD.define(MU));
 
   EXPECT_FALSE(FooMaterialized) << "Foo should not be materialized yet";
   EXPECT_FALSE(BarMaterialized) << "Bar should not be materialized yet";
 
   auto FooSymResult =
-      cantFail(ES.lookup(JITDylibSearchList({{&JD, false}}), Foo));
+      llvm_cantFail(ES.lookup(JITDylibSearchList({{&JD, false}}), Foo));
   EXPECT_EQ(FooSymResult.getAddress(), FooSym.getAddress())
       << "Address mismatch for Foo";
 
   EXPECT_TRUE(FooMaterialized) << "Foo should be materialized now";
   EXPECT_FALSE(BarMaterialized) << "Bar still should not be materialized";
 
   auto BarSymResult =
-      cantFail(ES.lookup(JITDylibSearchList({{&JD, false}}), Bar));
+      llvm_cantFail(ES.lookup(JITDylibSearchList({{&JD, false}}), Bar));
   EXPECT_EQ(BarSymResult.getAddress(), BarSym.getAddress())
       << "Address mismatch for Bar";
   EXPECT_TRUE(BarMaterialized) << "Bar should be materialized now";
 }
 
 TEST_F(CoreAPIsStandardTest, TestMaterializationResponsibilityDelegation) {
   auto MU = std::make_unique<SimpleMaterializationUnit>(
       SymbolFlagsMap({{Foo, FooSym.getFlags()}, {Bar, BarSym.getFlags()}}),
       [&](MaterializationResponsibility R) {
         auto R2 = R.delegate({Bar});
 
-        cantFail(R.notifyResolved({{Foo, FooSym}}));
-        cantFail(R.notifyEmitted());
-        cantFail(R2.notifyResolved({{Bar, BarSym}}));
-        cantFail(R2.notifyEmitted());
+        llvm_cantFail(R.notifyResolved({{Foo, FooSym}}));
+        llvm_cantFail(R.notifyEmitted());
+        llvm_cantFail(R2.notifyResolved({{Bar, BarSym}}));
+        llvm_cantFail(R2.notifyEmitted());
       });
 
-  cantFail(JD.define(MU));
+  llvm_cantFail(JD.define(MU));
 
   auto Result = ES.lookup(JITDylibSearchList({{&JD, false}}), {Foo, Bar});
 
   EXPECT_TRUE(!!Result) << "Result should be a success value";
   EXPECT_EQ(Result->count(Foo), 1U) << "\"Foo\" entry missing";
   EXPECT_EQ(Result->count(Bar), 1U) << "\"Bar\" entry missing";
   EXPECT_EQ((*Result)[Foo].getAddress(), FooSym.getAddress())
       << "Address mismatch for \"Foo\"";
TEST_F(CoreAPIsStandardTest, TestMaterializeWeakSymbol) {
   std::unique_ptr<MaterializationResponsibility> FooResponsibility;
   auto MU = std::make_unique<SimpleMaterializationUnit>(
       SymbolFlagsMap({{Foo, FooSym.getFlags()}}),
       [&](MaterializationResponsibility R) {
         FooResponsibility =
             std::make_unique<MaterializationResponsibility>(std::move(R));
       });
 
-  cantFail(JD.define(MU));
+  llvm_cantFail(JD.define(MU));
   auto OnCompletion = [](Expected<SymbolMap> Result) {
-    cantFail(std::move(Result));
+    llvm_cantFail(std::move(Result));
   };
 
   ES.lookup(JITDylibSearchList({{&JD, false}}), {Foo}, SymbolState::Ready,
             std::move(OnCompletion), NoDependenciesToRegister);
 
   auto MU2 = std::make_unique<SimpleMaterializationUnit>(
       SymbolFlagsMap({{Foo, JITSymbolFlags::Exported}}),
       [](MaterializationResponsibility R) {
         llvm_unreachable("This unit should never be materialized");
       });
 
   auto Err = JD.define(MU2);
   EXPECT_TRUE(!!Err) << "Expected failure value";
   EXPECT_TRUE(Err.isA<DuplicateDefinition>())
       << "Expected a duplicate definition error";
   consumeError(std::move(Err));
 
   // No dependencies registered, can't fail:
-  cantFail(FooResponsibility->notifyResolved(SymbolMap({{Foo, FooSym}})));
-  cantFail(FooResponsibility->notifyEmitted());
+  llvm_cantFail(FooResponsibility->notifyResolved(SymbolMap({{Foo, FooSym}})));
+  llvm_cantFail(FooResponsibility->notifyEmitted());
 }
 
 } // namespace

llvm/unittests/ExecutionEngine/Orc/GlobalMappingLayerTest.cpp

[](const std::string &Name, bool ExportedSymbolsOnly) -> JITSymbol {
       if (Name == "bar")
         return llvm::JITSymbol(0x4567, JITSymbolFlags::Exported);
       return nullptr;
     };
 
   GlobalMappingLayer<decltype(TestBaseLayer)> L(TestBaseLayer);
 
   // Test addModule interface.
-  int H = cantFail(L.addModule(nullptr, nullptr));
+  int H = llvm_cantFail(L.addModule(nullptr, nullptr));
   EXPECT_EQ(H, 42) << "Incorrect result from addModule";
 
   // Test fall-through for missing symbol.
   auto FooSym = L.findSymbol("foo", true);
   EXPECT_FALSE(FooSym) << "Found unexpected symbol.";
 
   // Test fall-through for symbol in base layer.
   auto BarSym = L.findSymbol("bar", true);
-  EXPECT_EQ(cantFail(BarSym.getAddress()),
+  EXPECT_EQ(llvm_cantFail(BarSym.getAddress()),
             static_cast<JITTargetAddress>(0x4567))
     << "Symbol lookup fall-through failed.";
 
   // Test setup of a global mapping.
   L.setGlobalMapping("foo", 0x0123);
   auto FooSym2 = L.findSymbol("foo", true);
-  EXPECT_EQ(cantFail(FooSym2.getAddress()),
+  EXPECT_EQ(llvm_cantFail(FooSym2.getAddress()),
             static_cast<JITTargetAddress>(0x0123))
     << "Symbol mapping setup failed.";
 
   // Test removal of a global mapping.
   L.eraseGlobalMapping("foo");
   auto FooSym3 = L.findSymbol("foo", true);
   EXPECT_FALSE(FooSym3) << "Symbol mapping removal failed.";
 }
 
 }

llvm/unittests/ExecutionEngine/Orc/JITTargetMachineBuilderTest.cpp

 TEST(ExecutionUtilsTest, JITTargetMachineBuilder) {
   // Tests basic API usage.
   // Bails out on error, as it is valid to run this test without any targets
   // built.
 
   // Make sure LLVM has been initialized.
   OrcNativeTarget::initialize();
 
-  auto JTMB = cantFail(JITTargetMachineBuilder::detectHost());
+  auto JTMB = llvm_cantFail(JITTargetMachineBuilder::detectHost());
 
   // Test API by performing a bunch of no-ops.
   JTMB.setCPU("");
   JTMB.setRelocationModel(None);
   JTMB.setCodeModel(None);
   JTMB.setCodeGenOptLevel(CodeGenOpt::None);
   JTMB.addFeatures(std::vector<std::string>());
   SubtargetFeatures &STF = JTMB.getFeatures();

llvm/unittests/ExecutionEngine/Orc/LazyCallThroughAndReexportsTest.cpp

if (!LCTM) {
     consumeError(LCTM.takeError());
     return;
   }
 
   auto DummyTarget = ES.intern("DummyTarget");
 
   bool DummyTargetMaterialized = false;
 
-  cantFail(JD.define(std::make_unique<SimpleMaterializationUnit>(
+  llvm_cantFail(JD.define(std::make_unique<SimpleMaterializationUnit>(
       SymbolFlagsMap({{DummyTarget, JITSymbolFlags::Exported}}),
       [&](MaterializationResponsibility R) {
         DummyTargetMaterialized = true;
         // No dependencies registered, can't fail.
-        cantFail(R.notifyResolved(
+        llvm_cantFail(R.notifyResolved(
             {{DummyTarget,
               JITEvaluatedSymbol(static_cast<JITTargetAddress>(
                                      reinterpret_cast<uintptr_t>(&dummyTarget)),
                                  JITSymbolFlags::Exported)}}));
-        cantFail(R.notifyEmitted());
+        llvm_cantFail(R.notifyEmitted());
       })));
 
   unsigned NotifyResolvedCount = 0;
   auto NotifyResolved = LazyCallThroughManager::createNotifyResolvedFunction(
       [&](JITDylib &JD, const SymbolStringPtr &SymbolName,
           JITTargetAddress ResolvedAddr) {
         ++NotifyResolvedCount;
         return Error::success();
       });
 
-  auto CallThroughTrampoline = cantFail((*LCTM)->getCallThroughTrampoline(
+  auto CallThroughTrampoline = llvm_cantFail((*LCTM)->getCallThroughTrampoline(
       JD, DummyTarget, std::move(NotifyResolved)));
 
   auto CTTPtr = reinterpret_cast<int (*)()>(
       static_cast<uintptr_t>(CallThroughTrampoline));
 
   // Call twice to verify nothing unexpected happens on redundant calls.
   auto Result = CTTPtr();
   (void)CTTPtr();
 
   EXPECT_TRUE(DummyTargetMaterialized)
       << "CallThrough did not materialize target";
   EXPECT_EQ(NotifyResolvedCount, 1U)
       << "CallThrough should have generated exactly one 'NotifyResolved' call";
   EXPECT_EQ(Result, 42) << "Failed to call through to target";
 }

llvm/unittests/ExecutionEngine/Orc/LazyEmittingLayerTest.cpp

ModuleHandleT addModule(llvm::orc::VModuleKey,
     return 42;
   }
 };
 
 TEST(LazyEmittingLayerTest, Empty) {
   MockBaseLayer M;
   llvm::orc::LazyEmittingLayer<MockBaseLayer> L(
       llvm::AcknowledgeORCv1Deprecation, M);
-  cantFail(
+  llvm_cantFail(
       L.addModule(llvm::orc::VModuleKey(), std::unique_ptr<llvm::Module>()));
 }
 
 }

llvm/unittests/ExecutionEngine/Orc/LegacyAPIInteropTest.cpp

 
 class LegacyAPIsStandardTest : public CoreAPIsBasedStandardTest {};
 
 namespace {
 
 TEST_F(LegacyAPIsStandardTest, TestLambdaSymbolResolver) {
   BarSym.setFlags(BarSym.getFlags() | JITSymbolFlags::Weak);
 
-  cantFail(JD.define(absoluteSymbols({{Foo, FooSym}, {Bar, BarSym}})));
+  llvm_cantFail(JD.define(absoluteSymbols({{Foo, FooSym}, {Bar, BarSym}})));
 
   auto Resolver = createSymbolResolver(
       [&](const SymbolNameSet &Symbols) {
-        auto FlagsMap = cantFail(JD.lookupFlags(Symbols));
+        auto FlagsMap = llvm_cantFail(JD.lookupFlags(Symbols));
         SymbolNameSet Result;
         for (auto &KV : FlagsMap)
           if (!KV.second.isStrong())
             Result.insert(KV.first);
         return Result;
       },
       [&](std::shared_ptr<AsynchronousSymbolQuery> Q, SymbolNameSet Symbols) {
-        return cantFail(JD.legacyLookup(std::move(Q), Symbols));
+        return llvm_cantFail(JD.legacyLookup(std::move(Q), Symbols));
       });
 
   auto RS = Resolver->getResponsibilitySet(SymbolNameSet({Bar, Baz}));
 
   EXPECT_EQ(RS.size(), 1U)
       << "getResponsibilitySet returned the wrong number of results";
   EXPECT_EQ(RS.count(Bar), 1U)
       << "getResponsibilitySet result incorrect. Should be {'bar'}";

llvm/unittests/ExecutionEngine/Orc/LegacyRTDyldObjectLinkingLayerTest.cpp

TEST(LegacyRTDyldObjectLinkingLayerTest, TestSetProcessAllSections) {
   if (!TM)
     return;
 
   auto Obj = SimpleCompiler(*TM)(*M);
 
   {
     // Test with ProcessAllSections = false (the default).
     auto K = ES.allocateVModule();
-    cantFail(ObjLayer.addObject(
+    llvm_cantFail(ObjLayer.addObject(
         K, MemoryBuffer::getMemBufferCopy(Obj->getBuffer())));
-    cantFail(ObjLayer.emitAndFinalize(K));
+    llvm_cantFail(ObjLayer.emitAndFinalize(K));
     EXPECT_EQ(DebugSectionSeen, false)
       << "Unexpected debug info section";
-    cantFail(ObjLayer.removeObject(K));
+    llvm_cantFail(ObjLayer.removeObject(K));
   }
 
   {
     // Test with ProcessAllSections = true.
     ObjLayer.setProcessAllSections(true);
     auto K = ES.allocateVModule();
-    cantFail(ObjLayer.addObject(K, std::move(Obj)));
-    cantFail(ObjLayer.emitAndFinalize(K));
+    llvm_cantFail(ObjLayer.addObject(K, std::move(Obj)));
+    llvm_cantFail(ObjLayer.emitAndFinalize(K));
     EXPECT_EQ(DebugSectionSeen, true)
       << "Expected debug info section not seen";
-    cantFail(ObjLayer.removeObject(K));
+    llvm_cantFail(ObjLayer.removeObject(K));
   }
 }
 
 TEST_F(LegacyRTDyldObjectLinkingLayerExecutionTest, NoDuplicateFinalization) {
   if (!SupportsJIT)
     return;
 
   Type *Int32Ty = IntegerType::get(Context, 32);
ModuleBuilder MB2(Context, "", "dummy");
     BasicBlock *FooEntry = BasicBlock::Create(Context, "entry", FooImpl);
     IRBuilder<> Builder(FooEntry);
     Builder.CreateRet(Builder.CreateCall(BarDecl));
   }
   auto Obj2 = Compile(*MB2.getModule());
 
   auto K1 = ES.allocateVModule();
   Resolvers[K1] = std::make_shared<NullResolver>();
-  cantFail(ObjLayer.addObject(K1, std::move(Obj1)));
+  llvm_cantFail(ObjLayer.addObject(K1, std::move(Obj1)));
 
   auto K2 = ES.allocateVModule();
   auto LegacyLookup = [&](const std::string &Name) {
     return ObjLayer.findSymbol(Name, true);
   };
 
   Resolvers[K2] = createSymbolResolver(
       [&](const SymbolNameSet &Symbols) {
-        return cantFail(
+        return llvm_cantFail(
             getResponsibilitySetWithLegacyFn(Symbols, LegacyLookup));
       },
       [&](std::shared_ptr<AsynchronousSymbolQuery> Query,
           const SymbolNameSet &Symbols) {
         return lookupWithLegacyFn(ES, *Query, Symbols, LegacyLookup);
       });
 
-  cantFail(ObjLayer.addObject(K2, std::move(Obj2)));
-  cantFail(ObjLayer.emitAndFinalize(K2));
-  cantFail(ObjLayer.removeObject(K2));
+  llvm_cantFail(ObjLayer.addObject(K2, std::move(Obj2)));
+  llvm_cantFail(ObjLayer.emitAndFinalize(K2));
+  llvm_cantFail(ObjLayer.removeObject(K2));
 
   // Finalization of module 2 should trigger finalization of module 1.
   // Verify that finalize on SMMW is only called once.
   EXPECT_EQ(MM->FinalizationCount, 1)
       << "Extra call to finalize";
 }
 
 TEST_F(LegacyRTDyldObjectLinkingLayerExecutionTest, NoPrematureAllocation) {
ModuleBuilder MB2(Context, "", "dummy");
     IRBuilder<> Builder(BarEntry);
     IntegerType *Int32Ty = IntegerType::get(Context, 32);
     Value *Seven = ConstantInt::getSigned(Int32Ty, 7);
     Builder.CreateRet(Seven);
   }
   auto Obj2 = Compile(*MB2.getModule());
 
   auto K = ES.allocateVModule();
-  cantFail(ObjLayer.addObject(K, std::move(Obj1)));
-  cantFail(ObjLayer.addObject(ES.allocateVModule(), std::move(Obj2)));
-  cantFail(ObjLayer.emitAndFinalize(K));
-  cantFail(ObjLayer.removeObject(K));
+  llvm_cantFail(ObjLayer.addObject(K, std::move(Obj1)));
+  llvm_cantFail(ObjLayer.addObject(ES.allocateVModule(), std::move(Obj2)));
+  llvm_cantFail(ObjLayer.emitAndFinalize(K));
+  llvm_cantFail(ObjLayer.removeObject(K));
 
   // Only one call to needsToReserveAllocationSpace should have been made.
   EXPECT_EQ(MM->NeedsToReserveAllocationSpaceCount, 1)
       << "More than one call to needsToReserveAllocationSpace "
          "(multiple unrelated objects loaded prior to finalization)";
 }
 
 TEST_F(LegacyRTDyldObjectLinkingLayerExecutionTest, TestNotifyLoadedSignature) {

llvm/unittests/ExecutionEngine/Orc/ObjectTransformLayerTest.cpp

llvm::JITSymbol findSymbol(const std::string &Name,
     return llvm::JITSymbol(122, llvm::JITSymbolFlags::None);
   }
   void expectFindSymbol(const std::string &Name, bool ExportedSymbolsOnly) {
     MockName = Name;
     MockBool = ExportedSymbolsOnly;
   }
   void verifyFindSymbol(llvm::JITSymbol Returned) {
     EXPECT_EQ("findSymbol", LastCalled);
-    EXPECT_EQ(cantFail(MockSymbol.getAddress()),
-              cantFail(Returned.getAddress()))
+    EXPECT_EQ(llvm_cantFail(MockSymbol.getAddress()),
+              llvm_cantFail(Returned.getAddress()))
         << "Return should pass through";
     resetExpectations();
   }
 
   llvm::JITSymbol findSymbolIn(VModuleKey K, const std::string &Name,
                                bool ExportedSymbolsOnly) {
     EXPECT_EQ(MockKey, K) << "VModuleKey should pass through";
     EXPECT_EQ(MockName, Name) << "Name should pass through";
     EXPECT_EQ(MockBool, ExportedSymbolsOnly) << "Flag should pass through";
     LastCalled = "findSymbolIn";
     MockSymbol = llvm::JITSymbol(122, llvm::JITSymbolFlags::None);
     return llvm::JITSymbol(122, llvm::JITSymbolFlags::None);
   }
   void expectFindSymbolIn(VModuleKey K, const std::string &Name,
                           bool ExportedSymbolsOnly) {
     MockKey = K;
     MockName = Name;
     MockBool = ExportedSymbolsOnly;
   }
   void verifyFindSymbolIn(llvm::JITSymbol Returned) {
     EXPECT_EQ("findSymbolIn", LastCalled);
-    EXPECT_EQ(cantFail(MockSymbol.getAddress()),
-              cantFail(Returned.getAddress()))
+    EXPECT_EQ(llvm_cantFail(MockSymbol.getAddress()),
+              llvm_cantFail(Returned.getAddress()))
         << "Return should pass through";
     resetExpectations();
   }
 
   llvm::Error emitAndFinalize(VModuleKey K) {
     EXPECT_EQ(MockKey, K) << "VModuleKey should pass through";
     LastCalled = "emitAndFinalize";
     return llvm::Error::success();
LegacyObjectTransformLayer<MockBaseLayer,
            ++(*Obj);
            return Obj;
          });
 
   // Test addObject with T1 (allocating)
   auto K1 = ES.allocateVModule();
   auto Obj1 = std::make_shared<MockObjectFile>(211);
   M.expectAddObject(K1, Obj1);
-  cantFail(T1.addObject(K1, std::move(Obj1)));
+  llvm_cantFail(T1.addObject(K1, std::move(Obj1)));
   M.verifyAddObject();
 
   // Test addObjectSet with T2 (mutating)
   auto K2 = ES.allocateVModule();
   auto Obj2 = std::make_shared<MockObjectFile>(222);
   M.expectAddObject(K2, Obj2);
-  cantFail(T2.addObject(K2, Obj2));
+  llvm_cantFail(T2.addObject(K2, Obj2));
   M.verifyAddObject();
   EXPECT_EQ(223, *Obj2) << "Expected mutation";
 
   // Test removeObjectSet
   M.expectRemoveObject(K2);
-  cantFail(T1.removeObject(K2));
+  llvm_cantFail(T1.removeObject(K2));
   M.verifyRemoveObject();
 
   // Test findSymbol
   std::string Name = "foo";
   bool ExportedOnly = true;
   M.expectFindSymbol(Name, ExportedOnly);
   llvm::JITSymbol Sym1 = T2.findSymbol(Name, ExportedOnly);
   M.verifyFindSymbol(std::move(Sym1));
 
   // Test findSymbolIn
   Name = "bar";
   ExportedOnly = false;
   M.expectFindSymbolIn(K1, Name, ExportedOnly);
   llvm::JITSymbol Sym2 = T1.findSymbolIn(K1, Name, ExportedOnly);
   M.verifyFindSymbolIn(std::move(Sym2));
 
   // Test emitAndFinalize
   M.expectEmitAndFinalize(K1);
-  cantFail(T2.emitAndFinalize(K1));
+  llvm_cantFail(T2.emitAndFinalize(K1));
   M.verifyEmitAndFinalize();
 
   // Test mapSectionAddress
   char Buffer[24];
   llvm::JITTargetAddress MockAddress = 255;
   M.expectMapSectionAddress(K1, Buffer, MockAddress);
   T1.mapSectionAddress(K1, Buffer, MockAddress);
   M.verifyMapSectionAddress();
auto NullCompiler = [](llvm::Module &) {
     return std::unique_ptr<llvm::MemoryBuffer>(nullptr);
   };
   LegacyIRCompileLayer<decltype(TransformLayer), decltype(NullCompiler)>
       CompileLayer(llvm::AcknowledgeORCv1Deprecation, TransformLayer,
                    NullCompiler);
 
   // Make sure that the calls from LegacyIRCompileLayer to LegacyObjectTransformLayer
   // compile.
-  cantFail(CompileLayer.addModule(ES.allocateVModule(),
+  llvm_cantFail(CompileLayer.addModule(ES.allocateVModule(),
                                   std::unique_ptr<llvm::Module>()));
 
   // Make sure that the calls from LegacyObjectTransformLayer to ObjectLinkingLayer
   // compile.
   VModuleKey DummyKey = ES.allocateVModule();
-  cantFail(TransformLayer.emitAndFinalize(DummyKey));
+  llvm_cantFail(TransformLayer.emitAndFinalize(DummyKey));
   TransformLayer.findSymbolIn(DummyKey, Name, false);
   TransformLayer.findSymbol(Name, true);
   TransformLayer.mapSectionAddress(DummyKey, nullptr, 0);
-  cantFail(TransformLayer.removeObject(DummyKey));
+  llvm_cantFail(TransformLayer.removeObject(DummyKey));
 }
 }

llvm/unittests/ExecutionEngine/Orc/RPCUtilsTest.cpp

TEST(DummyRPC, TestAsyncVoidBoolHandler) {
   DummyRPCEndpoint Client(*Channels.first);
   DummyRPCEndpoint Server(*Channels.second);
 
   std::thread ServerThread([&]() {
       Server.addAsyncHandler<DummyRPCAPI::VoidBool>(
           [](std::function<Error(Error)> SendResult,
              bool B) {
             EXPECT_EQ(B, true) << "Server void(bool) receieved unexpected result";
-            cantFail(SendResult(Error::success()));
+            llvm_cantFail(SendResult(Error::success()));
             return Error::success();
           });
 
       {
         // Poke the server to handle the negotiate call.
         auto Err = Server.handleOne();
         EXPECT_FALSE(!!Err) << "Server failed to handle call to negotiate";
       }
TEST(DummyRPC, ReturnErrorSuccess) {
   std::thread ServerThread([&]() {
       Server.addHandler<DummyRPCAPI::ErrorFunc>(
         []() {
           return Error::success();
         });
 
       // Handle the negotiate plus one call.
       for (unsigned I = 0; I != 2; ++I)
-        cantFail(Server.handleOne());
+        llvm_cantFail(Server.handleOne());
     });
 
-  cantFail(Client.callAsync<DummyRPCAPI::ErrorFunc>(
+  llvm_cantFail(Client.callAsync<DummyRPCAPI::ErrorFunc>(
              [&](Error Err) {
                EXPECT_FALSE(!!Err) << "Expected success value";
                return Error::success();
              }));
 
-  cantFail(Client.handleOne());
+  llvm_cantFail(Client.handleOne());
 
   ServerThread.join();
 }
 
 TEST(DummyRPC, ReturnErrorFailure) {
   registerDummyErrorSerialization<QueueChannel>();
 
   auto Channels = createPairedQueueChannels();
   DummyRPCEndpoint Client(*Channels.first);
   DummyRPCEndpoint Server(*Channels.second);
 
   std::thread ServerThread([&]() {
       Server.addHandler<DummyRPCAPI::ErrorFunc>(
         []() {
           return make_error<DummyError>(42);
         });
 
       // Handle the negotiate plus one call.
       for (unsigned I = 0; I != 2; ++I)
-        cantFail(Server.handleOne());
+        llvm_cantFail(Server.handleOne());
     });
 
-  cantFail(Client.callAsync<DummyRPCAPI::ErrorFunc>(
+  llvm_cantFail(Client.callAsync<DummyRPCAPI::ErrorFunc>(
              [&](Error Err) {
                EXPECT_TRUE(Err.isA<DummyError>())
                  << "Incorrect error type";
                return handleErrors(
                         std::move(Err),
                         [](const DummyError &DE) {
                           EXPECT_EQ(DE.getValue(), 42ULL)
                             << "Incorrect DummyError serialization";
                         });
              }));
 
-  cantFail(Client.handleOne());
+  llvm_cantFail(Client.handleOne());
 
   ServerThread.join();
 }
 
 TEST(DummyRPC, ReturnExpectedSuccess) {
   registerDummyErrorSerialization<QueueChannel>();
 
   auto Channels = createPairedQueueChannels();
   DummyRPCEndpoint Client(*Channels.first);
   DummyRPCEndpoint Server(*Channels.second);
 
   std::thread ServerThread([&]() {
       Server.addHandler<DummyRPCAPI::ExpectedFunc>(
         []() -> uint32_t {
           return 42;
         });
 
       // Handle the negotiate plus one call.
       for (unsigned I = 0; I != 2; ++I)
-        cantFail(Server.handleOne());
+        llvm_cantFail(Server.handleOne());
     });
 
-  cantFail(Client.callAsync<DummyRPCAPI::ExpectedFunc>(
+  llvm_cantFail(Client.callAsync<DummyRPCAPI::ExpectedFunc>(
                [&](Expected<uint32_t> ValOrErr) {
                  EXPECT_TRUE(!!ValOrErr)
                    << "Expected success value";
                  EXPECT_EQ(*ValOrErr, 42ULL)
                    << "Incorrect Expected<uint32_t> deserialization";
                  return Error::success();
                }));
 
-  cantFail(Client.handleOne());
+  llvm_cantFail(Client.handleOne());
 
   ServerThread.join();
 }
 
 TEST(DummyRPC, ReturnExpectedFailure) {
   registerDummyErrorSerialization<QueueChannel>();
 
   auto Channels = createPairedQueueChannels();
   DummyRPCEndpoint Client(*Channels.first);
   DummyRPCEndpoint Server(*Channels.second);
 
   std::thread ServerThread([&]() {
       Server.addHandler<DummyRPCAPI::ExpectedFunc>(
         []() -> Expected<uint32_t> {
           return make_error<DummyError>(7);
         });
 
       // Handle the negotiate plus one call.
       for (unsigned I = 0; I != 2; ++I)
-        cantFail(Server.handleOne());
+        llvm_cantFail(Server.handleOne());
     });
 
-  cantFail(Client.callAsync<DummyRPCAPI::ExpectedFunc>(
+  llvm_cantFail(Client.callAsync<DummyRPCAPI::ExpectedFunc>(
                [&](Expected<uint32_t> ValOrErr) {
                  EXPECT_FALSE(!!ValOrErr)
                    << "Expected failure value";
                  auto Err = ValOrErr.takeError();
                  EXPECT_TRUE(Err.isA<DummyError>())
                    << "Incorrect error type";
                  return handleErrors(
                           std::move(Err),
                           [](const DummyError &DE) {
                             EXPECT_EQ(DE.getValue(), 7ULL)
                               << "Incorrect DummyError serialization";
                           });
                }));
 
-  cantFail(Client.handleOne());
+  llvm_cantFail(Client.handleOne());
 
   ServerThread.join();
 }
 
 TEST(DummyRPC, TestParallelCallGroup) {
   auto Channels = createPairedQueueChannels();
   DummyRPCEndpoint Client(*Channels.first);
   DummyRPCEndpoint Server(*Channels.second);

llvm/unittests/ExecutionEngine/Orc/RTDyldObjectLinkingLayerTest.cpp

static bool testSetProcessAllSections(std::unique_ptr<MemoryBuffer> Obj,
   auto &JD = ES.createJITDylib("main");
   auto Foo = ES.intern("foo");
 
   RTDyldObjectLinkingLayer ObjLayer(ES, [&DebugSectionSeen]() {
     return std::make_unique<MemoryManagerWrapper>(DebugSectionSeen);
   });
 
   auto OnResolveDoNothing = [](Expected<SymbolMap> R) {
-    cantFail(std::move(R));
+    llvm_cantFail(std::move(R));
   };
 
   ObjLayer.setProcessAllSections(ProcessAllSections);
-  cantFail(ObjLayer.add(JD, std::move(Obj), ES.allocateVModule()));
+  llvm_cantFail(ObjLayer.add(JD, std::move(Obj), ES.allocateVModule()));
   ES.lookup(JITDylibSearchList({{&JD, false}}), {Foo}, SymbolState::Resolved,
             OnResolveDoNothing, NoDependenciesToRegister);
 
   return DebugSectionSeen;
 }
 
 TEST(RTDyldObjectLinkingLayerTest, TestSetProcessAllSections) {
   LLVMContext Context;
TEST(RTDyldObjectLinkingLayerTest, TestOverrideObjectFlags) {
   auto &JD = ES.createJITDylib("main");
   auto Foo = ES.intern("foo");
   RTDyldObjectLinkingLayer ObjLayer(
       ES, []() { return std::make_unique<SectionMemoryManager>(); });
   IRCompileLayer CompileLayer(ES, ObjLayer, FunkySimpleCompiler(*TM));
 
   ObjLayer.setOverrideObjectFlagsWithResponsibilityFlags(true);
 
-  cantFail(CompileLayer.add(JD, std::move(M), ES.allocateVModule()));
+  llvm_cantFail(CompileLayer.add(JD, std::move(M), ES.allocateVModule()));
   ES.lookup(
       JITDylibSearchList({{&JD, false}}), {Foo}, SymbolState::Resolved,
-      [](Expected<SymbolMap> R) { cantFail(std::move(R)); },
+      [](Expected<SymbolMap> R) { llvm_cantFail(std::move(R)); },
       NoDependenciesToRegister);
 }
 
 TEST(RTDyldObjectLinkingLayerTest, TestAutoClaimResponsibilityForSymbols) {
 
   OrcNativeTarget::initialize();
 
   std::unique_ptr<TargetMachine> TM(
TEST(RTDyldObjectLinkingLayerTest, TestAutoClaimResponsibilityForSymbols) {
   auto &JD = ES.createJITDylib("main");
   auto Foo = ES.intern("foo");
   RTDyldObjectLinkingLayer ObjLayer(
       ES, []() { return std::make_unique<SectionMemoryManager>(); });
   IRCompileLayer CompileLayer(ES, ObjLayer, FunkySimpleCompiler(*TM));
 
   ObjLayer.setAutoClaimResponsibilityForObjectSymbols(true);
 
-  cantFail(CompileLayer.add(JD, std::move(M), ES.allocateVModule()));
+  llvm_cantFail(CompileLayer.add(JD, std::move(M), ES.allocateVModule()));
   ES.lookup(
       JITDylibSearchList({{&JD, false}}), {Foo}, SymbolState::Resolved,
-      [](Expected<SymbolMap> R) { cantFail(std::move(R)); },
+      [](Expected<SymbolMap> R) { llvm_cantFail(std::move(R)); },
       NoDependenciesToRegister);
 }
 
 } // end anonymous namespace

llvm/unittests/ExecutionEngine/Orc/RemoteObjectLayerTest.cpp

TEST(RemoteObjectLayer, AddObject) {
   bool Finished = false;
   ServerEP.addHandler<remote::utils::TerminateSession>(
     [&]() { Finished = true; }
   );
 
   auto ServerThread =
     std::thread([&]() {
       while (!Finished)
-        cantFail(ServerEP.handleOne());
+        llvm_cantFail(ServerEP.handleOne());
     });
 
-  cantFail(Client.addObject(std::move(TestObject),
+  llvm_cantFail(Client.addObject(std::move(TestObject),
                             std::make_shared<NullLegacyResolver>()));
-  cantFail(ClientEP.callB<remote::utils::TerminateSession>());
+  llvm_cantFail(ClientEP.callB<remote::utils::TerminateSession>());
   ServerThread.join();
 }
 
 TEST(RemoteObjectLayer, AddObjectFailure) {
   llvm::orc::rpc::registerStringError<rpc::RawByteChannel>();
   auto TestObject = createTestObject();
   if (!TestObject)
     return;
TEST(RemoteObjectLayer, AddObjectFailure) {
   bool Finished = false;
   ServerEP.addHandler<remote::utils::TerminateSession>(
     [&]() { Finished = true; }
   );
 
   auto ServerThread =
     std::thread([&]() {
       while (!Finished)
-        cantFail(ServerEP.handleOne());
+        llvm_cantFail(ServerEP.handleOne());
     });
 
   auto HandleOrErr = Client.addObject(std::move(TestObject),
                                       std::make_shared<NullLegacyResolver>());
 
   EXPECT_FALSE(HandleOrErr) << "Expected error from addObject";
 
   auto ErrMsg = toString(HandleOrErr.takeError());
   EXPECT_EQ(ErrMsg, "AddObjectFailure - Test Message")
     << "Expected error string to be \"AddObjectFailure - Test Message\"";
 
-  cantFail(ClientEP.callB<remote::utils::TerminateSession>());
+  llvm_cantFail(ClientEP.callB<remote::utils::TerminateSession>());
   ServerThread.join();
 }
 
 
 TEST(RemoteObjectLayer, RemoveObject) {
   llvm::orc::rpc::registerStringError<rpc::RawByteChannel>();
   auto TestObject = createTestObject();
   if (!TestObject)
TEST(RemoteObjectLayer, RemoveObject) {
   bool Finished = false;
   ServerEP.addHandler<remote::utils::TerminateSession>(
     [&]() { Finished = true; }
   );
 
   auto ServerThread =
     std::thread([&]() {
       while (!Finished)
-        cantFail(ServerEP.handleOne());
+        llvm_cantFail(ServerEP.handleOne());
     });
 
-  auto H = cantFail(Client.addObject(std::move(TestObject),
+  auto H = llvm_cantFail(Client.addObject(std::move(TestObject),
                                      std::make_shared<NullLegacyResolver>()));
 
-  cantFail(Client.removeObject(H));
+  llvm_cantFail(Client.removeObject(H));
 
-  cantFail(ClientEP.callB<remote::utils::TerminateSession>());
+  llvm_cantFail(ClientEP.callB<remote::utils::TerminateSession>());
   ServerThread.join();
 }
 
 TEST(RemoteObjectLayer, RemoveObjectFailure) {
   llvm::orc::rpc::registerStringError<rpc::RawByteChannel>();
   auto TestObject = createTestObject();
   if (!TestObject)
     return;
TEST(RemoteObjectLayer, RemoveObjectFailure) {
   bool Finished = false;
   ServerEP.addHandler<remote::utils::TerminateSession>(
     [&]() { Finished = true; }
   );
 
   auto ServerThread =
     std::thread([&]() {
       while (!Finished)
-        cantFail(ServerEP.handleOne());
+        llvm_cantFail(ServerEP.handleOne());
     });
 
-  auto H = cantFail(Client.addObject(std::move(TestObject),
+  auto H = llvm_cantFail(Client.addObject(std::move(TestObject),
                                      std::make_shared<NullLegacyResolver>()));
 
   auto Err = Client.removeObject(H);
   EXPECT_TRUE(!!Err) << "Expected error from removeObject";
 
   auto ErrMsg = toString(std::move(Err));
   EXPECT_EQ(ErrMsg, "Object handle 42 not found")
     << "Expected error string to be \"Object handle 42 not found\"";
 
-  cantFail(ClientEP.callB<remote::utils::TerminateSession>());
+  llvm_cantFail(ClientEP.callB<remote::utils::TerminateSession>());
   ServerThread.join();
 }
 
 TEST(RemoteObjectLayer, FindSymbol) {
   llvm::orc::rpc::registerStringError<rpc::RawByteChannel>();
   auto TestObject = createTestObject();
   if (!TestObject)
     return;
TEST(RemoteObjectLayer, FindSymbol) {
   bool Finished = false;
   ServerEP.addHandler<remote::utils::TerminateSession>(
     [&]() { Finished = true; }
   );
 
   auto ServerThread =
     std::thread([&]() {
       while (!Finished)
-        cantFail(ServerEP.handleOne());
+        llvm_cantFail(ServerEP.handleOne());
     });
 
-  cantFail(Client.addObject(std::move(TestObject),
+  llvm_cantFail(Client.addObject(std::move(TestObject),
                             std::make_shared<NullLegacyResolver>()));
 
   // Check that we can find and materialize a valid symbol.
   auto Sym1 = Client.findSymbol("foobar", true);
   EXPECT_TRUE(!!Sym1) << "Symbol 'foobar' should be findable";
-  EXPECT_EQ(cantFail(Sym1.getAddress()), 0x12348765ULL)
+  EXPECT_EQ(llvm_cantFail(Sym1.getAddress()), 0x12348765ULL)
     << "Symbol 'foobar' does not return the correct address";
 
   {
     // Check that we can return a symbol containing an error.
     auto Sym2 = Client.findSymbol("badsymbol", true);
     EXPECT_FALSE(!!Sym2) << "Symbol 'badsymbol' should not be findable";
     auto Err = Sym2.takeError();
     EXPECT_TRUE(!!Err) << "Sym2 should contain an error value";
     auto ErrMsg = toString(std::move(Err));
     EXPECT_EQ(ErrMsg, "Could not find symbol 'badsymbol'")
       << "Expected symbol-not-found error for Sym2";
   }
 
   {
     // Check that we can return a 'null' symbol.
     auto Sym3 = Client.findSymbol("baz", true);
     EXPECT_FALSE(!!Sym3) << "Symbol 'baz' should convert to false";
     auto Err = Sym3.takeError();
     EXPECT_FALSE(!!Err) << "Symbol 'baz' should not contain an error";
   }
 
-  cantFail(ClientEP.callB<remote::utils::TerminateSession>());
+  llvm_cantFail(ClientEP.callB<remote::utils::TerminateSession>());
   ServerThread.join();
 }
 
 TEST(RemoteObjectLayer, FindSymbolIn) {
   llvm::orc::rpc::registerStringError<rpc::RawByteChannel>();
   auto TestObject = createTestObject();
   if (!TestObject)
     return;
TEST(RemoteObjectLayer, FindSymbolIn) {
   bool Finished = false;
   ServerEP.addHandler<remote::utils::TerminateSession>(
     [&]() { Finished = true; }
   );
 
   auto ServerThread =
     std::thread([&]() {
       while (!Finished)
-        cantFail(ServerEP.handleOne());
+        llvm_cantFail(ServerEP.handleOne());
     });
 
-  auto H = cantFail(Client.addObject(std::move(TestObject),
+  auto H = llvm_cantFail(Client.addObject(std::move(TestObject),
                                      std::make_shared<NullLegacyResolver>()));
 
   auto Sym1 = Client.findSymbolIn(H, "foobar", true);
 
   EXPECT_TRUE(!!Sym1) << "Symbol 'foobar' should be findable";
-  EXPECT_EQ(cantFail(Sym1.getAddress()), 0x12348765ULL)
+  EXPECT_EQ(llvm_cantFail(Sym1.getAddress()), 0x12348765ULL)
     << "Symbol 'foobar' does not return the correct address";
 
   auto Sym2 = Client.findSymbolIn(H, "barbaz", true);
   EXPECT_FALSE(!!Sym2) << "Symbol 'barbaz' should not be findable";
   auto Err = Sym2.takeError();
   EXPECT_TRUE(!!Err) << "Sym2 should contain an error value";
   auto ErrMsg = toString(std::move(Err));
   EXPECT_EQ(ErrMsg, "Could not find symbol 'barbaz'")
     << "Expected symbol-not-found error for Sym2";
 
-  cantFail(ClientEP.callB<remote::utils::TerminateSession>());
+  llvm_cantFail(ClientEP.callB<remote::utils::TerminateSession>());
   ServerThread.join();
 }
 
 TEST(RemoteObjectLayer, EmitAndFinalize) {
   llvm::orc::rpc::registerStringError<rpc::RawByteChannel>();
   auto TestObject = createTestObject();
   if (!TestObject)
     return;
TEST(RemoteObjectLayer, EmitAndFinalize) {
   bool Finished = false;
   ServerEP.addHandler<remote::utils::TerminateSession>(
     [&]() { Finished = true; }
   );
 
   auto ServerThread =
     std::thread([&]() {
       while (!Finished)
-        cantFail(ServerEP.handleOne());
+        llvm_cantFail(ServerEP.handleOne());
     });
 
-  auto H = cantFail(Client.addObject(std::move(TestObject),
+  auto H = llvm_cantFail(Client.addObject(std::move(TestObject),
                                      std::make_shared<NullLegacyResolver>()));
 
   auto Err = Client.emitAndFinalize(H);
   EXPECT_FALSE(!!Err) << "emitAndFinalize should work";
 
-  cantFail(ClientEP.callB<remote::utils::TerminateSession>());
+  llvm_cantFail(ClientEP.callB<remote::utils::TerminateSession>());
   ServerThread.join();
 }
 
 TEST(RemoteObjectLayer, EmitAndFinalizeFailure) {
   llvm::orc::rpc::registerStringError<rpc::RawByteChannel>();
   auto TestObject = createTestObject();
   if (!TestObject)
     return;
TEST(RemoteObjectLayer, EmitAndFinalizeFailure) {
   bool Finished = false;
   ServerEP.addHandler<remote::utils::TerminateSession>(
     [&]() { Finished = true; }
   );
 
   auto ServerThread =
     std::thread([&]() {
       while (!Finished)
-        cantFail(ServerEP.handleOne());
+        llvm_cantFail(ServerEP.handleOne());
     });
 
-  auto H = cantFail(Client.addObject(std::move(TestObject),
+  auto H = llvm_cantFail(Client.addObject(std::move(TestObject),
                                      std::make_shared<NullLegacyResolver>()));
 
   auto Err = Client.emitAndFinalize(H);
   EXPECT_TRUE(!!Err) << "emitAndFinalize should work";
 
   auto ErrMsg = toString(std::move(Err));
   EXPECT_EQ(ErrMsg, "Object handle 1 not found")
     << "emitAndFinalize returned incorrect error";
 
-  cantFail(ClientEP.callB<remote::utils::TerminateSession>());
+  llvm_cantFail(ClientEP.callB<remote::utils::TerminateSession>());
   ServerThread.join();
 }
 
 }

llvm/unittests/Support/ErrorTest.cpp

TEST(Error, FailureToHandle) {
   auto FailToHandle = []() {
     handleAllErrors(make_error<CustomError>(7), [&](const CustomSubError &SE) {
       errs() << "This should never be called";
       exit(1);
     });
   };
 
   EXPECT_DEATH(FailToHandle(),
-               "Failure value returned from cantFail wrapped call\n"
-               "CustomError \\{7\\}")
+               "CustomError \\{7\\}\n"
+               "Failure value returned from cantFail wrapped call")
       << "Unhandled Error in handleAllErrors call did not cause an "
          "abort()";
 }
 #endif
 
 // Test that handleAllUnhandledErrors crashes if an error is returned from a
 // handler.
 // Test runs in debug mode only.
 #if LLVM_ENABLE_ABI_BREAKING_CHECKS
 TEST(Error, FailureFromHandler) {
   auto ReturnErrorFromHandler = []() {
     handleAllErrors(make_error<CustomError>(7),
                     [&](std::unique_ptr<CustomSubError> SE) {
                       return Error(std::move(SE));
                     });
   };
 
   EXPECT_DEATH(ReturnErrorFromHandler(),
-               "Failure value returned from cantFail wrapped call\n"
-               "CustomError \\{7\\}")
+               "CustomError \\{7\\}\n"
+               "Failure value returned from cantFail wrapped call")
       << " Error returned from handler in handleAllErrors call did not "
          "cause abort()";
 }
 #endif
 
 // Test that we can return values from handleErrors.
 TEST(Error, CatchErrorFromHandler) {
   int ErrorInfo = 0;
TEST(Error, ExitOnError) {
 
   EXPECT_EXIT(ExitOnErr(Expected<int>(make_error<CustomSubError>(0, 0))),
               ::testing::ExitedWithCode(2), "Error in tool:")
       << "exitOnError returned an unexpected error result";
 }
 
 // Test that the ExitOnError utility works as expected.
 TEST(Error, CantFailSuccess) {
-  cantFail(Error::success());
+  llvm_cantFail(Error::success());
 
-  int X = cantFail(Expected<int>(42));
-  EXPECT_EQ(X, 42) << "Expected value modified by cantFail";
+  int X = llvm_cantFail(Expected<int>(42));
+  EXPECT_EQ(X, 42) << "Expected value modified by llvm_cantFail";
 
   int Dummy = 42;
-  int &Y = cantFail(Expected<int&>(Dummy));
-  EXPECT_EQ(&Dummy, &Y) << "Reference mangled by cantFail";
+  int &Y = llvm_cantFail(Expected<int&>(Dummy));
+  EXPECT_EQ(&Dummy, &Y) << "Reference mangled by llvm_cantFail";
 }
 
-// Test that cantFail results in a crash if you pass it a failure value.
+// Test that llvm_cantFail results in a crash if you pass it a failure value.
 #if LLVM_ENABLE_ABI_BREAKING_CHECKS && !defined(NDEBUG)
 TEST(Error, CantFailDeath) {
-  EXPECT_DEATH(cantFail(make_error<StringError>("Original error message",
+  EXPECT_DEATH(llvm_cantFail(make_error<StringError>("Original error message",
                                                 inconvertibleErrorCode()),
                         "Cantfail call failed"),
-               "Cantfail call failed\n"
-               "Original error message")
-      << "cantFail(Error) did not cause an abort for failure value";
+               "Original error message\n"
+               "Cantfail call failed")
+      << "llvm_cantFail(Error) did not cause an abort for failure value";
 
   EXPECT_DEATH(
       {
         auto IEC = inconvertibleErrorCode();
-        int X = cantFail(Expected<int>(make_error<StringError>("foo", IEC)));
+        int X = llvm_cantFail(Expected<int>(make_error<StringError>("foo", IEC)));
         (void)X;
       },
       "Failure value returned from cantFail wrapped call")
-    << "cantFail(Expected<int>) did not cause an abort for failure value";
+    << "llvm_cantFail(Expected<int>) did not cause an abort for failure value";
 }
 #endif
 
+TEST(Error, CantFailSourceLocation) {
+  std::string ErrStr;
+  raw_string_ostream OS(ErrStr);
+  OS << "\nFailure value returned from cantFail wrapped call";
+
+#if defined(NDEBUG)
+  // __FILE__ and __LINE_ not added
+  OS << "\n";
+  EXPECT_DEATH(llvm_cantFail(make_error<CustomError>(1)), OS.str())
+      << "llvm_cantFail(Error) did not cause an abort for failure value";
+#else
+  // __FILE__ and __LINE__ added
+  int Line = __LINE__;
+  OS << " at " << __FILE__ << ":" << (Line + 2) << "\n";
+  EXPECT_DEATH(llvm_cantFail(make_error<CustomError>(1)), OS.str())
+      << "llvm_cantFail(Error) did not cause an abort for failure value";
+#endif
+}
 
 // Test Checked Expected<T> in success mode.
 TEST(Error, CheckedExpectedInSuccessMode) {
   Expected<int> A = 7;
   EXPECT_TRUE(!!A) << "Expected with non-error value doesn't convert to 'true'";
   // Access is safe in second test, since we checked the error in the first.
   EXPECT_EQ(*A, 7) << "Incorrect Expected non-error value";
 }

llvm/unittests/Support/Path.cpp

TEST_F(FileSystemTest, TempFileCollisions) {
   // 2191 attempts not producing a given hexadecimal digit is
   // (1 - 1/16) ** 2191 or 3.88e-62.
   int Successes = 0;
   for (int i = 0; i < 32; ++i)
     if (TryCreateTempFile()) ++Successes;
   EXPECT_EQ(Successes, 16);
 
   for (fs::TempFile &T : TempFiles)
-    cantFail(T.discard());
+    llvm_cantFail(T.discard());
 }
 
 TEST_F(FileSystemTest, CreateDir) {
   ASSERT_NO_ERROR(fs::create_directory(Twine(TestDirectory) + "foo"));
   ASSERT_NO_ERROR(fs::create_directory(Twine(TestDirectory) + "foo"));
   ASSERT_EQ(fs::create_directory(Twine(TestDirectory) + "foo", false),
             errc::file_exists);
   ASSERT_NO_ERROR(fs::remove(Twine(TestDirectory) + "foo"));