[ORC] Add deprecation warnings to ORCv1 layers and utilities.

[lhames]

Summary

ORCv1 is deprecated and my current aim is to remove it after LLVM 9.0. This
patch adds deprecation attributes to the ORCv1 layers and utilities to warn
clients of the change.

[lhames]

This is the fist time I’ve used the deprecation attribute, so I’ve just taken a stab at maintaining sanity here. To keep the tree building cleanly, since we still have tests and internal utilities using these classes, I have added the attribute to the constructors of classes being removed, and added new, non-warning constructors alongside, distinguished by a dummy argument at the start of the list. Adding ‘AcknowledgeORCv1Deprecation’ to the start of any call to a deprecated constructor thus removes the warning.

While I wait for any feedback on this I am going to work on the ORCv2 docs and add a section on transitioning from ORCv1. I hope to have all this in-tree before we branch for LLVM 9.0.

[sgraenitz]

A lot of complexity and maintenance overhead sticks around in the code due to ORCv1. It complicates and slows down ORCv2 development. I agree that it's time to let go.

This is the fist time I’ve used the deprecation attribute, so I’ve just taken a stab at maintaining sanity here. To keep the tree building cleanly, since we still have tests and internal utilities using these classes, I have added the attribute to the constructors of classes being removed, and added new, non-warning constructors alongside, distinguished by a dummy argument at the start of the list. Adding ‘AcknowledgeORCv1Deprecation’ to the start of any call to a deprecated constructor thus removes the warning.

Interesting approach! The reason for it is also my question: Can we call something deprecated that we still use ourselves? The answer may vary for different parts of ORCv1.

OrcMCJITReplacement appears to be the pivotal point. It uses LegacyIRCompileLayer, LazyEmittingLayer and LegacyRTDyldLinkingLayer, but it's not marked deprecated itself. If they were removed, wouldn't OrcMCJITReplacement follow immediately?
What would that mean for the lit tests in llvm/test/ExecutionEngine/OrcMCJIT? We would probably discard a lot of them. Could some be moved to either orc-lazy or mcjit?
Should we deprecate lli's orc-mcjit mode?

And then I certainly won't miss:

• layers LegacyObjectTransformLayer, RemoteObjectClient/ServerLayer, LegacyCompileOnDemandLayer, LegacyIRTransformLayer
• utils like LegacyCtorDtorRunner or LegacyLocalCXXRuntimeOverrides

I hope to have all this in-tree before we branch for LLVM 9.0.

ORCv1 should be deprecated sooner rather than later. Though, a decision for the scope proposed here should come with a plan for OrcMCJITReplacement.

include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h

277

These look like clang-format artifacts.

[lhames]

In D64609#1583075, @sgraenitz wrote:

... ORCv1 should be deprecated sooner rather than later. Though, a decision for the scope proposed here should come with a plan for OrcMCJITReplacement.

I'm going to deprecate OrcMCJITReplacement too. I'll have a patch up for that shortly. If there are enough people who need/want it we can re-instate it, but I'm hoping LLJIT will be as easy transition for most people.

[lhames]

• [ORC] Add deprecation warning for OrcMCJITReplacement

[sgraenitz]

tools/lli/lli.cpp

94–95

Orc-based MCJIT replacement (deprecated)?

[sgraenitz]

What would that mean for the lit tests in llvm/test/ExecutionEngine/OrcMCJIT? We would probably discard a lot of them. Could some be moved to either orc-lazy or mcjit?

I checked on my machine and found that out of 78 tests in OrcMCJIT:

• 72 work with orc-lazy https://reviews.llvm.org/differential/diff/210161/
• only 6 are failing with orc-lazy but succeed with mcjit https://reviews.llvm.org/differential/diff/210162/

Not sure if this is a change we want now. What do you think?

[sgraenitz]

Pardon 79. With the two patches applied:

$ cd /path/to/llvm-build-tree/test
$ python ../bin/llvm-lit -sv ExecutionEngine/OrcMCJIT/
Testing Time: 0.65s
  Expected Passes    : 77
  Expected Failures  : 2

[lhames]

In D64609#1588195, @sgraenitz wrote:

• 72 work with orc-lazy https://reviews.llvm.org/differential/diff/210161/

That’s pretty encouraging. The main wrinkle is the remote tests: orc-lazy is currently running in-process only, so these tests aren’t properly testing remote-jitting support. I will see if I can get the remote-execution utility working with orc-lazy mode. That probably won’t make the branch cut-off, but hopefully can be done soon enough that we can cherry- pick before the 9.0 release.

Long term I would like to reconsider these tests. They were added in an ad-hoc fashion and many would now be better expressed as rtdyld or jitlink tests (neither of which were available at the time). I won’t have time to audit them before the release though, so perhaps the best option would be to pull them in under a new directory name (OrcLazy-LegacyTests?) in LLVM 9.0.

What do you think?

tools/lli/lli.cpp

94–95

Good idea. I will update the patch in a moment.

[lhames]

• [ORC] Add a deprecation note to the lli -jit-kind=orc-mcjit option.

[lhames]

I’m going to land this. There may be fallout to example programs and other LLVM projects and want to try to shake that out before the 9.0 branch gets cut.

[sgraenitz]

In D64609#1588668, @lhames wrote:

The main wrinkle is the remote tests: orc-lazy is currently running in-process only, so these tests aren’t properly testing remote-jitting support.
Long term I would like to reconsider these tests. They were added in an ad-hoc fashion and many would now be better expressed as rtdyld or jitlink tests (neither of which were available at the time).

Right. Maybe that should happen before the deprecated code is actually removed.

I will see if I can get the remote-execution utility working with orc-lazy mode. That probably won’t make the branch cut-off, but hopefully can be done soon enough that we can cherry-pick before the 9.0 release.

If that's a low-hanging fruit why not. Otherwise features might be better deferred to the next release?

[...] perhaps the best option would be to pull them in under a new directory name (OrcLazy-LegacyTests?) in LLVM 9.0.

Well, after all LLVM 9.0 has OrcMCJITReplacement. Thinking again, maybe it's best to leave these tests untouched for the current release and review them during the 10.0 time frame. Once all OrcMCJIT tests are sorted out, saying bye bye to ORCv1 sounds reasonable to me.

I’m going to land this. There may be fallout to example programs and other LLVM projects and want to try to shake that out before the 9.0 branch gets cut.

Agree, thanks for working on this!

[RKSimon]

@lhames We have deprecation warnings (and Werror failures) on the buildbots due to this change, are you in a position to get these fixed prior to branching off 9.00?

include/llvm/ExecutionEngine/ExecutionEngine.h

 
 #include "llvm-c/ExecutionEngine.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallVector.h"
 #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"
 #include "llvm/Support/CBindingWrapping.h"
 #include "llvm/Support/CodeGen.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/Mutex.h"
 #include "llvm/Target/TargetMachine.h"
public:
   template<typename StringSequence>
   EngineBuilder &setMAttrs(const StringSequence &mattrs) {
     MAttrs.clear();
     MAttrs.append(mattrs.begin(), mattrs.end());
     return *this;
   }
 
   // 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;
   }
 
   void setEmulatedTLS(bool EmulatedTLS) {
     this->EmulatedTLS = EmulatedTLS;
   }
 
   TargetMachine *selectTarget();
 
   /// selectTarget - Pick a target either via -march or by guessing the native
   /// arch.  Add any CPU features specified via -mcpu or -mattr.
   TargetMachine *selectTarget(const Triple &TargetTriple,
                               StringRef MArch,
                               StringRef MCPU,
                               const SmallVectorImpl<std::string>& MAttrs);
 
   ExecutionEngine *create() {
     return create(selectTarget());
   }
 
   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)
 
 } // end namespace llvm
 
 #endif // LLVM_EXECUTIONENGINE_EXECUTIONENGINE_H

include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h

public:
 
   using SymbolResolverGetter =
       std::function<std::shared_ptr<SymbolResolver>(VModuleKey K)>;
 
   using SymbolResolverSetter =
       std::function<void(VModuleKey K, std::shared_ptr<SymbolResolver> 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,
+          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,
       : ES(ES), BaseLayer(BaseLayer),
         GetSymbolResolver(std::move(GetSymbolResolver)),
         SetSymbolResolver(std::move(SetSymbolResolver)),
         Partition(std::move(Partition)), CompileCallbackMgr(CallbackMgr),
         CreateIndirectStubsManager(std::move(CreateIndirectStubsManager)),
         CloneStubsIntoPartitions(CloneStubsIntoPartitions) {}
 
   ~LegacyCompileOnDemandLayer() {
private:
   PartitioningFtor Partition;
   CompileCallbackMgrT &CompileCallbackMgr;
   IndirectStubsManagerBuilderT CreateIndirectStubsManager;
 
   std::map<VModuleKey, LogicalDylib> LogicalDylibs;
   bool CloneStubsIntoPartitions;
 };
 
-} // end namespace orc
+template <typename BaseLayerT, typename CompileCallbackMgrT,
+          typename IndirectStubsMgrT>
+LegacyCompileOnDemandLayer<BaseLayerT, CompileCallbackMgrT, IndirectStubsMgrT>::
+    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

include/llvm/ExecutionEngine/Orc/Core.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_EXECUTIONENGINE_ORC_CORE_H
 #define LLVM_EXECUTIONENGINE_ORC_CORE_H
 
 #include "llvm/ADT/BitmaskEnum.h"
 #include "llvm/ExecutionEngine/JITSymbol.h"
+#include "llvm/ExecutionEngine/OrcV1Deprecation.h"
 #include "llvm/ExecutionEngine/Orc/SymbolStringPool.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Support/Debug.h"
 
 #include <memory>
 #include <vector>
 
 #define DEBUG_TYPE "orc"

include/llvm/ExecutionEngine/Orc/ExecutionUtils.h

 
 /// Convenience class for recording constructor/destructor names for
 ///        later execution.
 template <typename JITLayerT>
 class LegacyCtorDtorRunner {
 public:
   /// Construct a CtorDtorRunner for the given range using the given
   ///        name mangling function.
-  LegacyCtorDtorRunner(std::vector<std::string> CtorDtorNames, VModuleKey K)
+  LLVM_ATTRIBUTE_DEPRECATED(
+      LegacyCtorDtorRunner(std::vector<std::string> CtorDtorNames,
+                           VModuleKey K),
+      "ORCv1 utilities (utilities with the 'Legacy' prefix) are deprecated. "
+      "Please use the ORCv2 CtorDtorRunner utility instead");
+
+  LegacyCtorDtorRunner(ORCv1DeprecationAcknowledgement,
+                       std::vector<std::string> CtorDtorNames, VModuleKey K)
       : CtorDtorNames(std::move(CtorDtorNames)), K(K) {}
 
   /// Run the recorded constructors/destructors through the given JIT
   ///        layer.
   Error runViaLayer(JITLayerT &JITLayer) const {
     using CtorDtorTy = void (*)();
 
     for (const auto &CtorDtorName : CtorDtorNames) {
Error runViaLayer(JITLayerT &JITLayer) const {
     return Error::success();
   }
 
 private:
   std::vector<std::string> CtorDtorNames;
   orc::VModuleKey K;
 };
 
+template <typename JITLayerT>
+LegacyCtorDtorRunner<JITLayerT>::LegacyCtorDtorRunner(
+    std::vector<std::string> CtorDtorNames, VModuleKey K)
+    : CtorDtorNames(std::move(CtorDtorNames)), K(K) {}
+
 class CtorDtorRunner {
 public:
   CtorDtorRunner(JITDylib &JD) : JD(JD) {}
   void add(iterator_range<CtorDtorIterator> CtorDtors);
   Error run();
 
 private:
   using CtorDtorList = std::vector<SymbolStringPtr>;
protected:
   static int CXAAtExitOverride(DestructorPtr Destructor, void *Arg,
                                void *DSOHandle);
 };
 
 class LegacyLocalCXXRuntimeOverrides : public LocalCXXRuntimeOverridesBase {
 public:
   /// Create a runtime-overrides class.
   template <typename MangleFtorT>
-  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 <typename MangleFtorT>
+  LegacyLocalCXXRuntimeOverrides(ORCv1DeprecationAcknowledgement,
+                                 const MangleFtorT &Mangle) {
     addOverride(Mangle("__dso_handle"), toTargetAddress(&DSOHandleOverride));
     addOverride(Mangle("__cxa_atexit"), toTargetAddress(&CXAAtExitOverride));
   }
 
   /// Search overrided symbols.
   JITEvaluatedSymbol searchOverrides(const std::string &Name) {
     auto I = CXXRuntimeOverrides.find(Name);
     if (I != CXXRuntimeOverrides.end())
       return JITEvaluatedSymbol(I->second, JITSymbolFlags::Exported);
     return nullptr;
   }
 
 private:
   void addOverride(const std::string &Name, JITTargetAddress Addr) {
     CXXRuntimeOverrides.insert(std::make_pair(Name, Addr));
   }
 
   StringMap<JITTargetAddress> CXXRuntimeOverrides;
 };
 
+template <typename MangleFtorT>
+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);
 };
 
 /// A utility class to expose symbols found via dlsym to the JIT.
 ///
 /// If an instance of this class is attached to a JITDylib as a fallback

include/llvm/ExecutionEngine/Orc/IRCompileLayer.h

 class LegacyIRCompileLayer {
 public:
   /// Callback type for notifications when modules are compiled.
   using NotifyCompiledCallback =
       std::function<void(VModuleKey K, std::unique_ptr<Module>)>;
 
   /// 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(
+      ORCv1DeprecationAcknowledgement, BaseLayerT &BaseLayer,
+      CompileFtor Compile,
       NotifyCompiledCallback NotifyCompiled = NotifyCompiledCallback())
       : BaseLayer(BaseLayer), Compile(std::move(Compile)),
         NotifyCompiled(std::move(NotifyCompiled)) {}
 
   /// Get a reference to the compiler functor.
   CompileFtor& getCompiler() { return Compile; }
 
   /// (Re)set the NotifyCompiled callback.
public:
   Error emitAndFinalize(VModuleKey K) { return BaseLayer.emitAndFinalize(K); }
 
 private:
   BaseLayerT &BaseLayer;
   CompileFtor Compile;
   NotifyCompiledCallback NotifyCompiled;
 };
 
-} // end namespace orc
+template <typename BaseLayerT, typename CompileFtor>
+LegacyIRCompileLayer<BaseLayerT, CompileFtor>::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

include/llvm/ExecutionEngine/Orc/IRTransformLayer.h

 ///
 ///   This layer applies a user supplied transform to each module that is added,
 /// then adds the transformed module to the layer below.
 template <typename BaseLayerT, typename TransformFtor>
 class LegacyIRTransformLayer {
 public:
 
   /// Construct an LegacyIRTransformLayer with the given BaseLayer
+  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.
   ///
   /// @return A handle for the added modules.
   Error addModule(VModuleKey K, std::unique_ptr<Module> M) {
     return BaseLayer.addModule(std::move(K), Transform(std::move(M)));
   }
public:
   /// Access the mumate functor directly.
   const TransformFtor& getTransform() const { return Transform; }
 
 private:
   BaseLayerT &BaseLayer;
   TransformFtor Transform;
 };
 
+template <typename BaseLayerT, typename TransformFtor>
+LegacyIRTransformLayer<BaseLayerT, TransformFtor>::LegacyIRTransformLayer(
+    BaseLayerT &BaseLayer, TransformFtor Transform)
+    : BaseLayer(BaseLayer), Transform(std::move(Transform)) {}
+
 } // end namespace orc
 } // end namespace llvm
 
 #endif // LLVM_EXECUTIONENGINE_ORC_IRTRANSFORMLAYER_H

include/llvm/ExecutionEngine/Orc/LambdaResolver.h

 #include <memory>
 
 namespace llvm {
 namespace orc {
 
 template <typename DylibLookupFtorT, typename ExternalLookupFtorT>
 class LambdaResolver : public LegacyJITSymbolResolver {
 public:
+  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) {}
 
   JITSymbol findSymbolInLogicalDylib(const std::string &Name) final {
     return DylibLookupFtor(Name);
   }
 
   JITSymbol findSymbol(const std::string &Name) final {
     return ExternalLookupFtor(Name);
   }
 
 private:
   DylibLookupFtorT DylibLookupFtor;
   ExternalLookupFtorT ExternalLookupFtor;
 };
 
+template <typename DylibLookupFtorT, typename ExternalLookupFtorT>
+LambdaResolver<DylibLookupFtorT, ExternalLookupFtorT>::LambdaResolver(
+    DylibLookupFtorT DylibLookupFtor, ExternalLookupFtorT ExternalLookupFtor)
+    : DylibLookupFtor(DylibLookupFtor), ExternalLookupFtor(ExternalLookupFtor) {
+}
+
 template <typename DylibLookupFtorT,
           typename ExternalLookupFtorT>
 std::shared_ptr<LambdaResolver<DylibLookupFtorT, ExternalLookupFtorT>>
 createLambdaResolver(DylibLookupFtorT DylibLookupFtor,
                      ExternalLookupFtorT ExternalLookupFtor) {
   using LR = LambdaResolver<DylibLookupFtorT, ExternalLookupFtorT>;
   return make_unique<LR>(std::move(DylibLookupFtor),
                          std::move(ExternalLookupFtor));
 }
 
+template <typename DylibLookupFtorT, typename ExternalLookupFtorT>
+std::shared_ptr<LambdaResolver<DylibLookupFtorT, ExternalLookupFtorT>>
+createLambdaResolver(ORCv1DeprecationAcknowledgement,
+                     DylibLookupFtorT DylibLookupFtor,
+                     ExternalLookupFtorT ExternalLookupFtor) {
+  using LR = LambdaResolver<DylibLookupFtorT, ExternalLookupFtorT>;
+  return make_unique<LR>(AcknowledgeORCv1Deprecation,
+                         std::move(DylibLookupFtor),
+                         std::move(ExternalLookupFtor));
+}
+
 } // end namespace orc
 } // end namespace llvm
 
 #endif // LLVM_EXECUTIONENGINE_ORC_LAMBDARESOLVER_H

include/llvm/ExecutionEngine/Orc/LazyEmittingLayer.h

private:
   };
 
   BaseLayerT &BaseLayer;
   std::map<VModuleKey, std::unique_ptr<EmissionDeferredModule>> ModuleMap;
 
 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<Module> M) {
     assert(!ModuleMap.count(K) && "VModuleKey K already in use");
     ModuleMap[K] =
         llvm::make_unique<EmissionDeferredModule>(std::move(K), std::move(M));
     return Error::success();
   }
public:
   /// Immediately emit and finalize the module represented by the given
   ///        key.
   Error emitAndFinalize(VModuleKey K) {
     assert(ModuleMap.count(K) && "VModuleKey K not valid here");
     return ModuleMap[K]->emitAndFinalize(BaseLayer);
   }
 };
 
+template <typename BaseLayerT>
+LazyEmittingLayer<BaseLayerT>::LazyEmittingLayer(BaseLayerT &BaseLayer)
+    : BaseLayer(BaseLayer) {}
+
 } // end namespace orc
 } // end namespace llvm
 
 #endif // LLVM_EXECUTIONENGINE_ORC_LAZYEMITTINGLAYER_H

include/llvm/ExecutionEngine/Orc/ObjectTransformLayer.h

 ///
 ///   This layer accepts sets of ObjectFiles (via addObject). It
 /// immediately applies the user supplied functor to each object, then adds
 /// the set of transformed objects to the layer below.
 template <typename BaseLayerT, typename TransformFtor>
 class LegacyObjectTransformLayer {
 public:
   /// Construct an ObjectTransformLayer with the given 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)) {}
 
   /// Apply the transform functor to each object in the object set, then
   ///        add the resulting set of objects to the base layer, along with the
   ///        memory manager and symbol resolver.
   ///
   /// @return A handle for the added objects.
public:
   /// Access the mumate functor directly.
   const TransformFtor &getTransform() const { return Transform; }
 
 private:
   BaseLayerT &BaseLayer;
   TransformFtor Transform;
 };
 
+template <typename BaseLayerT, typename TransformFtor>
+LegacyObjectTransformLayer<BaseLayerT, TransformFtor>::
+    LegacyObjectTransformLayer(BaseLayerT &BaseLayer, TransformFtor Transform)
+    : BaseLayer(BaseLayer), Transform(std::move(Transform)) {}
+
 } // end namespace orc
 } // end namespace llvm
 
 #endif // LLVM_EXECUTIONENGINE_ORC_OBJECTTRANSFORMLAYER_H

include/llvm/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.h

struct Resources {
     std::shared_ptr<RuntimeDyld::MemoryManager> MemMgr;
     std::shared_ptr<SymbolResolver> Resolver;
   };
 
   using ResourcesGetter = std::function<Resources(VModuleKey)>;
 
   /// 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(
+      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.
   ///
   /// If set to true, all sections in each object file will be allocated using
   /// the memory manager, rather than just the sections required for execution.
   ///
   /// This is kludgy, and may be removed in the future.
   void setProcessAllSections(bool ProcessAllSections) {

include/llvm/ExecutionEngine/Orc/RemoteObjectLayer.h

 //===------ RemoteObjectLayer.h - Forwards objs to a remote -----*- 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Forwards objects to a remote object layer via RPC.
 //
 //===----------------------------------------------------------------------===//
 
 #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 <map>
 
 namespace llvm {
 namespace orc {
 
 /// RPC API needed by RemoteObjectClientLayer and RemoteObjectServerLayer.
 class RemoteObjectLayerAPI {
 public:
public:
 
   using ObjectPtr = std::unique_ptr<MemoryBuffer>;
 
   /// Create a RemoteObjectClientLayer that communicates with a
   /// RemoteObjectServerLayer instance via the given RPCEndpoint.
   ///
   /// The ReportError functor can be used locally log errors that are intended
   /// to be sent  sent
+  LLVM_ATTRIBUTE_DEPRECATED(
       RemoteObjectClientLayer(RPCEndpoint &Remote,
+                              std::function<void(Error)> ReportError),
+      "ORCv1 layers (including RemoteObjectClientLayer) are deprecated. Please "
+      "use "
+      "ORCv2 (see docs/ORCv2.rst)");
+
+  RemoteObjectClientLayer(ORCv1DeprecationAcknowledgement, RPCEndpoint &Remote,
                           std::function<void(Error)> ReportError)
       : RemoteObjectLayer<RPCEndpoint>(Remote, std::move(ReportError)) {
     using ThisT = RemoteObjectClientLayer<RPCEndpoint>;
     Remote.template addHandler<Lookup>(*this, &ThisT::lookup);
     Remote.template addHandler<LookupInLogicalDylib>(
             *this, &ThisT::lookupInLogicalDylib);
   }
 
private:
   using RemoteObjectLayer<RPCEndpoint>::teeLog;
   using RemoteObjectLayer<RPCEndpoint>::badObjectHandleError;
   using RemoteObjectLayer<RPCEndpoint>::remoteToJITSymbol;
 
 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<void(Error)> ReportError),
+      "ORCv1 layers (including RemoteObjectServerLayer) are deprecated. Please "
+      "use "
+      "ORCv2 (see docs/ORCv2.rst)");
+
+  RemoteObjectServerLayer(ORCv1DeprecationAcknowledgement,
+                          BaseLayerT &BaseLayer, RPCEndpoint &Remote,
                           std::function<void(Error)> ReportError)
       : RemoteObjectLayer<RPCEndpoint>(Remote, std::move(ReportError)),
         BaseLayer(BaseLayer), HandleIdMgr(1) {
     using ThisT = RemoteObjectServerLayer<BaseLayerT, RPCEndpoint>;
 
     Remote.template addHandler<AddObject>(*this, &ThisT::addObject);
     Remote.template addHandler<RemoveObject>(*this, &ThisT::removeObject);
     Remote.template addHandler<FindSymbol>(*this, &ThisT::findSymbol);
     Remote.template addHandler<FindSymbolIn>(*this, &ThisT::findSymbolIn);
     Remote.template addHandler<EmitAndFinalize>(*this, &ThisT::emitAndFinalize);
   }
private:
   }
 
   Expected<ObjHandleT> addObject(std::string ObjBuffer) {
     auto Buffer = llvm::make_unique<StringMemoryBuffer>(std::move(ObjBuffer));
     auto Id = HandleIdMgr.getNext();
     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);
         });
 
     if (auto HandleOrErr =
             BaseLayer.addObject(std::move(Buffer), std::move(Resolver))) {
       BaseLayerHandles[Id] = std::move(*HandleOrErr);
if (HI != BaseLayerHandles.end()) {
       return teeLog(badObjectHandleError(H));
   }
 
   BaseLayerT &BaseLayer;
   remote::ResourceIdMgr HandleIdMgr;
   std::map<ObjHandleT, typename BaseLayerT::ObjHandleT> BaseLayerHandles;
 };
 
+template <typename RPCEndpoint>
+RemoteObjectClientLayer<RPCEndpoint>::RemoteObjectClientLayer(
+    RPCEndpoint &Remote, std::function<void(Error)> ReportError)
+    : RemoteObjectLayer<RPCEndpoint>(Remote, std::move(ReportError)) {
+  using ThisT = RemoteObjectClientLayer<RPCEndpoint>;
+  Remote.template addHandler<Lookup>(*this, &ThisT::lookup);
+  Remote.template addHandler<LookupInLogicalDylib>(
+      *this, &ThisT::lookupInLogicalDylib);
+}
+
+template <typename BaseLayerT, typename RPCEndpoint>
+RemoteObjectServerLayer<BaseLayerT, RPCEndpoint>::RemoteObjectServerLayer(
+    BaseLayerT &BaseLayer, RPCEndpoint &Remote,
+    std::function<void(Error)> ReportError)
+    : RemoteObjectLayer<RPCEndpoint>(Remote, std::move(ReportError)),
+      BaseLayer(BaseLayer), HandleIdMgr(1) {
+  using ThisT = RemoteObjectServerLayer<BaseLayerT, RPCEndpoint>;
+
+  Remote.template addHandler<AddObject>(*this, &ThisT::addObject);
+  Remote.template addHandler<RemoveObject>(*this, &ThisT::removeObject);
+  Remote.template addHandler<FindSymbol>(*this, &ThisT::findSymbol);
+  Remote.template addHandler<FindSymbolIn>(*this, &ThisT::findSymbolIn);
+  Remote.template addHandler<EmitAndFinalize>(*this, &ThisT::emitAndFinalize);
+}
+
 } // end namespace orc
 } // end namespace llvm
 
 #endif // LLVM_EXECUTIONENGINE_ORC_REMOTEOBJECTLAYER_H

include/llvm/ExecutionEngine/OrcV1Deprecation.h

+//===------ 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

lib/ExecutionEngine/Orc/OrcCBindingsStack.h

private:
     void *ExternalResolverCtx = nullptr;
   };
 
 public:
   OrcCBindingsStack(TargetMachine &TM,
                     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<SectionMemoryManager>(), 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->notifyFinalized(K, Obj, LoadedObjInfo);
+              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() {
     // Run any destructors registered with __cxa_atexit.
     CXXRuntimeOverrides.runDestructors();
     // Run any IR destructors.
     for (auto &DtorRunner : IRStaticDestructorRunners)
       if (auto Err = DtorRunner.runViaLayer(*this))
Resolvers[K] = std::make_shared<CBindingsResolver>(*this, ExternalResolver,
                                                        ExternalResolverCtx);
     if (auto Err = Layer.addModule(K, std::move(M)))
       return std::move(Err);
 
     KeyLayers[K] = detail::createGenericLayer(Layer);
 
     // Run the static constructors, and save the static destructor runner for
     // execution when the JIT is torn down.
-    orc::LegacyCtorDtorRunner<OrcCBindingsStack> CtorRunner(std::move(CtorNames), K);
+    orc::LegacyCtorDtorRunner<OrcCBindingsStack> CtorRunner(
+        AcknowledgeORCv1Deprecation, std::move(CtorNames), K);
     if (auto Err = CtorRunner.runViaLayer(*this))
       return std::move(Err);
 
     IRStaticDestructorRunners.emplace_back(std::move(DtorNames), K);
 
     return K;
   }
 
createCODLayer(orc::ExecutionSession &ES, CompileLayerT &CompileLayer,
                  IndirectStubsManagerBuilder IndirectStubsMgrBuilder,
                  ResolverMap &Resolvers) {
     // If there is no compile callback manager available we can not create a
     // compile on demand layer.
     if (!CCMgr)
       return nullptr;
 
     return llvm::make_unique<CODLayerT>(
-        ES, CompileLayer,
+        AcknowledgeORCv1Deprecation, ES, CompileLayer,
         [&Resolvers](orc::VModuleKey K) {
           auto ResolverI = Resolvers.find(K);
           assert(ResolverI != Resolvers.end() && "No resolver for module K");
           return ResolverI->second;
         },
         [&Resolvers](orc::VModuleKey K,
                      std::shared_ptr<orc::SymbolResolver> Resolver) {
           assert(!Resolvers.count(K) && "Resolver already present");

lib/ExecutionEngine/Orc/OrcMCJITReplacement.h

private:
   void reportError(Error Err) {
     logAllUnhandledErrors(std::move(Err), errs(), "MCJIT error: ");
   }
 
 public:
   OrcMCJITReplacement(std::shared_ptr<MCJITMemoryManager> MemMgr,
                       std::shared_ptr<LegacyJITSymbolResolver> ClientResolver,
                       std::unique_ptr<TargetMachine> TM)
-      : ExecutionEngine(TM->createDataLayout()),
-        TM(std::move(TM)),
+      : ExecutionEngine(TM->createDataLayout()), TM(std::move(TM)),
         MemMgr(
             std::make_shared<MCJITReplacementMemMgr>(*this, std::move(MemMgr))),
         Resolver(std::make_shared<LinkingORCResolver>(*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<Module> M) {
                        Modules.push_back(std::move(M));
                      }),
-        LazyEmitLayer(CompileLayer) {}
+        LazyEmitLayer(AcknowledgeORCv1Deprecation, CompileLayer) {}
 
   static void Register() {
     OrcMCJITReplacementCtor = createOrcMCJITReplacement;
   }
 
   void addModule(std::unique_ptr<Module> M) override {
     // If this module doesn't have a DataLayout attached then attach the
     // default.

lib/ExecutionEngine/Orc/OrcMCJITReplacement.cpp

OrcMCJITReplacement::runFunction(Function *F,
 
   llvm_unreachable("Full-featured argument passing not supported yet!");
 }
 
 void OrcMCJITReplacement::runStaticConstructorsDestructors(bool isDtors) {
   auto &CtorDtorsMap = isDtors ? UnexecutedDestructors : UnexecutedConstructors;
 
   for (auto &KV : CtorDtorsMap)
-    cantFail(LegacyCtorDtorRunner<LazyEmitLayerT>(std::move(KV.second), KV.first)
+    cantFail(LegacyCtorDtorRunner<LazyEmitLayerT>(
+                 AcknowledgeORCv1Deprecation, std::move(KV.second), KV.first)
                  .runViaLayer(LazyEmitLayer));
 
   CtorDtorsMap.clear();
 }
 
 } // End namespace orc.
 } // End namespace llvm.

lib/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.cpp

void RTDyldObjectLinkingLayer::onObjEmit(
   }
 
   R.notifyEmitted();
 
   if (NotifyEmitted)
     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.

tools/lli/lli.cpp

namespace {
   cl::opt<JITKind> 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"),
+                                           "Orc-based MCJIT replacement "
+                                           "(deprecated)"),
                                 clEnumValN(JITKind::OrcLazy,
                                            "orc-lazy",
                                            "Orc-based lazy JIT.")));
 
   cl::opt<unsigned>
   LazyJITCompileThreads("compile-threads",
                         cl::desc("Choose the number of compile threads "
                                  "(jit-kind=orc-lazy only)"),
int main(int argc, char **argv, char * const *envp) {
   if (RelocModel.getNumOccurrences())
     builder.setRelocationModel(RelocModel);
   if (CMModel.getNumOccurrences())
     builder.setCodeModel(CMModel);
   builder.setErrorStr(&ErrorMsg);
   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())
     Mod->setTargetTriple(Triple::normalize(TargetTriple));
 
   // Enable MCJIT if desired.
   RTDyldMemoryManager *RTDyldMM = nullptr;
   if (!ForceInterpreter) {
if (!RemoteMCJIT) {
 
     // Forward MCJIT's memory manager calls to the remote memory manager.
     static_cast<ForwardingMemoryManager*>(RTDyldMM)->setMemMgr(
       std::move(RemoteMM));
 
     // Forward MCJIT's symbol resolution calls to the remote.
     static_cast<ForwardingMemoryManager *>(RTDyldMM)->setResolver(
         orc::createLambdaResolver(
+            AcknowledgeORCv1Deprecation,
             [](const std::string &Name) { return nullptr; },
             [&](const std::string &Name) {
               if (auto Addr = ExitOnErr(R->getSymbolAddress(Name)))
                 return JITSymbol(Addr, JITSymbolFlags::Exported);
               return JITSymbol(nullptr);
             }));
 
     // Grab the target address of the JIT'd main function on the remote and call

unittests/ExecutionEngine/Orc/LazyEmittingLayerTest.cpp

struct MockBaseLayer {
   ModuleHandleT addModule(llvm::orc::VModuleKey,
                           std::shared_ptr<llvm::Module>) {
     return 42;
   }
 };
 
 TEST(LazyEmittingLayerTest, Empty) {
   MockBaseLayer M;
-  llvm::orc::LazyEmittingLayer<MockBaseLayer> L(M);
+  llvm::orc::LazyEmittingLayer<MockBaseLayer> L(
+      llvm::AcknowledgeORCv1Deprecation, M);
   cantFail(
       L.addModule(llvm::orc::VModuleKey(), std::unique_ptr<llvm::Module>()));
 }
 
 }

unittests/ExecutionEngine/Orc/LegacyCompileOnDemandLayerTest.cpp

auto GetResolver =
     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,
+      AcknowledgeORCv1Deprecation, 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.";
 }
 }

unittests/ExecutionEngine/Orc/LegacyRTDyldObjectLinkingLayerTest.cpp

private:
     bool &DebugSeen;
   };
 
   bool DebugSectionSeen = false;
   auto MM = std::make_shared<MemoryManagerWrapper>(DebugSectionSeen);
 
   ExecutionSession ES;
 
-  LegacyRTDyldObjectLinkingLayer ObjLayer(ES, [&MM](VModuleKey) {
+  LegacyRTDyldObjectLinkingLayer ObjLayer(
+      AcknowledgeORCv1Deprecation, ES, [&MM](VModuleKey) {
         return LegacyRTDyldObjectLinkingLayer::Resources{
             MM, std::make_shared<NullResolver>()};
       });
 
   LLVMContext Context;
   auto M = llvm::make_unique<Module>("", Context);
   M->setTargetTriple("x86_64-unknown-linux-gnu");
   Type *Int32Ty = IntegerType::get(Context, 32);
   GlobalVariable *GV =
     new GlobalVariable(*M, Int32Ty, false, GlobalValue::ExternalLinkage,
                          ConstantInt::get(Int32Ty, 42), "foo");
TEST_F(LegacyRTDyldObjectLinkingLayerExecutionTest, NoDuplicateFinalization) {
   Type *Int32Ty = IntegerType::get(Context, 32);
 
   ExecutionSession ES;
 
   auto MM = std::make_shared<SectionMemoryManagerWrapper>();
 
   std::map<orc::VModuleKey, std::shared_ptr<orc::SymbolResolver>> Resolvers;
 
-  LegacyRTDyldObjectLinkingLayer ObjLayer(ES, [&](VModuleKey K) {
+  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:
   // Module 1:
   //   int bar() { return 42; }
   // Module 2:
   //   int bar();
   //   int foo() { return bar(); }
if (!SupportsJIT)
     return;
 
   Type *Int32Ty = IntegerType::get(Context, 32);
 
   ExecutionSession ES;
 
   auto MM = std::make_shared<SectionMemoryManagerWrapper>();
 
-  LegacyRTDyldObjectLinkingLayer ObjLayer(ES, [&MM](VModuleKey K) {
+  LegacyRTDyldObjectLinkingLayer ObjLayer(
+      AcknowledgeORCv1Deprecation, ES, [&MM](VModuleKey K) {
         return LegacyRTDyldObjectLinkingLayer::Resources{
             MM, std::make_shared<NullResolver>()};
       });
   SimpleCompiler Compile(*TM);
 
   // Create a pair of unrelated modules:
   //
   // Module 1:
   //   int foo() { return 42; }
   // Module 2:
   //   int bar() { return 7; }
TEST_F(LegacyRTDyldObjectLinkingLayerExecutionTest, NoPrematureAllocation) {
   EXPECT_EQ(MM->NeedsToReserveAllocationSpaceCount, 1)
       << "More than one call to needsToReserveAllocationSpace "
          "(multiple unrelated objects loaded prior to finalization)";
 }
 
 TEST_F(LegacyRTDyldObjectLinkingLayerExecutionTest, TestNotifyLoadedSignature) {
   ExecutionSession ES;
   LegacyRTDyldObjectLinkingLayer ObjLayer(
-      ES,
+      AcknowledgeORCv1Deprecation, ES,
       [](VModuleKey) {
         return LegacyRTDyldObjectLinkingLayer::Resources{
             nullptr, std::make_shared<NullResolver>()};
       },
       [](VModuleKey, const object::ObjectFile &obj,
          const RuntimeDyld::LoadedObjectInfo &info) {});
 }
 
 } // end anonymous namespace

unittests/ExecutionEngine/Orc/ObjectTransformLayerTest.cpp

 // Test each operation on LegacyObjectTransformLayer.
 TEST(LegacyObjectTransformLayerTest, Main) {
   MockBaseLayer M;
 
   ExecutionSession ES(std::make_shared<SymbolStringPool>());
 
   // Create one object transform layer using a transform (as a functor)
   // that allocates new objects, and deals in unique pointers.
-  LegacyObjectTransformLayer<MockBaseLayer, AllocatingTransform> T1(M);
+  LegacyObjectTransformLayer<MockBaseLayer, AllocatingTransform> 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<MockBaseLayer,
                              std::function<std::shared_ptr<MockObjectFile>(
                                  std::shared_ptr<MockObjectFile>)>>
-    T2(M, [](std::shared_ptr<MockObjectFile> Obj) {
+      T2(llvm::AcknowledgeORCv1Deprecation, M,
+         [](std::shared_ptr<MockObjectFile> Obj) {
            ++(*Obj);
            return Obj;
          });
 
   // Test addObject with T1 (allocating)
   auto K1 = ES.allocateVModule();
   auto Obj1 = std::make_shared<MockObjectFile>(211);
   M.expectAddObject(K1, Obj1);
   cantFail(T1.addObject(K1, std::move(Obj1)));
   M.verifyAddObject();
 
uint8_t *allocateDataSection(uintptr_t, unsigned, unsigned, llvm::StringRef,
       return nullptr;
     }
     void registerEHFrames(uint8_t *, uint64_t, size_t) override {}
     void deregisterEHFrames() override {}
     bool finalizeMemory(std::string *) override { return false; }
   };
 
   // Construct the jit layers.
-  LegacyRTDyldObjectLinkingLayer BaseLayer(ES, [](VModuleKey) {
+  LegacyRTDyldObjectLinkingLayer BaseLayer(
+      llvm::AcknowledgeORCv1Deprecation, ES, [](VModuleKey) {
         return LegacyRTDyldObjectLinkingLayer::Resources{
             std::make_shared<llvm::SectionMemoryManager>(),
             std::make_shared<NullResolver>()};
       });
 
   auto IdentityTransform = [](std::unique_ptr<llvm::MemoryBuffer> Obj) {
     return Obj;
   };
   LegacyObjectTransformLayer<decltype(BaseLayer), decltype(IdentityTransform)>
-      TransformLayer(BaseLayer, IdentityTransform);
+      TransformLayer(llvm::AcknowledgeORCv1Deprecation, BaseLayer, IdentityTransform);
   auto NullCompiler = [](llvm::Module &) {
     return std::unique_ptr<llvm::MemoryBuffer>(nullptr);
   };
   LegacyIRCompileLayer<decltype(TransformLayer), decltype(NullCompiler)>
-    CompileLayer(TransformLayer, NullCompiler);
+      CompileLayer(llvm::AcknowledgeORCv1Deprecation, TransformLayer, NullCompiler);
 
   // Make sure that the calls from LegacyIRCompileLayer to LegacyObjectTransformLayer
   // compile.
   cantFail(CompileLayer.addModule(ES.allocateVModule(),
                                   std::unique_ptr<llvm::Module>()));
 
   // Make sure that the calls from LegacyObjectTransformLayer to ObjectLinkingLayer
   // compile.
   VModuleKey DummyKey = ES.allocateVModule();
   cantFail(TransformLayer.emitAndFinalize(DummyKey));
   TransformLayer.findSymbolIn(DummyKey, Name, false);
   TransformLayer.findSymbol(Name, true);
   TransformLayer.mapSectionAddress(DummyKey, nullptr, 0);
   cantFail(TransformLayer.removeObject(DummyKey));
 }
 }

unittests/ExecutionEngine/Orc/RemoteObjectLayerTest.cpp

TEST(RemoteObjectLayer, AddObject) {
 
   // Copy the bytes out of the test object: the copy will be used to verify
   // that the original is correctly transmitted over RPC to the mock layer.
   StringRef ObjBytes = TestObject->getBuffer();
   std::vector<char> ObjContents(ObjBytes.size());
   std::copy(ObjBytes.begin(), ObjBytes.end(), ObjContents.begin());
 
   RPCEndpoint ClientEP(*Channels.first, true);
-  RemoteObjectClientLayer<RPCEndpoint> Client(ClientEP, ReportError);
+  RemoteObjectClientLayer<RPCEndpoint> Client(AcknowledgeORCv1Deprecation,
+                                              ClientEP, ReportError);
 
   RPCEndpoint ServerEP(*Channels.second, true);
   MockObjectLayer BaseLayer(
     [&ObjContents](MockObjectLayer::ObjectPtr Obj,
                    MockObjectLayer::SymbolLookupTable &SymTab) {
 
       // Check that the received object file content matches the original.
       StringRef RPCObjContents = Obj->getBuffer();
       EXPECT_EQ(RPCObjContents.size(), ObjContents.size())
         << "RPC'd object file has incorrect size";
       EXPECT_TRUE(std::equal(RPCObjContents.begin(), RPCObjContents.end(),
                              ObjContents.begin()))
         << "RPC'd object file content does not match original content";
 
       return 1;
     });
-  RemoteObjectServerLayer<MockObjectLayer, RPCEndpoint> Server(BaseLayer,
-                                                               ServerEP,
-                                                               ReportError);
+  RemoteObjectServerLayer<MockObjectLayer, RPCEndpoint> Server(
+      AcknowledgeORCv1Deprecation, BaseLayer, ServerEP, ReportError);
 
   bool Finished = false;
   ServerEP.addHandler<remote::utils::TerminateSession>(
     [&]() { Finished = true; }
   );
 
   auto ServerThread =
     std::thread([&]() {
TEST(RemoteObjectLayer, AddObjectFailure) {
   auto ReportError =
     [](Error Err) {
       auto ErrMsg = toString(std::move(Err));
       EXPECT_EQ(ErrMsg, "AddObjectFailure - Test Message")
         << "Expected error string to be \"AddObjectFailure - Test Message\"";
     };
 
   RPCEndpoint ClientEP(*Channels.first, true);
-  RemoteObjectClientLayer<RPCEndpoint> Client(ClientEP, ReportError);
+  RemoteObjectClientLayer<RPCEndpoint> Client(AcknowledgeORCv1Deprecation,
+                                              ClientEP, ReportError);
 
   RPCEndpoint ServerEP(*Channels.second, true);
   MockObjectLayer BaseLayer(
     [](MockObjectLayer::ObjectPtr Obj,
        MockObjectLayer::SymbolLookupTable &SymTab)
         -> Expected<MockObjectLayer::ObjHandleT> {
       return make_error<StringError>("AddObjectFailure - Test Message",
                                      inconvertibleErrorCode());
     });
-  RemoteObjectServerLayer<MockObjectLayer, RPCEndpoint> Server(BaseLayer,
-                                                               ServerEP,
-                                                               ReportError);
+  RemoteObjectServerLayer<MockObjectLayer, RPCEndpoint> Server(
+      AcknowledgeORCv1Deprecation, BaseLayer, ServerEP, ReportError);
 
   bool Finished = false;
   ServerEP.addHandler<remote::utils::TerminateSession>(
     [&]() { Finished = true; }
   );
 
   auto ServerThread =
     std::thread([&]() {
TEST(RemoteObjectLayer, RemoveObject) {
 
   auto Channels = createPairedQueueChannels();
 
   auto ReportError = [](Error Err) {
     logAllUnhandledErrors(std::move(Err), llvm::errs());
   };
 
   RPCEndpoint ClientEP(*Channels.first, true);
-  RemoteObjectClientLayer<RPCEndpoint> Client(ClientEP, ReportError);
+  RemoteObjectClientLayer<RPCEndpoint> Client(AcknowledgeORCv1Deprecation,
+                                              ClientEP, ReportError);
 
   RPCEndpoint ServerEP(*Channels.second, true);
 
   MockObjectLayer BaseLayer(
     [](MockObjectLayer::ObjectPtr Obj,
        MockObjectLayer::SymbolLookupTable &SymTab) {
       SymTab[1] = MockObjectLayer::LookupFn();
       return 1;
     });
-  RemoteObjectServerLayer<MockObjectLayer, RPCEndpoint> Server(BaseLayer,
-                                                               ServerEP,
-                                                               ReportError);
+  RemoteObjectServerLayer<MockObjectLayer, RPCEndpoint> Server(
+      AcknowledgeORCv1Deprecation, BaseLayer, ServerEP, ReportError);
 
   bool Finished = false;
   ServerEP.addHandler<remote::utils::TerminateSession>(
     [&]() { Finished = true; }
   );
 
   auto ServerThread =
     std::thread([&]() {
TEST(RemoteObjectLayer, RemoveObjectFailure) {
   auto ReportError =
     [](Error Err) {
       auto ErrMsg = toString(std::move(Err));
       EXPECT_EQ(ErrMsg, "Object handle 42 not found")
         << "Expected error string to be \"Object handle 42 not found\"";
     };
 
   RPCEndpoint ClientEP(*Channels.first, true);
-  RemoteObjectClientLayer<RPCEndpoint> Client(ClientEP, ReportError);
+  RemoteObjectClientLayer<RPCEndpoint> Client(AcknowledgeORCv1Deprecation,
+                                              ClientEP, ReportError);
 
   RPCEndpoint ServerEP(*Channels.second, true);
 
   // AddObject lambda does not update symbol table, so removeObject will treat
   // this as a bad object handle.
   MockObjectLayer BaseLayer(
     [](MockObjectLayer::ObjectPtr Obj,
        MockObjectLayer::SymbolLookupTable &SymTab) {
       return 42;
     });
-  RemoteObjectServerLayer<MockObjectLayer, RPCEndpoint> Server(BaseLayer,
-                                                               ServerEP,
-                                                               ReportError);
+  RemoteObjectServerLayer<MockObjectLayer, RPCEndpoint> Server(
+      AcknowledgeORCv1Deprecation, BaseLayer, ServerEP, ReportError);
 
   bool Finished = false;
   ServerEP.addHandler<remote::utils::TerminateSession>(
     [&]() { Finished = true; }
   );
 
   auto ServerThread =
     std::thread([&]() {
TEST(RemoteObjectLayer, FindSymbol) {
   auto ReportError =
     [](Error Err) {
       auto ErrMsg = toString(std::move(Err));
       EXPECT_EQ(ErrMsg, "Could not find symbol 'badsymbol'")
         << "Expected error string to be \"Object handle 42 not found\"";
     };
 
   RPCEndpoint ClientEP(*Channels.first, true);
-  RemoteObjectClientLayer<RPCEndpoint> Client(ClientEP, ReportError);
+  RemoteObjectClientLayer<RPCEndpoint> Client(AcknowledgeORCv1Deprecation,
+                                              ClientEP, ReportError);
 
   RPCEndpoint ServerEP(*Channels.second, true);
 
   // AddObject lambda does not update symbol table, so removeObject will treat
   // this as a bad object handle.
   MockObjectLayer BaseLayer(
     [](MockObjectLayer::ObjectPtr Obj,
        MockObjectLayer::SymbolLookupTable &SymTab) {
       SymTab[42] =
         [](StringRef Name, bool ExportedSymbolsOnly) -> JITSymbol {
           if (Name == "foobar")
             return JITSymbol(0x12348765, JITSymbolFlags::Exported);
           if (Name == "badsymbol")
             return make_error<JITSymbolNotFound>(Name);
           return nullptr;
         };
       return 42;
     });
-  RemoteObjectServerLayer<MockObjectLayer, RPCEndpoint> Server(BaseLayer,
-                                                               ServerEP,
-                                                               ReportError);
+  RemoteObjectServerLayer<MockObjectLayer, RPCEndpoint> Server(
+      AcknowledgeORCv1Deprecation, BaseLayer, ServerEP, ReportError);
 
   bool Finished = false;
   ServerEP.addHandler<remote::utils::TerminateSession>(
     [&]() { Finished = true; }
   );
 
   auto ServerThread =
     std::thread([&]() {
TEST(RemoteObjectLayer, FindSymbolIn) {
   auto ReportError =
     [](Error Err) {
       auto ErrMsg = toString(std::move(Err));
       EXPECT_EQ(ErrMsg, "Could not find symbol 'barbaz'")
         << "Expected error string to be \"Object handle 42 not found\"";
     };
 
   RPCEndpoint ClientEP(*Channels.first, true);
-  RemoteObjectClientLayer<RPCEndpoint> Client(ClientEP, ReportError);
+  RemoteObjectClientLayer<RPCEndpoint> Client(AcknowledgeORCv1Deprecation,
+                                              ClientEP, ReportError);
 
   RPCEndpoint ServerEP(*Channels.second, true);
 
   // AddObject lambda does not update symbol table, so removeObject will treat
   // this as a bad object handle.
   MockObjectLayer BaseLayer(
     [](MockObjectLayer::ObjectPtr Obj,
        MockObjectLayer::SymbolLookupTable &SymTab) {
[](MockObjectLayer::ObjectPtr Obj,
         [](StringRef Name, bool ExportedSymbolsOnly) -> JITSymbol {
           if (Name == "barbaz")
             return JITSymbol(0xdeadbeef, JITSymbolFlags::Exported);
           return make_error<JITSymbolNotFound>(Name);
         };
 
       return 42;
     });
-  RemoteObjectServerLayer<MockObjectLayer, RPCEndpoint> Server(BaseLayer,
-                                                               ServerEP,
-                                                               ReportError);
+  RemoteObjectServerLayer<MockObjectLayer, RPCEndpoint> Server(
+      AcknowledgeORCv1Deprecation, BaseLayer, ServerEP, ReportError);
 
   bool Finished = false;
   ServerEP.addHandler<remote::utils::TerminateSession>(
     [&]() { Finished = true; }
   );
 
   auto ServerThread =
     std::thread([&]() {
TEST(RemoteObjectLayer, EmitAndFinalize) {
 
   auto Channels = createPairedQueueChannels();
 
   auto ReportError = [](Error Err) {
     logAllUnhandledErrors(std::move(Err), llvm::errs());
   };
 
   RPCEndpoint ClientEP(*Channels.first, true);
-  RemoteObjectClientLayer<RPCEndpoint> Client(ClientEP, ReportError);
+  RemoteObjectClientLayer<RPCEndpoint> Client(AcknowledgeORCv1Deprecation,
+                                              ClientEP, ReportError);
 
   RPCEndpoint ServerEP(*Channels.second, true);
 
   MockObjectLayer BaseLayer(
     [](MockObjectLayer::ObjectPtr Obj,
        MockObjectLayer::SymbolLookupTable &SymTab) {
       SymTab[1] = MockObjectLayer::LookupFn();
       return 1;
     });
-  RemoteObjectServerLayer<MockObjectLayer, RPCEndpoint> Server(BaseLayer,
-                                                               ServerEP,
-                                                               ReportError);
+  RemoteObjectServerLayer<MockObjectLayer, RPCEndpoint> Server(
+      AcknowledgeORCv1Deprecation, BaseLayer, ServerEP, ReportError);
 
   bool Finished = false;
   ServerEP.addHandler<remote::utils::TerminateSession>(
     [&]() { Finished = true; }
   );
 
   auto ServerThread =
     std::thread([&]() {
TEST(RemoteObjectLayer, EmitAndFinalizeFailure) {
   auto ReportError =
     [](Error Err) {
       auto ErrMsg = toString(std::move(Err));
       EXPECT_EQ(ErrMsg, "Object handle 1 not found")
         << "Expected bad handle error";
     };
 
   RPCEndpoint ClientEP(*Channels.first, true);
-  RemoteObjectClientLayer<RPCEndpoint> Client(ClientEP, ReportError);
+  RemoteObjectClientLayer<RPCEndpoint> Client(AcknowledgeORCv1Deprecation,
+                                              ClientEP, ReportError);
 
   RPCEndpoint ServerEP(*Channels.second, true);
 
   MockObjectLayer BaseLayer(
     [](MockObjectLayer::ObjectPtr Obj,
        MockObjectLayer::SymbolLookupTable &SymTab) {
       return 1;
     });
-  RemoteObjectServerLayer<MockObjectLayer, RPCEndpoint> Server(BaseLayer,
-                                                               ServerEP,
-                                                               ReportError);
+  RemoteObjectServerLayer<MockObjectLayer, RPCEndpoint> Server(
+      AcknowledgeORCv1Deprecation, BaseLayer, ServerEP, ReportError);
 
   bool Finished = false;
   ServerEP.addHandler<remote::utils::TerminateSession>(
     [&]() { Finished = true; }
   );
 
   auto ServerThread =
     std::thread([&]() {