blob: 596584b7117e3b08f489b5e1d48e57d4dff47102 [file] [log] [blame]
Lang Hames635fd902018-01-22 03:00:31 +00001//===----------- CoreAPIsTest.cpp - Unit tests for Core ORC APIs ----------===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9
10#include "OrcTestCommon.h"
11#include "llvm/ExecutionEngine/Orc/Legacy.h"
12#include "gtest/gtest.h"
13
14using namespace llvm;
15using namespace llvm::orc;
16
Lang Hamesfd0c1e712018-07-20 18:31:50 +000017class LegacyAPIsStandardTest : public CoreAPIsBasedStandardTest {};
18
Lang Hames635fd902018-01-22 03:00:31 +000019namespace {
20
Lang Hamesfd0c1e712018-07-20 18:31:50 +000021TEST_F(LegacyAPIsStandardTest, TestLambdaSymbolResolver) {
22 cantFail(V.define(absoluteSymbols({{Foo, FooSym}, {Bar, BarSym}})));
23
24 auto Resolver = createSymbolResolver(
Lang Hamesd4df0f12018-07-20 18:31:52 +000025 [&](const SymbolNameSet &Symbols) { return V.lookupFlags(Symbols); },
Lang Hamesfd0c1e712018-07-20 18:31:50 +000026 [&](std::shared_ptr<AsynchronousSymbolQuery> Q, SymbolNameSet Symbols) {
27 return V.lookup(std::move(Q), Symbols);
28 });
29
30 SymbolNameSet Symbols({Foo, Bar, Baz});
31
Lang Hamesd4df0f12018-07-20 18:31:52 +000032 SymbolFlagsMap SymbolFlags = Resolver->lookupFlags(Symbols);
Lang Hamesfd0c1e712018-07-20 18:31:50 +000033
34 EXPECT_EQ(SymbolFlags.size(), 2U)
35 << "lookupFlags returned the wrong number of results";
36 EXPECT_EQ(SymbolFlags.count(Foo), 1U) << "Missing lookupFlags result for foo";
37 EXPECT_EQ(SymbolFlags.count(Bar), 1U) << "Missing lookupFlags result for bar";
38 EXPECT_EQ(SymbolFlags[Foo], FooSym.getFlags())
39 << "Incorrect lookupFlags result for Foo";
40 EXPECT_EQ(SymbolFlags[Bar], BarSym.getFlags())
41 << "Incorrect lookupFlags result for Bar";
Lang Hamesfd0c1e712018-07-20 18:31:50 +000042
43 bool OnResolvedRun = false;
44
45 auto OnResolved =
46 [&](Expected<AsynchronousSymbolQuery::ResolutionResult> Result) {
47 OnResolvedRun = true;
48 EXPECT_TRUE(!!Result) << "Unexpected error";
49 EXPECT_EQ(Result->Symbols.size(), 2U)
50 << "Unexpected number of resolved symbols";
51 EXPECT_EQ(Result->Symbols.count(Foo), 1U)
52 << "Missing lookup result for foo";
53 EXPECT_EQ(Result->Symbols.count(Bar), 1U)
54 << "Missing lookup result for bar";
55 EXPECT_EQ(Result->Symbols[Foo].getAddress(), FooSym.getAddress())
56 << "Incorrect address for foo";
57 EXPECT_EQ(Result->Symbols[Bar].getAddress(), BarSym.getAddress())
58 << "Incorrect address for bar";
59 };
60 auto OnReady = [&](Error Err) {
61 EXPECT_FALSE(!!Err) << "Finalization should never fail in this test";
62 };
63
64 auto Q = std::make_shared<AsynchronousSymbolQuery>(SymbolNameSet({Foo, Bar}),
65 OnResolved, OnReady);
66 auto Unresolved = Resolver->lookup(std::move(Q), Symbols);
67
68 EXPECT_EQ(Unresolved.size(), 1U) << "Expected one unresolved symbol";
69 EXPECT_EQ(Unresolved.count(Baz), 1U) << "Expected baz to not be resolved";
70 EXPECT_TRUE(OnResolvedRun) << "OnResolved was never run";
71}
72
Lang Hames635fd902018-01-22 03:00:31 +000073TEST(LegacyAPIInteropTest, QueryAgainstVSO) {
74
Lang Hames3fdfc042018-04-02 20:57:56 +000075 ExecutionSession ES(std::make_shared<SymbolStringPool>());
76 auto Foo = ES.getSymbolStringPool().intern("foo");
Lang Hames635fd902018-01-22 03:00:31 +000077
Lang Hamesd261e122018-05-16 22:24:30 +000078 auto &V = ES.createVSO("V");
Lang Hames635fd902018-01-22 03:00:31 +000079 JITEvaluatedSymbol FooSym(0xdeadbeef, JITSymbolFlags::Exported);
Lang Hamesd261e122018-05-16 22:24:30 +000080 cantFail(V.define(absoluteSymbols({{Foo, FooSym}})));
Lang Hames635fd902018-01-22 03:00:31 +000081
Lang Hamesd4df0f12018-07-20 18:31:52 +000082 auto LookupFlags = [&](const SymbolNameSet &Names) {
83 return V.lookupFlags(Names);
Lang Hames635fd902018-01-22 03:00:31 +000084 };
85
Lang Hamese833fe82018-02-14 22:12:56 +000086 auto Lookup = [&](std::shared_ptr<AsynchronousSymbolQuery> Query,
87 SymbolNameSet Symbols) {
Lang Hamesd261e122018-05-16 22:24:30 +000088 return V.lookup(std::move(Query), Symbols);
Lang Hames635fd902018-01-22 03:00:31 +000089 };
90
Lang Hamese833fe82018-02-14 22:12:56 +000091 auto UnderlyingResolver =
92 createSymbolResolver(std::move(LookupFlags), std::move(Lookup));
Lang Hamesd261e122018-05-16 22:24:30 +000093 JITSymbolResolverAdapter Resolver(ES, *UnderlyingResolver, nullptr);
Lang Hames635fd902018-01-22 03:00:31 +000094
95 JITSymbolResolver::LookupSet Names{StringRef("foo")};
96
97 auto LFR = Resolver.lookupFlags(Names);
98 EXPECT_TRUE(!!LFR) << "lookupFlags failed";
99 EXPECT_EQ(LFR->size(), 1U)
100 << "lookupFlags returned the wrong number of results";
101 EXPECT_EQ(LFR->count(*Foo), 1U)
102 << "lookupFlags did not contain a result for 'foo'";
103 EXPECT_EQ((*LFR)[*Foo], FooSym.getFlags())
104 << "lookupFlags contained the wrong result for 'foo'";
105
106 auto LR = Resolver.lookup(Names);
107 EXPECT_TRUE(!!LR) << "lookup failed";
108 EXPECT_EQ(LR->size(), 1U) << "lookup returned the wrong number of results";
109 EXPECT_EQ(LR->count(*Foo), 1U) << "lookup did not contain a result for 'foo'";
110 EXPECT_EQ((*LR)[*Foo].getFlags(), FooSym.getFlags())
111 << "lookup returned the wrong result for flags of 'foo'";
112 EXPECT_EQ((*LR)[*Foo].getAddress(), FooSym.getAddress())
113 << "lookup returned the wrong result for address of 'foo'";
114}
115
Lang Hamesd78ba0d2018-01-24 23:09:07 +0000116TEST(LegacyAPIInteropTset, LegacyLookupHelpersFn) {
117 constexpr JITTargetAddress FooAddr = 0xdeadbeef;
118 JITSymbolFlags FooFlags = JITSymbolFlags::Exported;
119
120 bool BarMaterialized = false;
121 constexpr JITTargetAddress BarAddr = 0xcafef00d;
122 JITSymbolFlags BarFlags = static_cast<JITSymbolFlags::FlagNames>(
123 JITSymbolFlags::Exported | JITSymbolFlags::Weak);
124
125 auto LegacyLookup = [&](const std::string &Name) -> JITSymbol {
126 if (Name == "foo")
127 return {FooAddr, FooFlags};
128
129 if (Name == "bar") {
130 auto BarMaterializer = [&]() -> Expected<JITTargetAddress> {
131 BarMaterialized = true;
132 return BarAddr;
133 };
134
135 return {BarMaterializer, BarFlags};
136 }
137
138 return nullptr;
139 };
140
Lang Hamesd261e122018-05-16 22:24:30 +0000141 ExecutionSession ES;
142 auto Foo = ES.getSymbolStringPool().intern("foo");
143 auto Bar = ES.getSymbolStringPool().intern("bar");
144 auto Baz = ES.getSymbolStringPool().intern("baz");
Lang Hamesd78ba0d2018-01-24 23:09:07 +0000145
146 SymbolNameSet Symbols({Foo, Bar, Baz});
147
Lang Hamesd4df0f12018-07-20 18:31:52 +0000148 auto SymbolFlags = lookupFlagsWithLegacyFn(Symbols, LegacyLookup);
Lang Hamesd78ba0d2018-01-24 23:09:07 +0000149
Lang Hamesd4df0f12018-07-20 18:31:52 +0000150 EXPECT_TRUE(!!SymbolFlags) << "Expected lookupFlagsWithLegacyFn to succeed";
151 EXPECT_EQ(SymbolFlags->size(), 2U) << "Wrong number of flags returned";
152 EXPECT_EQ(SymbolFlags->count(Foo), 1U) << "Flags for foo missing";
153 EXPECT_EQ(SymbolFlags->count(Bar), 1U) << "Flags for foo missing";
154 EXPECT_EQ((*SymbolFlags)[Foo], FooFlags) << "Wrong flags for foo";
155 EXPECT_EQ((*SymbolFlags)[Bar], BarFlags) << "Wrong flags for foo";
Lang Hamesd78ba0d2018-01-24 23:09:07 +0000156 EXPECT_FALSE(BarMaterialized)
157 << "lookupFlags should not have materialized bar";
158
159 bool OnResolvedRun = false;
160 bool OnReadyRun = false;
Lang Hamesd261e122018-05-16 22:24:30 +0000161 auto OnResolved =
162 [&](Expected<AsynchronousSymbolQuery::ResolutionResult> Result) {
163 OnResolvedRun = true;
164 EXPECT_TRUE(!!Result) << "lookuWithLegacy failed to resolve";
165
166 auto &Resolved = Result->Symbols;
167 EXPECT_EQ(Resolved.size(), 2U) << "Wrong number of symbols resolved";
168 EXPECT_EQ(Resolved.count(Foo), 1U) << "Result for foo missing";
169 EXPECT_EQ(Resolved.count(Bar), 1U) << "Result for bar missing";
170 EXPECT_EQ(Resolved[Foo].getAddress(), FooAddr)
171 << "Wrong address for foo";
172 EXPECT_EQ(Resolved[Foo].getFlags(), FooFlags) << "Wrong flags for foo";
173 EXPECT_EQ(Resolved[Bar].getAddress(), BarAddr)
174 << "Wrong address for bar";
175 EXPECT_EQ(Resolved[Bar].getFlags(), BarFlags) << "Wrong flags for bar";
176 };
Lang Hamesd78ba0d2018-01-24 23:09:07 +0000177 auto OnReady = [&](Error Err) {
178 EXPECT_FALSE(!!Err) << "Finalization unexpectedly failed";
179 OnReadyRun = true;
180 };
181
182 AsynchronousSymbolQuery Q({Foo, Bar}, OnResolved, OnReady);
Lang Hamesd261e122018-05-16 22:24:30 +0000183 auto Unresolved = lookupWithLegacyFn(ES, Q, Symbols, LegacyLookup);
Lang Hamesd78ba0d2018-01-24 23:09:07 +0000184
185 EXPECT_TRUE(OnResolvedRun) << "OnResolved was not run";
186 EXPECT_TRUE(OnReadyRun) << "OnReady was not run";
187 EXPECT_EQ(Unresolved.size(), 1U) << "Expected one unresolved symbol";
188 EXPECT_EQ(Unresolved.count(Baz), 1U) << "Expected baz to be unresolved";
189}
190
Lang Hames635fd902018-01-22 03:00:31 +0000191} // namespace