[ORC] Rename ORC layers to make the "new" ORC layers the default.
This commit adds a 'Legacy' prefix to old ORC layers and utilities, and removes
the '2' suffix from the new ORC layers. If you wish to continue using the old
ORC layers you will need to add a 'Legacy' prefix to your classes. If you were
already using the new ORC layers you will need to drop the '2' suffix.
The legacy layers will remain in-tree until the new layers reach feature
parity with them. This will involve adding support for removing code from the
new layers, and ensuring that performance is comperable.
llvm-svn: 344572
diff --git a/llvm/unittests/ExecutionEngine/Orc/LegacyCompileOnDemandLayerTest.cpp b/llvm/unittests/ExecutionEngine/Orc/LegacyCompileOnDemandLayerTest.cpp
new file mode 100644
index 0000000..38f7a65
--- /dev/null
+++ b/llvm/unittests/ExecutionEngine/Orc/LegacyCompileOnDemandLayerTest.cpp
@@ -0,0 +1,89 @@
+//===----- CompileOnDemandLayerTest.cpp - Unit tests for the COD layer ----===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h"
+#include "OrcTestCommon.h"
+#include "gtest/gtest.h"
+
+using namespace llvm;
+using namespace llvm::orc;
+
+namespace {
+
+class DummyTrampolinePool : public orc::TrampolinePool {
+public:
+ Expected<JITTargetAddress> getTrampoline() {
+ llvm_unreachable("Unimplemented");
+ }
+};
+
+class DummyCallbackManager : public JITCompileCallbackManager {
+public:
+ DummyCallbackManager(ExecutionSession &ES)
+ : JITCompileCallbackManager(llvm::make_unique<DummyTrampolinePool>(), ES,
+ 0) {}
+};
+
+class DummyStubsManager : public orc::IndirectStubsManager {
+public:
+ Error createStub(StringRef StubName, JITTargetAddress InitAddr,
+ JITSymbolFlags Flags) override {
+ llvm_unreachable("Not implemented");
+ }
+
+ Error createStubs(const StubInitsMap &StubInits) override {
+ llvm_unreachable("Not implemented");
+ }
+
+ JITEvaluatedSymbol findStub(StringRef Name, bool ExportedStubsOnly) override {
+ llvm_unreachable("Not implemented");
+ }
+
+ JITEvaluatedSymbol findPointer(StringRef Name) override {
+ llvm_unreachable("Not implemented");
+ }
+
+ Error updatePointer(StringRef Name, JITTargetAddress NewAddr) override {
+ llvm_unreachable("Not implemented");
+ }
+};
+
+TEST(LegacyCompileOnDemandLayerTest, FindSymbol) {
+ MockBaseLayer<int, std::shared_ptr<Module>> TestBaseLayer;
+ TestBaseLayer.findSymbolImpl =
+ [](const std::string &Name, bool) {
+ if (Name == "foo")
+ return JITSymbol(1, JITSymbolFlags::Exported);
+ return JITSymbol(nullptr);
+ };
+
+
+ ExecutionSession ES(std::make_shared<SymbolStringPool>());
+ DummyCallbackManager CallbackMgr(ES);
+
+ auto GetResolver =
+ [](orc::VModuleKey) -> std::shared_ptr<llvm::orc::SymbolResolver> {
+ llvm_unreachable("Should never be called");
+ };
+
+ auto SetResolver = [](orc::VModuleKey, std::shared_ptr<orc::SymbolResolver>) {
+ llvm_unreachable("Should never be called");
+ };
+
+ llvm::orc::LegacyCompileOnDemandLayer<decltype(TestBaseLayer)> COD(
+ ES, TestBaseLayer, GetResolver, SetResolver,
+ [](Function &F) { return std::set<Function *>{&F}; }, CallbackMgr,
+ [] { return llvm::make_unique<DummyStubsManager>(); }, true);
+
+ auto Sym = COD.findSymbol("foo", true);
+
+ EXPECT_TRUE(!!Sym) << "CompileOnDemand::findSymbol should call findSymbol in "
+ "the base layer.";
+}
+}