Import LLVM 8.0.0 release including clang, lld and lldb.

1 files changed, 34 insertions, 84 deletions

diff --git a/gnu/llvm/unittests/ExecutionEngine/Orc/LegacyAPIInteropTest.cpp b/gnu/llvm/unittests/ExecutionEngine/Orc/LegacyAPIInteropTest.cpp
index 746ae1dca49..36cb7102623 100644
--- a/gnu/llvm/unittests/ExecutionEngine/Orc/LegacyAPIInteropTest.cpp
+++ b/gnu/llvm/unittests/ExecutionEngine/Orc/LegacyAPIInteropTest.cpp
@@ -19,26 +19,29 @@ class LegacyAPIsStandardTest : public CoreAPIsBasedStandardTest {};
 namespace {
 
 TEST_F(LegacyAPIsStandardTest, TestLambdaSymbolResolver) {
-  cantFail(V.define(absoluteSymbols({{Foo, FooSym}, {Bar, BarSym}})));
+  BarSym.setFlags(BarSym.getFlags() | JITSymbolFlags::Weak);
+
+  cantFail(JD.define(absoluteSymbols({{Foo, FooSym}, {Bar, BarSym}})));
 
   auto Resolver = createSymbolResolver(
-      [&](const SymbolNameSet &Symbols) { return V.lookupFlags(Symbols); },
+      [&](const SymbolNameSet &Symbols) {
+        auto FlagsMap = JD.lookupFlags(Symbols);
+        SymbolNameSet Result;
+        for (auto &KV : FlagsMap)
+          if (!KV.second.isStrong())
+            Result.insert(KV.first);
+        return Result;
+      },
       [&](std::shared_ptr<AsynchronousSymbolQuery> Q, SymbolNameSet Symbols) {
-        return V.legacyLookup(std::move(Q), Symbols);
+        return JD.legacyLookup(std::move(Q), Symbols);
       });
 
-  SymbolNameSet Symbols({Foo, Bar, Baz});
-
-  SymbolFlagsMap SymbolFlags = Resolver->lookupFlags(Symbols);
+  auto RS = Resolver->getResponsibilitySet(SymbolNameSet({Bar, Baz}));
 
-  EXPECT_EQ(SymbolFlags.size(), 2U)
-      << "lookupFlags returned the wrong number of results";
-  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(SymbolFlags[Bar], BarSym.getFlags())
-      << "Incorrect lookupFlags result for Bar";
+  EXPECT_EQ(RS.size(), 1U)
+      << "getResponsibilitySet returned the wrong number of results";
+  EXPECT_EQ(RS.count(Bar), 1U)
+      << "getResponsibilitySet result incorrect. Should be {'bar'}";
 
   bool OnResolvedRun = false;
 
@@ -59,68 +62,21 @@ TEST_F(LegacyAPIsStandardTest, TestLambdaSymbolResolver) {
 
   auto Q = std::make_shared<AsynchronousSymbolQuery>(SymbolNameSet({Foo, Bar}),
                                                      OnResolved, OnReady);
-  auto Unresolved = Resolver->lookup(std::move(Q), Symbols);
+  auto Unresolved =
+      Resolver->lookup(std::move(Q), SymbolNameSet({Foo, Bar, Baz}));
 
   EXPECT_EQ(Unresolved.size(), 1U) << "Expected one unresolved symbol";
   EXPECT_EQ(Unresolved.count(Baz), 1U) << "Expected baz to not be resolved";
   EXPECT_TRUE(OnResolvedRun) << "OnResolved was never run";
 }
 
-TEST(LegacyAPIInteropTest, QueryAgainstVSO) {
-
-  ExecutionSession ES(std::make_shared<SymbolStringPool>());
-  auto Foo = ES.getSymbolStringPool().intern("foo");
-
-  auto &V = ES.createVSO("V");
-  JITEvaluatedSymbol FooSym(0xdeadbeef, JITSymbolFlags::Exported);
-  cantFail(V.define(absoluteSymbols({{Foo, FooSym}})));
-
-  auto LookupFlags = [&](const SymbolNameSet &Names) {
-    return V.lookupFlags(Names);
-  };
-
-  auto Lookup = [&](std::shared_ptr<AsynchronousSymbolQuery> Query,
-                    SymbolNameSet Symbols) {
-    return V.legacyLookup(std::move(Query), Symbols);
-  };
-
-  auto UnderlyingResolver =
-      createSymbolResolver(std::move(LookupFlags), std::move(Lookup));
-  JITSymbolResolverAdapter Resolver(ES, *UnderlyingResolver, nullptr);
-
-  JITSymbolResolver::LookupSet Names{StringRef("foo")};
-
-  auto LFR = Resolver.lookupFlags(Names);
-  EXPECT_TRUE(!!LFR) << "lookupFlags failed";
-  EXPECT_EQ(LFR->size(), 1U)
-      << "lookupFlags returned the wrong number of results";
-  EXPECT_EQ(LFR->count(*Foo), 1U)
-      << "lookupFlags did not contain a result for 'foo'";
-  EXPECT_EQ((*LFR)[*Foo], FooSym.getFlags())
-      << "lookupFlags contained the wrong result for 'foo'";
-
-  auto LR = Resolver.lookup(Names);
-  EXPECT_TRUE(!!LR) << "lookup failed";
-  EXPECT_EQ(LR->size(), 1U) << "lookup returned the wrong number of results";
-  EXPECT_EQ(LR->count(*Foo), 1U) << "lookup did not contain a result for 'foo'";
-  EXPECT_EQ((*LR)[*Foo].getFlags(), FooSym.getFlags())
-      << "lookup returned the wrong result for flags of 'foo'";
-  EXPECT_EQ((*LR)[*Foo].getAddress(), FooSym.getAddress())
-      << "lookup returned the wrong result for address of 'foo'";
-}
-
-TEST(LegacyAPIInteropTset, LegacyLookupHelpersFn) {
-  constexpr JITTargetAddress FooAddr = 0xdeadbeef;
-  JITSymbolFlags FooFlags = JITSymbolFlags::Exported;
-
+TEST_F(LegacyAPIsStandardTest, LegacyLookupHelpersFn) {
   bool BarMaterialized = false;
-  constexpr JITTargetAddress BarAddr = 0xcafef00d;
-  JITSymbolFlags BarFlags = static_cast<JITSymbolFlags::FlagNames>(
-      JITSymbolFlags::Exported | JITSymbolFlags::Weak);
+  BarSym.setFlags(BarSym.getFlags() | JITSymbolFlags::Weak);
 
   auto LegacyLookup = [&](const std::string &Name) -> JITSymbol {
     if (Name == "foo")
-      return {FooAddr, FooFlags};
+      return FooSym;
 
     if (Name == "bar") {
       auto BarMaterializer = [&]() -> Expected<JITTargetAddress> {
@@ -128,27 +84,18 @@ TEST(LegacyAPIInteropTset, LegacyLookupHelpersFn) {
         return BarAddr;
       };
 
-      return {BarMaterializer, BarFlags};
+      return {BarMaterializer, BarSym.getFlags()};
     }
 
     return nullptr;
   };
 
-  ExecutionSession ES;
-  auto Foo = ES.getSymbolStringPool().intern("foo");
-  auto Bar = ES.getSymbolStringPool().intern("bar");
-  auto Baz = ES.getSymbolStringPool().intern("baz");
-
-  SymbolNameSet Symbols({Foo, Bar, Baz});
-
-  auto SymbolFlags = lookupFlagsWithLegacyFn(Symbols, LegacyLookup);
+  auto RS =
+      getResponsibilitySetWithLegacyFn(SymbolNameSet({Bar, Baz}), LegacyLookup);
 
-  EXPECT_TRUE(!!SymbolFlags) << "Expected lookupFlagsWithLegacyFn to succeed";
-  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_TRUE(!!RS) << "Expected getResponsibilitySetWithLegacyFn to succeed";
+  EXPECT_EQ(RS->size(), 1U) << "Wrong number of symbols returned";
+  EXPECT_EQ(RS->count(Bar), 1U) << "Incorrect responsibility set returned";
   EXPECT_FALSE(BarMaterialized)
       << "lookupFlags should not have materialized bar";
 
@@ -162,9 +109,11 @@ TEST(LegacyAPIInteropTset, LegacyLookupHelpersFn) {
     EXPECT_EQ(Result->count(Foo), 1U) << "Result for foo missing";
     EXPECT_EQ(Result->count(Bar), 1U) << "Result for bar missing";
     EXPECT_EQ((*Result)[Foo].getAddress(), FooAddr) << "Wrong address for foo";
-    EXPECT_EQ((*Result)[Foo].getFlags(), FooFlags) << "Wrong flags for foo";
+    EXPECT_EQ((*Result)[Foo].getFlags(), FooSym.getFlags())
+        << "Wrong flags for foo";
     EXPECT_EQ((*Result)[Bar].getAddress(), BarAddr) << "Wrong address for bar";
-    EXPECT_EQ((*Result)[Bar].getFlags(), BarFlags) << "Wrong flags for bar";
+    EXPECT_EQ((*Result)[Bar].getFlags(), BarSym.getFlags())
+        << "Wrong flags for bar";
   };
   auto OnReady = [&](Error Err) {
     EXPECT_FALSE(!!Err) << "Finalization unexpectedly failed";
@@ -172,7 +121,8 @@ TEST(LegacyAPIInteropTset, LegacyLookupHelpersFn) {
   };
 
   AsynchronousSymbolQuery Q({Foo, Bar}, OnResolved, OnReady);
-  auto Unresolved = lookupWithLegacyFn(ES, Q, Symbols, LegacyLookup);
+  auto Unresolved =
+      lookupWithLegacyFn(ES, Q, SymbolNameSet({Foo, Bar, Baz}), LegacyLookup);
 
   EXPECT_TRUE(OnResolvedRun) << "OnResolved was not run";
   EXPECT_TRUE(OnReadyRun) << "OnReady was not run";