[ORC] Add an initial implementation of a replacement CompileOnDemandLayer.

CompileOnDemandLayer2 is a replacement for CompileOnDemandLayer built on the ORC
Core APIs. Functions in added modules are extracted and compiled lazily.
CompileOnDemandLayer2 supports multithreaded JIT'd code, and compilation on
multiple threads.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@334967 91177308-0d34-0410-b5e6-96231b3b80d8

Author: lhames

include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h

@@ -20,9 +20,9 @@
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/ExecutionEngine/JITSymbol.h"
-#include "llvm/ExecutionEngine/Orc/Core.h"
 #include "llvm/ExecutionEngine/Orc/IndirectionUtils.h"
 #include "llvm/ExecutionEngine/Orc/LambdaResolver.h"
+#include "llvm/ExecutionEngine/Orc/Layer.h"
 #include "llvm/ExecutionEngine/Orc/OrcError.h"
 #include "llvm/ExecutionEngine/RuntimeDyld.h"
 #include "llvm/IR/Attributes.h"
@@ -57,6 +57,66 @@ class Value;
 
 namespace orc {
 
+class ExtractingIRMaterializationUnit;
+
+class CompileOnDemandLayer2 : public IRLayer {
+  friend class ExtractingIRMaterializationUnit;
+
+public:
+  /// Builder for IndirectStubsManagers.
+  using IndirectStubsManagerBuilder =
+      std::function<std::unique_ptr<IndirectStubsManager>()>;
+
+  /// Retrieve symbol resolver for the given VModuleKey.
+  using GetSymbolResolverFunction =
+      std::function<std::shared_ptr<SymbolResolver>(VModuleKey K)>;
+
+  /// Set the symbol resolver for the given VModuleKey.
+  using SetSymbolResolverFunction =
+      std::function<void(VModuleKey K, std::shared_ptr<SymbolResolver> R)>;
+
+  using GetAvailableContextFunction = std::function<LLVMContext &()>;
+
+  CompileOnDemandLayer2(ExecutionSession &ES, IRLayer &BaseLayer,
+                        JITCompileCallbackManager &CCMgr,
+                        IndirectStubsManagerBuilder BuildIndirectStubsManager,
+                        GetSymbolResolverFunction GetSymbolResolver,
+                        SetSymbolResolverFunction SetSymbolResolver,
+                        GetAvailableContextFunction GetAvailableContext);
+
+  Error add(VSO &V, VModuleKey K, std::unique_ptr<Module> M) override;
+
+  void emit(MaterializationResponsibility R, VModuleKey K,
+            std::unique_ptr<Module> M) override;
+
+private:
+  using StubManagersMap =
+      std::map<const VSO *, std::unique_ptr<IndirectStubsManager>>;
+
+  using SymbolNameToDefinitionMap =
+      IRMaterializationUnit::SymbolNameToDefinitionMap;
+
+  IndirectStubsManager &getStubsManager(const VSO &V);
+
+  std::unique_ptr<Module>
+  extractFunctions(Module &M, const SymbolNameSet &SymbolNames,
+                   const SymbolNameToDefinitionMap &SymbolToDefiniton);
+
+  void emitExtractedFunctionsModule(MaterializationResponsibility R,
+                                    std::unique_ptr<Module> M,
+                                    std::shared_ptr<SymbolResolver> Resolver);
+
+  mutable std::mutex CODLayerMutex;
+
+  IRLayer &BaseLayer;
+  JITCompileCallbackManager &CCMgr;
+  IndirectStubsManagerBuilder BuildIndirectStubsManager;
+  StubManagersMap StubsMgrs;
+  GetSymbolResolverFunction GetSymbolResolver;
+  SetSymbolResolverFunction SetSymbolResolver;
+  GetAvailableContextFunction GetAvailableContext;
+};
+
 /// Compile-on-demand layer.
 ///
 ///   When a module is added to this layer a stub is created for each of its

include/llvm/ExecutionEngine/Orc/Core.h

@@ -115,7 +115,7 @@ class MaterializationResponsibility {
 
   /// Returns the target VSO that these symbols are being materialized
   ///        into.
-  const VSO &getTargetVSO() const { return V; }
+  VSO &getTargetVSO() const { return V; }
 
   /// Returns the names of any symbols covered by this
   /// MaterializationResponsibility object that have queries pending. This

lib/ExecutionEngine/Orc/CMakeLists.txt

@@ -1,4 +1,5 @@
 add_llvm_library(LLVMOrcJIT
+  CompileOnDemandLayer.cpp
   Core.cpp
   ExecutionUtils.cpp
   IndirectionUtils.cpp