[ORC] Add new symbol lookup methods to ExecutionSessionBase in preparation for

deprecating SymbolResolver and AsynchronousSymbolQuery.

Both lookup overloads take a VSO search order to perform the lookup. The first
overload is non-blocking and takes OnResolved and OnReady callbacks. The second
is blocking, takes a boolean flag to indicate whether to wait until all symbols
are ready, and returns a SymbolMap. Both overloads take a RegisterDependencies
function to register symbol dependencies (if any) on the query.

llvm-svn: 337595

1 files changed, 25 insertions, 33 deletions

diff --git a/llvm/unittests/ExecutionEngine/Orc/LegacyAPIInteropTest.cpp b/llvm/unittests/ExecutionEngine/Orc/LegacyAPIInteropTest.cpp
index 596584b7117..746ae1dca49 100644
--- a/llvm/unittests/ExecutionEngine/Orc/LegacyAPIInteropTest.cpp
+++ b/llvm/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;