Re-apply r337595 with fix for LLVM_ENABLE_THREADS=Off.
llvm-svn: 337626
diff --git a/llvm/unittests/ExecutionEngine/Orc/CoreAPIsTest.cpp b/llvm/unittests/ExecutionEngine/Orc/CoreAPIsTest.cpp
index c0afbc6..d53c455 100644
--- a/llvm/unittests/ExecutionEngine/Orc/CoreAPIsTest.cpp
+++ b/llvm/unittests/ExecutionEngine/Orc/CoreAPIsTest.cpp
@@ -59,51 +59,57 @@
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 @@
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 @@
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 @@
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 @@
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 @@
// 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 @@
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 @@
});
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/llvm/unittests/ExecutionEngine/Orc/LegacyAPIInteropTest.cpp b/llvm/unittests/ExecutionEngine/Orc/LegacyAPIInteropTest.cpp
index 596584b..746ae1d 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.lookup(std::move(Q), Symbols);
+ return V.legacyLookup(std::move(Q), Symbols);
});
SymbolNameSet Symbols({Foo, Bar, Baz});
@@ -42,21 +42,17 @@
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 @@
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 @@
bool OnResolvedRun = false;
bool OnReadyRun = false;
- auto OnResolved =
- [&](Expected<AsynchronousSymbolQuery::ResolutionResult> Result) {
- OnResolvedRun = true;
- EXPECT_TRUE(!!Result) << "lookuWithLegacy failed to resolve";
+ auto OnResolved = [&](Expected<SymbolMap> 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";
- };
+ 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;