Re-apply r337595 with fix for LLVM_ENABLE_THREADS=Off.

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

2 files changed, 135 insertions, 182 deletions

diff --git a/unittests/ExecutionEngine/Orc/CoreAPIsTest.cpp b/unittests/ExecutionEngine/Orc/CoreAPIsTest.cpp
index c0afbc6be06..d53c4558e0c 100644
--- a/unittests/ExecutionEngine/Orc/CoreAPIsTest.cpp
+++ b/unittests/ExecutionEngine/Orc/CoreAPIsTest.cpp
@@ -59,51 +59,57 @@ private:
   DestructorFunction Destructor;
 };
 
-
-TEST_F(CoreAPIsStandardTest, AsynchronousSymbolQuerySuccessfulResolutionOnly) {
+TEST_F(CoreAPIsStandardTest, BasicSuccessfulLookup) {
   bool OnResolutionRun = false;
   bool OnReadyRun = false;
-  auto OnResolution =
-      [&](Expected<AsynchronousSymbolQuery::ResolutionResult> Result) {
-        EXPECT_TRUE(!!Result) << "Resolution unexpectedly returned error";
-        auto &Resolved = Result->Symbols;
-        auto I = Resolved.find(Foo);
-        EXPECT_NE(I, Resolved.end()) << "Could not find symbol definition";
-        EXPECT_EQ(I->second.getAddress(), FooAddr)
-            << "Resolution returned incorrect result";
-        OnResolutionRun = true;
-      };
+
+  auto OnResolution = [&](Expected<SymbolMap> Result) {
+    EXPECT_TRUE(!!Result) << "Resolution unexpectedly returned error";
+    auto &Resolved = *Result;
+    auto I = Resolved.find(Foo);
+    EXPECT_NE(I, Resolved.end()) << "Could not find symbol definition";
+    EXPECT_EQ(I->second.getAddress(), FooAddr)
+        << "Resolution returned incorrect result";
+    OnResolutionRun = true;
+  };
   auto OnReady = [&](Error Err) {
     cantFail(std::move(Err));
     OnReadyRun = true;
   };
 
-  AsynchronousSymbolQuery Q(SymbolNameSet({Foo}), OnResolution, OnReady);
+  std::shared_ptr<MaterializationResponsibility> FooMR;
 
-  Q.resolve(Foo, FooSym);
+  cantFail(V.define(llvm::make_unique<SimpleMaterializationUnit>(
+      SymbolFlagsMap({{Foo, FooSym.getFlags()}}),
+      [&](MaterializationResponsibility R) {
+        FooMR = std::make_shared<MaterializationResponsibility>(std::move(R));
+      })));
 
-  EXPECT_TRUE(Q.isFullyResolved()) << "Expected query to be fully resolved";
+  ES.lookup({&V}, {Foo}, OnResolution, OnReady, NoDependenciesToRegister);
 
-  if (!Q.isFullyResolved())
-    return;
+  EXPECT_FALSE(OnResolutionRun) << "Should not have been resolved yet";
+  EXPECT_FALSE(OnReadyRun) << "Should not have been marked ready yet";
 
-  Q.handleFullyResolved();
+  FooMR->resolve({{Foo, FooSym}});
 
-  EXPECT_TRUE(OnResolutionRun) << "OnResolutionCallback was not run";
-  EXPECT_FALSE(OnReadyRun) << "OnReady unexpectedly run";
+  EXPECT_TRUE(OnResolutionRun) << "Should have been resolved";
+  EXPECT_FALSE(OnReadyRun) << "Should not have been marked ready yet";
+
+  FooMR->finalize();
+
+  EXPECT_TRUE(OnReadyRun) << "Should have been marked ready";
 }
 
 TEST_F(CoreAPIsStandardTest, ExecutionSessionFailQuery) {
   bool OnResolutionRun = false;
   bool OnReadyRun = false;
 
-  auto OnResolution =
-      [&](Expected<AsynchronousSymbolQuery::ResolutionResult> Result) {
-        EXPECT_FALSE(!!Result) << "Resolution unexpectedly returned success";
-        auto Msg = toString(Result.takeError());
-        EXPECT_EQ(Msg, "xyz") << "Resolution returned incorrect result";
-        OnResolutionRun = true;
-      };
+  auto OnResolution = [&](Expected<SymbolMap> Result) {
+    EXPECT_FALSE(!!Result) << "Resolution unexpectedly returned success";
+    auto Msg = toString(Result.takeError());
+    EXPECT_EQ(Msg, "xyz") << "Resolution returned incorrect result";
+    OnResolutionRun = true;
+  };
   auto OnReady = [&](Error Err) {
     cantFail(std::move(Err));
     OnReadyRun = true;
@@ -111,62 +117,28 @@ TEST_F(CoreAPIsStandardTest, ExecutionSessionFailQuery) {
 
   AsynchronousSymbolQuery Q(SymbolNameSet({Foo}), OnResolution, OnReady);
 
-  ES.failQuery(Q, make_error<StringError>("xyz", inconvertibleErrorCode()));
+  ES.legacyFailQuery(Q,
+                     make_error<StringError>("xyz", inconvertibleErrorCode()));
 
   EXPECT_TRUE(OnResolutionRun) << "OnResolutionCallback was not run";
   EXPECT_FALSE(OnReadyRun) << "OnReady unexpectedly run";
 }
 
-TEST_F(CoreAPIsStandardTest, SimpleAsynchronousSymbolQueryAgainstVSO) {
-  bool OnResolutionRun = false;
+TEST_F(CoreAPIsStandardTest, EmptyLookup) {
+  bool OnResolvedRun = false;
   bool OnReadyRun = false;
 
-  auto OnResolution =
-      [&](Expected<AsynchronousSymbolQuery::ResolutionResult> Result) {
-        EXPECT_TRUE(!!Result) << "Query unexpectedly returned error";
-        auto &Resolved = Result->Symbols;
-        auto I = Resolved.find(Foo);
-        EXPECT_NE(I, Resolved.end()) << "Could not find symbol definition";
-        EXPECT_EQ(I->second.getAddress(), FooSym.getAddress())
-            << "Resolution returned incorrect result";
-        OnResolutionRun = true;
-      };
+  auto OnResolution = [&](Expected<SymbolMap> Result) {
+    cantFail(std::move(Result));
+    OnResolvedRun = true;
+  };
 
   auto OnReady = [&](Error Err) {
     cantFail(std::move(Err));
     OnReadyRun = true;
   };
 
-  SymbolNameSet Names({Foo});
-
-  auto Q =
-      std::make_shared<AsynchronousSymbolQuery>(Names, OnResolution, OnReady);
-
-  auto Defs = absoluteSymbols({{Foo, FooSym}});
-  cantFail(V.define(Defs));
-  assert(Defs == nullptr && "Defs should have been accepted");
-  V.lookup(Q, Names);
-
-  EXPECT_TRUE(OnResolutionRun) << "OnResolutionCallback was not run";
-  EXPECT_TRUE(OnReadyRun) << "OnReady was not run";
-}
-
-TEST_F(CoreAPIsStandardTest, EmptyVSOAndQueryLookup) {
-  bool OnResolvedRun = false;
-  bool OnReadyRun = false;
-
-  auto Q = std::make_shared<AsynchronousSymbolQuery>(
-      SymbolNameSet(),
-      [&](Expected<AsynchronousSymbolQuery::ResolutionResult> RR) {
-        cantFail(std::move(RR));
-        OnResolvedRun = true;
-      },
-      [&](Error Err) {
-        cantFail(std::move(Err));
-        OnReadyRun = true;
-      });
-
-  V.lookup(std::move(Q), {});
+  ES.lookup({&V}, {}, OnResolution, OnReady, NoDependenciesToRegister);
 
   EXPECT_TRUE(OnResolvedRun) << "OnResolved was not run for empty query";
   EXPECT_TRUE(OnReadyRun) << "OnReady was not run for empty query";
@@ -182,8 +154,8 @@ TEST_F(CoreAPIsStandardTest, ChainedVSOLookup) {
 
   auto Q = std::make_shared<AsynchronousSymbolQuery>(
       SymbolNameSet({Foo}),
-      [&](Expected<AsynchronousSymbolQuery::ResolutionResult> RR) {
-        cantFail(std::move(RR));
+      [&](Expected<SymbolMap> Result) {
+        cantFail(std::move(Result));
         OnResolvedRun = true;
       },
       [&](Error Err) {
@@ -191,7 +163,7 @@ TEST_F(CoreAPIsStandardTest, ChainedVSOLookup) {
         OnReadyRun = true;
       });
 
-  V2.lookup(Q, V.lookup(Q, {Foo}));
+  V2.legacyLookup(Q, V.legacyLookup(Q, {Foo}));
 
   EXPECT_TRUE(OnResolvedRun) << "OnResolved was not run for empty query";
   EXPECT_TRUE(OnReadyRun) << "OnReady was not run for empty query";
@@ -268,20 +240,15 @@ TEST_F(CoreAPIsStandardTest, TestTrivialCircularDependency) {
   cantFail(V.define(FooMU));
 
   bool FooReady = false;
-  auto Q =
-    std::make_shared<AsynchronousSymbolQuery>(
-      SymbolNameSet({ Foo }),
-      [](Expected<AsynchronousSymbolQuery::ResolutionResult> R) {
-        cantFail(std::move(R));
-      },
-      [&](Error Err) {
-        cantFail(std::move(Err));
-        FooReady = true;
-      });
+  auto OnResolution = [](Expected<SymbolMap> R) { cantFail(std::move(R)); };
+  auto OnReady = [&](Error Err) {
+    cantFail(std::move(Err));
+    FooReady = true;
+  };
 
-  V.lookup(std::move(Q), { Foo });
+  ES.lookup({&V}, {Foo}, std::move(OnResolution), std::move(OnReady),
+            NoDependenciesToRegister);
 
-  FooR->addDependencies({{&V, {Foo}}});
   FooR->resolve({{Foo, FooSym}});
   FooR->finalize();
 
@@ -323,54 +290,52 @@ TEST_F(CoreAPIsStandardTest, TestCircularDependenceInOneVSO) {
   // Query each of the symbols to trigger materialization.
   bool FooResolved = false;
   bool FooReady = false;
-  auto FooQ = std::make_shared<AsynchronousSymbolQuery>(
-      SymbolNameSet({Foo}),
-      [&](Expected<AsynchronousSymbolQuery::ResolutionResult> RR) {
-        cantFail(std::move(RR));
-        FooResolved = true;
-      },
-      [&](Error Err) {
-        cantFail(std::move(Err));
-        FooReady = true;
-      });
-  {
-    auto Unresolved = V.lookup(FooQ, {Foo});
-    EXPECT_TRUE(Unresolved.empty()) << "Failed to resolve \"Foo\"";
-  }
+
+  auto OnFooResolution = [&](Expected<SymbolMap> Result) {
+    cantFail(std::move(Result));
+    FooResolved = true;
+  };
+
+  auto OnFooReady = [&](Error Err) {
+    cantFail(std::move(Err));
+    FooReady = true;
+  };
+
+  // Issue a lookup for Foo. Use NoDependenciesToRegister: We're going to add
+  // the dependencies manually below.
+  ES.lookup({&V}, {Foo}, std::move(OnFooResolution), std::move(OnFooReady),
+            NoDependenciesToRegister);
 
   bool BarResolved = false;
   bool BarReady = false;
-  auto BarQ = std::make_shared<AsynchronousSymbolQuery>(
-      SymbolNameSet({Bar}),
-      [&](Expected<AsynchronousSymbolQuery::ResolutionResult> RR) {
-        cantFail(std::move(RR));
-        BarResolved = true;
-      },
-      [&](Error Err) {
-        cantFail(std::move(Err));
-        BarReady = true;
-      });
-  {
-    auto Unresolved = V.lookup(BarQ, {Bar});
-    EXPECT_TRUE(Unresolved.empty()) << "Failed to resolve \"Bar\"";
-  }
+  auto OnBarResolution = [&](Expected<SymbolMap> Result) {
+    cantFail(std::move(Result));
+    BarResolved = true;
+  };
+
+  auto OnBarReady = [&](Error Err) {
+    cantFail(std::move(Err));
+    BarReady = true;
+  };
+
+  ES.lookup({&V}, {Bar}, std::move(OnBarResolution), std::move(OnBarReady),
+            NoDependenciesToRegister);
 
   bool BazResolved = false;
   bool BazReady = false;
-  auto BazQ = std::make_shared<AsynchronousSymbolQuery>(
-      SymbolNameSet({Baz}),
-      [&](Expected<AsynchronousSymbolQuery::ResolutionResult> RR) {
-        cantFail(std::move(RR));
-        BazResolved = true;
-      },
-      [&](Error Err) {
-        cantFail(std::move(Err));
-        BazReady = true;
-      });
-  {
-    auto Unresolved = V.lookup(BazQ, {Baz});
-    EXPECT_TRUE(Unresolved.empty()) << "Failed to resolve \"Baz\"";
-  }
+
+  auto OnBazResolution = [&](Expected<SymbolMap> Result) {
+    cantFail(std::move(Result));
+    BazResolved = true;
+  };
+
+  auto OnBazReady = [&](Error Err) {
+    cantFail(std::move(Err));
+    BazReady = true;
+  };
+
+  ES.lookup({&V}, {Baz}, std::move(OnBazResolution), std::move(OnBazReady),
+            NoDependenciesToRegister);
 
   // Add a circular dependency: Foo -> Bar, Bar -> Baz, Baz -> Foo.
   FooR->addDependencies({{&V, SymbolNameSet({Bar})}});
@@ -478,28 +443,23 @@ TEST_F(CoreAPIsStandardTest, AddAndMaterializeLazySymbol) {
   bool OnResolutionRun = false;
   bool OnReadyRun = false;
 
-  auto OnResolution =
-      [&](Expected<AsynchronousSymbolQuery::ResolutionResult> Result) {
-        EXPECT_TRUE(!!Result) << "Resolution unexpectedly returned error";
-        auto I = Result->Symbols.find(Foo);
-        EXPECT_NE(I, Result->Symbols.end())
-            << "Could not find symbol definition";
-        EXPECT_EQ(I->second.getAddress(), FooSym.getAddress())
-            << "Resolution returned incorrect result";
-        OnResolutionRun = true;
-      };
+  auto OnResolution = [&](Expected<SymbolMap> Result) {
+    EXPECT_TRUE(!!Result) << "Resolution unexpectedly returned error";
+    auto I = Result->find(Foo);
+    EXPECT_NE(I, Result->end()) << "Could not find symbol definition";
+    EXPECT_EQ(I->second.getAddress(), FooSym.getAddress())
+        << "Resolution returned incorrect result";
+    OnResolutionRun = true;
+  };
 
   auto OnReady = [&](Error Err) {
     cantFail(std::move(Err));
     OnReadyRun = true;
   };
 
-  auto Q =
-      std::make_shared<AsynchronousSymbolQuery>(Names, OnResolution, OnReady);
+  ES.lookup({&V}, Names, std::move(OnResolution), std::move(OnReady),
+            NoDependenciesToRegister);
 
-  auto Unresolved = V.lookup(std::move(Q), Names);
-
-  EXPECT_TRUE(Unresolved.empty()) << "Could not find Foo in dylib";
   EXPECT_TRUE(FooMaterialized) << "Foo was not materialized";
   EXPECT_TRUE(BarDiscarded) << "Bar was not discarded";
   EXPECT_TRUE(OnResolutionRun) << "OnResolutionCallback was not run";
@@ -714,13 +674,14 @@ TEST_F(CoreAPIsStandardTest, TestMaterializeWeakSymbol) {
       });
 
   cantFail(V.define(MU));
-  auto Q = std::make_shared<AsynchronousSymbolQuery>(
-      SymbolNameSet({Foo}),
-      [](Expected<AsynchronousSymbolQuery::ResolutionResult> R) {
-        cantFail(std::move(R));
-      },
-      [](Error Err) { cantFail(std::move(Err)); });
-  V.lookup(std::move(Q), SymbolNameSet({Foo}));
+  auto OnResolution = [](Expected<SymbolMap> Result) {
+    cantFail(std::move(Result));
+  };
+
+  auto OnReady = [](Error Err) { cantFail(std::move(Err)); };
+
+  ES.lookup({&V}, {Foo}, std::move(OnResolution), std::move(OnReady),
+            NoDependenciesToRegister);
 
   auto MU2 = llvm::make_unique<SimpleMaterializationUnit>(
       SymbolFlagsMap({{Foo, JITSymbolFlags::Exported}}),
diff --git a/unittests/ExecutionEngine/Orc/LegacyAPIInteropTest.cpp b/unittests/ExecutionEngine/Orc/LegacyAPIInteropTest.cpp
index 596584b7117..746ae1dca49 100644
--- a/unittests/ExecutionEngine/Orc/LegacyAPIInteropTest.cpp
+++ b/unittests/ExecutionEngine/Orc/LegacyAPIInteropTest.cpp
@@ -24,7 +24,7 @@ TEST_F(LegacyAPIsStandardTest, TestLambdaSymbolResolver) {
   auto Resolver = createSymbolResolver(
       [&](const SymbolNameSet &Symbols) { return V.lookupFlags(Symbols); },
       [&](std::shared_ptr<AsynchronousSymbolQuery> Q, SymbolNameSet Symbols) {
-        return V.lookup(std::move(Q), Symbols);
+        return V.legacyLookup(std::move(Q), Symbols);
       });
 
   SymbolNameSet Symbols({Foo, Bar, Baz});
@@ -42,21 +42,17 @@ TEST_F(LegacyAPIsStandardTest, TestLambdaSymbolResolver) {
 
   bool OnResolvedRun = false;
 
-  auto OnResolved =
-      [&](Expected<AsynchronousSymbolQuery::ResolutionResult> Result) {
-        OnResolvedRun = true;
-        EXPECT_TRUE(!!Result) << "Unexpected error";
-        EXPECT_EQ(Result->Symbols.size(), 2U)
-            << "Unexpected number of resolved symbols";
-        EXPECT_EQ(Result->Symbols.count(Foo), 1U)
-            << "Missing lookup result for foo";
-        EXPECT_EQ(Result->Symbols.count(Bar), 1U)
-            << "Missing lookup result for bar";
-        EXPECT_EQ(Result->Symbols[Foo].getAddress(), FooSym.getAddress())
-            << "Incorrect address for foo";
-        EXPECT_EQ(Result->Symbols[Bar].getAddress(), BarSym.getAddress())
-            << "Incorrect address for bar";
-      };
+  auto OnResolved = [&](Expected<SymbolMap> Result) {
+    OnResolvedRun = true;
+    EXPECT_TRUE(!!Result) << "Unexpected error";
+    EXPECT_EQ(Result->size(), 2U) << "Unexpected number of resolved symbols";
+    EXPECT_EQ(Result->count(Foo), 1U) << "Missing lookup result for foo";
+    EXPECT_EQ(Result->count(Bar), 1U) << "Missing lookup result for bar";
+    EXPECT_EQ((*Result)[Foo].getAddress(), FooSym.getAddress())
+        << "Incorrect address for foo";
+    EXPECT_EQ((*Result)[Bar].getAddress(), BarSym.getAddress())
+        << "Incorrect address for bar";
+  };
   auto OnReady = [&](Error Err) {
     EXPECT_FALSE(!!Err) << "Finalization should never fail in this test";
   };
@@ -85,7 +81,7 @@ TEST(LegacyAPIInteropTest, QueryAgainstVSO) {
 
   auto Lookup = [&](std::shared_ptr<AsynchronousSymbolQuery> Query,
                     SymbolNameSet Symbols) {
-    return V.lookup(std::move(Query), Symbols);
+    return V.legacyLookup(std::move(Query), Symbols);
   };
 
   auto UnderlyingResolver =
@@ -158,22 +154,18 @@ TEST(LegacyAPIInteropTset, LegacyLookupHelpersFn) {
 
   bool OnResolvedRun = false;
   bool OnReadyRun = false;
-  auto OnResolved =
-      [&](Expected<AsynchronousSymbolQuery::ResolutionResult> Result) {
-        OnResolvedRun = true;
-        EXPECT_TRUE(!!Result) << "lookuWithLegacy failed to resolve";
-
-        auto &Resolved = Result->Symbols;
-        EXPECT_EQ(Resolved.size(), 2U) << "Wrong number of symbols resolved";
-        EXPECT_EQ(Resolved.count(Foo), 1U) << "Result for foo missing";
-        EXPECT_EQ(Resolved.count(Bar), 1U) << "Result for bar missing";
-        EXPECT_EQ(Resolved[Foo].getAddress(), FooAddr)
-            << "Wrong address for foo";
-        EXPECT_EQ(Resolved[Foo].getFlags(), FooFlags) << "Wrong flags for foo";
-        EXPECT_EQ(Resolved[Bar].getAddress(), BarAddr)
-            << "Wrong address for bar";
-        EXPECT_EQ(Resolved[Bar].getFlags(), BarFlags) << "Wrong flags for bar";
-      };
+  auto OnResolved = [&](Expected<SymbolMap> Result) {
+    OnResolvedRun = true;
+    EXPECT_TRUE(!!Result) << "lookuWithLegacy failed to resolve";
+
+    EXPECT_EQ(Result->size(), 2U) << "Wrong number of symbols resolved";
+    EXPECT_EQ(Result->count(Foo), 1U) << "Result for foo missing";
+    EXPECT_EQ(Result->count(Bar), 1U) << "Result for bar missing";
+    EXPECT_EQ((*Result)[Foo].getAddress(), FooAddr) << "Wrong address for foo";
+    EXPECT_EQ((*Result)[Foo].getFlags(), FooFlags) << "Wrong flags for foo";
+    EXPECT_EQ((*Result)[Bar].getAddress(), BarAddr) << "Wrong address for bar";
+    EXPECT_EQ((*Result)[Bar].getFlags(), BarFlags) << "Wrong flags for bar";
+  };
   auto OnReady = [&](Error Err) {
     EXPECT_FALSE(!!Err) << "Finalization unexpectedly failed";
     OnReadyRun = true;