1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
|
//===----------- 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.lookup(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<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";
};
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.lookup(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<AsynchronousSymbolQuery::ResolutionResult> 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";
};
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
|
