[ORC] Consolidate materialization errors, and generate them in VSO's

notifyFailed method rather than passing in an error generator.

VSO::notifyFailed is responsible for notifying queries that they will not
succeed due to error. In practice the queries don't care about the details
of the failure, just the fact that a failure occurred for some symbols.
Having VSO::notifyFailed take care of this simplifies the interface.

llvm-svn: 332666

1 files changed, 19 insertions, 76 deletions

diff --git a/llvm/unittests/ExecutionEngine/Orc/CoreAPIsTest.cpp b/llvm/unittests/ExecutionEngine/Orc/CoreAPIsTest.cpp
index c36b347d670..976185bba2f 100644
--- a/llvm/unittests/ExecutionEngine/Orc/CoreAPIsTest.cpp
+++ b/llvm/unittests/ExecutionEngine/Orc/CoreAPIsTest.cpp
@@ -518,33 +518,30 @@ TEST(CoreAPIsTest, FailResolution) {
   auto MU = llvm::make_unique<SimpleMaterializationUnit>(
       SymbolFlagsMap(
           {{Foo, JITSymbolFlags::Weak}, {Bar, JITSymbolFlags::Weak}}),
-      [&](MaterializationResponsibility R) {
-        R.failMaterialization(
-            [&]() { return make_error<FailedToResolve>(Names); });
-      });
+      [&](MaterializationResponsibility R) { R.failMaterialization(); });
 
   auto &V = ES.createVSO("V");
 
   cantFail(V.define(MU));
 
-  auto OnResolution = [&](Expected<AsynchronousSymbolQuery::ResolutionResult>
-                              Result) {
-    handleAllErrors(Result.takeError(),
-                    [&](FailedToResolve &F) {
-                      EXPECT_EQ(F.getSymbols(), Names)
-                          << "Expected to fail on symbols in Names";
-                    },
-                    [](ErrorInfoBase &EIB) {
-                      std::string ErrMsg;
-                      {
-                        raw_string_ostream ErrOut(ErrMsg);
-                        EIB.log(ErrOut);
-                      }
-                      ADD_FAILURE()
-                          << "Expected a FailedToResolve error. Got:\n"
-                          << ErrMsg;
-                    });
-  };
+  auto OnResolution =
+      [&](Expected<AsynchronousSymbolQuery::ResolutionResult> Result) {
+        handleAllErrors(Result.takeError(),
+                        [&](FailedToMaterialize &F) {
+                          EXPECT_EQ(F.getSymbols(), Names)
+                              << "Expected to fail on symbols in Names";
+                        },
+                        [](ErrorInfoBase &EIB) {
+                          std::string ErrMsg;
+                          {
+                            raw_string_ostream ErrOut(ErrMsg);
+                            EIB.log(ErrOut);
+                          }
+                          ADD_FAILURE()
+                              << "Expected a FailedToResolve error. Got:\n"
+                              << ErrMsg;
+                        });
+      };
 
   auto OnReady = [](Error Err) {
     cantFail(std::move(Err));
@@ -557,60 +554,6 @@ TEST(CoreAPIsTest, FailResolution) {
   V.lookup(std::move(Q), Names);
 }
 
-TEST(CoreAPIsTest, FailFinalization) {
-  ExecutionSession ES;
-  auto Foo = ES.getSymbolStringPool().intern("foo");
-  auto Bar = ES.getSymbolStringPool().intern("bar");
-
-  SymbolNameSet Names({Foo, Bar});
-
-  auto MU = llvm::make_unique<SimpleMaterializationUnit>(
-      SymbolFlagsMap(
-          {{Foo, JITSymbolFlags::Exported}, {Bar, JITSymbolFlags::Exported}}),
-      [&](MaterializationResponsibility R) {
-        constexpr JITTargetAddress FakeFooAddr = 0xdeadbeef;
-        constexpr JITTargetAddress FakeBarAddr = 0xcafef00d;
-
-        auto FooSym = JITEvaluatedSymbol(FakeFooAddr, JITSymbolFlags::Exported);
-        auto BarSym = JITEvaluatedSymbol(FakeBarAddr, JITSymbolFlags::Exported);
-        R.resolve(SymbolMap({{Foo, FooSym}, {Bar, BarSym}}));
-        R.failMaterialization(
-            [&]() { return make_error<FailedToFinalize>(Names); });
-      });
-
-  auto &V = ES.createVSO("V");
-
-  cantFail(V.define(MU));
-
-  auto OnResolution =
-      [](Expected<AsynchronousSymbolQuery::ResolutionResult> Result) {
-        cantFail(std::move(Result));
-      };
-
-  auto OnReady = [&](Error Err) {
-    handleAllErrors(std::move(Err),
-                    [&](FailedToFinalize &F) {
-                      EXPECT_EQ(F.getSymbols(), Names)
-                          << "Expected to fail on symbols in Names";
-                    },
-                    [](ErrorInfoBase &EIB) {
-                      std::string ErrMsg;
-                      {
-                        raw_string_ostream ErrOut(ErrMsg);
-                        EIB.log(ErrOut);
-                      }
-                      ADD_FAILURE()
-                          << "Expected a FailedToFinalize error. Got:\n"
-                          << ErrMsg;
-                    });
-  };
-
-  auto Q =
-      std::make_shared<AsynchronousSymbolQuery>(Names, OnResolution, OnReady);
-
-  V.lookup(std::move(Q), Names);
-}
-
 TEST(CoreAPIsTest, TestLambdaSymbolResolver) {
   JITEvaluatedSymbol FooSym(0xdeadbeef, JITSymbolFlags::Exported);
   JITEvaluatedSymbol BarSym(0xcafef00d, JITSymbolFlags::Exported);