Skip to content
This repository was archived by the owner on Feb 5, 2019. It is now read-only.

Commit ec3e957

Browse files
lhameslhames
committed
[ORC] Simplify VSO::lookupFlags to return the flags map.
This discards the unresolved symbols set and returns the flags map directly (rather than mutating it via the first argument). The unresolved symbols result made it easy to chain lookupFlags calls, but such chaining should be rare to non-existant (especially now that symbol resolvers are being deprecated) so the simpler method signature is preferable. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@337594 91177308-0d34-0410-b5e6-96231b3b80d8
1 parent cea401e commit ec3e957

File tree

13 files changed

+96
-105
lines changed

13 files changed

+96
-105
lines changed

‎include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h

Lines changed: 40 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -499,20 +499,29 @@ class CompileOnDemandLayer {
499499
};
500500

501501
auto GVsResolver = createSymbolResolver(
502-
[&LD, LegacyLookup](SymbolFlagsMap &SymbolFlags,
503-
const SymbolNameSet &Symbols) {
504-
auto NotFoundViaLegacyLookup =
505-
lookupFlagsWithLegacyFn(SymbolFlags, Symbols, LegacyLookup);
502+
[&LD, LegacyLookup](const SymbolNameSet &Symbols) {
503+
auto SymbolFlags = lookupFlagsWithLegacyFn(Symbols, LegacyLookup);
506504

507-
if (!NotFoundViaLegacyLookup) {
508-
logAllUnhandledErrors(NotFoundViaLegacyLookup.takeError(), errs(),
505+
if (!SymbolFlags) {
506+
logAllUnhandledErrors(SymbolFlags.takeError(), errs(),
509507
"CODLayer/GVsResolver flags lookup failed: ");
510-
SymbolFlags.clear();
511-
return SymbolNameSet();
508+
return SymbolFlagsMap();
512509
}
513510

514-
return LD.BackingResolver->lookupFlags(SymbolFlags,
515-
*NotFoundViaLegacyLookup);
511+
if (SymbolFlags->size() == Symbols.size())
512+
return *SymbolFlags;
513+
514+
SymbolNameSet NotFoundViaLegacyLookup;
515+
for (auto &S : Symbols)
516+
if (!SymbolFlags->count(S))
517+
NotFoundViaLegacyLookup.insert(S);
518+
auto SymbolFlags2 =
519+
LD.BackingResolver->lookupFlags(NotFoundViaLegacyLookup);
520+
521+
for (auto &KV : SymbolFlags2)
522+
(*SymbolFlags)[KV.first] = std::move(KV.second);
523+
524+
return *SymbolFlags;
516525
},
517526
[this, &LD,
518527
LegacyLookup](std::shared_ptr<AsynchronousSymbolQuery> Query,
@@ -659,18 +668,29 @@ class CompileOnDemandLayer {
659668

660669
// Create memory manager and symbol resolver.
661670
auto Resolver = createSymbolResolver(
662-
[&LD, LegacyLookup](SymbolFlagsMap &SymbolFlags,
663-
const SymbolNameSet &Symbols) {
664-
auto NotFoundViaLegacyLookup =
665-
lookupFlagsWithLegacyFn(SymbolFlags, Symbols, LegacyLookup);
666-
if (!NotFoundViaLegacyLookup) {
667-
logAllUnhandledErrors(NotFoundViaLegacyLookup.takeError(), errs(),
671+
[&LD, LegacyLookup](const SymbolNameSet &Symbols) {
672+
auto SymbolFlags = lookupFlagsWithLegacyFn(Symbols, LegacyLookup);
673+
if (!SymbolFlags) {
674+
logAllUnhandledErrors(SymbolFlags.takeError(), errs(),
668675
"CODLayer/SubResolver flags lookup failed: ");
669-
SymbolFlags.clear();
670-
return SymbolNameSet();
676+
return SymbolFlagsMap();
671677
}
672-
return LD.BackingResolver->lookupFlags(SymbolFlags,
673-
*NotFoundViaLegacyLookup);
678+
679+
if (SymbolFlags->size() == Symbols.size())
680+
return *SymbolFlags;
681+
682+
SymbolNameSet NotFoundViaLegacyLookup;
683+
for (auto &S : Symbols)
684+
if (!SymbolFlags->count(S))
685+
NotFoundViaLegacyLookup.insert(S);
686+
687+
auto SymbolFlags2 =
688+
LD.BackingResolver->lookupFlags(NotFoundViaLegacyLookup);
689+
690+
for (auto &KV : SymbolFlags2)
691+
(*SymbolFlags)[KV.first] = std::move(KV.second);
692+
693+
return *SymbolFlags;
674694
},
675695
[this, &LD, LegacyLookup](std::shared_ptr<AsynchronousSymbolQuery> Q,
676696
SymbolNameSet Symbols) {

‎include/llvm/ExecutionEngine/Orc/Core.h

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -577,7 +577,7 @@ class VSO {
577577

578578
/// Search the given VSO for the symbols in Symbols. If found, store
579579
/// the flags for each symbol in Flags. Returns any unresolved symbols.
580-
SymbolNameSet lookupFlags(SymbolFlagsMap &Flags, const SymbolNameSet &Names);
580+
SymbolFlagsMap lookupFlags(const SymbolNameSet &Names);
581581

582582
/// Search the given VSOs in order for the symbols in Symbols. Results
583583
/// (once they become available) will be returned via the given Query.

‎include/llvm/ExecutionEngine/Orc/Legacy.h

Lines changed: 12 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -33,8 +33,7 @@ class SymbolResolver {
3333

3434
/// Returns the flags for each symbol in Symbols that can be found,
3535
/// along with the set of symbol that could not be found.
36-
virtual SymbolNameSet lookupFlags(SymbolFlagsMap &Flags,
37-
const SymbolNameSet &Symbols) = 0;
36+
virtual SymbolFlagsMap lookupFlags(const SymbolNameSet &Symbols) = 0;
3837

3938
/// For each symbol in Symbols that can be found, assigns that symbols
4039
/// value in Query. Returns the set of symbols that could not be found.
@@ -55,9 +54,8 @@ class LambdaSymbolResolver final : public SymbolResolver {
5554
: LookupFlags(std::forward<LookupFlagsFnRef>(LookupFlags)),
5655
Lookup(std::forward<LookupFnRef>(Lookup)) {}
5756

58-
SymbolNameSet lookupFlags(SymbolFlagsMap &Flags,
59-
const SymbolNameSet &Symbols) final {
60-
return LookupFlags(Flags, Symbols);
57+
SymbolFlagsMap lookupFlags(const SymbolNameSet &Symbols) final {
58+
return LookupFlags(Symbols);
6159
}
6260

6361
SymbolNameSet lookup(std::shared_ptr<AsynchronousSymbolQuery> Query,
@@ -111,21 +109,18 @@ class JITSymbolResolverAdapter : public JITSymbolResolver {
111109
///
112110
/// Useful for implementing lookupFlags bodies that query legacy resolvers.
113111
template <typename FindSymbolFn>
114-
Expected<SymbolNameSet> lookupFlagsWithLegacyFn(SymbolFlagsMap &SymbolFlags,
115-
const SymbolNameSet &Symbols,
116-
FindSymbolFn FindSymbol) {
117-
SymbolNameSet SymbolsNotFound;
112+
Expected<SymbolFlagsMap> lookupFlagsWithLegacyFn(const SymbolNameSet &Symbols,
113+
FindSymbolFn FindSymbol) {
114+
SymbolFlagsMap SymbolFlags;
118115

119116
for (auto &S : Symbols) {
120117
if (JITSymbol Sym = FindSymbol(*S))
121118
SymbolFlags[S] = Sym.getFlags();
122119
else if (auto Err = Sym.takeError())
123120
return std::move(Err);
124-
else
125-
SymbolsNotFound.insert(S);
126121
}
127122

128-
return SymbolsNotFound;
123+
return SymbolFlags;
129124
}
130125

131126
/// Use the given legacy-style FindSymbol function (i.e. a function that
@@ -182,14 +177,12 @@ class LegacyLookupFnResolver final : public SymbolResolver {
182177
: ES(ES), LegacyLookup(std::move(LegacyLookup)),
183178
ReportError(std::move(ReportError)) {}
184179

185-
SymbolNameSet lookupFlags(SymbolFlagsMap &Flags,
186-
const SymbolNameSet &Symbols) final {
187-
if (auto RemainingSymbols =
188-
lookupFlagsWithLegacyFn(Flags, Symbols, LegacyLookup))
189-
return std::move(*RemainingSymbols);
180+
SymbolFlagsMap lookupFlags(const SymbolNameSet &Symbols) final {
181+
if (auto SymbolFlags = lookupFlagsWithLegacyFn(Symbols, LegacyLookup))
182+
return std::move(*SymbolFlags);
190183
else {
191-
ReportError(RemainingSymbols.takeError());
192-
return Symbols;
184+
ReportError(SymbolFlags.takeError());
185+
return SymbolFlagsMap();
193186
}
194187
}
195188

‎include/llvm/ExecutionEngine/Orc/NullResolver.h

Lines changed: 1 addition & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -23,8 +23,7 @@ namespace orc {
2323

2424
class NullResolver : public SymbolResolver {
2525
public:
26-
SymbolNameSet lookupFlags(SymbolFlagsMap &Flags,
27-
const SymbolNameSet &Symbols) override;
26+
SymbolFlagsMap lookupFlags(const SymbolNameSet &Symbols) override;
2827

2928
SymbolNameSet lookup(std::shared_ptr<AsynchronousSymbolQuery> Query,
3029
SymbolNameSet Symbols) override;

‎lib/ExecutionEngine/Orc/Core.cpp

Lines changed: 11 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -522,11 +522,14 @@ ReExportsMaterializationUnit::extractFlags(const SymbolAliasMap &Aliases) {
522522

523523
Expected<SymbolAliasMap>
524524
buildSimpleReexportsAliasMap(VSO &SourceV, const SymbolNameSet &Symbols) {
525-
SymbolFlagsMap Flags;
526-
auto Unresolved = SourceV.lookupFlags(Flags, Symbols);
525+
auto Flags = SourceV.lookupFlags(Symbols);
527526

528-
if (!Unresolved.empty())
527+
if (Flags.size() != Symbols.size()) {
528+
SymbolNameSet Unresolved = Symbols;
529+
for (auto &KV : Flags)
530+
Unresolved.erase(KV.first);
529531
return make_error<SymbolsNotFound>(std::move(Unresolved));
532+
}
530533

531534
SymbolAliasMap Result;
532535
for (auto &Name : Symbols) {
@@ -900,22 +903,20 @@ void VSO::removeFromSearchOrder(VSO &V) {
900903
});
901904
}
902905

903-
SymbolNameSet VSO::lookupFlags(SymbolFlagsMap &Flags,
904-
const SymbolNameSet &Names) {
906+
SymbolFlagsMap VSO::lookupFlags(const SymbolNameSet &Names) {
905907
return ES.runSessionLocked([&, this]() {
906-
auto Unresolved = lookupFlagsImpl(Flags, Names);
908+
SymbolFlagsMap Result;
909+
auto Unresolved = lookupFlagsImpl(Result, Names);
907910
if (FallbackDefinitionGenerator && !Unresolved.empty()) {
908911
auto FallbackDefs = FallbackDefinitionGenerator(*this, Unresolved);
909912
if (!FallbackDefs.empty()) {
910-
auto Unresolved2 = lookupFlagsImpl(Flags, FallbackDefs);
913+
auto Unresolved2 = lookupFlagsImpl(Result, FallbackDefs);
911914
(void)Unresolved2;
912915
assert(Unresolved2.empty() &&
913916
"All fallback defs should have been found by lookupFlagsImpl");
914-
for (auto &D : FallbackDefs)
915-
Unresolved.erase(D);
916917
}
917918
};
918-
return Unresolved;
919+
return Result;
919920
});
920921
}
921922

‎lib/ExecutionEngine/Orc/Legacy.cpp

Lines changed: 1 addition & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -48,8 +48,7 @@ JITSymbolResolverAdapter::lookupFlags(const LookupSet &Symbols) {
4848
for (auto &S : Symbols)
4949
InternedSymbols.insert(ES.getSymbolStringPool().intern(S));
5050

51-
SymbolFlagsMap SymbolFlags;
52-
R.lookupFlags(SymbolFlags, InternedSymbols);
51+
SymbolFlagsMap SymbolFlags = R.lookupFlags(InternedSymbols);
5352
LookupFlagsResult Result;
5453
for (auto &KV : SymbolFlags) {
5554
ResolvedStrings.insert(KV.first);

‎lib/ExecutionEngine/Orc/NullResolver.cpp

Lines changed: 2 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -14,9 +14,8 @@
1414
namespace llvm {
1515
namespace orc {
1616

17-
SymbolNameSet NullResolver::lookupFlags(SymbolFlagsMap &Flags,
18-
const SymbolNameSet &Symbols) {
19-
return Symbols;
17+
SymbolFlagsMap NullResolver::lookupFlags(const SymbolNameSet &Symbols) {
18+
return SymbolFlagsMap();
2019
}
2120

2221
SymbolNameSet

‎lib/ExecutionEngine/Orc/OrcCBindingsStack.h

Lines changed: 6 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -129,21 +129,20 @@ class OrcCBindingsStack {
129129
: Stack(Stack), ExternalResolver(std::move(ExternalResolver)),
130130
ExternalResolverCtx(std::move(ExternalResolverCtx)) {}
131131

132-
orc::SymbolNameSet lookupFlags(orc::SymbolFlagsMap &SymbolFlags,
133-
const orc::SymbolNameSet &Symbols) override {
134-
orc::SymbolNameSet SymbolsNotFound;
132+
orc::SymbolFlagsMap
133+
lookupFlags(const orc::SymbolNameSet &Symbols) override {
134+
orc::SymbolFlagsMap SymbolFlags;
135135

136136
for (auto &S : Symbols) {
137137
if (auto Sym = findSymbol(*S))
138138
SymbolFlags[S] = Sym.getFlags();
139139
else if (auto Err = Sym.takeError()) {
140140
Stack.reportError(std::move(Err));
141-
return orc::SymbolNameSet();
142-
} else
143-
SymbolsNotFound.insert(S);
141+
return orc::SymbolFlagsMap();
142+
}
144143
}
145144

146-
return SymbolsNotFound;
145+
return SymbolFlags;
147146
}
148147

149148
orc::SymbolNameSet

‎lib/ExecutionEngine/Orc/OrcMCJITReplacement.h

Lines changed: 6 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -144,28 +144,26 @@ class OrcMCJITReplacement : public ExecutionEngine {
144144
public:
145145
LinkingORCResolver(OrcMCJITReplacement &M) : M(M) {}
146146

147-
SymbolNameSet lookupFlags(SymbolFlagsMap &SymbolFlags,
148-
const SymbolNameSet &Symbols) override {
149-
SymbolNameSet UnresolvedSymbols;
147+
SymbolFlagsMap lookupFlags(const SymbolNameSet &Symbols) override {
148+
SymbolFlagsMap SymbolFlags;
150149

151150
for (auto &S : Symbols) {
152151
if (auto Sym = M.findMangledSymbol(*S)) {
153152
SymbolFlags[S] = Sym.getFlags();
154153
} else if (auto Err = Sym.takeError()) {
155154
M.reportError(std::move(Err));
156-
return SymbolNameSet();
155+
return SymbolFlagsMap();
157156
} else {
158157
if (auto Sym2 = M.ClientResolver->findSymbolInLogicalDylib(*S)) {
159158
SymbolFlags[S] = Sym2.getFlags();
160159
} else if (auto Err = Sym2.takeError()) {
161160
M.reportError(std::move(Err));
162-
return SymbolNameSet();
163-
} else
164-
UnresolvedSymbols.insert(S);
161+
return SymbolFlagsMap();
162+
}
165163
}
166164
}
167165

168-
return UnresolvedSymbols;
166+
return SymbolFlags;
169167
}
170168

171169
SymbolNameSet lookup(std::shared_ptr<AsynchronousSymbolQuery> Query,

‎lib/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.cpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -64,7 +64,7 @@ class VSOSearchOrderResolver : public JITSymbolResolver {
6464
return;
6565

6666
assert(VSOs.front() && "VSOList entry can not be null");
67-
VSOs.front()->lookupFlags(InternedResult, InternedSymbols);
67+
InternedResult = VSOs.front()->lookupFlags(InternedSymbols);
6868
});
6969

7070
LookupFlagsResult Result;

‎unittests/ExecutionEngine/Orc/CoreAPIsTest.cpp

Lines changed: 1 addition & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -215,11 +215,8 @@ TEST_F(CoreAPIsStandardTest, LookupFlagsTest) {
215215

216216
SymbolNameSet Names({Foo, Bar, Baz});
217217

218-
SymbolFlagsMap SymbolFlags;
219-
auto SymbolsNotFound = V.lookupFlags(SymbolFlags, Names);
218+
auto SymbolFlags = V.lookupFlags(Names);
220219

221-
EXPECT_EQ(SymbolsNotFound.size(), 1U) << "Expected one not-found symbol";
222-
EXPECT_EQ(SymbolsNotFound.count(Baz), 1U) << "Expected Baz to be not-found";
223220
EXPECT_EQ(SymbolFlags.size(), 2U)
224221
<< "Returned symbol flags contains unexpected results";
225222
EXPECT_EQ(SymbolFlags.count(Foo), 1U) << "Missing lookupFlags result for Foo";

‎unittests/ExecutionEngine/Orc/LegacyAPIInteropTest.cpp

Lines changed: 12 additions & 25 deletions
Original file line numberDiff line numberDiff line change
@@ -22,17 +22,14 @@ TEST_F(LegacyAPIsStandardTest, TestLambdaSymbolResolver) {
2222
cantFail(V.define(absoluteSymbols({{Foo, FooSym}, {Bar, BarSym}})));
2323

2424
auto Resolver = createSymbolResolver(
25-
[&](SymbolFlagsMap &SymbolFlags, const SymbolNameSet &Symbols) {
26-
return V.lookupFlags(SymbolFlags, Symbols);
27-
},
25+
[&](const SymbolNameSet &Symbols) { return V.lookupFlags(Symbols); },
2826
[&](std::shared_ptr<AsynchronousSymbolQuery> Q, SymbolNameSet Symbols) {
2927
return V.lookup(std::move(Q), Symbols);
3028
});
3129

3230
SymbolNameSet Symbols({Foo, Bar, Baz});
3331

34-
SymbolFlagsMap SymbolFlags;
35-
SymbolNameSet SymbolsNotFound = Resolver->lookupFlags(SymbolFlags, Symbols);
32+
SymbolFlagsMap SymbolFlags = Resolver->lookupFlags(Symbols);
3633

3734
EXPECT_EQ(SymbolFlags.size(), 2U)
3835
<< "lookupFlags returned the wrong number of results";
@@ -42,10 +39,6 @@ TEST_F(LegacyAPIsStandardTest, TestLambdaSymbolResolver) {
4239
<< "Incorrect lookupFlags result for Foo";
4340
EXPECT_EQ(SymbolFlags[Bar], BarSym.getFlags())
4441
<< "Incorrect lookupFlags result for Bar";
45-
EXPECT_EQ(SymbolsNotFound.size(), 1U)
46-
<< "Expected one symbol not found in lookupFlags";
47-
EXPECT_EQ(SymbolsNotFound.count(Baz), 1U)
48-
<< "Expected baz not to be found in lookupFlags";
4942

5043
bool OnResolvedRun = false;
5144

@@ -86,9 +79,8 @@ TEST(LegacyAPIInteropTest, QueryAgainstVSO) {
8679
JITEvaluatedSymbol FooSym(0xdeadbeef, JITSymbolFlags::Exported);
8780
cantFail(V.define(absoluteSymbols({{Foo, FooSym}})));
8881

89-
auto LookupFlags = [&](SymbolFlagsMap &SymbolFlags,
90-
const SymbolNameSet &Names) {
91-
return V.lookupFlags(SymbolFlags, Names);
82+
auto LookupFlags = [&](const SymbolNameSet &Names) {
83+
return V.lookupFlags(Names);
9284
};
9385

9486
auto Lookup = [&](std::shared_ptr<AsynchronousSymbolQuery> Query,
@@ -153,19 +145,14 @@ TEST(LegacyAPIInteropTset, LegacyLookupHelpersFn) {
153145

154146
SymbolNameSet Symbols({Foo, Bar, Baz});
155147

156-
SymbolFlagsMap SymbolFlags;
157-
auto SymbolsNotFound =
158-
lookupFlagsWithLegacyFn(SymbolFlags, Symbols, LegacyLookup);
159-
160-
EXPECT_TRUE(!!SymbolsNotFound) << "lookupFlagsWithLegacy failed unexpectedly";
161-
EXPECT_EQ(SymbolFlags.size(), 2U) << "Wrong number of flags returned";
162-
EXPECT_EQ(SymbolFlags.count(Foo), 1U) << "Flags for foo missing";
163-
EXPECT_EQ(SymbolFlags.count(Bar), 1U) << "Flags for foo missing";
164-
EXPECT_EQ(SymbolFlags[Foo], FooFlags) << "Wrong flags for foo";
165-
EXPECT_EQ(SymbolFlags[Bar], BarFlags) << "Wrong flags for foo";
166-
EXPECT_EQ(SymbolsNotFound->size(), 1U) << "Expected one symbol not found";
167-
EXPECT_EQ(SymbolsNotFound->count(Baz), 1U)
168-
<< "Expected symbol baz to be not found";
148+
auto SymbolFlags = lookupFlagsWithLegacyFn(Symbols, LegacyLookup);
149+
150+
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";
169156
EXPECT_FALSE(BarMaterialized)
170157
<< "lookupFlags should not have materialized bar";
171158

0 commit comments

Comments
 (0)