Revert r337595 "[ORC] Add new symbol lookup methods to ExecutionSessionBase in preparation for"
Breaks the build with LLVM_ENABLE_THREADS=OFF.
llvm-svn: 337608
diff --git a/llvm/unittests/ExecutionEngine/Orc/CoreAPIsTest.cpp b/llvm/unittests/ExecutionEngine/Orc/CoreAPIsTest.cpp
index d53c455..c0afbc6 100644
--- a/llvm/unittests/ExecutionEngine/Orc/CoreAPIsTest.cpp
+++ b/llvm/unittests/ExecutionEngine/Orc/CoreAPIsTest.cpp
@@ -59,57 +59,20 @@
DestructorFunction Destructor;
};
-TEST_F(CoreAPIsStandardTest, BasicSuccessfulLookup) {
+
+TEST_F(CoreAPIsStandardTest, AsynchronousSymbolQuerySuccessfulResolutionOnly) {
bool OnResolutionRun = false;
bool OnReadyRun = false;
-
- 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;
- };
-
- std::shared_ptr<MaterializationResponsibility> FooMR;
-
- cantFail(V.define(llvm::make_unique<SimpleMaterializationUnit>(
- SymbolFlagsMap({{Foo, FooSym.getFlags()}}),
- [&](MaterializationResponsibility R) {
- FooMR = std::make_shared<MaterializationResponsibility>(std::move(R));
- })));
-
- ES.lookup({&V}, {Foo}, OnResolution, OnReady, NoDependenciesToRegister);
-
- EXPECT_FALSE(OnResolutionRun) << "Should not have been resolved yet";
- EXPECT_FALSE(OnReadyRun) << "Should not have been marked ready yet";
-
- FooMR->resolve({{Foo, FooSym}});
-
- 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<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 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 OnReady = [&](Error Err) {
cantFail(std::move(Err));
OnReadyRun = true;
@@ -117,28 +80,93 @@
AsynchronousSymbolQuery Q(SymbolNameSet({Foo}), OnResolution, OnReady);
- ES.legacyFailQuery(Q,
- make_error<StringError>("xyz", inconvertibleErrorCode()));
+ Q.resolve(Foo, FooSym);
+
+ EXPECT_TRUE(Q.isFullyResolved()) << "Expected query to be fully resolved";
+
+ if (!Q.isFullyResolved())
+ return;
+
+ Q.handleFullyResolved();
EXPECT_TRUE(OnResolutionRun) << "OnResolutionCallback was not run";
EXPECT_FALSE(OnReadyRun) << "OnReady unexpectedly run";
}
-TEST_F(CoreAPIsStandardTest, EmptyLookup) {
- bool OnResolvedRun = false;
+TEST_F(CoreAPIsStandardTest, ExecutionSessionFailQuery) {
+ bool OnResolutionRun = false;
bool OnReadyRun = false;
- auto OnResolution = [&](Expected<SymbolMap> Result) {
- cantFail(std::move(Result));
- OnResolvedRun = true;
+ 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 OnReady = [&](Error Err) {
+ cantFail(std::move(Err));
+ OnReadyRun = true;
};
+ AsynchronousSymbolQuery Q(SymbolNameSet({Foo}), OnResolution, OnReady);
+
+ ES.failQuery(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;
+ 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 OnReady = [&](Error Err) {
cantFail(std::move(Err));
OnReadyRun = true;
};
- ES.lookup({&V}, {}, OnResolution, OnReady, NoDependenciesToRegister);
+ 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), {});
EXPECT_TRUE(OnResolvedRun) << "OnResolved was not run for empty query";
EXPECT_TRUE(OnReadyRun) << "OnReady was not run for empty query";
@@ -154,8 +182,8 @@
auto Q = std::make_shared<AsynchronousSymbolQuery>(
SymbolNameSet({Foo}),
- [&](Expected<SymbolMap> Result) {
- cantFail(std::move(Result));
+ [&](Expected<AsynchronousSymbolQuery::ResolutionResult> RR) {
+ cantFail(std::move(RR));
OnResolvedRun = true;
},
[&](Error Err) {
@@ -163,7 +191,7 @@
OnReadyRun = true;
});
- V2.legacyLookup(Q, V.legacyLookup(Q, {Foo}));
+ V2.lookup(Q, V.lookup(Q, {Foo}));
EXPECT_TRUE(OnResolvedRun) << "OnResolved was not run for empty query";
EXPECT_TRUE(OnReadyRun) << "OnReady was not run for empty query";
@@ -240,15 +268,20 @@
cantFail(V.define(FooMU));
bool FooReady = false;
- auto OnResolution = [](Expected<SymbolMap> R) { cantFail(std::move(R)); };
- auto OnReady = [&](Error Err) {
- cantFail(std::move(Err));
- FooReady = true;
- };
+ auto Q =
+ std::make_shared<AsynchronousSymbolQuery>(
+ SymbolNameSet({ Foo }),
+ [](Expected<AsynchronousSymbolQuery::ResolutionResult> R) {
+ cantFail(std::move(R));
+ },
+ [&](Error Err) {
+ cantFail(std::move(Err));
+ FooReady = true;
+ });
- ES.lookup({&V}, {Foo}, std::move(OnResolution), std::move(OnReady),
- NoDependenciesToRegister);
+ V.lookup(std::move(Q), { Foo });
+ FooR->addDependencies({{&V, {Foo}}});
FooR->resolve({{Foo, FooSym}});
FooR->finalize();
@@ -290,52 +323,54 @@
// Query each of the symbols to trigger materialization.
bool FooResolved = false;
bool FooReady = false;
-
- 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);
+ 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\"";
+ }
bool BarResolved = false;
bool BarReady = false;
- 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);
+ 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\"";
+ }
bool BazResolved = false;
bool BazReady = false;
-
- 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);
+ 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\"";
+ }
// Add a circular dependency: Foo -> Bar, Bar -> Baz, Baz -> Foo.
FooR->addDependencies({{&V, SymbolNameSet({Bar})}});
@@ -443,23 +478,28 @@
bool OnResolutionRun = false;
bool OnReadyRun = false;
- 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 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 OnReady = [&](Error Err) {
cantFail(std::move(Err));
OnReadyRun = true;
};
- ES.lookup({&V}, Names, std::move(OnResolution), std::move(OnReady),
- NoDependenciesToRegister);
+ auto Q =
+ std::make_shared<AsynchronousSymbolQuery>(Names, OnResolution, OnReady);
+ 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";
@@ -674,14 +714,13 @@
});
cantFail(V.define(MU));
- 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 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 MU2 = llvm::make_unique<SimpleMaterializationUnit>(
SymbolFlagsMap({{Foo, JITSymbolFlags::Exported}}),
diff --git a/llvm/unittests/ExecutionEngine/Orc/LegacyAPIInteropTest.cpp b/llvm/unittests/ExecutionEngine/Orc/LegacyAPIInteropTest.cpp
index 746ae1d..596584b 100644
--- a/llvm/unittests/ExecutionEngine/Orc/LegacyAPIInteropTest.cpp
+++ b/llvm/unittests/ExecutionEngine/Orc/LegacyAPIInteropTest.cpp
@@ -24,7 +24,7 @@
auto Resolver = createSymbolResolver(
[&](const SymbolNameSet &Symbols) { return V.lookupFlags(Symbols); },
[&](std::shared_ptr<AsynchronousSymbolQuery> Q, SymbolNameSet Symbols) {
- return V.legacyLookup(std::move(Q), Symbols);
+ return V.lookup(std::move(Q), Symbols);
});
SymbolNameSet Symbols({Foo, Bar, Baz});
@@ -42,17 +42,21 @@
bool OnResolvedRun = false;
- 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 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 OnReady = [&](Error Err) {
EXPECT_FALSE(!!Err) << "Finalization should never fail in this test";
};
@@ -81,7 +85,7 @@
auto Lookup = [&](std::shared_ptr<AsynchronousSymbolQuery> Query,
SymbolNameSet Symbols) {
- return V.legacyLookup(std::move(Query), Symbols);
+ return V.lookup(std::move(Query), Symbols);
};
auto UnderlyingResolver =
@@ -154,18 +158,22 @@
bool OnResolvedRun = false;
bool OnReadyRun = false;
- auto OnResolved = [&](Expected<SymbolMap> Result) {
- OnResolvedRun = true;
- EXPECT_TRUE(!!Result) << "lookuWithLegacy failed to resolve";
+ auto OnResolved =
+ [&](Expected<AsynchronousSymbolQuery::ResolutionResult> 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 &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 OnReady = [&](Error Err) {
EXPECT_FALSE(!!Err) << "Finalization unexpectedly failed";
OnReadyRun = true;