diff --git a/llvm/unittests/ExecutionEngine/Orc/CoreAPIsTest.cpp b/llvm/unittests/ExecutionEngine/Orc/CoreAPIsTest.cpp
index 3454ee2..1f1eb51 100644
--- a/llvm/unittests/ExecutionEngine/Orc/CoreAPIsTest.cpp
+++ b/llvm/unittests/ExecutionEngine/Orc/CoreAPIsTest.cpp
@@ -163,21 +163,18 @@
 
   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 @@
   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 @@
 
   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 963ce9f..19c194b 100644
--- a/llvm/unittests/ExecutionEngine/Orc/LegacyAPIInteropTest.cpp
+++ b/llvm/unittests/ExecutionEngine/Orc/LegacyAPIInteropTest.cpp
@@ -16,15 +16,17 @@
 
 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 @@
   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 @@
 
   SymbolNameSet Symbols({Foo, Bar, Baz});
 
-  auto LFR = lookupFlagsWithLegacyFn(Symbols, LegacyLookup);
+  SymbolFlagsMap SymbolFlags;
+  auto SymbolsNotFound =
+      lookupFlagsWithLegacyFn(SymbolFlags, 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)
+  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";