From 19f0f50d66e48b3e00ccb7e87700e6eff1b5e56a Mon Sep 17 00:00:00 2001 From: Lang Hames Date: Wed, 17 Jul 2019 16:40:52 +0000 Subject: [PATCH] [ORC] Add deprecation warnings to ORCv1 layers and utilities. Summary: ORCv1 is deprecated. The current aim is to remove it before the LLVM 10.0 release. This patch adds deprecation attributes to the ORCv1 layers and utilities to warn clients of the change. Reviewers: dblaikie, sgraenitz, AlexDenisov Subscribers: llvm-commits Tags: #llvm Differential Revision: https://reviews.llvm.org/D64609 git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@366344 91177308-0d34-0410-b5e6-96231b3b80d8 --- .../BuildingAJIT/Chapter3/KaleidoscopeJIT.h | 26 ++++---- .../BuildingAJIT/Chapter4/KaleidoscopeJIT.h | 7 +- .../BuildingAJIT/Chapter5/KaleidoscopeJIT.h | 7 +- .../Kaleidoscope/include/KaleidoscopeJIT.h | 9 ++- .../llvm/ExecutionEngine/ExecutionEngine.h | 13 +++- .../Orc/CompileOnDemandLayer.h | 45 ++++++++++--- include/llvm/ExecutionEngine/Orc/Core.h | 1 + .../llvm/ExecutionEngine/Orc/ExecutionUtils.h | 30 ++++++++- .../llvm/ExecutionEngine/Orc/IRCompileLayer.h | 20 +++++- .../ExecutionEngine/Orc/IRTransformLayer.h | 19 +++++- .../llvm/ExecutionEngine/Orc/LambdaResolver.h | 27 +++++++- .../ExecutionEngine/Orc/LazyEmittingLayer.h | 13 +++- .../Orc/ObjectTransformLayer.h | 16 ++++- .../Orc/RTDyldObjectLinkingLayer.h | 18 ++++-- .../ExecutionEngine/Orc/RemoteObjectLayer.h | 53 +++++++++++++-- .../llvm/ExecutionEngine/OrcV1Deprecation.h | 22 +++++++ lib/ExecutionEngine/Orc/OrcCBindingsStack.h | 46 +++++++------ .../Orc/OrcMCJITReplacement.cpp | 3 +- lib/ExecutionEngine/Orc/OrcMCJITReplacement.h | 10 +-- .../Orc/RTDyldObjectLinkingLayer.cpp | 9 +++ tools/lli/lli.cpp | 25 ++++---- .../Orc/LazyEmittingLayerTest.cpp | 3 +- .../Orc/LegacyCompileOnDemandLayerTest.cpp | 2 +- .../LegacyRTDyldObjectLinkingLayerTest.cpp | 35 +++++----- .../Orc/ObjectTransformLayerTest.cpp | 33 ++++++---- .../Orc/RemoteObjectLayerTest.cpp | 64 +++++++++---------- 26 files changed, 400 insertions(+), 156 deletions(-) create mode 100644 include/llvm/ExecutionEngine/OrcV1Deprecation.h diff --git a/examples/Kaleidoscope/BuildingAJIT/Chapter3/KaleidoscopeJIT.h b/examples/Kaleidoscope/BuildingAJIT/Chapter3/KaleidoscopeJIT.h index 717fbb7d995..35104f926d4 100644 --- a/examples/Kaleidoscope/BuildingAJIT/Chapter3/KaleidoscopeJIT.h +++ b/examples/Kaleidoscope/BuildingAJIT/Chapter3/KaleidoscopeJIT.h @@ -64,28 +64,30 @@ private: public: KaleidoscopeJIT() : TM(EngineBuilder().selectTarget()), DL(TM->createDataLayout()), - ObjectLayer(ES, + ObjectLayer(AcknowledgeORCv1Deprecation, ES, [this](VModuleKey K) { return LegacyRTDyldObjectLinkingLayer::Resources{ std::make_shared(), Resolvers[K]}; }), - CompileLayer(ObjectLayer, SimpleCompiler(*TM)), - OptimizeLayer(CompileLayer, + CompileLayer(AcknowledgeORCv1Deprecation, ObjectLayer, + SimpleCompiler(*TM)), + OptimizeLayer(AcknowledgeORCv1Deprecation, CompileLayer, [this](std::unique_ptr M) { return optimizeModule(std::move(M)); }), CompileCallbackManager(cantFail(orc::createLocalCompileCallbackManager( TM->getTargetTriple(), ES, 0))), - CODLayer(ES, OptimizeLayer, - [&](orc::VModuleKey K) { return Resolvers[K]; }, - [&](orc::VModuleKey K, std::shared_ptr R) { - Resolvers[K] = std::move(R); - }, - [](Function &F) { return std::set({&F}); }, - *CompileCallbackManager, - orc::createLocalIndirectStubsManagerBuilder( - TM->getTargetTriple())) { + CODLayer( + AcknowledgeORCv1Deprecation, ES, OptimizeLayer, + [&](orc::VModuleKey K) { return Resolvers[K]; }, + [&](orc::VModuleKey K, std::shared_ptr R) { + Resolvers[K] = std::move(R); + }, + [](Function &F) { return std::set({&F}); }, + *CompileCallbackManager, + orc::createLocalIndirectStubsManagerBuilder( + TM->getTargetTriple())) { llvm::sys::DynamicLibrary::LoadLibraryPermanently(nullptr); } diff --git a/examples/Kaleidoscope/BuildingAJIT/Chapter4/KaleidoscopeJIT.h b/examples/Kaleidoscope/BuildingAJIT/Chapter4/KaleidoscopeJIT.h index 3cf521ce2be..ee5225672fc 100644 --- a/examples/Kaleidoscope/BuildingAJIT/Chapter4/KaleidoscopeJIT.h +++ b/examples/Kaleidoscope/BuildingAJIT/Chapter4/KaleidoscopeJIT.h @@ -105,13 +105,14 @@ public: }, [](Error Err) { cantFail(std::move(Err), "lookupFlags failed"); })), TM(EngineBuilder().selectTarget()), DL(TM->createDataLayout()), - ObjectLayer(ES, + ObjectLayer(AcknowledgeORCv1Deprecation, ES, [this](VModuleKey K) { return LegacyRTDyldObjectLinkingLayer::Resources{ std::make_shared(), Resolver}; }), - CompileLayer(ObjectLayer, SimpleCompiler(*TM)), - OptimizeLayer(CompileLayer, + CompileLayer(AcknowledgeORCv1Deprecation, ObjectLayer, + SimpleCompiler(*TM)), + OptimizeLayer(AcknowledgeORCv1Deprecation, CompileLayer, [this](std::unique_ptr M) { return optimizeModule(std::move(M)); }), diff --git a/examples/Kaleidoscope/BuildingAJIT/Chapter5/KaleidoscopeJIT.h b/examples/Kaleidoscope/BuildingAJIT/Chapter5/KaleidoscopeJIT.h index d6c9d12c538..5cc64da68cc 100644 --- a/examples/Kaleidoscope/BuildingAJIT/Chapter5/KaleidoscopeJIT.h +++ b/examples/Kaleidoscope/BuildingAJIT/Chapter5/KaleidoscopeJIT.h @@ -113,14 +113,15 @@ public: TM(EngineBuilder().selectTarget(Triple(Remote.getTargetTriple()), "", "", SmallVector())), DL(TM->createDataLayout()), - ObjectLayer(ES, + ObjectLayer(AcknowledgeORCv1Deprecation, ES, [this](VModuleKey K) { return LegacyRTDyldObjectLinkingLayer::Resources{ cantFail(this->Remote.createRemoteMemoryManager()), Resolver}; }), - CompileLayer(ObjectLayer, SimpleCompiler(*TM)), - OptimizeLayer(CompileLayer, + CompileLayer(AcknowledgeORCv1Deprecation, ObjectLayer, + SimpleCompiler(*TM)), + OptimizeLayer(AcknowledgeORCv1Deprecation, CompileLayer, [this](std::unique_ptr M) { return optimizeModule(std::move(M)); }), diff --git a/examples/Kaleidoscope/include/KaleidoscopeJIT.h b/examples/Kaleidoscope/include/KaleidoscopeJIT.h index 162dcfed989..a253a973a4c 100644 --- a/examples/Kaleidoscope/include/KaleidoscopeJIT.h +++ b/examples/Kaleidoscope/include/KaleidoscopeJIT.h @@ -45,17 +45,16 @@ public: KaleidoscopeJIT() : Resolver(createLegacyLookupResolver( ES, - [this](const std::string &Name) { - return findMangledSymbol(Name); - }, + [this](const std::string &Name) { return findMangledSymbol(Name); }, [](Error Err) { cantFail(std::move(Err), "lookupFlags failed"); })), TM(EngineBuilder().selectTarget()), DL(TM->createDataLayout()), - ObjectLayer(ES, + ObjectLayer(AcknowledgeORCv1Deprecation, ES, [this](VModuleKey) { return ObjLayerT::Resources{ std::make_shared(), Resolver}; }), - CompileLayer(ObjectLayer, SimpleCompiler(*TM)) { + CompileLayer(AcknowledgeORCv1Deprecation, ObjectLayer, + SimpleCompiler(*TM)) { llvm::sys::DynamicLibrary::LoadLibraryPermanently(nullptr); } diff --git a/include/llvm/ExecutionEngine/ExecutionEngine.h b/include/llvm/ExecutionEngine/ExecutionEngine.h index 68cc920483b..4fb6dad9638 100644 --- a/include/llvm/ExecutionEngine/ExecutionEngine.h +++ b/include/llvm/ExecutionEngine/ExecutionEngine.h @@ -21,6 +21,7 @@ #include "llvm/ADT/StringMap.h" #include "llvm/ADT/StringRef.h" #include "llvm/ExecutionEngine/JITSymbol.h" +#include "llvm/ExecutionEngine/OrcV1Deprecation.h" #include "llvm/IR/DataLayout.h" #include "llvm/IR/Module.h" #include "llvm/Object/Binary.h" @@ -634,7 +635,13 @@ public: } // Use OrcMCJITReplacement instead of MCJIT. Off by default. - void setUseOrcMCJITReplacement(bool UseOrcMCJITReplacement) { + LLVM_ATTRIBUTE_DEPRECATED( + inline void setUseOrcMCJITReplacement(bool UseOrcMCJITReplacement), + "ORCv1 utilities (including OrcMCJITReplacement) are deprecated. Please " + "use ORCv2/LLJIT instead (see docs/ORCv2.rst)"); + + void setUseOrcMCJITReplacement(ORCv1DeprecationAcknowledgement, + bool UseOrcMCJITReplacement) { this->UseOrcMCJITReplacement = UseOrcMCJITReplacement; } @@ -658,6 +665,10 @@ public: ExecutionEngine *create(TargetMachine *TM); }; +void EngineBuilder::setUseOrcMCJITReplacement(bool UseOrcMCJITReplacement) { + this->UseOrcMCJITReplacement = UseOrcMCJITReplacement; +} + // Create wrappers for C Binding types (see CBindingWrapping.h). DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ExecutionEngine, LLVMExecutionEngineRef) diff --git a/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h b/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h index ca1ce40cdae..5f593a27cad 100644 --- a/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h +++ b/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h @@ -264,13 +264,26 @@ public: std::function R)>; /// Construct a compile-on-demand layer instance. - LegacyCompileOnDemandLayer(ExecutionSession &ES, BaseLayerT &BaseLayer, - SymbolResolverGetter GetSymbolResolver, - SymbolResolverSetter SetSymbolResolver, - PartitioningFtor Partition, - CompileCallbackMgrT &CallbackMgr, - IndirectStubsManagerBuilderT CreateIndirectStubsManager, - bool CloneStubsIntoPartitions = true) + LLVM_ATTRIBUTE_DEPRECATED( + LegacyCompileOnDemandLayer( + ExecutionSession &ES, BaseLayerT &BaseLayer, + SymbolResolverGetter GetSymbolResolver, + SymbolResolverSetter SetSymbolResolver, PartitioningFtor Partition, + CompileCallbackMgrT &CallbackMgr, + IndirectStubsManagerBuilderT CreateIndirectStubsManager, + bool CloneStubsIntoPartitions = true), + "ORCv1 layers (layers with the 'Legacy' prefix) are deprecated. Please " + "use " + "the ORCv2 LegacyCompileOnDemandLayer instead"); + + /// Legacy layer constructor with deprecation acknowledgement. + LegacyCompileOnDemandLayer( + ORCv1DeprecationAcknowledgement, ExecutionSession &ES, + BaseLayerT &BaseLayer, SymbolResolverGetter GetSymbolResolver, + SymbolResolverSetter SetSymbolResolver, PartitioningFtor Partition, + CompileCallbackMgrT &CallbackMgr, + IndirectStubsManagerBuilderT CreateIndirectStubsManager, + bool CloneStubsIntoPartitions = true) : ES(ES), BaseLayer(BaseLayer), GetSymbolResolver(std::move(GetSymbolResolver)), SetSymbolResolver(std::move(SetSymbolResolver)), @@ -729,8 +742,24 @@ private: bool CloneStubsIntoPartitions; }; -} // end namespace orc +template +LegacyCompileOnDemandLayer:: + LegacyCompileOnDemandLayer( + ExecutionSession &ES, BaseLayerT &BaseLayer, + SymbolResolverGetter GetSymbolResolver, + SymbolResolverSetter SetSymbolResolver, PartitioningFtor Partition, + CompileCallbackMgrT &CallbackMgr, + IndirectStubsManagerBuilderT CreateIndirectStubsManager, + bool CloneStubsIntoPartitions) + : ES(ES), BaseLayer(BaseLayer), + GetSymbolResolver(std::move(GetSymbolResolver)), + SetSymbolResolver(std::move(SetSymbolResolver)), + Partition(std::move(Partition)), CompileCallbackMgr(CallbackMgr), + CreateIndirectStubsManager(std::move(CreateIndirectStubsManager)), + CloneStubsIntoPartitions(CloneStubsIntoPartitions) {} +} // end namespace orc } // end namespace llvm #endif // LLVM_EXECUTIONENGINE_ORC_COMPILEONDEMANDLAYER_H diff --git a/include/llvm/ExecutionEngine/Orc/Core.h b/include/llvm/ExecutionEngine/Orc/Core.h index 016fd829bf9..94a5618233e 100644 --- a/include/llvm/ExecutionEngine/Orc/Core.h +++ b/include/llvm/ExecutionEngine/Orc/Core.h @@ -16,6 +16,7 @@ #include "llvm/ADT/BitmaskEnum.h" #include "llvm/ExecutionEngine/JITSymbol.h" #include "llvm/ExecutionEngine/Orc/SymbolStringPool.h" +#include "llvm/ExecutionEngine/OrcV1Deprecation.h" #include "llvm/IR/Module.h" #include "llvm/Support/Debug.h" diff --git a/include/llvm/ExecutionEngine/Orc/ExecutionUtils.h b/include/llvm/ExecutionEngine/Orc/ExecutionUtils.h index ae3ab8c095f..75865920c74 100644 --- a/include/llvm/ExecutionEngine/Orc/ExecutionUtils.h +++ b/include/llvm/ExecutionEngine/Orc/ExecutionUtils.h @@ -97,7 +97,14 @@ class LegacyCtorDtorRunner { public: /// Construct a CtorDtorRunner for the given range using the given /// name mangling function. - LegacyCtorDtorRunner(std::vector CtorDtorNames, VModuleKey K) + LLVM_ATTRIBUTE_DEPRECATED( + LegacyCtorDtorRunner(std::vector CtorDtorNames, + VModuleKey K), + "ORCv1 utilities (utilities with the 'Legacy' prefix) are deprecated. " + "Please use the ORCv2 CtorDtorRunner utility instead"); + + LegacyCtorDtorRunner(ORCv1DeprecationAcknowledgement, + std::vector CtorDtorNames, VModuleKey K) : CtorDtorNames(std::move(CtorDtorNames)), K(K) {} /// Run the recorded constructors/destructors through the given JIT @@ -128,6 +135,11 @@ private: orc::VModuleKey K; }; +template +LegacyCtorDtorRunner::LegacyCtorDtorRunner( + std::vector CtorDtorNames, VModuleKey K) + : CtorDtorNames(std::move(CtorDtorNames)), K(K) {} + class CtorDtorRunner { public: CtorDtorRunner(JITDylib &JD) : JD(JD) {} @@ -180,7 +192,14 @@ class LegacyLocalCXXRuntimeOverrides : public LocalCXXRuntimeOverridesBase { public: /// Create a runtime-overrides class. template - LegacyLocalCXXRuntimeOverrides(const MangleFtorT &Mangle) { + LLVM_ATTRIBUTE_DEPRECATED( + LegacyLocalCXXRuntimeOverrides(const MangleFtorT &Mangle), + "ORCv1 utilities (utilities with the 'Legacy' prefix) are deprecated. " + "Please use the ORCv2 LocalCXXRuntimeOverrides utility instead"); + + template + LegacyLocalCXXRuntimeOverrides(ORCv1DeprecationAcknowledgement, + const MangleFtorT &Mangle) { addOverride(Mangle("__dso_handle"), toTargetAddress(&DSOHandleOverride)); addOverride(Mangle("__cxa_atexit"), toTargetAddress(&CXAAtExitOverride)); } @@ -201,6 +220,13 @@ private: StringMap CXXRuntimeOverrides; }; +template +LegacyLocalCXXRuntimeOverrides::LegacyLocalCXXRuntimeOverrides( + const MangleFtorT &Mangle) { + addOverride(Mangle("__dso_handle"), toTargetAddress(&DSOHandleOverride)); + addOverride(Mangle("__cxa_atexit"), toTargetAddress(&CXAAtExitOverride)); +} + class LocalCXXRuntimeOverrides : public LocalCXXRuntimeOverridesBase { public: Error enable(JITDylib &JD, MangleAndInterner &Mangler); diff --git a/include/llvm/ExecutionEngine/Orc/IRCompileLayer.h b/include/llvm/ExecutionEngine/Orc/IRCompileLayer.h index ecff09b98f8..52223a83ad4 100644 --- a/include/llvm/ExecutionEngine/Orc/IRCompileLayer.h +++ b/include/llvm/ExecutionEngine/Orc/IRCompileLayer.h @@ -63,8 +63,18 @@ public: /// Construct an LegacyIRCompileLayer with the given BaseLayer, which must /// implement the ObjectLayer concept. + LLVM_ATTRIBUTE_DEPRECATED( + LegacyIRCompileLayer( + BaseLayerT &BaseLayer, CompileFtor Compile, + NotifyCompiledCallback NotifyCompiled = NotifyCompiledCallback()), + "ORCv1 layers (layers with the 'Legacy' prefix) are deprecated. Please " + "use " + "the ORCv2 IRCompileLayer instead"); + + /// Legacy layer constructor with deprecation acknowledgement. LegacyIRCompileLayer( - BaseLayerT &BaseLayer, CompileFtor Compile, + ORCv1DeprecationAcknowledgement, BaseLayerT &BaseLayer, + CompileFtor Compile, NotifyCompiledCallback NotifyCompiled = NotifyCompiledCallback()) : BaseLayer(BaseLayer), Compile(std::move(Compile)), NotifyCompiled(std::move(NotifyCompiled)) {} @@ -122,8 +132,14 @@ private: NotifyCompiledCallback NotifyCompiled; }; -} // end namespace orc +template +LegacyIRCompileLayer::LegacyIRCompileLayer( + BaseLayerT &BaseLayer, CompileFtor Compile, + NotifyCompiledCallback NotifyCompiled) + : BaseLayer(BaseLayer), Compile(std::move(Compile)), + NotifyCompiled(std::move(NotifyCompiled)) {} +} // end namespace orc } // end namespace llvm #endif // LLVM_EXECUTIONENGINE_ORC_IRCOMPILINGLAYER_H diff --git a/include/llvm/ExecutionEngine/Orc/IRTransformLayer.h b/include/llvm/ExecutionEngine/Orc/IRTransformLayer.h index 8890a572f65..1b4c8b6cd95 100644 --- a/include/llvm/ExecutionEngine/Orc/IRTransformLayer.h +++ b/include/llvm/ExecutionEngine/Orc/IRTransformLayer.h @@ -56,9 +56,17 @@ class LegacyIRTransformLayer { public: /// Construct an LegacyIRTransformLayer with the given BaseLayer - LegacyIRTransformLayer(BaseLayerT &BaseLayer, - TransformFtor Transform = TransformFtor()) - : BaseLayer(BaseLayer), Transform(std::move(Transform)) {} + LLVM_ATTRIBUTE_DEPRECATED( + LegacyIRTransformLayer(BaseLayerT &BaseLayer, + TransformFtor Transform = TransformFtor()), + "ORCv1 layers (layers with the 'Legacy' prefix) are deprecated. Please " + "use " + "the ORCv2 IRTransformLayer instead"); + + /// Legacy layer constructor with deprecation acknowledgement. + LegacyIRTransformLayer(ORCv1DeprecationAcknowledgement, BaseLayerT &BaseLayer, + TransformFtor Transform = TransformFtor()) + : BaseLayer(BaseLayer), Transform(std::move(Transform)) {} /// Apply the transform functor to the module, then add the module to /// the layer below, along with the memory manager and symbol resolver. @@ -108,6 +116,11 @@ private: TransformFtor Transform; }; +template +LegacyIRTransformLayer::LegacyIRTransformLayer( + BaseLayerT &BaseLayer, TransformFtor Transform) + : BaseLayer(BaseLayer), Transform(std::move(Transform)) {} + } // end namespace orc } // end namespace llvm diff --git a/include/llvm/ExecutionEngine/Orc/LambdaResolver.h b/include/llvm/ExecutionEngine/Orc/LambdaResolver.h index 92efdeded36..855e31b3354 100644 --- a/include/llvm/ExecutionEngine/Orc/LambdaResolver.h +++ b/include/llvm/ExecutionEngine/Orc/LambdaResolver.h @@ -24,7 +24,15 @@ namespace orc { template class LambdaResolver : public LegacyJITSymbolResolver { public: - LambdaResolver(DylibLookupFtorT DylibLookupFtor, + LLVM_ATTRIBUTE_DEPRECATED( + LambdaResolver(DylibLookupFtorT DylibLookupFtor, + ExternalLookupFtorT ExternalLookupFtor), + "ORCv1 utilities (including resolvers) are deprecated and will be " + "removed " + "in the next release. Please use ORCv2 (see docs/ORCv2.rst)"); + + LambdaResolver(ORCv1DeprecationAcknowledgement, + DylibLookupFtorT DylibLookupFtor, ExternalLookupFtorT ExternalLookupFtor) : DylibLookupFtor(DylibLookupFtor), ExternalLookupFtor(ExternalLookupFtor) {} @@ -42,6 +50,12 @@ private: ExternalLookupFtorT ExternalLookupFtor; }; +template +LambdaResolver::LambdaResolver( + DylibLookupFtorT DylibLookupFtor, ExternalLookupFtorT ExternalLookupFtor) + : DylibLookupFtor(DylibLookupFtor), ExternalLookupFtor(ExternalLookupFtor) { +} + template std::shared_ptr> @@ -52,6 +66,17 @@ createLambdaResolver(DylibLookupFtorT DylibLookupFtor, std::move(ExternalLookupFtor)); } +template +std::shared_ptr> +createLambdaResolver(ORCv1DeprecationAcknowledgement, + DylibLookupFtorT DylibLookupFtor, + ExternalLookupFtorT ExternalLookupFtor) { + using LR = LambdaResolver; + return make_unique(AcknowledgeORCv1Deprecation, + std::move(DylibLookupFtor), + std::move(ExternalLookupFtor)); +} + } // end namespace orc } // end namespace llvm diff --git a/include/llvm/ExecutionEngine/Orc/LazyEmittingLayer.h b/include/llvm/ExecutionEngine/Orc/LazyEmittingLayer.h index e5c5feb2281..16202d89f86 100644 --- a/include/llvm/ExecutionEngine/Orc/LazyEmittingLayer.h +++ b/include/llvm/ExecutionEngine/Orc/LazyEmittingLayer.h @@ -196,7 +196,14 @@ private: public: /// Construct a lazy emitting layer. - LazyEmittingLayer(BaseLayerT &BaseLayer) : BaseLayer(BaseLayer) {} + LLVM_ATTRIBUTE_DEPRECATED( + LazyEmittingLayer(BaseLayerT &BaseLayer), + "ORCv1 layers (including LazyEmittingLayer) are deprecated. Please use " + "ORCv2, where lazy emission is the default"); + + /// Construct a lazy emitting layer. + LazyEmittingLayer(ORCv1DeprecationAcknowledgement, BaseLayerT &BaseLayer) + : BaseLayer(BaseLayer) {} /// Add the given module to the lazy emitting layer. Error addModule(VModuleKey K, std::unique_ptr M) { @@ -254,6 +261,10 @@ public: } }; +template +LazyEmittingLayer::LazyEmittingLayer(BaseLayerT &BaseLayer) + : BaseLayer(BaseLayer) {} + } // end namespace orc } // end namespace llvm diff --git a/include/llvm/ExecutionEngine/Orc/ObjectTransformLayer.h b/include/llvm/ExecutionEngine/Orc/ObjectTransformLayer.h index de4603f98f8..eac1cc3e097 100644 --- a/include/llvm/ExecutionEngine/Orc/ObjectTransformLayer.h +++ b/include/llvm/ExecutionEngine/Orc/ObjectTransformLayer.h @@ -48,7 +48,16 @@ template class LegacyObjectTransformLayer { public: /// Construct an ObjectTransformLayer with the given BaseLayer - LegacyObjectTransformLayer(BaseLayerT &BaseLayer, + LLVM_ATTRIBUTE_DEPRECATED( + LegacyObjectTransformLayer(BaseLayerT &BaseLayer, + TransformFtor Transform = TransformFtor()), + "ORCv1 layers (layers with the 'Legacy' prefix) are deprecated. Please " + "use " + "the ORCv2 ObjectTransformLayer instead"); + + /// Legacy layer constructor with deprecation acknowledgement. + LegacyObjectTransformLayer(ORCv1DeprecationAcknowledgement, + BaseLayerT &BaseLayer, TransformFtor Transform = TransformFtor()) : BaseLayer(BaseLayer), Transform(std::move(Transform)) {} @@ -107,6 +116,11 @@ private: TransformFtor Transform; }; +template +LegacyObjectTransformLayer:: + LegacyObjectTransformLayer(BaseLayerT &BaseLayer, TransformFtor Transform) + : BaseLayer(BaseLayer), Transform(std::move(Transform)) {} + } // end namespace orc } // end namespace llvm diff --git a/include/llvm/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.h b/include/llvm/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.h index 479658b11e9..d9535ce5f21 100644 --- a/include/llvm/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.h +++ b/include/llvm/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.h @@ -353,17 +353,27 @@ public: /// Construct an ObjectLinkingLayer with the given NotifyLoaded, /// and NotifyFinalized functors. + LLVM_ATTRIBUTE_DEPRECATED( + LegacyRTDyldObjectLinkingLayer( + ExecutionSession &ES, ResourcesGetter GetResources, + NotifyLoadedFtor NotifyLoaded = NotifyLoadedFtor(), + NotifyFinalizedFtor NotifyFinalized = NotifyFinalizedFtor(), + NotifyFreedFtor NotifyFreed = NotifyFreedFtor()), + "ORCv1 layers (layers with the 'Legacy' prefix) are deprecated. Please " + "use " + "ORCv2 (see docs/ORCv2.rst)"); + + // Legacy layer constructor with deprecation acknowledgement. LegacyRTDyldObjectLinkingLayer( - ExecutionSession &ES, ResourcesGetter GetResources, + ORCv1DeprecationAcknowledgement, ExecutionSession &ES, + ResourcesGetter GetResources, NotifyLoadedFtor NotifyLoaded = NotifyLoadedFtor(), NotifyFinalizedFtor NotifyFinalized = NotifyFinalizedFtor(), NotifyFreedFtor NotifyFreed = NotifyFreedFtor()) : ES(ES), GetResources(std::move(GetResources)), NotifyLoaded(std::move(NotifyLoaded)), NotifyFinalized(std::move(NotifyFinalized)), - NotifyFreed(std::move(NotifyFreed)), - ProcessAllSections(false) { - } + NotifyFreed(std::move(NotifyFreed)), ProcessAllSections(false) {} /// Set the 'ProcessAllSections' flag. /// diff --git a/include/llvm/ExecutionEngine/Orc/RemoteObjectLayer.h b/include/llvm/ExecutionEngine/Orc/RemoteObjectLayer.h index 9550edceb10..b87cf697a81 100644 --- a/include/llvm/ExecutionEngine/Orc/RemoteObjectLayer.h +++ b/include/llvm/ExecutionEngine/Orc/RemoteObjectLayer.h @@ -13,9 +13,10 @@ #ifndef LLVM_EXECUTIONENGINE_ORC_REMOTEOBJECTLAYER_H #define LLVM_EXECUTIONENGINE_ORC_REMOTEOBJECTLAYER_H +#include "llvm/ExecutionEngine/Orc/Core.h" +#include "llvm/ExecutionEngine/Orc/LambdaResolver.h" #include "llvm/ExecutionEngine/Orc/OrcRemoteTargetRPCAPI.h" #include "llvm/Object/ObjectFile.h" -#include "llvm/ExecutionEngine/Orc/LambdaResolver.h" #include namespace llvm { @@ -312,7 +313,14 @@ public: /// /// The ReportError functor can be used locally log errors that are intended /// to be sent sent - RemoteObjectClientLayer(RPCEndpoint &Remote, + LLVM_ATTRIBUTE_DEPRECATED( + RemoteObjectClientLayer(RPCEndpoint &Remote, + std::function ReportError), + "ORCv1 layers (including RemoteObjectClientLayer) are deprecated. Please " + "use " + "ORCv2 (see docs/ORCv2.rst)"); + + RemoteObjectClientLayer(ORCv1DeprecationAcknowledgement, RPCEndpoint &Remote, std::function ReportError) : RemoteObjectLayer(Remote, std::move(ReportError)) { using ThisT = RemoteObjectClientLayer; @@ -417,11 +425,18 @@ public: /// Create a RemoteObjectServerLayer with the given base layer (which must be /// an object layer), RPC endpoint, and error reporter function. - RemoteObjectServerLayer(BaseLayerT &BaseLayer, - RPCEndpoint &Remote, + LLVM_ATTRIBUTE_DEPRECATED( + RemoteObjectServerLayer(BaseLayerT &BaseLayer, RPCEndpoint &Remote, + std::function ReportError), + "ORCv1 layers (including RemoteObjectServerLayer) are deprecated. Please " + "use " + "ORCv2 (see docs/ORCv2.rst)"); + + RemoteObjectServerLayer(ORCv1DeprecationAcknowledgement, + BaseLayerT &BaseLayer, RPCEndpoint &Remote, std::function ReportError) - : RemoteObjectLayer(Remote, std::move(ReportError)), - BaseLayer(BaseLayer), HandleIdMgr(1) { + : RemoteObjectLayer(Remote, std::move(ReportError)), + BaseLayer(BaseLayer), HandleIdMgr(1) { using ThisT = RemoteObjectServerLayer; Remote.template addHandler(*this, &ThisT::addObject); @@ -462,6 +477,7 @@ private: assert(!BaseLayerHandles.count(Id) && "Id already in use?"); auto Resolver = createLambdaResolver( + AcknowledgeORCv1Deprecation, [this, Id](const std::string &Name) { return lookup(Id, Name); }, [this, Id](const std::string &Name) { return lookupInLogicalDylib(Id, Name); @@ -522,6 +538,31 @@ private: std::map BaseLayerHandles; }; +template +RemoteObjectClientLayer::RemoteObjectClientLayer( + RPCEndpoint &Remote, std::function ReportError) + : RemoteObjectLayer(Remote, std::move(ReportError)) { + using ThisT = RemoteObjectClientLayer; + Remote.template addHandler(*this, &ThisT::lookup); + Remote.template addHandler( + *this, &ThisT::lookupInLogicalDylib); +} + +template +RemoteObjectServerLayer::RemoteObjectServerLayer( + BaseLayerT &BaseLayer, RPCEndpoint &Remote, + std::function ReportError) + : RemoteObjectLayer(Remote, std::move(ReportError)), + BaseLayer(BaseLayer), HandleIdMgr(1) { + using ThisT = RemoteObjectServerLayer; + + Remote.template addHandler(*this, &ThisT::addObject); + Remote.template addHandler(*this, &ThisT::removeObject); + Remote.template addHandler(*this, &ThisT::findSymbol); + Remote.template addHandler(*this, &ThisT::findSymbolIn); + Remote.template addHandler(*this, &ThisT::emitAndFinalize); +} + } // end namespace orc } // end namespace llvm diff --git a/include/llvm/ExecutionEngine/OrcV1Deprecation.h b/include/llvm/ExecutionEngine/OrcV1Deprecation.h new file mode 100644 index 00000000000..7ed254b3ee0 --- /dev/null +++ b/include/llvm/ExecutionEngine/OrcV1Deprecation.h @@ -0,0 +1,22 @@ +//===------ OrcV1Deprecation.h - Memory manager for MC-JIT ------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// +// +// Tag for suppressing ORCv1 deprecation warnings. +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_EXECUTIONENGINE_ORCV1DEPRECATION_H +#define LLVM_EXECUTIONENGINE_ORCV1DEPRECATION_H + +namespace llvm { + +enum ORCv1DeprecationAcknowledgement { AcknowledgeORCv1Deprecation }; + +} // namespace llvm + +#endif // LLVM_EXECUTIONENGINE_ORCV1DEPRECATION_H diff --git a/lib/ExecutionEngine/Orc/OrcCBindingsStack.h b/lib/ExecutionEngine/Orc/OrcCBindingsStack.h index 71f05b0e806..98129e1690d 100644 --- a/lib/ExecutionEngine/Orc/OrcCBindingsStack.h +++ b/lib/ExecutionEngine/Orc/OrcCBindingsStack.h @@ -211,28 +211,31 @@ public: IndirectStubsManagerBuilder IndirectStubsMgrBuilder) : CCMgr(createCompileCallbackManager(TM, ES)), DL(TM.createDataLayout()), IndirectStubsMgr(IndirectStubsMgrBuilder()), - ObjectLayer(ES, - [this](orc::VModuleKey K) { - auto ResolverI = Resolvers.find(K); - assert(ResolverI != Resolvers.end() && - "No resolver for module K"); - auto Resolver = std::move(ResolverI->second); - Resolvers.erase(ResolverI); - return ObjLayerT::Resources{ - std::make_shared(), Resolver}; - }, - nullptr, - [this](orc::VModuleKey K, const object::ObjectFile &Obj, - const RuntimeDyld::LoadedObjectInfo &LoadedObjInfo) { - this->notifyFinalized(K, Obj, LoadedObjInfo); - }, - [this](orc::VModuleKey K, const object::ObjectFile &Obj) { - this->notifyFreed(K, Obj); - }), - CompileLayer(ObjectLayer, orc::SimpleCompiler(TM)), + ObjectLayer( + AcknowledgeORCv1Deprecation, ES, + [this](orc::VModuleKey K) { + auto ResolverI = Resolvers.find(K); + assert(ResolverI != Resolvers.end() && + "No resolver for module K"); + auto Resolver = std::move(ResolverI->second); + Resolvers.erase(ResolverI); + return ObjLayerT::Resources{ + std::make_shared(), Resolver}; + }, + nullptr, + [this](orc::VModuleKey K, const object::ObjectFile &Obj, + const RuntimeDyld::LoadedObjectInfo &LoadedObjInfo) { + this->notifyFinalized(K, Obj, LoadedObjInfo); + }, + [this](orc::VModuleKey K, const object::ObjectFile &Obj) { + this->notifyFreed(K, Obj); + }), + CompileLayer(AcknowledgeORCv1Deprecation, ObjectLayer, + orc::SimpleCompiler(TM)), CODLayer(createCODLayer(ES, CompileLayer, CCMgr.get(), std::move(IndirectStubsMgrBuilder), Resolvers)), CXXRuntimeOverrides( + AcknowledgeORCv1Deprecation, [this](const std::string &S) { return mangle(S); }) {} Error shutdown() { @@ -308,7 +311,8 @@ public: // Run the static constructors, and save the static destructor runner for // execution when the JIT is torn down. - orc::LegacyCtorDtorRunner CtorRunner(std::move(CtorNames), K); + orc::LegacyCtorDtorRunner CtorRunner( + AcknowledgeORCv1Deprecation, std::move(CtorNames), K); if (auto Err = CtorRunner.runViaLayer(*this)) return std::move(Err); @@ -465,7 +469,7 @@ private: return nullptr; return llvm::make_unique( - ES, CompileLayer, + AcknowledgeORCv1Deprecation, ES, CompileLayer, [&Resolvers](orc::VModuleKey K) { auto ResolverI = Resolvers.find(K); assert(ResolverI != Resolvers.end() && "No resolver for module K"); diff --git a/lib/ExecutionEngine/Orc/OrcMCJITReplacement.cpp b/lib/ExecutionEngine/Orc/OrcMCJITReplacement.cpp index 7c56ecc36be..772a9c2c4ab 100644 --- a/lib/ExecutionEngine/Orc/OrcMCJITReplacement.cpp +++ b/lib/ExecutionEngine/Orc/OrcMCJITReplacement.cpp @@ -127,7 +127,8 @@ void OrcMCJITReplacement::runStaticConstructorsDestructors(bool isDtors) { auto &CtorDtorsMap = isDtors ? UnexecutedDestructors : UnexecutedConstructors; for (auto &KV : CtorDtorsMap) - cantFail(LegacyCtorDtorRunner(std::move(KV.second), KV.first) + cantFail(LegacyCtorDtorRunner( + AcknowledgeORCv1Deprecation, std::move(KV.second), KV.first) .runViaLayer(LazyEmitLayer)); CtorDtorsMap.clear(); diff --git a/lib/ExecutionEngine/Orc/OrcMCJITReplacement.h b/lib/ExecutionEngine/Orc/OrcMCJITReplacement.h index 5585008bc8e..169dc8f1d02 100644 --- a/lib/ExecutionEngine/Orc/OrcMCJITReplacement.h +++ b/lib/ExecutionEngine/Orc/OrcMCJITReplacement.h @@ -232,24 +232,24 @@ public: OrcMCJITReplacement(std::shared_ptr MemMgr, std::shared_ptr ClientResolver, std::unique_ptr TM) - : ExecutionEngine(TM->createDataLayout()), - TM(std::move(TM)), + : ExecutionEngine(TM->createDataLayout()), TM(std::move(TM)), MemMgr( std::make_shared(*this, std::move(MemMgr))), Resolver(std::make_shared(*this)), ClientResolver(std::move(ClientResolver)), NotifyObjectLoaded(*this), NotifyFinalized(*this), ObjectLayer( - ES, + AcknowledgeORCv1Deprecation, ES, [this](VModuleKey K) { return ObjectLayerT::Resources{this->MemMgr, this->Resolver}; }, NotifyObjectLoaded, NotifyFinalized), - CompileLayer(ObjectLayer, SimpleCompiler(*this->TM), + CompileLayer(AcknowledgeORCv1Deprecation, ObjectLayer, + SimpleCompiler(*this->TM), [this](VModuleKey K, std::unique_ptr M) { Modules.push_back(std::move(M)); }), - LazyEmitLayer(CompileLayer) {} + LazyEmitLayer(AcknowledgeORCv1Deprecation, CompileLayer) {} static void Register() { OrcMCJITReplacementCtor = createOrcMCJITReplacement; diff --git a/lib/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.cpp b/lib/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.cpp index 054a2a74290..b22ecd5f80a 100644 --- a/lib/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.cpp +++ b/lib/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.cpp @@ -207,5 +207,14 @@ void RTDyldObjectLinkingLayer::onObjEmit( NotifyEmitted(K, std::move(ObjBuffer)); } +LegacyRTDyldObjectLinkingLayer::LegacyRTDyldObjectLinkingLayer( + ExecutionSession &ES, ResourcesGetter GetResources, + NotifyLoadedFtor NotifyLoaded, NotifyFinalizedFtor NotifyFinalized, + NotifyFreedFtor NotifyFreed) + : ES(ES), GetResources(std::move(GetResources)), + NotifyLoaded(std::move(NotifyLoaded)), + NotifyFinalized(std::move(NotifyFinalized)), + NotifyFreed(std::move(NotifyFreed)), ProcessAllSections(false) {} + } // End namespace orc. } // End namespace llvm. diff --git a/tools/lli/lli.cpp b/tools/lli/lli.cpp index fb6cf6ff915..8c8cd88c971 100644 --- a/tools/lli/lli.cpp +++ b/tools/lli/lli.cpp @@ -83,18 +83,15 @@ namespace { cl::desc("Force interpretation: disable JIT"), cl::init(false)); - cl::opt UseJITKind("jit-kind", - cl::desc("Choose underlying JIT kind."), - cl::init(JITKind::MCJIT), - cl::values( - clEnumValN(JITKind::MCJIT, "mcjit", - "MCJIT"), - clEnumValN(JITKind::OrcMCJITReplacement, - "orc-mcjit", - "Orc-based MCJIT replacement"), - clEnumValN(JITKind::OrcLazy, - "orc-lazy", - "Orc-based lazy JIT."))); + cl::opt UseJITKind( + "jit-kind", cl::desc("Choose underlying JIT kind."), + cl::init(JITKind::MCJIT), + cl::values(clEnumValN(JITKind::MCJIT, "mcjit", "MCJIT"), + clEnumValN(JITKind::OrcMCJITReplacement, "orc-mcjit", + "Orc-based MCJIT replacement " + "(deprecated)"), + clEnumValN(JITKind::OrcLazy, "orc-lazy", + "Orc-based lazy JIT."))); cl::opt LazyJITCompileThreads("compile-threads", @@ -419,7 +416,8 @@ int main(int argc, char **argv, char * const *envp) { builder.setEngineKind(ForceInterpreter ? EngineKind::Interpreter : EngineKind::JIT); - builder.setUseOrcMCJITReplacement(UseJITKind == JITKind::OrcMCJITReplacement); + builder.setUseOrcMCJITReplacement(AcknowledgeORCv1Deprecation, + UseJITKind == JITKind::OrcMCJITReplacement); // If we are supposed to override the target triple, do so now. if (!TargetTriple.empty()) @@ -665,6 +663,7 @@ int main(int argc, char **argv, char * const *envp) { // Forward MCJIT's symbol resolution calls to the remote. static_cast(RTDyldMM)->setResolver( orc::createLambdaResolver( + AcknowledgeORCv1Deprecation, [](const std::string &Name) { return nullptr; }, [&](const std::string &Name) { if (auto Addr = ExitOnErr(R->getSymbolAddress(Name))) diff --git a/unittests/ExecutionEngine/Orc/LazyEmittingLayerTest.cpp b/unittests/ExecutionEngine/Orc/LazyEmittingLayerTest.cpp index 88d12cd103a..cc67aa07b80 100644 --- a/unittests/ExecutionEngine/Orc/LazyEmittingLayerTest.cpp +++ b/unittests/ExecutionEngine/Orc/LazyEmittingLayerTest.cpp @@ -22,7 +22,8 @@ struct MockBaseLayer { TEST(LazyEmittingLayerTest, Empty) { MockBaseLayer M; - llvm::orc::LazyEmittingLayer L(M); + llvm::orc::LazyEmittingLayer L( + llvm::AcknowledgeORCv1Deprecation, M); cantFail( L.addModule(llvm::orc::VModuleKey(), std::unique_ptr())); } diff --git a/unittests/ExecutionEngine/Orc/LegacyCompileOnDemandLayerTest.cpp b/unittests/ExecutionEngine/Orc/LegacyCompileOnDemandLayerTest.cpp index 9a526071c84..06b96f9fd38 100644 --- a/unittests/ExecutionEngine/Orc/LegacyCompileOnDemandLayerTest.cpp +++ b/unittests/ExecutionEngine/Orc/LegacyCompileOnDemandLayerTest.cpp @@ -76,7 +76,7 @@ TEST(LegacyCompileOnDemandLayerTest, FindSymbol) { }; llvm::orc::LegacyCompileOnDemandLayer COD( - ES, TestBaseLayer, GetResolver, SetResolver, + AcknowledgeORCv1Deprecation, ES, TestBaseLayer, GetResolver, SetResolver, [](Function &F) { return std::set{&F}; }, CallbackMgr, [] { return llvm::make_unique(); }, true); diff --git a/unittests/ExecutionEngine/Orc/LegacyRTDyldObjectLinkingLayerTest.cpp b/unittests/ExecutionEngine/Orc/LegacyRTDyldObjectLinkingLayerTest.cpp index 04b6f2101b2..001019daa4b 100644 --- a/unittests/ExecutionEngine/Orc/LegacyRTDyldObjectLinkingLayerTest.cpp +++ b/unittests/ExecutionEngine/Orc/LegacyRTDyldObjectLinkingLayerTest.cpp @@ -68,10 +68,11 @@ TEST(LegacyRTDyldObjectLinkingLayerTest, TestSetProcessAllSections) { ExecutionSession ES; - LegacyRTDyldObjectLinkingLayer ObjLayer(ES, [&MM](VModuleKey) { - return LegacyRTDyldObjectLinkingLayer::Resources{ - MM, std::make_shared()}; - }); + LegacyRTDyldObjectLinkingLayer ObjLayer( + AcknowledgeORCv1Deprecation, ES, [&MM](VModuleKey) { + return LegacyRTDyldObjectLinkingLayer::Resources{ + MM, std::make_shared()}; + }); LLVMContext Context; auto M = llvm::make_unique("", Context); @@ -130,13 +131,14 @@ TEST_F(LegacyRTDyldObjectLinkingLayerExecutionTest, NoDuplicateFinalization) { std::map> Resolvers; - LegacyRTDyldObjectLinkingLayer ObjLayer(ES, [&](VModuleKey K) { - auto I = Resolvers.find(K); - assert(I != Resolvers.end() && "Missing resolver"); - auto R = std::move(I->second); - Resolvers.erase(I); - return LegacyRTDyldObjectLinkingLayer::Resources{MM, std::move(R)}; - }); + LegacyRTDyldObjectLinkingLayer ObjLayer( + AcknowledgeORCv1Deprecation, ES, [&](VModuleKey K) { + auto I = Resolvers.find(K); + assert(I != Resolvers.end() && "Missing resolver"); + auto R = std::move(I->second); + Resolvers.erase(I); + return LegacyRTDyldObjectLinkingLayer::Resources{MM, std::move(R)}; + }); SimpleCompiler Compile(*TM); // Create a pair of modules that will trigger recursive finalization: @@ -217,10 +219,11 @@ TEST_F(LegacyRTDyldObjectLinkingLayerExecutionTest, NoPrematureAllocation) { auto MM = std::make_shared(); - LegacyRTDyldObjectLinkingLayer ObjLayer(ES, [&MM](VModuleKey K) { - return LegacyRTDyldObjectLinkingLayer::Resources{ - MM, std::make_shared()}; - }); + LegacyRTDyldObjectLinkingLayer ObjLayer( + AcknowledgeORCv1Deprecation, ES, [&MM](VModuleKey K) { + return LegacyRTDyldObjectLinkingLayer::Resources{ + MM, std::make_shared()}; + }); SimpleCompiler Compile(*TM); // Create a pair of unrelated modules: @@ -278,7 +281,7 @@ TEST_F(LegacyRTDyldObjectLinkingLayerExecutionTest, NoPrematureAllocation) { TEST_F(LegacyRTDyldObjectLinkingLayerExecutionTest, TestNotifyLoadedSignature) { ExecutionSession ES; LegacyRTDyldObjectLinkingLayer ObjLayer( - ES, + AcknowledgeORCv1Deprecation, ES, [](VModuleKey) { return LegacyRTDyldObjectLinkingLayer::Resources{ nullptr, std::make_shared()}; diff --git a/unittests/ExecutionEngine/Orc/ObjectTransformLayerTest.cpp b/unittests/ExecutionEngine/Orc/ObjectTransformLayerTest.cpp index 2b6b5a7670d..2ff7e91a732 100644 --- a/unittests/ExecutionEngine/Orc/ObjectTransformLayerTest.cpp +++ b/unittests/ExecutionEngine/Orc/ObjectTransformLayerTest.cpp @@ -182,17 +182,19 @@ TEST(LegacyObjectTransformLayerTest, Main) { // Create one object transform layer using a transform (as a functor) // that allocates new objects, and deals in unique pointers. - LegacyObjectTransformLayer T1(M); + LegacyObjectTransformLayer T1( + llvm::AcknowledgeORCv1Deprecation, M); // Create a second object transform layer using a transform (as a lambda) // that mutates objects in place, and deals in naked pointers LegacyObjectTransformLayer( - std::shared_ptr)>> - T2(M, [](std::shared_ptr Obj) { - ++(*Obj); - return Obj; - }); + std::function( + std::shared_ptr)>> + T2(llvm::AcknowledgeORCv1Deprecation, M, + [](std::shared_ptr Obj) { + ++(*Obj); + return Obj; + }); // Test addObject with T1 (allocating) auto K1 = ES.allocateVModule(); @@ -281,22 +283,25 @@ TEST(LegacyObjectTransformLayerTest, Main) { }; // Construct the jit layers. - LegacyRTDyldObjectLinkingLayer BaseLayer(ES, [](VModuleKey) { - return LegacyRTDyldObjectLinkingLayer::Resources{ - std::make_shared(), - std::make_shared()}; - }); + LegacyRTDyldObjectLinkingLayer BaseLayer( + llvm::AcknowledgeORCv1Deprecation, ES, [](VModuleKey) { + return LegacyRTDyldObjectLinkingLayer::Resources{ + std::make_shared(), + std::make_shared()}; + }); auto IdentityTransform = [](std::unique_ptr Obj) { return Obj; }; LegacyObjectTransformLayer - TransformLayer(BaseLayer, IdentityTransform); + TransformLayer(llvm::AcknowledgeORCv1Deprecation, BaseLayer, + IdentityTransform); auto NullCompiler = [](llvm::Module &) { return std::unique_ptr(nullptr); }; LegacyIRCompileLayer - CompileLayer(TransformLayer, NullCompiler); + CompileLayer(llvm::AcknowledgeORCv1Deprecation, TransformLayer, + NullCompiler); // Make sure that the calls from LegacyIRCompileLayer to LegacyObjectTransformLayer // compile. diff --git a/unittests/ExecutionEngine/Orc/RemoteObjectLayerTest.cpp b/unittests/ExecutionEngine/Orc/RemoteObjectLayerTest.cpp index cb02a91cb6c..4377d526779 100644 --- a/unittests/ExecutionEngine/Orc/RemoteObjectLayerTest.cpp +++ b/unittests/ExecutionEngine/Orc/RemoteObjectLayerTest.cpp @@ -127,7 +127,8 @@ TEST(RemoteObjectLayer, AddObject) { std::copy(ObjBytes.begin(), ObjBytes.end(), ObjContents.begin()); RPCEndpoint ClientEP(*Channels.first, true); - RemoteObjectClientLayer Client(ClientEP, ReportError); + RemoteObjectClientLayer Client(AcknowledgeORCv1Deprecation, + ClientEP, ReportError); RPCEndpoint ServerEP(*Channels.second, true); MockObjectLayer BaseLayer( @@ -144,9 +145,8 @@ TEST(RemoteObjectLayer, AddObject) { return 1; }); - RemoteObjectServerLayer Server(BaseLayer, - ServerEP, - ReportError); + RemoteObjectServerLayer Server( + AcknowledgeORCv1Deprecation, BaseLayer, ServerEP, ReportError); bool Finished = false; ServerEP.addHandler( @@ -181,7 +181,8 @@ TEST(RemoteObjectLayer, AddObjectFailure) { }; RPCEndpoint ClientEP(*Channels.first, true); - RemoteObjectClientLayer Client(ClientEP, ReportError); + RemoteObjectClientLayer Client(AcknowledgeORCv1Deprecation, + ClientEP, ReportError); RPCEndpoint ServerEP(*Channels.second, true); MockObjectLayer BaseLayer( @@ -191,9 +192,8 @@ TEST(RemoteObjectLayer, AddObjectFailure) { return make_error("AddObjectFailure - Test Message", inconvertibleErrorCode()); }); - RemoteObjectServerLayer Server(BaseLayer, - ServerEP, - ReportError); + RemoteObjectServerLayer Server( + AcknowledgeORCv1Deprecation, BaseLayer, ServerEP, ReportError); bool Finished = false; ServerEP.addHandler( @@ -233,7 +233,8 @@ TEST(RemoteObjectLayer, RemoveObject) { }; RPCEndpoint ClientEP(*Channels.first, true); - RemoteObjectClientLayer Client(ClientEP, ReportError); + RemoteObjectClientLayer Client(AcknowledgeORCv1Deprecation, + ClientEP, ReportError); RPCEndpoint ServerEP(*Channels.second, true); @@ -243,9 +244,8 @@ TEST(RemoteObjectLayer, RemoveObject) { SymTab[1] = MockObjectLayer::LookupFn(); return 1; }); - RemoteObjectServerLayer Server(BaseLayer, - ServerEP, - ReportError); + RemoteObjectServerLayer Server( + AcknowledgeORCv1Deprecation, BaseLayer, ServerEP, ReportError); bool Finished = false; ServerEP.addHandler( @@ -283,7 +283,8 @@ TEST(RemoteObjectLayer, RemoveObjectFailure) { }; RPCEndpoint ClientEP(*Channels.first, true); - RemoteObjectClientLayer Client(ClientEP, ReportError); + RemoteObjectClientLayer Client(AcknowledgeORCv1Deprecation, + ClientEP, ReportError); RPCEndpoint ServerEP(*Channels.second, true); @@ -294,9 +295,8 @@ TEST(RemoteObjectLayer, RemoveObjectFailure) { MockObjectLayer::SymbolLookupTable &SymTab) { return 42; }); - RemoteObjectServerLayer Server(BaseLayer, - ServerEP, - ReportError); + RemoteObjectServerLayer Server( + AcknowledgeORCv1Deprecation, BaseLayer, ServerEP, ReportError); bool Finished = false; ServerEP.addHandler( @@ -339,7 +339,8 @@ TEST(RemoteObjectLayer, FindSymbol) { }; RPCEndpoint ClientEP(*Channels.first, true); - RemoteObjectClientLayer Client(ClientEP, ReportError); + RemoteObjectClientLayer Client(AcknowledgeORCv1Deprecation, + ClientEP, ReportError); RPCEndpoint ServerEP(*Channels.second, true); @@ -358,9 +359,8 @@ TEST(RemoteObjectLayer, FindSymbol) { }; return 42; }); - RemoteObjectServerLayer Server(BaseLayer, - ServerEP, - ReportError); + RemoteObjectServerLayer Server( + AcknowledgeORCv1Deprecation, BaseLayer, ServerEP, ReportError); bool Finished = false; ServerEP.addHandler( @@ -421,7 +421,8 @@ TEST(RemoteObjectLayer, FindSymbolIn) { }; RPCEndpoint ClientEP(*Channels.first, true); - RemoteObjectClientLayer Client(ClientEP, ReportError); + RemoteObjectClientLayer Client(AcknowledgeORCv1Deprecation, + ClientEP, ReportError); RPCEndpoint ServerEP(*Channels.second, true); @@ -447,9 +448,8 @@ TEST(RemoteObjectLayer, FindSymbolIn) { return 42; }); - RemoteObjectServerLayer Server(BaseLayer, - ServerEP, - ReportError); + RemoteObjectServerLayer Server( + AcknowledgeORCv1Deprecation, BaseLayer, ServerEP, ReportError); bool Finished = false; ServerEP.addHandler( @@ -496,7 +496,8 @@ TEST(RemoteObjectLayer, EmitAndFinalize) { }; RPCEndpoint ClientEP(*Channels.first, true); - RemoteObjectClientLayer Client(ClientEP, ReportError); + RemoteObjectClientLayer Client(AcknowledgeORCv1Deprecation, + ClientEP, ReportError); RPCEndpoint ServerEP(*Channels.second, true); @@ -506,9 +507,8 @@ TEST(RemoteObjectLayer, EmitAndFinalize) { SymTab[1] = MockObjectLayer::LookupFn(); return 1; }); - RemoteObjectServerLayer Server(BaseLayer, - ServerEP, - ReportError); + RemoteObjectServerLayer Server( + AcknowledgeORCv1Deprecation, BaseLayer, ServerEP, ReportError); bool Finished = false; ServerEP.addHandler( @@ -547,7 +547,8 @@ TEST(RemoteObjectLayer, EmitAndFinalizeFailure) { }; RPCEndpoint ClientEP(*Channels.first, true); - RemoteObjectClientLayer Client(ClientEP, ReportError); + RemoteObjectClientLayer Client(AcknowledgeORCv1Deprecation, + ClientEP, ReportError); RPCEndpoint ServerEP(*Channels.second, true); @@ -556,9 +557,8 @@ TEST(RemoteObjectLayer, EmitAndFinalizeFailure) { MockObjectLayer::SymbolLookupTable &SymTab) { return 1; }); - RemoteObjectServerLayer Server(BaseLayer, - ServerEP, - ReportError); + RemoteObjectServerLayer Server( + AcknowledgeORCv1Deprecation, BaseLayer, ServerEP, ReportError); bool Finished = false; ServerEP.addHandler( -- 2.50.1