[ORC] Refactor the various lookupFlags methods to return the flags map via the

first argument.

This makes lookupFlags more consistent with lookup (which takes the query as the
first argument) and composes better in practice, since lookups are usually
linearly chained: Each lookupFlags can populate the result map based on the
symbols not found in the previous lookup. (If the maps were returned rather than
passed by reference there would have to be a merge step at the end).

llvm-svn: 323398

2 files changed, 41 insertions, 38 deletions

diff --git a/llvm/unittests/ExecutionEngine/Orc/CoreAPIsTest.cpp b/llvm/unittests/ExecutionEngine/Orc/CoreAPIsTest.cpp
index 3454ee236c3..1f1eb510c40 100644
--- a/llvm/unittests/ExecutionEngine/Orc/CoreAPIsTest.cpp
+++ b/llvm/unittests/ExecutionEngine/Orc/CoreAPIsTest.cpp
@@ -163,21 +163,18 @@ TEST(CoreAPIsTest, LookupFlagsTest) {
 
   SymbolNameSet Names({Foo, Bar, Baz});
 
-  auto LFR = V.lookupFlags(Names);
+  SymbolFlagsMap SymbolFlags;
+  auto SymbolsNotFound = V.lookupFlags(SymbolFlags, Names);
 
-  EXPECT_EQ(LFR.SymbolsNotFound.size(), 1U) << "Expected one not-found symbol";
-  EXPECT_EQ(*LFR.SymbolsNotFound.begin(), Baz)
-      << "Expected Baz to be not-found";
-  EXPECT_EQ(LFR.SymbolFlags.size(), 2U)
+  EXPECT_EQ(SymbolsNotFound.size(), 1U) << "Expected one not-found symbol";
+  EXPECT_EQ(SymbolsNotFound.count(Baz), 1U) << "Expected Baz to be not-found";
+  EXPECT_EQ(SymbolFlags.size(), 2U)
       << "Returned symbol flags contains unexpected results";
-  EXPECT_EQ(LFR.SymbolFlags.count(Foo), 1U)
-      << "Missing lookupFlags result for Foo";
-  EXPECT_EQ(LFR.SymbolFlags[Foo], FooFlags)
-      << "Incorrect flags returned for Foo";
-  EXPECT_EQ(LFR.SymbolFlags.count(Bar), 1U)
+  EXPECT_EQ(SymbolFlags.count(Foo), 1U) << "Missing lookupFlags result for Foo";
+  EXPECT_EQ(SymbolFlags[Foo], FooFlags) << "Incorrect flags returned for Foo";
+  EXPECT_EQ(SymbolFlags.count(Bar), 1U)
       << "Missing  lookupFlags result for Bar";
-  EXPECT_EQ(LFR.SymbolFlags[Bar], BarFlags)
-      << "Incorrect flags returned for Bar";
+  EXPECT_EQ(SymbolFlags[Bar], BarFlags) << "Incorrect flags returned for Bar";
 }
 
 TEST(CoreAPIsTest, AddAndMaterializeLazySymbol) {
@@ -271,7 +268,9 @@ TEST(CoreAPIsTest, TestLambdaSymbolResolver) {
   cantFail(V.define({{Foo, FooSym}, {Bar, BarSym}}));
 
   auto Resolver = createSymbolResolver(
-      [&](const SymbolNameSet &Symbols) { return V.lookupFlags(Symbols); },
+      [&](SymbolFlagsMap &SymbolFlags, const SymbolNameSet &Symbols) {
+        return V.lookupFlags(SymbolFlags, Symbols);
+      },
       [&](AsynchronousSymbolQuery &Q, SymbolNameSet Symbols) {
         auto LR = V.lookup(Q, Symbols);
         assert(LR.MaterializationWork.empty() &&
@@ -282,21 +281,20 @@ TEST(CoreAPIsTest, TestLambdaSymbolResolver) {
 
   SymbolNameSet Symbols({Foo, Bar, Baz});
 
-  LookupFlagsResult LFR = Resolver->lookupFlags(Symbols);
+  SymbolFlagsMap SymbolFlags;
+  SymbolNameSet SymbolsNotFound = Resolver->lookupFlags(SymbolFlags, Symbols);
 
-  EXPECT_EQ(LFR.SymbolFlags.size(), 2U)
+  EXPECT_EQ(SymbolFlags.size(), 2U)
       << "lookupFlags returned the wrong number of results";
-  EXPECT_EQ(LFR.SymbolFlags.count(Foo), 1U)
-      << "Missing lookupFlags result for foo";
-  EXPECT_EQ(LFR.SymbolFlags.count(Bar), 1U)
-      << "Missing lookupFlags result for bar";
-  EXPECT_EQ(LFR.SymbolFlags[Foo], FooSym.getFlags())
+  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(LFR.SymbolFlags[Bar], BarSym.getFlags())
+  EXPECT_EQ(SymbolFlags[Bar], BarSym.getFlags())
       << "Incorrect lookupFlags result for Bar";
-  EXPECT_EQ(LFR.SymbolsNotFound.size(), 1U)
+  EXPECT_EQ(SymbolsNotFound.size(), 1U)
       << "Expected one symbol not found in lookupFlags";
-  EXPECT_EQ(LFR.SymbolsNotFound.count(Baz), 1U)
+  EXPECT_EQ(SymbolsNotFound.count(Baz), 1U)
       << "Expected baz not to be found in lookupFlags";
 
   bool OnResolvedRun = false;
diff --git a/llvm/unittests/ExecutionEngine/Orc/LegacyAPIInteropTest.cpp b/llvm/unittests/ExecutionEngine/Orc/LegacyAPIInteropTest.cpp
index 963ce9f50ad..19c194bd166 100644
--- a/llvm/unittests/ExecutionEngine/Orc/LegacyAPIInteropTest.cpp
+++ b/llvm/unittests/ExecutionEngine/Orc/LegacyAPIInteropTest.cpp
@@ -16,15 +16,17 @@ using namespace llvm::orc;
 
 class SimpleORCResolver : public SymbolResolver {
 public:
-  using LookupFlagsFn = std::function<LookupFlagsResult(const SymbolNameSet &)>;
+  using LookupFlagsFn = std::function<SymbolNameSet(SymbolFlagsMap &SymbolFlags,
+                                                    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 lookupFlags(SymbolFlagsMap &SymbolFlags,
+                            const SymbolNameSet &Symbols) override {
+    return LookupFlags(SymbolFlags, Symbols);
   }
 
   SymbolNameSet lookup(AsynchronousSymbolQuery &Query,
@@ -51,8 +53,9 @@ TEST(LegacyAPIInteropTest, QueryAgainstVSO) {
   Defs[Foo] = FooSym;
   cantFail(V.define(std::move(Defs)));
 
-  auto LookupFlags = [&](const SymbolNameSet &Names) {
-    return V.lookupFlags(Names);
+  auto LookupFlags = [&](SymbolFlagsMap &SymbolFlags,
+                         const SymbolNameSet &Names) {
+    return V.lookupFlags(SymbolFlags, Names);
   };
 
   auto Lookup = [&](AsynchronousSymbolQuery &Query, SymbolNameSet Symbols) {
@@ -119,16 +122,18 @@ TEST(LegacyAPIInteropTset, LegacyLookupHelpersFn) {
 
   SymbolNameSet Symbols({Foo, Bar, Baz});
 
-  auto LFR = lookupFlagsWithLegacyFn(Symbols, LegacyLookup);
-
-  EXPECT_TRUE(!!LFR) << "lookupFlagsWithLegacy failed unexpectedly";
-  EXPECT_EQ(LFR->SymbolFlags.size(), 2U) << "Wrong number of flags returned";
-  EXPECT_EQ(LFR->SymbolFlags.count(Foo), 1U) << "Flags for foo missing";
-  EXPECT_EQ(LFR->SymbolFlags.count(Bar), 1U) << "Flags for foo missing";
-  EXPECT_EQ(LFR->SymbolFlags[Foo], FooFlags) << "Wrong flags for foo";
-  EXPECT_EQ(LFR->SymbolFlags[Bar], BarFlags) << "Wrong flags for foo";
-  EXPECT_EQ(LFR->SymbolsNotFound.size(), 1U) << "Expected one symbol not found";
-  EXPECT_EQ(LFR->SymbolsNotFound.count(Baz), 1U)
+  SymbolFlagsMap SymbolFlags;
+  auto SymbolsNotFound =
+      lookupFlagsWithLegacyFn(SymbolFlags, Symbols, LegacyLookup);
+
+  EXPECT_TRUE(!!SymbolsNotFound) << "lookupFlagsWithLegacy failed unexpectedly";
+  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_EQ(SymbolsNotFound->size(), 1U) << "Expected one symbol not found";
+  EXPECT_EQ(SymbolsNotFound->count(Baz), 1U)
       << "Expected symbol baz to be not found";
   EXPECT_FALSE(BarMaterialized)
       << "lookupFlags should not have materialized bar";