diff options
Diffstat (limited to 'unittests/ExecutionEngine/Orc/LegacyAPIInteropTest.cpp')
| -rw-r--r-- | unittests/ExecutionEngine/Orc/LegacyAPIInteropTest.cpp | 183 |
1 files changed, 183 insertions, 0 deletions
diff --git a/unittests/ExecutionEngine/Orc/LegacyAPIInteropTest.cpp b/unittests/ExecutionEngine/Orc/LegacyAPIInteropTest.cpp new file mode 100644 index 000000000000..746ae1dca490 --- /dev/null +++ b/unittests/ExecutionEngine/Orc/LegacyAPIInteropTest.cpp @@ -0,0 +1,183 @@ +//===----------- CoreAPIsTest.cpp - Unit tests for Core ORC APIs ----------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include "OrcTestCommon.h" +#include "llvm/ExecutionEngine/Orc/Legacy.h" +#include "gtest/gtest.h" + +using namespace llvm; +using namespace llvm::orc; + +class LegacyAPIsStandardTest : public CoreAPIsBasedStandardTest {}; + +namespace { + +TEST_F(LegacyAPIsStandardTest, TestLambdaSymbolResolver) { + cantFail(V.define(absoluteSymbols({{Foo, FooSym}, {Bar, BarSym}}))); + + auto Resolver = createSymbolResolver( + [&](const SymbolNameSet &Symbols) { return V.lookupFlags(Symbols); }, + [&](std::shared_ptr<AsynchronousSymbolQuery> Q, SymbolNameSet Symbols) { + return V.legacyLookup(std::move(Q), Symbols); + }); + + SymbolNameSet Symbols({Foo, Bar, Baz}); + + SymbolFlagsMap SymbolFlags = Resolver->lookupFlags(Symbols); + + EXPECT_EQ(SymbolFlags.size(), 2U) + << "lookupFlags returned the wrong number of results"; + EXPECT_EQ(SymbolFlags.count(Foo), 1U) << "Missing lookupFlags result for foo"; + EXPECT_EQ(SymbolFlags.count(Bar), 1U) << "Missing lookupFlags result for bar"; + EXPECT_EQ(SymbolFlags[Foo], FooSym.getFlags()) + << "Incorrect lookupFlags result for Foo"; + EXPECT_EQ(SymbolFlags[Bar], BarSym.getFlags()) + << "Incorrect lookupFlags result for Bar"; + + 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 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 Unresolved = Resolver->lookup(std::move(Q), Symbols); + + 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"; +} + +TEST(LegacyAPIInteropTest, QueryAgainstVSO) { + + ExecutionSession ES(std::make_shared<SymbolStringPool>()); + auto Foo = ES.getSymbolStringPool().intern("foo"); + + auto &V = ES.createVSO("V"); + JITEvaluatedSymbol FooSym(0xdeadbeef, JITSymbolFlags::Exported); + cantFail(V.define(absoluteSymbols({{Foo, FooSym}}))); + + auto LookupFlags = [&](const SymbolNameSet &Names) { + return V.lookupFlags(Names); + }; + + auto Lookup = [&](std::shared_ptr<AsynchronousSymbolQuery> Query, + SymbolNameSet Symbols) { + return V.legacyLookup(std::move(Query), Symbols); + }; + + auto UnderlyingResolver = + createSymbolResolver(std::move(LookupFlags), std::move(Lookup)); + JITSymbolResolverAdapter Resolver(ES, *UnderlyingResolver, nullptr); + + JITSymbolResolver::LookupSet Names{StringRef("foo")}; + + auto LFR = Resolver.lookupFlags(Names); + EXPECT_TRUE(!!LFR) << "lookupFlags failed"; + EXPECT_EQ(LFR->size(), 1U) + << "lookupFlags returned the wrong number of results"; + EXPECT_EQ(LFR->count(*Foo), 1U) + << "lookupFlags did not contain a result for 'foo'"; + EXPECT_EQ((*LFR)[*Foo], FooSym.getFlags()) + << "lookupFlags contained the wrong result for 'foo'"; + + auto LR = Resolver.lookup(Names); + EXPECT_TRUE(!!LR) << "lookup failed"; + EXPECT_EQ(LR->size(), 1U) << "lookup returned the wrong number of results"; + EXPECT_EQ(LR->count(*Foo), 1U) << "lookup did not contain a result for 'foo'"; + EXPECT_EQ((*LR)[*Foo].getFlags(), FooSym.getFlags()) + << "lookup returned the wrong result for flags of 'foo'"; + EXPECT_EQ((*LR)[*Foo].getAddress(), FooSym.getAddress()) + << "lookup returned the wrong result for address of 'foo'"; +} + +TEST(LegacyAPIInteropTset, LegacyLookupHelpersFn) { + constexpr JITTargetAddress FooAddr = 0xdeadbeef; + JITSymbolFlags FooFlags = JITSymbolFlags::Exported; + + bool BarMaterialized = false; + constexpr JITTargetAddress BarAddr = 0xcafef00d; + JITSymbolFlags BarFlags = static_cast<JITSymbolFlags::FlagNames>( + JITSymbolFlags::Exported | JITSymbolFlags::Weak); + + auto LegacyLookup = [&](const std::string &Name) -> JITSymbol { + if (Name == "foo") + return {FooAddr, FooFlags}; + + if (Name == "bar") { + auto BarMaterializer = [&]() -> Expected<JITTargetAddress> { + BarMaterialized = true; + return BarAddr; + }; + + return {BarMaterializer, BarFlags}; + } + + return nullptr; + }; + + ExecutionSession ES; + auto Foo = ES.getSymbolStringPool().intern("foo"); + auto Bar = ES.getSymbolStringPool().intern("bar"); + auto Baz = ES.getSymbolStringPool().intern("baz"); + + SymbolNameSet Symbols({Foo, Bar, Baz}); + + auto SymbolFlags = lookupFlagsWithLegacyFn(Symbols, LegacyLookup); + + EXPECT_TRUE(!!SymbolFlags) << "Expected lookupFlagsWithLegacyFn to succeed"; + EXPECT_EQ(SymbolFlags->size(), 2U) << "Wrong number of flags returned"; + EXPECT_EQ(SymbolFlags->count(Foo), 1U) << "Flags for foo missing"; + EXPECT_EQ(SymbolFlags->count(Bar), 1U) << "Flags for foo missing"; + EXPECT_EQ((*SymbolFlags)[Foo], FooFlags) << "Wrong flags for foo"; + EXPECT_EQ((*SymbolFlags)[Bar], BarFlags) << "Wrong flags for foo"; + EXPECT_FALSE(BarMaterialized) + << "lookupFlags should not have materialized bar"; + + bool OnResolvedRun = false; + bool OnReadyRun = false; + 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; + }; + + AsynchronousSymbolQuery Q({Foo, Bar}, OnResolved, OnReady); + auto Unresolved = lookupWithLegacyFn(ES, Q, Symbols, LegacyLookup); + + EXPECT_TRUE(OnResolvedRun) << "OnResolved was not run"; + EXPECT_TRUE(OnReadyRun) << "OnReady was not run"; + EXPECT_EQ(Unresolved.size(), 1U) << "Expected one unresolved symbol"; + EXPECT_EQ(Unresolved.count(Baz), 1U) << "Expected baz to be unresolved"; +} + +} // namespace |