diff options
Diffstat (limited to 'llvm/unittests/ExecutionEngine/Orc')
3 files changed, 102 insertions, 151 deletions
diff --git a/llvm/unittests/ExecutionEngine/Orc/CoreAPIsTest.cpp b/llvm/unittests/ExecutionEngine/Orc/CoreAPIsTest.cpp index f5088e38761..6f9dd1fb481 100644 --- a/llvm/unittests/ExecutionEngine/Orc/CoreAPIsTest.cpp +++ b/llvm/unittests/ExecutionEngine/Orc/CoreAPIsTest.cpp @@ -23,21 +23,16 @@ class CoreAPIsStandardTest : public CoreAPIsBasedStandardTest {}; namespace { TEST_F(CoreAPIsStandardTest, BasicSuccessfulLookup) { - bool OnResolutionRun = false; - bool OnReadyRun = false; + bool OnCompletionRun = false; - auto OnResolution = [&](Expected<SymbolMap> Result) { + auto OnCompletion = [&](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; + OnCompletionRun = true; }; std::shared_ptr<MaterializationResponsibility> FooMR; @@ -48,65 +43,51 @@ TEST_F(CoreAPIsStandardTest, BasicSuccessfulLookup) { FooMR = std::make_shared<MaterializationResponsibility>(std::move(R)); }))); - ES.lookup(JITDylibSearchList({{&JD, false}}), {Foo}, OnResolution, OnReady, - NoDependenciesToRegister); + ES.lookup(JITDylibSearchList({{&JD, false}}), {Foo}, SymbolState::Ready, + OnCompletion, NoDependenciesToRegister); - EXPECT_FALSE(OnResolutionRun) << "Should not have been resolved yet"; - EXPECT_FALSE(OnReadyRun) << "Should not have been marked ready yet"; + EXPECT_FALSE(OnCompletionRun) << "Should not have been resolved yet"; FooMR->resolve({{Foo, FooSym}}); - EXPECT_TRUE(OnResolutionRun) << "Should have been resolved"; - EXPECT_FALSE(OnReadyRun) << "Should not have been marked ready yet"; + EXPECT_FALSE(OnCompletionRun) << "Should not be ready yet"; FooMR->emit(); - EXPECT_TRUE(OnReadyRun) << "Should have been marked ready"; + EXPECT_TRUE(OnCompletionRun) << "Should have been marked ready"; } TEST_F(CoreAPIsStandardTest, ExecutionSessionFailQuery) { - bool OnResolutionRun = false; - bool OnReadyRun = false; + bool OnCompletionRun = false; - auto OnResolution = [&](Expected<SymbolMap> Result) { + auto OnCompletion = [&](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; + OnCompletionRun = true; }; - AsynchronousSymbolQuery Q(SymbolNameSet({Foo}), OnResolution, OnReady); + AsynchronousSymbolQuery Q(SymbolNameSet({Foo}), SymbolState::Ready, + OnCompletion); ES.legacyFailQuery(Q, make_error<StringError>("xyz", inconvertibleErrorCode())); - EXPECT_TRUE(OnResolutionRun) << "OnResolutionCallback was not run"; - EXPECT_FALSE(OnReadyRun) << "OnReady unexpectedly run"; + EXPECT_TRUE(OnCompletionRun) << "OnCompletionCallback was not run"; } TEST_F(CoreAPIsStandardTest, EmptyLookup) { - bool OnResolvedRun = false; - bool OnReadyRun = false; + bool OnCompletionRun = false; - auto OnResolution = [&](Expected<SymbolMap> Result) { + auto OnCompletion = [&](Expected<SymbolMap> Result) { cantFail(std::move(Result)); - OnResolvedRun = true; - }; - - auto OnReady = [&](Error Err) { - cantFail(std::move(Err)); - OnReadyRun = true; + OnCompletionRun = true; }; - ES.lookup(JITDylibSearchList({{&JD, false}}), {}, OnResolution, OnReady, - NoDependenciesToRegister); + ES.lookup(JITDylibSearchList({{&JD, false}}), {}, SymbolState::Ready, + OnCompletion, NoDependenciesToRegister); - EXPECT_TRUE(OnResolvedRun) << "OnResolved was not run for empty query"; - EXPECT_TRUE(OnReadyRun) << "OnReady was not run for empty query"; + EXPECT_TRUE(OnCompletionRun) << "OnCompletion was not run for empty query"; } TEST_F(CoreAPIsStandardTest, RemoveSymbolsTest) { @@ -148,20 +129,14 @@ TEST_F(CoreAPIsStandardTest, RemoveSymbolsTest) { ADD_FAILURE() << "\"Baz\" discarded unexpectedly"; }))); - bool OnResolvedRun = false; - bool OnReadyRun = false; - ES.lookup(JITDylibSearchList({{&JD, false}}), {Foo, Baz}, - [&](Expected<SymbolMap> Result) { - EXPECT_TRUE(!!Result) << "OnResolved failed unexpectedly"; - consumeError(Result.takeError()); - OnResolvedRun = true; - }, - [&](Error Err) { - EXPECT_FALSE(!!Err) << "OnReady failed unexpectedly"; - consumeError(std::move(Err)); - OnReadyRun = true; - }, - NoDependenciesToRegister); + bool OnCompletionRun = false; + ES.lookup( + JITDylibSearchList({{&JD, false}}), {Foo, Baz}, SymbolState::Ready, + [&](Expected<SymbolMap> Result) { + cantFail(Result.takeError()); + OnCompletionRun = true; + }, + NoDependenciesToRegister); { // Attempt 1: Search for a missing symbol, Qux. @@ -193,8 +168,7 @@ TEST_F(CoreAPIsStandardTest, RemoveSymbolsTest) { EXPECT_TRUE(BarDiscarded) << "\"Bar\" should have been discarded"; EXPECT_TRUE(BarMaterializerDestructed) << "\"Bar\"'s materializer should have been destructed"; - EXPECT_TRUE(OnResolvedRun) << "OnResolved should have been run"; - EXPECT_TRUE(OnReadyRun) << "OnReady should have been run"; + EXPECT_TRUE(OnCompletionRun) << "OnCompletion should have been run"; } TEST_F(CoreAPIsStandardTest, ChainedJITDylibLookup) { @@ -202,24 +176,18 @@ TEST_F(CoreAPIsStandardTest, ChainedJITDylibLookup) { auto &JD2 = ES.createJITDylib("JD2"); - bool OnResolvedRun = false; - bool OnReadyRun = false; + bool OnCompletionRun = false; auto Q = std::make_shared<AsynchronousSymbolQuery>( - SymbolNameSet({Foo}), + SymbolNameSet({Foo}), SymbolState::Ready, [&](Expected<SymbolMap> Result) { cantFail(std::move(Result)); - OnResolvedRun = true; - }, - [&](Error Err) { - cantFail(std::move(Err)); - OnReadyRun = true; + OnCompletionRun = true; }); cantFail(JD2.legacyLookup(Q, cantFail(JD.legacyLookup(Q, {Foo})))); - EXPECT_TRUE(OnResolvedRun) << "OnResolved was not run for empty query"; - EXPECT_TRUE(OnReadyRun) << "OnReady was not run for empty query"; + EXPECT_TRUE(OnCompletionRun) << "OnCompletion was not run for empty query"; } TEST_F(CoreAPIsStandardTest, LookupWithHiddenSymbols) { @@ -396,14 +364,13 @@ TEST_F(CoreAPIsStandardTest, TestTrivialCircularDependency) { cantFail(JD.define(FooMU)); bool FooReady = false; - auto OnResolution = [](Expected<SymbolMap> R) { cantFail(std::move(R)); }; - auto OnReady = [&](Error Err) { - cantFail(std::move(Err)); + auto OnCompletion = [&](Expected<SymbolMap> Result) { + cantFail(std::move(Result)); FooReady = true; }; - ES.lookup(JITDylibSearchList({{&JD, false}}), {Foo}, std::move(OnResolution), - std::move(OnReady), NoDependenciesToRegister); + ES.lookup(JITDylibSearchList({{&JD, false}}), {Foo}, SymbolState::Ready, + OnCompletion, NoDependenciesToRegister); FooR->resolve({{Foo, FooSym}}); FooR->emit(); @@ -452,16 +419,18 @@ TEST_F(CoreAPIsStandardTest, TestCircularDependenceInOneJITDylib) { FooResolved = true; }; - auto OnFooReady = [&](Error Err) { - cantFail(std::move(Err)); + auto OnFooReady = [&](Expected<SymbolMap> Result) { + cantFail(std::move(Result)); FooReady = true; }; - // Issue a lookup for Foo. Use NoDependenciesToRegister: We're going to add + // Issue lookups for Foo. Use NoDependenciesToRegister: We're going to add // the dependencies manually below. - ES.lookup(JITDylibSearchList({{&JD, false}}), {Foo}, - std::move(OnFooResolution), std::move(OnFooReady), - NoDependenciesToRegister); + ES.lookup(JITDylibSearchList({{&JD, false}}), {Foo}, SymbolState::Resolved, + std::move(OnFooResolution), NoDependenciesToRegister); + + ES.lookup(JITDylibSearchList({{&JD, false}}), {Foo}, SymbolState::Ready, + std::move(OnFooReady), NoDependenciesToRegister); bool BarResolved = false; bool BarReady = false; @@ -470,14 +439,16 @@ TEST_F(CoreAPIsStandardTest, TestCircularDependenceInOneJITDylib) { BarResolved = true; }; - auto OnBarReady = [&](Error Err) { - cantFail(std::move(Err)); + auto OnBarReady = [&](Expected<SymbolMap> Result) { + cantFail(std::move(Result)); BarReady = true; }; - ES.lookup(JITDylibSearchList({{&JD, false}}), {Bar}, - std::move(OnBarResolution), std::move(OnBarReady), - NoDependenciesToRegister); + ES.lookup(JITDylibSearchList({{&JD, false}}), {Bar}, SymbolState::Resolved, + std::move(OnBarResolution), NoDependenciesToRegister); + + ES.lookup(JITDylibSearchList({{&JD, false}}), {Bar}, SymbolState::Ready, + std::move(OnBarReady), NoDependenciesToRegister); bool BazResolved = false; bool BazReady = false; @@ -487,14 +458,16 @@ TEST_F(CoreAPIsStandardTest, TestCircularDependenceInOneJITDylib) { BazResolved = true; }; - auto OnBazReady = [&](Error Err) { - cantFail(std::move(Err)); + auto OnBazReady = [&](Expected<SymbolMap> Result) { + cantFail(std::move(Result)); BazReady = true; }; - ES.lookup(JITDylibSearchList({{&JD, false}}), {Baz}, - std::move(OnBazResolution), std::move(OnBazReady), - NoDependenciesToRegister); + ES.lookup(JITDylibSearchList({{&JD, false}}), {Baz}, SymbolState::Resolved, + std::move(OnBazResolution), NoDependenciesToRegister); + + ES.lookup(JITDylibSearchList({{&JD, false}}), {Baz}, SymbolState::Ready, + std::move(OnBazReady), NoDependenciesToRegister); // Add a circular dependency: Foo -> Bar, Bar -> Baz, Baz -> Foo. FooR->addDependenciesForAll({{&JD, SymbolNameSet({Bar})}}); @@ -599,30 +572,23 @@ TEST_F(CoreAPIsStandardTest, AddAndMaterializeLazySymbol) { SymbolNameSet Names({Foo}); - bool OnResolutionRun = false; - bool OnReadyRun = false; + bool OnCompletionRun = false; - auto OnResolution = [&](Expected<SymbolMap> Result) { + auto OnCompletion = [&](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; + OnCompletionRun = true; }; - ES.lookup(JITDylibSearchList({{&JD, false}}), Names, std::move(OnResolution), - std::move(OnReady), NoDependenciesToRegister); + ES.lookup(JITDylibSearchList({{&JD, false}}), Names, SymbolState::Ready, + std::move(OnCompletion), NoDependenciesToRegister); EXPECT_TRUE(FooMaterialized) << "Foo was not materialized"; EXPECT_TRUE(BarDiscarded) << "Bar was not discarded"; - EXPECT_TRUE(OnResolutionRun) << "OnResolutionCallback was not run"; - EXPECT_TRUE(OnReadyRun) << "OnReady was not run"; + EXPECT_TRUE(OnCompletionRun) << "OnResolutionCallback was not run"; } TEST_F(CoreAPIsStandardTest, TestBasicWeakSymbolMaterialization) { @@ -652,24 +618,17 @@ TEST_F(CoreAPIsStandardTest, TestBasicWeakSymbolMaterialization) { cantFail(JD.define(MU1)); cantFail(JD.define(MU2)); - bool OnResolvedRun = false; - bool OnReadyRun = false; + bool OnCompletionRun = false; - auto OnResolution = [&](Expected<SymbolMap> Result) { + auto OnCompletion = [&](Expected<SymbolMap> Result) { cantFail(std::move(Result)); - OnResolvedRun = true; + OnCompletionRun = true; }; - auto OnReady = [&](Error Err) { - cantFail(std::move(Err)); - OnReadyRun = true; - }; - - ES.lookup(JITDylibSearchList({{&JD, false}}), {Bar}, std::move(OnResolution), - std::move(OnReady), NoDependenciesToRegister); + ES.lookup(JITDylibSearchList({{&JD, false}}), {Bar}, SymbolState::Ready, + std::move(OnCompletion), NoDependenciesToRegister); - EXPECT_TRUE(OnResolvedRun) << "OnResolved not run"; - EXPECT_TRUE(OnReadyRun) << "OnReady not run"; + EXPECT_TRUE(OnCompletionRun) << "OnCompletion not run"; EXPECT_TRUE(BarMaterialized) << "Bar was not materialized at all"; EXPECT_TRUE(DuplicateBarDiscarded) << "Duplicate bar definition not discarded"; @@ -725,7 +684,11 @@ TEST_F(CoreAPIsStandardTest, FailResolution) { auto MU = llvm::make_unique<SimpleMaterializationUnit>( SymbolFlagsMap({{Foo, JITSymbolFlags::Exported | JITSymbolFlags::Weak}, {Bar, JITSymbolFlags::Exported | JITSymbolFlags::Weak}}), - [&](MaterializationResponsibility R) { R.failMaterialization(); }); + [&](MaterializationResponsibility R) { + dbgs() << "Before failMat:\n"; + ES.dump(dbgs()); + R.failMaterialization(); + }); cantFail(JD.define(MU)); @@ -763,6 +726,7 @@ TEST_F(CoreAPIsStandardTest, FailEmissionEarly) { ES.lookup( JITDylibSearchList({{&JD, false}}), SymbolNameSet({Baz}), + SymbolState::Resolved, [&R](Expected<SymbolMap> Result) { // Called when "baz" is resolved. We don't actually depend // on or care about baz, but use it to trigger failure of @@ -772,7 +736,6 @@ TEST_F(CoreAPIsStandardTest, FailEmissionEarly) { cantFail(std::move(Result)); R.failMaterialization(); }, - [](Error Err) { cantFail(std::move(Err)); }, [&](const SymbolDependenceMap &Deps) { R.addDependenciesForAll(Deps); }); @@ -923,14 +886,12 @@ TEST_F(CoreAPIsStandardTest, TestMaterializeWeakSymbol) { }); cantFail(JD.define(MU)); - auto OnResolution = [](Expected<SymbolMap> Result) { + auto OnCompletion = [](Expected<SymbolMap> Result) { cantFail(std::move(Result)); }; - auto OnReady = [](Error Err) { cantFail(std::move(Err)); }; - - ES.lookup(JITDylibSearchList({{&JD, false}}), {Foo}, std::move(OnResolution), - std::move(OnReady), NoDependenciesToRegister); + ES.lookup(JITDylibSearchList({{&JD, false}}), {Foo}, SymbolState::Ready, + std::move(OnCompletion), 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 dca3eeb75fe..f79d721b812 100644 --- a/llvm/unittests/ExecutionEngine/Orc/LegacyAPIInteropTest.cpp +++ b/llvm/unittests/ExecutionEngine/Orc/LegacyAPIInteropTest.cpp @@ -42,10 +42,10 @@ TEST_F(LegacyAPIsStandardTest, TestLambdaSymbolResolver) { EXPECT_EQ(RS.count(Bar), 1U) << "getResponsibilitySet result incorrect. Should be {'bar'}"; - bool OnResolvedRun = false; + bool OnCompletionRun = false; - auto OnResolved = [&](Expected<SymbolMap> Result) { - OnResolvedRun = true; + auto OnCompletion = [&](Expected<SymbolMap> Result) { + OnCompletionRun = 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"; @@ -55,18 +55,15 @@ TEST_F(LegacyAPIsStandardTest, TestLambdaSymbolResolver) { 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"; - }; - auto Q = std::make_shared<AsynchronousSymbolQuery>(SymbolNameSet({Foo, Bar}), - OnResolved, OnReady); + auto Q = std::make_shared<AsynchronousSymbolQuery>( + SymbolNameSet({Foo, Bar}), SymbolState::Resolved, OnCompletion); auto Unresolved = Resolver->lookup(std::move(Q), SymbolNameSet({Foo, Bar, Baz})); EXPECT_EQ(Unresolved.size(), 1U) << "Expected one unresolved symbol"; EXPECT_EQ(Unresolved.count(Baz), 1U) << "Expected baz to not be resolved"; - EXPECT_TRUE(OnResolvedRun) << "OnResolved was never run"; + EXPECT_TRUE(OnCompletionRun) << "OnCompletion was never run"; } TEST_F(LegacyAPIsStandardTest, LegacyLookupHelpersFn) { @@ -98,10 +95,9 @@ TEST_F(LegacyAPIsStandardTest, LegacyLookupHelpersFn) { EXPECT_FALSE(BarMaterialized) << "lookupFlags should not have materialized bar"; - bool OnResolvedRun = false; - bool OnReadyRun = false; - auto OnResolved = [&](Expected<SymbolMap> Result) { - OnResolvedRun = true; + bool OnCompletionRun = false; + auto OnCompletion = [&](Expected<SymbolMap> Result) { + OnCompletionRun = true; EXPECT_TRUE(!!Result) << "lookuWithLegacy failed to resolve"; EXPECT_EQ(Result->size(), 2U) << "Wrong number of symbols resolved"; @@ -114,17 +110,12 @@ TEST_F(LegacyAPIsStandardTest, LegacyLookupHelpersFn) { EXPECT_EQ((*Result)[Bar].getFlags(), BarSym.getFlags()) << "Wrong flags for bar"; }; - auto OnReady = [&](Error Err) { - EXPECT_FALSE(!!Err) << "Finalization unexpectedly failed"; - OnReadyRun = true; - }; - AsynchronousSymbolQuery Q({Foo, Bar}, OnResolved, OnReady); + AsynchronousSymbolQuery Q({Foo, Bar}, SymbolState::Resolved, OnCompletion); auto Unresolved = lookupWithLegacyFn(ES, Q, SymbolNameSet({Foo, Bar, Baz}), LegacyLookup); - EXPECT_TRUE(OnResolvedRun) << "OnResolved was not run"; - EXPECT_TRUE(OnReadyRun) << "OnReady was not run"; + EXPECT_TRUE(OnCompletionRun) << "OnCompletion was not run"; EXPECT_EQ(Unresolved.size(), 1U) << "Expected one unresolved symbol"; EXPECT_EQ(Unresolved.count(Baz), 1U) << "Expected baz to be unresolved"; } diff --git a/llvm/unittests/ExecutionEngine/Orc/RTDyldObjectLinkingLayerTest.cpp b/llvm/unittests/ExecutionEngine/Orc/RTDyldObjectLinkingLayerTest.cpp index a5f529a37b6..440b840faaa 100644 --- a/llvm/unittests/ExecutionEngine/Orc/RTDyldObjectLinkingLayerTest.cpp +++ b/llvm/unittests/ExecutionEngine/Orc/RTDyldObjectLinkingLayerTest.cpp @@ -61,12 +61,11 @@ static bool testSetProcessAllSections(std::unique_ptr<MemoryBuffer> Obj, cantFail(std::move(R)); }; - auto OnReadyDoNothing = [](Error Err) { cantFail(std::move(Err)); }; - ObjLayer.setProcessAllSections(ProcessAllSections); cantFail(ObjLayer.add(JD, std::move(Obj), ES.allocateVModule())); - ES.lookup(JITDylibSearchList({{&JD, false}}), {Foo}, OnResolveDoNothing, - OnReadyDoNothing, NoDependenciesToRegister); + ES.lookup(JITDylibSearchList({{&JD, false}}), {Foo}, SymbolState::Resolved, + OnResolveDoNothing, NoDependenciesToRegister); + return DebugSectionSeen; } @@ -160,10 +159,10 @@ TEST(RTDyldObjectLinkingLayerTest, TestOverrideObjectFlags) { ObjLayer.setOverrideObjectFlagsWithResponsibilityFlags(true); cantFail(CompileLayer.add(JD, std::move(M), ES.allocateVModule())); - ES.lookup(JITDylibSearchList({{&JD, false}}), {Foo}, - [](Expected<SymbolMap> R) { cantFail(std::move(R)); }, - [](Error Err) { cantFail(std::move(Err)); }, - NoDependenciesToRegister); + ES.lookup( + JITDylibSearchList({{&JD, false}}), {Foo}, SymbolState::Resolved, + [](Expected<SymbolMap> R) { cantFail(std::move(R)); }, + NoDependenciesToRegister); } TEST(RTDyldObjectLinkingLayerTest, TestAutoClaimResponsibilityForSymbols) { @@ -225,10 +224,10 @@ TEST(RTDyldObjectLinkingLayerTest, TestAutoClaimResponsibilityForSymbols) { ObjLayer.setAutoClaimResponsibilityForObjectSymbols(true); cantFail(CompileLayer.add(JD, std::move(M), ES.allocateVModule())); - ES.lookup(JITDylibSearchList({{&JD, false}}), {Foo}, - [](Expected<SymbolMap> R) { cantFail(std::move(R)); }, - [](Error Err) { cantFail(std::move(Err)); }, - NoDependenciesToRegister); + ES.lookup( + JITDylibSearchList({{&JD, false}}), {Foo}, SymbolState::Resolved, + [](Expected<SymbolMap> R) { cantFail(std::move(R)); }, + NoDependenciesToRegister); } } // end anonymous namespace |
