Mercurial > hg > CbC > CbC_llvm

comparison unittests/ExecutionEngine/Orc/LegacyAPIInteropTest.cpp @ 147:c2174574ed3a

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
LLVM 10
author Shinji KONO <kono@ie.u-ryukyu.ac.jp>
date Wed, 14 Aug 2019 16:55:33 +0900
parents 3a76565eade5
children
comparison
equal deleted inserted replaced
134:3a76565eade5 147:c2174574ed3a
1 //===----------- CoreAPIsTest.cpp - Unit tests for Core ORC APIs ----------===// 1 //===----------- CoreAPIsTest.cpp - Unit tests for Core ORC APIs ----------===//
2 // 2 //
3 // The LLVM Compiler Infrastructure 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // 4 // See https://llvm.org/LICENSE.txt for license information.
5 // This file is distributed under the University of Illinois Open Source 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 // License. See LICENSE.TXT for details.
7 // 6 //
8 //===----------------------------------------------------------------------===// 7 //===----------------------------------------------------------------------===//
9 8
10 #include "OrcTestCommon.h" 9 #include "OrcTestCommon.h"
11 #include "llvm/ExecutionEngine/Orc/Legacy.h" 10 #include "llvm/ExecutionEngine/Orc/Legacy.h"
12 #include "gtest/gtest.h" 11 #include "gtest/gtest.h"
13 12
14 using namespace llvm; 13 using namespace llvm;
15 using namespace llvm::orc; 14 using namespace llvm::orc;
16 15
16 class LegacyAPIsStandardTest : public CoreAPIsBasedStandardTest {};
17
17 namespace { 18 namespace {
18 19
19 TEST(LegacyAPIInteropTest, QueryAgainstVSO) { 20 TEST_F(LegacyAPIsStandardTest, TestLambdaSymbolResolver) {
21 BarSym.setFlags(BarSym.getFlags() | JITSymbolFlags::Weak);
20 22
21 SymbolStringPool SP; 23 cantFail(JD.define(absoluteSymbols({{Foo, FooSym}, {Bar, BarSym}})));
22 ExecutionSession ES(SP);
23 auto Foo = SP.intern("foo");
24 24
25 VSO V; 25 auto Resolver = createSymbolResolver(
26 SymbolMap Defs; 26 [&](const SymbolNameSet &Symbols) {
27 JITEvaluatedSymbol FooSym(0xdeadbeef, JITSymbolFlags::Exported); 27 auto FlagsMap = cantFail(JD.lookupFlags(Symbols));
28 Defs[Foo] = FooSym; 28 SymbolNameSet Result;
29 cantFail(V.define(std::move(Defs))); 29 for (auto &KV : FlagsMap)
30 if (!KV.second.isStrong())
31 Result.insert(KV.first);
32 return Result;
33 },
34 [&](std::shared_ptr<AsynchronousSymbolQuery> Q, SymbolNameSet Symbols) {
35 return cantFail(JD.legacyLookup(std::move(Q), Symbols));
36 });
30 37
31 auto LookupFlags = [&](SymbolFlagsMap &SymbolFlags, 38 auto RS = Resolver->getResponsibilitySet(SymbolNameSet({Bar, Baz}));
32 const SymbolNameSet &Names) { 39
33 return V.lookupFlags(SymbolFlags, Names); 40 EXPECT_EQ(RS.size(), 1U)
41 << "getResponsibilitySet returned the wrong number of results";
42 EXPECT_EQ(RS.count(Bar), 1U)
43 << "getResponsibilitySet result incorrect. Should be {'bar'}";
44
45 bool OnCompletionRun = false;
46
47 auto OnCompletion = [&](Expected<SymbolMap> Result) {
48 OnCompletionRun = true;
49 EXPECT_TRUE(!!Result) << "Unexpected error";
50 EXPECT_EQ(Result->size(), 2U) << "Unexpected number of resolved symbols";
51 EXPECT_EQ(Result->count(Foo), 1U) << "Missing lookup result for foo";
52 EXPECT_EQ(Result->count(Bar), 1U) << "Missing lookup result for bar";
53 EXPECT_EQ((*Result)[Foo].getAddress(), FooSym.getAddress())
54 << "Incorrect address for foo";
55 EXPECT_EQ((*Result)[Bar].getAddress(), BarSym.getAddress())
56 << "Incorrect address for bar";
34 }; 57 };
35 58
36 auto Lookup = [&](std::shared_ptr<AsynchronousSymbolQuery> Query, 59 auto Q = std::make_shared<AsynchronousSymbolQuery>(
37 SymbolNameSet Symbols) { 60 SymbolNameSet({Foo, Bar}), SymbolState::Resolved, OnCompletion);
38 auto R = V.lookup(std::move(Query), Symbols); 61 auto Unresolved =
39 EXPECT_TRUE(R.MaterializationWork.empty()) 62 Resolver->lookup(std::move(Q), SymbolNameSet({Foo, Bar, Baz}));
40 << "Query resulted in unexpected materialization work";
41 return std::move(R.UnresolvedSymbols);
42 };
43 63
44 auto UnderlyingResolver = 64 EXPECT_EQ(Unresolved.size(), 1U) << "Expected one unresolved symbol";
45 createSymbolResolver(std::move(LookupFlags), std::move(Lookup)); 65 EXPECT_EQ(Unresolved.count(Baz), 1U) << "Expected baz to not be resolved";
46 JITSymbolResolverAdapter Resolver(ES, *UnderlyingResolver); 66 EXPECT_TRUE(OnCompletionRun) << "OnCompletion was never run";
47
48 JITSymbolResolver::LookupSet Names{StringRef("foo")};
49
50 auto LFR = Resolver.lookupFlags(Names);
51 EXPECT_TRUE(!!LFR) << "lookupFlags failed";
52 EXPECT_EQ(LFR->size(), 1U)
53 << "lookupFlags returned the wrong number of results";
54 EXPECT_EQ(LFR->count(*Foo), 1U)
55 << "lookupFlags did not contain a result for 'foo'";
56 EXPECT_EQ((*LFR)[*Foo], FooSym.getFlags())
57 << "lookupFlags contained the wrong result for 'foo'";
58
59 auto LR = Resolver.lookup(Names);
60 EXPECT_TRUE(!!LR) << "lookup failed";
61 EXPECT_EQ(LR->size(), 1U) << "lookup returned the wrong number of results";
62 EXPECT_EQ(LR->count(*Foo), 1U) << "lookup did not contain a result for 'foo'";
63 EXPECT_EQ((*LR)[*Foo].getFlags(), FooSym.getFlags())
64 << "lookup returned the wrong result for flags of 'foo'";
65 EXPECT_EQ((*LR)[*Foo].getAddress(), FooSym.getAddress())
66 << "lookup returned the wrong result for address of 'foo'";
67 } 67 }
68 68
69 TEST(LegacyAPIInteropTset, LegacyLookupHelpersFn) { 69 TEST_F(LegacyAPIsStandardTest, LegacyLookupHelpersFn) {
70 constexpr JITTargetAddress FooAddr = 0xdeadbeef;
71 JITSymbolFlags FooFlags = JITSymbolFlags::Exported;
72
73 bool BarMaterialized = false; 70 bool BarMaterialized = false;
74 constexpr JITTargetAddress BarAddr = 0xcafef00d; 71 BarSym.setFlags(BarSym.getFlags() | JITSymbolFlags::Weak);
75 JITSymbolFlags BarFlags = static_cast<JITSymbolFlags::FlagNames>(
76 JITSymbolFlags::Exported | JITSymbolFlags::Weak);
77 72
78 auto LegacyLookup = [&](const std::string &Name) -> JITSymbol { 73 auto LegacyLookup = [&](const std::string &Name) -> JITSymbol {
79 if (Name == "foo") 74 if (Name == "foo")
80 return {FooAddr, FooFlags}; 75 return FooSym;
81 76
82 if (Name == "bar") { 77 if (Name == "bar") {
83 auto BarMaterializer = [&]() -> Expected<JITTargetAddress> { 78 auto BarMaterializer = [&]() -> Expected<JITTargetAddress> {
84 BarMaterialized = true; 79 BarMaterialized = true;
85 return BarAddr; 80 return BarAddr;
86 }; 81 };
87 82
88 return {BarMaterializer, BarFlags}; 83 return {BarMaterializer, BarSym.getFlags()};
89 } 84 }
90 85
91 return nullptr; 86 return nullptr;
92 }; 87 };
93 88
94 SymbolStringPool SP; 89 auto RS =
95 auto Foo = SP.intern("foo"); 90 getResponsibilitySetWithLegacyFn(SymbolNameSet({Bar, Baz}), LegacyLookup);
96 auto Bar = SP.intern("bar");
97 auto Baz = SP.intern("baz");
98 91
99 SymbolNameSet Symbols({Foo, Bar, Baz}); 92 EXPECT_TRUE(!!RS) << "Expected getResponsibilitySetWithLegacyFn to succeed";
100 93 EXPECT_EQ(RS->size(), 1U) << "Wrong number of symbols returned";
101 SymbolFlagsMap SymbolFlags; 94 EXPECT_EQ(RS->count(Bar), 1U) << "Incorrect responsibility set returned";
102 auto SymbolsNotFound =
103 lookupFlagsWithLegacyFn(SymbolFlags, Symbols, LegacyLookup);
104
105 EXPECT_TRUE(!!SymbolsNotFound) << "lookupFlagsWithLegacy failed unexpectedly";
106 EXPECT_EQ(SymbolFlags.size(), 2U) << "Wrong number of flags returned";
107 EXPECT_EQ(SymbolFlags.count(Foo), 1U) << "Flags for foo missing";
108 EXPECT_EQ(SymbolFlags.count(Bar), 1U) << "Flags for foo missing";
109 EXPECT_EQ(SymbolFlags[Foo], FooFlags) << "Wrong flags for foo";
110 EXPECT_EQ(SymbolFlags[Bar], BarFlags) << "Wrong flags for foo";
111 EXPECT_EQ(SymbolsNotFound->size(), 1U) << "Expected one symbol not found";
112 EXPECT_EQ(SymbolsNotFound->count(Baz), 1U)
113 << "Expected symbol baz to be not found";
114 EXPECT_FALSE(BarMaterialized) 95 EXPECT_FALSE(BarMaterialized)
115 << "lookupFlags should not have materialized bar"; 96 << "lookupFlags should not have materialized bar";
116 97
117 bool OnResolvedRun = false; 98 bool OnCompletionRun = false;
118 bool OnReadyRun = false; 99 auto OnCompletion = [&](Expected<SymbolMap> Result) {
119 auto OnResolved = [&](Expected<SymbolMap> Result) { 100 OnCompletionRun = true;
120 OnResolvedRun = true;
121 EXPECT_TRUE(!!Result) << "lookuWithLegacy failed to resolve"; 101 EXPECT_TRUE(!!Result) << "lookuWithLegacy failed to resolve";
102
122 EXPECT_EQ(Result->size(), 2U) << "Wrong number of symbols resolved"; 103 EXPECT_EQ(Result->size(), 2U) << "Wrong number of symbols resolved";
123 EXPECT_EQ(Result->count(Foo), 1U) << "Result for foo missing"; 104 EXPECT_EQ(Result->count(Foo), 1U) << "Result for foo missing";
124 EXPECT_EQ(Result->count(Bar), 1U) << "Result for bar missing"; 105 EXPECT_EQ(Result->count(Bar), 1U) << "Result for bar missing";
125 EXPECT_EQ((*Result)[Foo].getAddress(), FooAddr) << "Wrong address for foo"; 106 EXPECT_EQ((*Result)[Foo].getAddress(), FooAddr) << "Wrong address for foo";
126 EXPECT_EQ((*Result)[Foo].getFlags(), FooFlags) << "Wrong flags for foo"; 107 EXPECT_EQ((*Result)[Foo].getFlags(), FooSym.getFlags())
108 << "Wrong flags for foo";
127 EXPECT_EQ((*Result)[Bar].getAddress(), BarAddr) << "Wrong address for bar"; 109 EXPECT_EQ((*Result)[Bar].getAddress(), BarAddr) << "Wrong address for bar";
128 EXPECT_EQ((*Result)[Bar].getFlags(), BarFlags) << "Wrong flags for bar"; 110 EXPECT_EQ((*Result)[Bar].getFlags(), BarSym.getFlags())
129 }; 111 << "Wrong flags for bar";
130 auto OnReady = [&](Error Err) {
131 EXPECT_FALSE(!!Err) << "Finalization unexpectedly failed";
132 OnReadyRun = true;
133 }; 112 };
134 113
135 AsynchronousSymbolQuery Q({Foo, Bar}, OnResolved, OnReady); 114 AsynchronousSymbolQuery Q({Foo, Bar}, SymbolState::Resolved, OnCompletion);
136 auto Unresolved = lookupWithLegacyFn(Q, Symbols, LegacyLookup); 115 auto Unresolved =
116 lookupWithLegacyFn(ES, Q, SymbolNameSet({Foo, Bar, Baz}), LegacyLookup);
137 117
138 EXPECT_TRUE(OnResolvedRun) << "OnResolved was not run"; 118 EXPECT_TRUE(OnCompletionRun) << "OnCompletion was not run";
139 EXPECT_TRUE(OnReadyRun) << "OnReady was not run";
140 EXPECT_EQ(Unresolved.size(), 1U) << "Expected one unresolved symbol"; 119 EXPECT_EQ(Unresolved.size(), 1U) << "Expected one unresolved symbol";
141 EXPECT_EQ(Unresolved.count(Baz), 1U) << "Expected baz to be unresolved"; 120 EXPECT_EQ(Unresolved.count(Baz), 1U) << "Expected baz to be unresolved";
142 } 121 }
143 122
144 } // namespace 123 } // namespace