[ORC] Replace SymbolResolvers in the new ORC layers with search orders on VSOs.

A search order is a list of VSOs to be searched linearly to find symbols. Each
VSO now has a search order that will be used when fixing up definitions in that
VSO. Each VSO's search order defaults to just that VSO itself.

This is a first step towards removing symbol resolvers from ORC altogether. In
practice symbol resolvers tended to be used to implement a search order anyway,
sometimes with additional programatic generation of symbols. Now that VSOs
support programmatic generation of definitions via fallback generators, search
orders provide a cleaner way to achieve the desired effect (while removing a lot
of boilerplate).

llvm-svn: 337593

4 files changed, 109 insertions, 100 deletions

diff --git a/llvm/unittests/ExecutionEngine/Orc/CoreAPIsTest.cpp b/llvm/unittests/ExecutionEngine/Orc/CoreAPIsTest.cpp
index 68911d75877..9d4f9463372 100644
--- a/llvm/unittests/ExecutionEngine/Orc/CoreAPIsTest.cpp
+++ b/llvm/unittests/ExecutionEngine/Orc/CoreAPIsTest.cpp
@@ -11,7 +11,6 @@
 #include "llvm/Config/llvm-config.h"
 #include "llvm/ExecutionEngine/Orc/Core.h"
 #include "llvm/ExecutionEngine/Orc/OrcError.h"
-#include "gtest/gtest.h"
 
 #include <set>
 #include <thread>
@@ -19,6 +18,8 @@
 using namespace llvm;
 using namespace llvm::orc;
 
+class CoreAPIsStandardTest : public CoreAPIsBasedStandardTest {};
+
 namespace {
 
 class SimpleMaterializationUnit : public MaterializationUnit {
@@ -58,45 +59,6 @@ private:
   DestructorFunction Destructor;
 };
 
-// CoreAPIsStandardTest that saves a bunch of boilerplate by providing the
-// following:
-//
-// (1) ES -- An ExecutionSession
-// (2) Foo, Bar, Baz, Qux -- SymbolStringPtrs for strings "foo", "bar", "baz",
-//     and "qux" respectively.
-// (3) FooAddr, BarAddr, BazAddr, QuxAddr -- Dummy addresses. Guaranteed
-//     distinct and non-null.
-// (4) FooSym, BarSym, BazSym, QuxSym -- JITEvaluatedSymbols with FooAddr,
-//     BarAddr, BazAddr, and QuxAddr respectively. All with default strong,
-//     linkage and non-hidden visibility.
-// (5) V -- A VSO associated with ES.
-class CoreAPIsStandardTest : public testing::Test {
-public:
-protected:
-  ExecutionSession ES;
-  VSO &V = ES.createVSO("V");
-  SymbolStringPtr Foo = ES.getSymbolStringPool().intern("foo");
-  SymbolStringPtr Bar = ES.getSymbolStringPool().intern("bar");
-  SymbolStringPtr Baz = ES.getSymbolStringPool().intern("baz");
-  SymbolStringPtr Qux = ES.getSymbolStringPool().intern("qux");
-  static const JITTargetAddress FooAddr = 1U;
-  static const JITTargetAddress BarAddr = 2U;
-  static const JITTargetAddress BazAddr = 3U;
-  static const JITTargetAddress QuxAddr = 4U;
-  JITEvaluatedSymbol FooSym =
-      JITEvaluatedSymbol(FooAddr, JITSymbolFlags::Exported);
-  JITEvaluatedSymbol BarSym =
-      JITEvaluatedSymbol(BarAddr, JITSymbolFlags::Exported);
-  JITEvaluatedSymbol BazSym =
-      JITEvaluatedSymbol(BazAddr, JITSymbolFlags::Exported);
-  JITEvaluatedSymbol QuxSym =
-      JITEvaluatedSymbol(QuxAddr, JITSymbolFlags::Exported);
-};
-
-const JITTargetAddress CoreAPIsStandardTest::FooAddr;
-const JITTargetAddress CoreAPIsStandardTest::BarAddr;
-const JITTargetAddress CoreAPIsStandardTest::BazAddr;
-const JITTargetAddress CoreAPIsStandardTest::QuxAddr;
 
 TEST_F(CoreAPIsStandardTest, AsynchronousSymbolQuerySuccessfulResolutionOnly) {
   bool OnResolutionRun = false;
@@ -623,65 +585,6 @@ TEST_F(CoreAPIsStandardTest, FailResolution) {
   }
 }
 
-TEST_F(CoreAPIsStandardTest, TestLambdaSymbolResolver) {
-  cantFail(V.define(absoluteSymbols({{Foo, FooSym}, {Bar, BarSym}})));
-
-  auto Resolver = createSymbolResolver(
-      [&](SymbolFlagsMap &SymbolFlags, const SymbolNameSet &Symbols) {
-        return V.lookupFlags(SymbolFlags, Symbols);
-      },
-      [&](std::shared_ptr<AsynchronousSymbolQuery> Q, SymbolNameSet Symbols) {
-        return V.lookup(std::move(Q), Symbols);
-      });
-
-  SymbolNameSet Symbols({Foo, Bar, Baz});
-
-  SymbolFlagsMap SymbolFlags;
-  SymbolNameSet SymbolsNotFound = Resolver->lookupFlags(SymbolFlags, Symbols);
-
-  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(SymbolsNotFound.size(), 1U)
-      << "Expected one symbol not found in lookupFlags";
-  EXPECT_EQ(SymbolsNotFound.count(Baz), 1U)
-      << "Expected baz not to be found in lookupFlags";
-
-  bool OnResolvedRun = false;
-
-  auto OnResolved =
-      [&](Expected<AsynchronousSymbolQuery::ResolutionResult> Result) {
-        OnResolvedRun = true;
-        EXPECT_TRUE(!!Result) << "Unexpected error";
-        EXPECT_EQ(Result->Symbols.size(), 2U)
-            << "Unexpected number of resolved symbols";
-        EXPECT_EQ(Result->Symbols.count(Foo), 1U)
-            << "Missing lookup result for foo";
-        EXPECT_EQ(Result->Symbols.count(Bar), 1U)
-            << "Missing lookup result for bar";
-        EXPECT_EQ(Result->Symbols[Foo].getAddress(), FooSym.getAddress())
-            << "Incorrect address for foo";
-        EXPECT_EQ(Result->Symbols[Bar].getAddress(), BarSym.getAddress())
-            << "Incorrect address for bar";
-      };
-  auto OnReady = [&](Error Err) {
-    EXPECT_FALSE(!!Err) << "Finalization should never fail in this test";
-  };
-
-  auto Q = std::make_shared<AsynchronousSymbolQuery>(SymbolNameSet({Foo, Bar}),
-                                                     OnResolved, OnReady);
-  auto Unresolved = Resolver->lookup(std::move(Q), Symbols);
-
-  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_F(CoreAPIsStandardTest, TestLookupWithUnthreadedMaterialization) {
   auto MU = llvm::make_unique<SimpleMaterializationUnit>(
       SymbolFlagsMap({{Foo, JITSymbolFlags::Exported}}),
diff --git a/llvm/unittests/ExecutionEngine/Orc/LegacyAPIInteropTest.cpp b/llvm/unittests/ExecutionEngine/Orc/LegacyAPIInteropTest.cpp
index ade5aa26470..51f86eacfd9 100644
--- a/llvm/unittests/ExecutionEngine/Orc/LegacyAPIInteropTest.cpp
+++ b/llvm/unittests/ExecutionEngine/Orc/LegacyAPIInteropTest.cpp
@@ -14,8 +14,69 @@
 using namespace llvm;
 using namespace llvm::orc;
 
+class LegacyAPIsStandardTest : public CoreAPIsBasedStandardTest {};
+
 namespace {
 
+TEST_F(LegacyAPIsStandardTest, TestLambdaSymbolResolver) {
+  cantFail(V.define(absoluteSymbols({{Foo, FooSym}, {Bar, BarSym}})));
+
+  auto Resolver = createSymbolResolver(
+      [&](SymbolFlagsMap &SymbolFlags, const SymbolNameSet &Symbols) {
+        return V.lookupFlags(SymbolFlags, Symbols);
+      },
+      [&](std::shared_ptr<AsynchronousSymbolQuery> Q, SymbolNameSet Symbols) {
+        return V.lookup(std::move(Q), Symbols);
+      });
+
+  SymbolNameSet Symbols({Foo, Bar, Baz});
+
+  SymbolFlagsMap SymbolFlags;
+  SymbolNameSet SymbolsNotFound = Resolver->lookupFlags(SymbolFlags, Symbols);
+
+  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(SymbolsNotFound.size(), 1U)
+      << "Expected one symbol not found in lookupFlags";
+  EXPECT_EQ(SymbolsNotFound.count(Baz), 1U)
+      << "Expected baz not to be found in lookupFlags";
+
+  bool OnResolvedRun = false;
+
+  auto OnResolved =
+      [&](Expected<AsynchronousSymbolQuery::ResolutionResult> Result) {
+        OnResolvedRun = true;
+        EXPECT_TRUE(!!Result) << "Unexpected error";
+        EXPECT_EQ(Result->Symbols.size(), 2U)
+            << "Unexpected number of resolved symbols";
+        EXPECT_EQ(Result->Symbols.count(Foo), 1U)
+            << "Missing lookup result for foo";
+        EXPECT_EQ(Result->Symbols.count(Bar), 1U)
+            << "Missing lookup result for bar";
+        EXPECT_EQ(Result->Symbols[Foo].getAddress(), FooSym.getAddress())
+            << "Incorrect address for foo";
+        EXPECT_EQ(Result->Symbols[Bar].getAddress(), BarSym.getAddress())
+            << "Incorrect address for bar";
+      };
+  auto OnReady = [&](Error Err) {
+    EXPECT_FALSE(!!Err) << "Finalization should never fail in this test";
+  };
+
+  auto Q = std::make_shared<AsynchronousSymbolQuery>(SymbolNameSet({Foo, Bar}),
+                                                     OnResolved, OnReady);
+  auto Unresolved = Resolver->lookup(std::move(Q), Symbols);
+
+  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>());
diff --git a/llvm/unittests/ExecutionEngine/Orc/OrcTestCommon.cpp b/llvm/unittests/ExecutionEngine/Orc/OrcTestCommon.cpp
index ccd2fc0fb18..a12b1876e29 100644
--- a/llvm/unittests/ExecutionEngine/Orc/OrcTestCommon.cpp
+++ b/llvm/unittests/ExecutionEngine/Orc/OrcTestCommon.cpp
@@ -15,6 +15,11 @@
 
 using namespace llvm;
 
+const JITTargetAddress llvm::orc::CoreAPIsBasedStandardTest::FooAddr;
+const JITTargetAddress llvm::orc::CoreAPIsBasedStandardTest::BarAddr;
+const JITTargetAddress llvm::orc::CoreAPIsBasedStandardTest::BazAddr;
+const JITTargetAddress llvm::orc::CoreAPIsBasedStandardTest::QuxAddr;
+
 bool OrcNativeTarget::NativeTargetInitialized = false;
 
 ModuleBuilder::ModuleBuilder(LLVMContext &Context, StringRef Triple,
diff --git a/llvm/unittests/ExecutionEngine/Orc/OrcTestCommon.h b/llvm/unittests/ExecutionEngine/Orc/OrcTestCommon.h
index c4424e009b4..c6caaf07db0 100644
--- a/llvm/unittests/ExecutionEngine/Orc/OrcTestCommon.h
+++ b/llvm/unittests/ExecutionEngine/Orc/OrcTestCommon.h
@@ -24,12 +24,52 @@
 #include "llvm/IR/Module.h"
 #include "llvm/IR/TypeBuilder.h"
 #include "llvm/Object/ObjectFile.h"
-#include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/TargetRegistry.h"
+#include "llvm/Support/TargetSelect.h"
+#include "gtest/gtest.h"
+
 #include <memory>
 
 namespace llvm {
 
+namespace orc {
+// CoreAPIsStandardTest that saves a bunch of boilerplate by providing the
+// following:
+//
+// (1) ES -- An ExecutionSession
+// (2) Foo, Bar, Baz, Qux -- SymbolStringPtrs for strings "foo", "bar", "baz",
+//     and "qux" respectively.
+// (3) FooAddr, BarAddr, BazAddr, QuxAddr -- Dummy addresses. Guaranteed
+//     distinct and non-null.
+// (4) FooSym, BarSym, BazSym, QuxSym -- JITEvaluatedSymbols with FooAddr,
+//     BarAddr, BazAddr, and QuxAddr respectively. All with default strong,
+//     linkage and non-hidden visibility.
+// (5) V -- A VSO associated with ES.
+class CoreAPIsBasedStandardTest : public testing::Test {
+public:
+protected:
+  ExecutionSession ES;
+  VSO &V = ES.createVSO("V");
+  SymbolStringPtr Foo = ES.getSymbolStringPool().intern("foo");
+  SymbolStringPtr Bar = ES.getSymbolStringPool().intern("bar");
+  SymbolStringPtr Baz = ES.getSymbolStringPool().intern("baz");
+  SymbolStringPtr Qux = ES.getSymbolStringPool().intern("qux");
+  static const JITTargetAddress FooAddr = 1U;
+  static const JITTargetAddress BarAddr = 2U;
+  static const JITTargetAddress BazAddr = 3U;
+  static const JITTargetAddress QuxAddr = 4U;
+  JITEvaluatedSymbol FooSym =
+      JITEvaluatedSymbol(FooAddr, JITSymbolFlags::Exported);
+  JITEvaluatedSymbol BarSym =
+      JITEvaluatedSymbol(BarAddr, JITSymbolFlags::Exported);
+  JITEvaluatedSymbol BazSym =
+      JITEvaluatedSymbol(BazAddr, JITSymbolFlags::Exported);
+  JITEvaluatedSymbol QuxSym =
+      JITEvaluatedSymbol(QuxAddr, JITSymbolFlags::Exported);
+};
+
+} // end namespace orc
+
 class OrcNativeTarget {
 public:
   static void initialize() {