blob: 19c194bd166354d4de055d1f395901b9c2740413 [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
17class SimpleORCResolver : public SymbolResolver {
18public:
Lang Hamesc8a74a02018-01-25 01:43:00 +000019 using LookupFlagsFn = std::function<SymbolNameSet(SymbolFlagsMap &SymbolFlags,
20 const SymbolNameSet &)>;
Lang Hames635fd902018-01-22 03:00:31 +000021 using LookupFn = std::function<SymbolNameSet(AsynchronousSymbolQuery &Q,
22 SymbolNameSet Symbols)>;
23
24 SimpleORCResolver(LookupFlagsFn LookupFlags, LookupFn Lookup)
25 : LookupFlags(std::move(LookupFlags)), Lookup(std::move(Lookup)) {}
26
Lang Hamesc8a74a02018-01-25 01:43:00 +000027 SymbolNameSet lookupFlags(SymbolFlagsMap &SymbolFlags,
28 const SymbolNameSet &Symbols) override {
29 return LookupFlags(SymbolFlags, Symbols);
Lang Hames635fd902018-01-22 03:00:31 +000030 }
31
32 SymbolNameSet lookup(AsynchronousSymbolQuery &Query,
33 SymbolNameSet Symbols) override {
34 return Lookup(Query, std::move(Symbols));
35 };
36
37private:
38 LookupFlagsFn LookupFlags;
39 LookupFn Lookup;
40};
41
42namespace {
43
44TEST(LegacyAPIInteropTest, QueryAgainstVSO) {
45
46 SymbolStringPool SP;
47 ExecutionSession ES(SP);
48 auto Foo = SP.intern("foo");
49
50 VSO V;
51 SymbolMap Defs;
52 JITEvaluatedSymbol FooSym(0xdeadbeef, JITSymbolFlags::Exported);
53 Defs[Foo] = FooSym;
54 cantFail(V.define(std::move(Defs)));
55
Lang Hamesc8a74a02018-01-25 01:43:00 +000056 auto LookupFlags = [&](SymbolFlagsMap &SymbolFlags,
57 const SymbolNameSet &Names) {
58 return V.lookupFlags(SymbolFlags, Names);
Lang Hames635fd902018-01-22 03:00:31 +000059 };
60
61 auto Lookup = [&](AsynchronousSymbolQuery &Query, SymbolNameSet Symbols) {
62 auto R = V.lookup(Query, Symbols);
63 EXPECT_TRUE(R.MaterializationWork.empty())
64 << "Query resulted in unexpected materialization work";
65 return std::move(R.UnresolvedSymbols);
66 };
67
68 SimpleORCResolver UnderlyingResolver(std::move(LookupFlags),
69 std::move(Lookup));
70 JITSymbolResolverAdapter Resolver(ES, UnderlyingResolver);
71
72 JITSymbolResolver::LookupSet Names{StringRef("foo")};
73
74 auto LFR = Resolver.lookupFlags(Names);
75 EXPECT_TRUE(!!LFR) << "lookupFlags failed";
76 EXPECT_EQ(LFR->size(), 1U)
77 << "lookupFlags returned the wrong number of results";
78 EXPECT_EQ(LFR->count(*Foo), 1U)
79 << "lookupFlags did not contain a result for 'foo'";
80 EXPECT_EQ((*LFR)[*Foo], FooSym.getFlags())
81 << "lookupFlags contained the wrong result for 'foo'";
82
83 auto LR = Resolver.lookup(Names);
84 EXPECT_TRUE(!!LR) << "lookup failed";
85 EXPECT_EQ(LR->size(), 1U) << "lookup returned the wrong number of results";
86 EXPECT_EQ(LR->count(*Foo), 1U) << "lookup did not contain a result for 'foo'";
87 EXPECT_EQ((*LR)[*Foo].getFlags(), FooSym.getFlags())
88 << "lookup returned the wrong result for flags of 'foo'";
89 EXPECT_EQ((*LR)[*Foo].getAddress(), FooSym.getAddress())
90 << "lookup returned the wrong result for address of 'foo'";
91}
92
Lang Hamesd78ba0d2018-01-24 23:09:07 +000093TEST(LegacyAPIInteropTset, LegacyLookupHelpersFn) {
94 constexpr JITTargetAddress FooAddr = 0xdeadbeef;
95 JITSymbolFlags FooFlags = JITSymbolFlags::Exported;
96
97 bool BarMaterialized = false;
98 constexpr JITTargetAddress BarAddr = 0xcafef00d;
99 JITSymbolFlags BarFlags = static_cast<JITSymbolFlags::FlagNames>(
100 JITSymbolFlags::Exported | JITSymbolFlags::Weak);
101
102 auto LegacyLookup = [&](const std::string &Name) -> JITSymbol {
103 if (Name == "foo")
104 return {FooAddr, FooFlags};
105
106 if (Name == "bar") {
107 auto BarMaterializer = [&]() -> Expected<JITTargetAddress> {
108 BarMaterialized = true;
109 return BarAddr;
110 };
111
112 return {BarMaterializer, BarFlags};
113 }
114
115 return nullptr;
116 };
117
118 SymbolStringPool SP;
119 auto Foo = SP.intern("foo");
120 auto Bar = SP.intern("bar");
121 auto Baz = SP.intern("baz");
122
123 SymbolNameSet Symbols({Foo, Bar, Baz});
124
Lang Hamesc8a74a02018-01-25 01:43:00 +0000125 SymbolFlagsMap SymbolFlags;
126 auto SymbolsNotFound =
127 lookupFlagsWithLegacyFn(SymbolFlags, Symbols, LegacyLookup);
Lang Hamesd78ba0d2018-01-24 23:09:07 +0000128
Lang Hamesc8a74a02018-01-25 01:43:00 +0000129 EXPECT_TRUE(!!SymbolsNotFound) << "lookupFlagsWithLegacy failed unexpectedly";
130 EXPECT_EQ(SymbolFlags.size(), 2U) << "Wrong number of flags returned";
131 EXPECT_EQ(SymbolFlags.count(Foo), 1U) << "Flags for foo missing";
132 EXPECT_EQ(SymbolFlags.count(Bar), 1U) << "Flags for foo missing";
133 EXPECT_EQ(SymbolFlags[Foo], FooFlags) << "Wrong flags for foo";
134 EXPECT_EQ(SymbolFlags[Bar], BarFlags) << "Wrong flags for foo";
135 EXPECT_EQ(SymbolsNotFound->size(), 1U) << "Expected one symbol not found";
136 EXPECT_EQ(SymbolsNotFound->count(Baz), 1U)
Lang Hamesd78ba0d2018-01-24 23:09:07 +0000137 << "Expected symbol baz to be not found";
138 EXPECT_FALSE(BarMaterialized)
139 << "lookupFlags should not have materialized bar";
140
141 bool OnResolvedRun = false;
142 bool OnReadyRun = false;
143 auto OnResolved = [&](Expected<SymbolMap> Result) {
144 OnResolvedRun = true;
145 EXPECT_TRUE(!!Result) << "lookuWithLegacy failed to resolve";
146 EXPECT_EQ(Result->size(), 2U) << "Wrong number of symbols resolved";
147 EXPECT_EQ(Result->count(Foo), 1U) << "Result for foo missing";
148 EXPECT_EQ(Result->count(Bar), 1U) << "Result for bar missing";
149 EXPECT_EQ((*Result)[Foo].getAddress(), FooAddr) << "Wrong address for foo";
150 EXPECT_EQ((*Result)[Foo].getFlags(), FooFlags) << "Wrong flags for foo";
151 EXPECT_EQ((*Result)[Bar].getAddress(), BarAddr) << "Wrong address for bar";
152 EXPECT_EQ((*Result)[Bar].getFlags(), BarFlags) << "Wrong flags for bar";
153 };
154 auto OnReady = [&](Error Err) {
155 EXPECT_FALSE(!!Err) << "Finalization unexpectedly failed";
156 OnReadyRun = true;
157 };
158
159 AsynchronousSymbolQuery Q({Foo, Bar}, OnResolved, OnReady);
160 auto Unresolved = lookupWithLegacyFn(Q, Symbols, LegacyLookup);
161
162 EXPECT_TRUE(OnResolvedRun) << "OnResolved was not run";
163 EXPECT_TRUE(OnReadyRun) << "OnReady was not run";
164 EXPECT_EQ(Unresolved.size(), 1U) << "Expected one unresolved symbol";
165 EXPECT_EQ(Unresolved.count(Baz), 1U) << "Expected baz to be unresolved";
166}
167
Lang Hames635fd902018-01-22 03:00:31 +0000168} // namespace