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
|
//===----------- 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 SimpleORCResolver : public SymbolResolver {
public:
using LookupFlagsFn = std::function<LookupFlagsResult(const SymbolNameSet &)>;
using LookupFn = std::function<SymbolNameSet(AsynchronousSymbolQuery &Q,
SymbolNameSet Symbols)>;
SimpleORCResolver(LookupFlagsFn LookupFlags, LookupFn Lookup)
: LookupFlags(std::move(LookupFlags)), Lookup(std::move(Lookup)) {}
LookupFlagsResult lookupFlags(const SymbolNameSet &Symbols) override {
return LookupFlags(Symbols);
}
SymbolNameSet lookup(AsynchronousSymbolQuery &Query,
SymbolNameSet Symbols) override {
return Lookup(Query, std::move(Symbols));
};
private:
LookupFlagsFn LookupFlags;
LookupFn Lookup;
};
namespace {
TEST(LegacyAPIInteropTest, QueryAgainstVSO) {
SymbolStringPool SP;
ExecutionSession ES(SP);
auto Foo = SP.intern("foo");
VSO V;
SymbolMap Defs;
JITEvaluatedSymbol FooSym(0xdeadbeef, JITSymbolFlags::Exported);
Defs[Foo] = FooSym;
cantFail(V.define(std::move(Defs)));
auto LookupFlags = [&](const SymbolNameSet &Names) {
return V.lookupFlags(Names);
};
auto Lookup = [&](AsynchronousSymbolQuery &Query, SymbolNameSet Symbols) {
auto R = V.lookup(Query, Symbols);
EXPECT_TRUE(R.MaterializationWork.empty())
<< "Query resulted in unexpected materialization work";
return std::move(R.UnresolvedSymbols);
};
SimpleORCResolver UnderlyingResolver(std::move(LookupFlags),
std::move(Lookup));
JITSymbolResolverAdapter Resolver(ES, UnderlyingResolver);
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'";
}
} // namespace
|
